index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
18,300
|
ma_log_key_middle
|
eloqsql/storage/maria/ma_write.c
|
static my_bool _ma_log_key_middle(MARIA_PAGE *ma_page,
uint new_length,
uint data_added_first,
uint data_changed_first,
uint data_deleted_last,
const uchar *key_pos,
uint key_length, int move_length)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 2 + 2 + 3+5+3+3+3 + 7];
uchar *log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 6];
uint key_offset;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
my_off_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_key_middle");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(ma_page->size == new_length);
/* new place of key after changes */
key_pos+= data_added_first;
key_offset= (uint) (key_pos - ma_page->buff);
if (key_offset < new_length)
{
/* key is on page; Calculate how much of the key is there */
uint max_key_length= new_length - key_offset;
if (max_key_length < key_length)
{
/* Key is last on page */
key_length= max_key_length;
move_length= 0;
}
/*
Take into account that new data was added as part of original key
that also needs to be removed from page
*/
data_deleted_last+= move_length;
}
/* First log changes to page */
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
#ifdef EXTRA_DEBUG_KEY_CHANGES
*log_pos++= KEY_OP_DEBUG;
*log_pos++= KEY_OP_DEBUG_LOG_MIDDLE;
#endif
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, ma_page->buff);
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, data_deleted_last);
log_pos+= 3;
log_pos[0]= KEY_OP_ADD_PREFIX;
int2store(log_pos+1, data_added_first);
int2store(log_pos+3, data_changed_first);
log_pos+= 5;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= (ma_page->buff +
info->s->keypage_header);
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= data_changed_first;
translog_parts= 2;
extra_length= data_changed_first;
/* If changed key is on page, log those changes too */
if (key_offset < new_length)
{
uchar *start_log_pos= log_pos;
log_pos[0]= KEY_OP_OFFSET;
int2store(log_pos+1, key_offset);
log_pos+= 3;
if (move_length)
{
log_pos[0]= KEY_OP_SHIFT;
int2store(log_pos+1, move_length);
log_pos+= 3;
}
log_pos[0]= KEY_OP_CHANGE;
int2store(log_pos+1, key_length);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 2].str= start_log_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 2].length= (uint) (log_pos -
start_log_pos);
log_array[TRANSLOG_INTERNAL_PARTS + 3].str= key_pos;
log_array[TRANSLOG_INTERNAL_PARTS + 3].length= key_length;
translog_parts+=2;
extra_length+= (uint) (log_array[TRANSLOG_INTERNAL_PARTS + 2].length +
key_length);
}
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
(log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length),
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
}
|
O0
|
c
|
ma_log_key_middle:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movl %edx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movl %r8d, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x100(%rbp)
jmp 0x918e7
jmp 0x918e9
jmp 0x918eb
movl -0x40(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x9194e
movl -0x3c(%rbp), %eax
subl -0xe4(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
cmpl 0x10(%rbp), %eax
jae 0x91945
movl -0x104(%rbp), %eax
movl %eax, 0x10(%rbp)
movl $0x0, 0x18(%rbp)
movl 0x18(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x100(%rbp), %rax
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, (%rax)
movq -0x100(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x110(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x60(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0xa, (%rax)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x744(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movb $0x7, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x118(%rbp)
movl -0x48(%rbp), %eax
movw %ax, %cx
movq -0x118(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movb $0x4, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x120(%rbp)
movl -0x40(%rbp), %eax
movw %ax, %cx
movq -0x120(%rbp), %rax
movw %cx, (%rax)
jmp 0x91a3a
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x128(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x128(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0xb8(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0xf8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x744(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl $0x2, -0xe8(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xec(%rbp)
movl -0xe4(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jae 0x91bde
movq -0x60(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x60(%rbp), %rax
movb $0x1, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x138(%rbp)
movl -0xe4(%rbp), %eax
movw %ax, %cx
movq -0x138(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
cmpl $0x0, 0x18(%rbp)
je 0x91b4a
movq -0x60(%rbp), %rax
movb $0x2, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x140(%rbp)
movl 0x18(%rbp), %eax
movw %ax, %cx
movq -0x140(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movb $0x3, (%rax)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x148(%rbp)
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x148(%rbp), %rax
movw %cx, (%rax)
movq -0x60(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x130(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq -0x130(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x98(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movl 0x10(%rbp), %eax
movq %rax, -0x88(%rbp)
movl -0xe8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xe8(%rbp)
movq -0x98(%rbp), %rax
movl 0x10(%rbp), %ecx
addq %rcx, %rax
addl -0xec(%rbp), %eax
movl %eax, -0xec(%rbp)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0xf8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0xf8(%rbp), %rcx
movq -0xb8(%rbp), %rax
movl -0xec(%rbp), %esi
addq %rsi, %rax
movl %eax, %r8d
movl -0xe8(%rbp), %r9d
addl $0x2, %r9d
leaq -0xe0(%rbp), %r10
leaq -0x30(%rbp), %rax
leaq -0x58(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x59180
movb %al, -0x149(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x91c71
movb -0x149(%rbp), %al
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
callq 0x272b0
nopw %cs:(%rax,%rax)
|
_ma_log_key_middle:
push rbp
mov rbp, rsp
sub rsp, 170h
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov [rbp+var_44], ecx
mov [rbp+var_48], r8d
mov [rbp+var_50], r9
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_F8], rax
mov rax, [rbp+var_38]
mov rax, [rax+18h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_100], rax
jmp short $+2
loc_918E7:
jmp short $+2
loc_918E9:
jmp short $+2
loc_918EB:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_50]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
sub rax, rcx
mov [rbp+var_E4], eax
mov eax, [rbp+var_E4]
cmp eax, [rbp+var_3C]
jnb short loc_9194E
mov eax, [rbp+var_3C]
sub eax, [rbp+var_E4]
mov [rbp+var_104], eax
mov eax, [rbp+var_104]
cmp eax, [rbp+arg_0]
jnb short loc_91945
mov eax, [rbp+var_104]
mov [rbp+arg_0], eax
mov [rbp+arg_8], 0
loc_91945:
mov eax, [rbp+arg_8]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_9194E:
lea rax, [rbp+var_30]
add rax, 2
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov [rbp+var_110], rax
mov rax, [rbp+var_100]
mov ecx, eax
mov rax, [rbp+var_110]
mov [rax], ecx
mov rax, [rbp+var_100]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_110]
mov [rax+4], cl
mov rax, [rbp+var_60]
add rax, 5
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 0Ah
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+744h]
sub ecx, 2
sub ecx, 1
mov ecx, ecx
mov cl, [rax+rcx]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
mov rax, [rbp+var_60]
mov byte ptr [rax], 7
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_118], rax
mov eax, [rbp+var_48]
mov cx, ax
mov rax, [rbp+var_118]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov byte ptr [rax], 4
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_120], rax
mov eax, [rbp+var_40]
mov cx, ax
mov rax, [rbp+var_120]
mov [rax], cx
jmp short $+2
loc_91A3A:
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_128], rax
mov eax, [rbp+var_44]
mov cx, ax
mov rax, [rbp+var_128]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 5
mov [rbp+var_60], rax
lea rax, [rbp+var_30]
mov [rbp+var_C0], rax
mov rax, [rbp+var_60]
lea rcx, [rbp+var_30]
sub rax, rcx
mov eax, eax
mov [rbp+var_B8], rax
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov rcx, [rbp+var_F8]
mov rcx, [rcx]
mov ecx, [rcx+744h]
add rax, rcx
mov [rbp+var_B0], rax
mov eax, [rbp+var_44]
mov [rbp+var_A8], rax
mov [rbp+var_E8], 2
mov eax, [rbp+var_44]
mov [rbp+var_EC], eax
mov eax, [rbp+var_E4]
cmp eax, [rbp+var_3C]
jnb loc_91BDE
mov rax, [rbp+var_60]
mov [rbp+var_130], rax
mov rax, [rbp+var_60]
mov byte ptr [rax], 1
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_138], rax
mov eax, [rbp+var_E4]
mov cx, ax
mov rax, [rbp+var_138]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
cmp [rbp+arg_8], 0
jz short loc_91B4A
mov rax, [rbp+var_60]
mov byte ptr [rax], 2
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_140], rax
mov eax, [rbp+arg_8]
mov cx, ax
mov rax, [rbp+var_140]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
loc_91B4A:
mov rax, [rbp+var_60]
mov byte ptr [rax], 3
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_148], rax
mov eax, [rbp+arg_0]
mov cx, ax
mov rax, [rbp+var_148]
mov [rax], cx
mov rax, [rbp+var_60]
add rax, 3
mov [rbp+var_60], rax
mov rax, [rbp+var_130]
mov [rbp+var_A0], rax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_130]
sub rax, rcx
mov eax, eax
mov [rbp+var_98], rax
mov rax, [rbp+var_50]
mov [rbp+var_90], rax
mov eax, [rbp+arg_0]
mov [rbp+var_88], rax
mov eax, [rbp+var_E8]
add eax, 2
mov [rbp+var_E8], eax
mov rax, [rbp+var_98]
mov ecx, [rbp+arg_0]
add rax, rcx
add eax, [rbp+var_EC]
mov [rbp+var_EC], eax
loc_91BDE:
mov rax, [rbp+var_38]
mov ecx, [rax+20h]
mov rax, [rbp+var_38]
mov [rax+24h], ecx
mov rax, [rbp+var_F8]
mov rdx, [rax+8]
mov rcx, [rbp+var_F8]
mov rax, [rbp+var_B8]
mov esi, [rbp+var_EC]
add rax, rsi
mov r8d, eax
mov r9d, [rbp+var_E8]
add r9d, 2
lea r10, [rbp+var_E0]
lea rax, [rbp+var_30]
lea rdi, [rbp+var_58]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+170h+var_170], r10
mov [rsp+170h+var_168], rax
mov [rsp+170h+var_160], 0
call translog_write_record
mov [rbp+var_149], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_91C71
mov al, [rbp+var_149]
add rsp, 170h
pop rbp
retn
loc_91C71:
call ___stack_chk_fail
|
char ma_log_key_middle(
long long **a1,
unsigned int a2,
unsigned int a3,
unsigned int a4,
int a5,
long long a6,
unsigned int a7,
int a8)
{
_BYTE *v9; // [rsp+40h] [rbp-130h]
unsigned long long v10; // [rsp+70h] [rbp-100h]
long long *v11; // [rsp+78h] [rbp-F8h]
unsigned int v12; // [rsp+84h] [rbp-ECh]
int v13; // [rsp+88h] [rbp-E8h]
unsigned int v14; // [rsp+8Ch] [rbp-E4h]
_QWORD v15[5]; // [rsp+90h] [rbp-E0h] BYREF
long long v16; // [rsp+B8h] [rbp-B8h]
char *v17; // [rsp+C0h] [rbp-B0h]
long long v18; // [rsp+C8h] [rbp-A8h]
_BYTE *v19; // [rsp+D0h] [rbp-A0h]
long long v20; // [rsp+D8h] [rbp-98h]
long long v21; // [rsp+E0h] [rbp-90h]
long long v22; // [rsp+E8h] [rbp-88h]
_BYTE *v23; // [rsp+110h] [rbp-60h]
char v24[8]; // [rsp+118h] [rbp-58h] BYREF
long long v25; // [rsp+120h] [rbp-50h]
int v26; // [rsp+128h] [rbp-48h]
unsigned int v27; // [rsp+12Ch] [rbp-44h]
unsigned int v28; // [rsp+130h] [rbp-40h]
unsigned int v29; // [rsp+134h] [rbp-3Ch]
long long **v30; // [rsp+138h] [rbp-38h]
__int16 v31; // [rsp+140h] [rbp-30h] BYREF
int v32; // [rsp+142h] [rbp-2Eh]
char v33; // [rsp+146h] [rbp-2Ah]
char v34; // [rsp+147h] [rbp-29h]
_BYTE v35[2]; // [rsp+148h] [rbp-28h] BYREF
__int16 v36; // [rsp+14Ah] [rbp-26h]
char v37; // [rsp+14Ch] [rbp-24h]
__int16 v38; // [rsp+14Dh] [rbp-23h]
__int16 v39; // [rsp+14Fh] [rbp-21h]
_BYTE v40[31]; // [rsp+151h] [rbp-1Fh] BYREF
long long savedregs; // [rsp+170h] [rbp+0h] BYREF
*(_QWORD *)&v40[23] = __readfsqword(0x28u);
v30 = a1;
v29 = a2;
v28 = a3;
v27 = a4;
v26 = a5;
v25 = a6;
v11 = *a1;
v10 = (unsigned long long)a1[3] / *(unsigned int *)(**a1 + 1980);
v25 = a3 + a6;
v14 = v25 - (unsigned int)a1[2];
if ( v14 < a2 )
{
if ( v29 - v14 < a7 )
{
a7 = v29 - v14;
a8 = 0;
}
v26 += a8;
}
v32 = v10;
v33 = BYTE4(v10);
v23 = v35;
v34 = 10;
v35[0] = *((_BYTE *)v30[2] + (unsigned int)(*(_DWORD *)(*v11 + 1860) - 3));
v35[1] = 7;
v36 = v26;
v37 = 4;
v38 = v28;
v39 = v27;
v23 = v40;
v15[4] = &v31;
v16 = (unsigned int)v40 - ((unsigned int)&savedregs - 48);
v17 = (char *)v30[2] + *(unsigned int *)(*v11 + 1860);
v18 = v27;
v13 = 2;
v12 = v27;
if ( v14 < v29 )
{
v9 = v23;
*v23 = 1;
*(_WORD *)(v23 + 1) = v14;
v23 += 3;
if ( a8 )
{
*v23 = 2;
*(_WORD *)(v23 + 1) = a8;
v23 += 3;
}
*v23 = 3;
*(_WORD *)(v23 + 1) = a7;
v23 += 3;
v19 = v9;
v20 = (unsigned int)((_DWORD)v23 - (_DWORD)v9);
v21 = v25;
v22 = a7;
v13 = 4;
v12 += a7 + (_DWORD)v23 - (_DWORD)v9;
}
*((_DWORD *)v30 + 9) = *((_DWORD *)v30 + 8);
return translog_write_record((long long)v24, 0xCu, v11[1], v11, v12 + v16, v13 + 2, v15, &v31, 0LL);
}
|
_ma_log_key_middle:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV dword ptr [RBP + -0x44],ECX
MOV dword ptr [RBP + -0x48],R8D
MOV qword ptr [RBP + -0x50],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xf8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x100],RAX
JMP 0x001918e7
LAB_001918e7:
JMP 0x001918e9
LAB_001918e9:
JMP 0x001918eb
LAB_001918eb:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
MOV dword ptr [RBP + -0xe4],EAX
MOV EAX,dword ptr [RBP + -0xe4]
CMP EAX,dword ptr [RBP + -0x3c]
JNC 0x0019194e
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,dword ptr [RBP + -0xe4]
MOV dword ptr [RBP + -0x104],EAX
MOV EAX,dword ptr [RBP + -0x104]
CMP EAX,dword ptr [RBP + 0x10]
JNC 0x00191945
MOV EAX,dword ptr [RBP + -0x104]
MOV dword ptr [RBP + 0x10],EAX
MOV dword ptr [RBP + 0x18],0x0
LAB_00191945:
MOV EAX,dword ptr [RBP + 0x18]
ADD EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
LAB_0019194e:
LEA RAX,[RBP + -0x30]
ADD RAX,0x2
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x110],RAX
MOV RAX,qword ptr [RBP + -0x100]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x110]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x100]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x110]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x5
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0xa
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x2
SUB ECX,0x1
MOV ECX,ECX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x7
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x118],RAX
MOV EAX,dword ptr [RBP + -0x48]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x118]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x4
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x120]
MOV word ptr [RAX],CX
JMP 0x00191a3a
LAB_00191a3a:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x128],RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x128]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x5
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RBP + -0x30]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x744]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0xa8],RAX
MOV dword ptr [RBP + -0xe8],0x2
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0xec],EAX
MOV EAX,dword ptr [RBP + -0xe4]
CMP EAX,dword ptr [RBP + -0x3c]
JNC 0x00191bde
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x130],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0xe4]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x138]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
CMP dword ptr [RBP + 0x18],0x0
JZ 0x00191b4a
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x2
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x140],RAX
MOV EAX,dword ptr [RBP + 0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x140]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
LAB_00191b4a:
MOV RAX,qword ptr [RBP + -0x60]
MOV byte ptr [RAX],0x3
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x148],RAX
MOV EAX,dword ptr [RBP + 0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x148]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x3
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x130]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x130]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x90],RAX
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x88],RAX
MOV EAX,dword ptr [RBP + -0xe8]
ADD EAX,0x2
MOV dword ptr [RBP + -0xe8],EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,dword ptr [RBP + 0x10]
ADD RAX,RCX
ADD EAX,dword ptr [RBP + -0xec]
MOV dword ptr [RBP + -0xec],EAX
LAB_00191bde:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0xf8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0xf8]
MOV RAX,qword ptr [RBP + -0xb8]
MOV ESI,dword ptr [RBP + -0xec]
ADD RAX,RSI
MOV R8D,EAX
MOV R9D,dword ptr [RBP + -0xe8]
ADD R9D,0x2
LEA R10,[RBP + -0xe0]
LEA RAX,[RBP + -0x30]
LEA RDI,[RBP + -0x58]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00159180
MOV byte ptr [RBP + -0x149],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00191c71
MOV AL,byte ptr [RBP + -0x149]
ADD RSP,0x170
POP RBP
RET
LAB_00191c71:
CALL 0x001272b0
|
int8
_ma_log_key_middle(long *param_1,uint param_2,uint param_3,uint param_4,int param_5,long param_6,
uint param_7,int param_8)
{
long *plVar1;
int iVar2;
int1 uVar3;
uint uVar4;
uint uVar5;
ulong uVar6;
long in_FS_OFFSET;
uint local_f4;
int local_f0;
int1 local_e8 [32];
int1 *local_c8;
ulong local_c0;
long local_b8;
ulong local_b0;
int1 *local_a8;
ulong local_a0;
long local_98;
ulong local_90;
int1 *local_68;
int1 local_60 [8];
long local_58;
int local_50;
uint local_4c;
uint local_48;
uint local_44;
long *local_40;
int1 local_38 [2];
int4 local_36;
int1 local_32;
int1 local_31;
int1 local_30;
int1 local_2f;
int2 local_2e;
int1 local_2c;
int2 local_2b;
int2 local_29;
int1 local_27;
int2 local_26;
int1 local_24;
int2 local_23;
int1 local_21 [17];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar6 = (ulong)param_1[3] / (ulong)*(uint *)(*plVar1 + 0x7bc);
local_58 = param_6 + (ulong)param_3;
uVar4 = (int)local_58 - (int)param_1[2];
local_50 = param_5;
if (uVar4 < param_2) {
if (param_2 - uVar4 < param_7) {
param_8 = 0;
param_7 = param_2 - uVar4;
}
local_50 = param_8 + param_5;
}
local_36 = (int4)uVar6;
local_32 = (int1)(uVar6 >> 0x20);
local_31 = 10;
local_30 = *(int1 *)(param_1[2] + (ulong)(*(int *)(*plVar1 + 0x744) - 3));
local_2f = 7;
local_2e = (int2)local_50;
local_2c = 4;
local_2b = (int2)param_3;
local_29 = (int2)param_4;
local_c8 = local_38;
iVar2 = (int)&local_27;
uVar5 = iVar2 - (int)local_38;
local_c0 = (ulong)uVar5;
local_b8 = param_1[2] + (ulong)*(uint *)(*plVar1 + 0x744);
local_b0 = (ulong)param_4;
local_f0 = 2;
local_f4 = param_4;
local_68 = &local_27;
if (uVar4 < param_2) {
local_27 = 1;
local_26 = (int2)uVar4;
local_68 = &local_24;
if (param_8 != 0) {
local_24 = 2;
local_23 = (int2)param_8;
local_68 = local_21;
}
*local_68 = 3;
*(short *)(local_68 + 1) = (short)param_7;
local_68 = local_68 + 3;
uVar4 = (int)local_68 - iVar2;
local_a0 = (ulong)uVar4;
local_90 = (ulong)param_7;
local_f0 = 4;
local_f4 = uVar4 + param_7 + param_4;
local_a8 = &local_27;
local_98 = local_58;
}
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
local_4c = param_4;
local_48 = param_3;
local_44 = param_2;
local_40 = param_1;
uVar3 = translog_write_record
(local_60,0xc,plVar1[1],plVar1,uVar5 + local_f4,local_f0 + 2,local_e8,local_38,0
);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),uVar3);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
18,301
|
coro::shared_mutex<coro::io_scheduler>::lock_operation::await_suspend(std::__n4861::coroutine_handle<void>)
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/shared_mutex.hpp
|
auto await_suspend(std::coroutine_handle<> awaiting_coroutine) noexcept -> bool
{
std::unique_lock lk{m_shared_mutex.m_mutex};
// Its possible the lock has been released between await_ready() and await_suspend(), double
// check and make sure we are not going to suspend when nobody holds the lock.
if (m_exclusive)
{
if (m_shared_mutex.try_lock_locked(lk))
{
return false;
}
}
else
{
if (m_shared_mutex.try_lock_shared_locked(lk))
{
return false;
}
}
// For sure the lock is currently held in a manner that it cannot be acquired, suspend ourself
// at the end of the waiter list.
if (m_shared_mutex.m_tail_waiter == nullptr)
{
m_shared_mutex.m_head_waiter = this;
m_shared_mutex.m_tail_waiter = this;
}
else
{
m_shared_mutex.m_tail_waiter->m_next = this;
m_shared_mutex.m_tail_waiter = this;
}
// If this is an exclusive lock acquire then mark it as so so that shared locks after this
// exclusive one will also suspend so this exclusive lock doens't get starved.
if (m_exclusive)
{
++m_shared_mutex.m_exclusive_waiters;
}
m_awaiting_coroutine = awaiting_coroutine;
return true;
}
|
O3
|
cpp
|
coro::shared_mutex<coro::io_scheduler>::lock_operation::await_suspend(std::__n4861::coroutine_handle<void>):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
addq $0x10, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x2e99c
movb $0x1, 0x10(%rsp)
movq (%r14), %rdi
cmpb $0x1, 0x8(%r14)
jne 0x3485b
cmpl $0x0, 0x38(%rdi)
jne 0x34870
movl $0x2, 0x38(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x2e9d8
jmp 0x34869
leaq 0x8(%rsp), %rsi
callq 0x3497e
testb %al, %al
je 0x3486d
xorl %ebx, %ebx
jmp 0x3489b
movq (%r14), %rdi
movq 0x58(%rdi), %rax
leaq 0x18(%rax), %rcx
leaq 0x50(%rdi), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
movq %r14, (%rcx)
movq %r14, 0x58(%rdi)
cmpb $0x1, 0x8(%r14)
jne 0x34895
incq 0x48(%rdi)
movq %rbx, 0x10(%r14)
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x2e986
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1f2c3
nop
|
_ZN4coro12shared_mutexINS_12io_schedulerEE14lock_operation13await_suspendENSt7__n486116coroutine_handleIvEE:
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
add rax, 10h
lea rdi, [rsp+28h+var_20]
mov [rdi], rax
mov byte ptr [rdi+8], 0
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov [rsp+28h+var_18], 1
mov rdi, [r14]
cmp byte ptr [r14+8], 1
jnz short loc_3485B
cmp dword ptr [rdi+38h], 0
jnz short loc_34870
mov dword ptr [rdi+38h], 2
lea rdi, [rsp+28h+var_20]
call _ZNSt11unique_lockISt5mutexE6unlockEv; std::unique_lock<std::mutex>::unlock(void)
jmp short loc_34869
loc_3485B:
lea rsi, [rsp+28h+var_20]
call _ZN4coro12shared_mutexINS_12io_schedulerEE22try_lock_shared_lockedERSt11unique_lockISt5mutexE; coro::shared_mutex<coro::io_scheduler>::try_lock_shared_locked(std::unique_lock<std::mutex> &)
test al, al
jz short loc_3486D
loc_34869:
xor ebx, ebx
jmp short loc_3489B
loc_3486D:
mov rdi, [r14]
loc_34870:
mov rax, [rdi+58h]
lea rcx, [rax+18h]
lea rdx, [rdi+50h]
test rax, rax
cmovz rcx, rdx
mov [rcx], r14
mov [rdi+58h], r14
cmp byte ptr [r14+8], 1
jnz short loc_34895
inc qword ptr [rdi+48h]
loc_34895:
mov [r14+10h], rbx
mov bl, 1
loc_3489B:
lea rdi, [rsp+28h+var_20]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
mov rdi, rax
call __clang_call_terminate
|
long long coro::shared_mutex<coro::io_scheduler>::lock_operation::await_suspend(long long *a1, long long a2)
{
unsigned int v2; // ebx
long long v4; // rdi
long long v5; // rax
_QWORD *v6; // rcx
long long v8; // [rsp+8h] [rbp-20h] BYREF
char v9; // [rsp+10h] [rbp-18h]
v2 = a2;
v8 = *a1 + 16;
v9 = 0;
std::unique_lock<std::mutex>::lock(&v8);
v9 = 1;
v4 = *a1;
if ( *((_BYTE *)a1 + 8) == 1 )
{
if ( !*(_DWORD *)(v4 + 56) )
{
*(_DWORD *)(v4 + 56) = 2;
std::unique_lock<std::mutex>::unlock(&v8);
LABEL_5:
v2 = 0;
goto LABEL_12;
}
}
else
{
if ( (unsigned __int8)coro::shared_mutex<coro::io_scheduler>::try_lock_shared_locked(v4, &v8) )
goto LABEL_5;
v4 = *a1;
}
v5 = *(_QWORD *)(v4 + 88);
v6 = (_QWORD *)(v5 + 24);
if ( !v5 )
v6 = (_QWORD *)(v4 + 80);
*v6 = a1;
*(_QWORD *)(v4 + 88) = a1;
if ( *((_BYTE *)a1 + 8) == 1 )
++*(_QWORD *)(v4 + 72);
a1[2] = a2;
LOBYTE(v2) = 1;
LABEL_12:
std::unique_lock<std::mutex>::~unique_lock((long long)&v8);
return v2;
}
|
await_suspend:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
ADD RAX,0x10
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],RAX
MOV byte ptr [RDI + 0x8],0x0
LAB_0013482e:
CALL 0x0012e99c
MOV byte ptr [RSP + 0x10],0x1
MOV RDI,qword ptr [R14]
CMP byte ptr [R14 + 0x8],0x1
JNZ 0x0013485b
CMP dword ptr [RDI + 0x38],0x0
JNZ 0x00134870
MOV dword ptr [RDI + 0x38],0x2
LEA RDI,[RSP + 0x8]
CALL 0x0012e9d8
JMP 0x00134869
LAB_0013485b:
LEA RSI,[RSP + 0x8]
CALL 0x0013497e
TEST AL,AL
JZ 0x0013486d
LAB_00134869:
XOR EBX,EBX
JMP 0x0013489b
LAB_0013486d:
MOV RDI,qword ptr [R14]
LAB_00134870:
MOV RAX,qword ptr [RDI + 0x58]
LEA RCX,[RAX + 0x18]
LEA RDX,[RDI + 0x50]
TEST RAX,RAX
CMOVZ RCX,RDX
MOV qword ptr [RCX],R14
MOV qword ptr [RDI + 0x58],R14
CMP byte ptr [R14 + 0x8],0x1
JNZ 0x00134895
INC qword ptr [RDI + 0x48]
LAB_00134895:
MOV qword ptr [R14 + 0x10],RBX
MOV BL,0x1
LAB_0013489b:
LEA RDI,[RSP + 0x8]
CALL 0x0012e986
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* coro::shared_mutex<coro::io_scheduler>::lock_operation::await_suspend(std::__n4861::coroutine_handle<void>)
*/
ulong __thiscall
coro::shared_mutex<coro::io_scheduler>::lock_operation::await_suspend
(lock_operation *this,int8 param_2)
{
char cVar1;
shared_mutex<coro::io_scheduler> *psVar2;
ulong uVar3;
shared_mutex<coro::io_scheduler> *this_00;
long local_20;
int1 local_18;
local_20 = *(long *)this + 0x10;
local_18 = 0;
/* try { // try from 0013482e to 00134864 has its CatchHandler @ 001348af */
std::unique_lock<std::mutex>::lock((unique_lock<std::mutex> *)&local_20);
local_18 = 1;
this_00 = *(shared_mutex<coro::io_scheduler> **)this;
if (this[8] == (lock_operation)0x1) {
if (*(int *)(this_00 + 0x38) != 0) {
LAB_00134870:
psVar2 = (shared_mutex<coro::io_scheduler> *)(*(long *)(this_00 + 0x58) + 0x18);
if (*(long *)(this_00 + 0x58) == 0) {
psVar2 = this_00 + 0x50;
}
*(lock_operation **)psVar2 = this;
*(lock_operation **)(this_00 + 0x58) = this;
if (this[8] == (lock_operation)0x1) {
*(long *)(this_00 + 0x48) = *(long *)(this_00 + 0x48) + 1;
}
*(int8 *)(this + 0x10) = param_2;
uVar3 = CONCAT71((int7)((ulong)param_2 >> 8),1);
goto LAB_0013489b;
}
*(int4 *)(this_00 + 0x38) = 2;
std::unique_lock<std::mutex>::unlock((unique_lock<std::mutex> *)&local_20);
}
else {
cVar1 = try_lock_shared_locked(this_00,(unique_lock *)&local_20);
if (cVar1 == '\0') {
this_00 = *(shared_mutex<coro::io_scheduler> **)this;
goto LAB_00134870;
}
}
uVar3 = 0;
LAB_0013489b:
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_20);
return uVar3 & 0xffffffff;
}
|
|
18,302
|
psi_rwlock_tryrdlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_rwlock_tryrdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_TRYREADLOCK, file, line);
int result= rw_tryrdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_rwlock_tryrdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b172e(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x2, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33da0
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x335d3
leaq 0x1b16e8(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
psi_rwlock_tryrdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 2
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_tryrdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_335D3
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_335D3:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_rwlock_tryrdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 52))(
v6,
*(_QWORD *)(a1 + 144),
2LL,
a2,
a3);
v4 = my_rw_tryrdlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 53))(v5, v4);
return v4;
}
|
psi_rwlock_tryrdlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x2
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00133da0
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001335d3
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001335d3:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_tryrdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),2,param_2,param_3);
uVar1 = my_rw_tryrdlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
|
|
18,303
|
simple_read_change_write_read_test
|
eloqsql/storage/maria/unittest/ma_pagecache_single.c
|
int simple_read_change_write_read_test()
{
unsigned char *buffw= malloc(TEST_PAGE_SIZE);
unsigned char *buffr= malloc(TEST_PAGE_SIZE);
int res, res2;
DBUG_ENTER("simple_read_change_write_read_test");
/* prepare the file */
bfill(buffw, TEST_PAGE_SIZE, '\1');
pagecache_write(&pagecache, &file1, 0, 3, buffw,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY,
0, LSN_IMPOSSIBLE);
if (flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE))
{
diag("Got error during flushing pagecache\n");
exit(1);
}
/* test */
pagecache_read(&pagecache, &file1, 0, 3, buffw,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE,
0);
bfill(buffw, TEST_PAGE_SIZE/2, '\65');
pagecache_write(&pagecache, &file1, 0, 3, buffw,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN,
PAGECACHE_WRITE_DELAY,
0, LSN_IMPOSSIBLE);
pagecache_read(&pagecache, &file1, 0, 3, buffr,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
0);
ok((res= MY_TEST(memcmp(buffr, buffw, TEST_PAGE_SIZE) == 0)),
"Simple read-change-write-read page ");
DBUG_ASSERT(pagecache.blocks_changed == 1);
if (flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE))
{
diag("Got error during flushing pagecache\n");
exit(1);
}
DBUG_ASSERT(pagecache.blocks_changed == 0);
ok((res2= MY_TEST(test_file(file1, file1_name, TEST_PAGE_SIZE, TEST_PAGE_SIZE,
simple_read_change_write_read_test_file))),
"Simple read-change-write-read page file");
if (res && res2)
reset_file(&file1, file1_name);
free(buffw);
free(buffr);
DBUG_RETURN(res && res2);
}
|
O3
|
c
|
simple_read_change_write_read_test:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x400, %edi # imm = 0x400
callq 0x29710
movq %rax, %rbx
movl $0x400, %edi # imm = 0x400
callq 0x29710
movq %rax, %r14
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
movl $0x1, %esi
callq 0x292c0
leaq 0x3ce087(%rip), %r15 # 0x3fe460
movl 0x3ce101(%rip), %eax # 0x3fe4e0
movl %eax, 0x30(%rsp)
xorl %r13d, %r13d
movl %r13d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r13d, 0x10(%rsp)
movl %r13d, (%rsp)
movl $0x1, 0x8(%rsp)
leaq 0x3ce275(%rip), %r12 # 0x3fe680
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl $0x3, %ecx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x3497a
movq %r15, %rdi
movq %r12, %rsi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x35070
testl %eax, %eax
jne 0x305c9
movq %r13, 0x8(%rsp)
movl $0x4, (%rsp)
leaq 0x3ce00a(%rip), %r15 # 0x3fe460
leaq 0x3ce223(%rip), %r12 # 0x3fe680
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl $0x3, %ecx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x33516
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
movl $0x35, %esi
callq 0x292c0
movl 0x3ce050(%rip), %eax # 0x3fe4e0
movl %eax, 0x30(%rsp)
movl %r13d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r13d, 0x10(%rsp)
movl $0x3, 0x8(%rsp)
movl $0x6, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl $0x3, %ecx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x3497a
movq %r13, 0x8(%rsp)
movl %r13d, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl $0x3, %ecx
movq %r14, %r8
movl $0x1, %r9d
callq 0x33516
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29560
movl %eax, %r13d
xorl %edi, %edi
testl %eax, %eax
sete %dil
leaq 0xa9d19(%rip), %rsi # 0xda22f
xorl %eax, %eax
callq 0x92223
movq %r15, %rdi
movq %r12, %rsi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x35070
testl %eax, %eax
jne 0x305c9
testl %r13d, %r13d
sete %r12b
leaq 0x3ce138(%rip), %rsi # 0x3fe680
movl $0x9, %ecx
movq %rsp, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x3ce176(%rip), %rdi # 0x3fe6d0
leaq 0x355abf(%rip), %rcx # 0x386020
movl $0x400, %esi # imm = 0x400
movl $0x400, %edx # imm = 0x400
callq 0x31b78
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
leaq 0xa9cd3(%rip), %rsi # 0xda253
movl %r15d, %edi
xorl %eax, %eax
callq 0x92223
andb %r12b, %r15b
cmpb $0x1, %r15b
jne 0x305a6
leaq 0x3ce0e6(%rip), %rdi # 0x3fe680
leaq 0x3ce12f(%rip), %rsi # 0x3fe6d0
callq 0x3016c
movq %rbx, %rdi
callq 0x29160
movq %r14, %rdi
callq 0x29160
movzbl %r15b, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa9c1e(%rip), %rdi # 0xda1ee
xorl %eax, %eax
callq 0x91fc3
movl $0x1, %edi
callq 0x29540
|
simple_read_change_write_read_test:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov edi, 400h
call _malloc
mov rbx, rax
mov edi, 400h
call _malloc
mov r14, rax
mov edx, 400h
mov rdi, rbx
mov esi, 1
call _memset
lea r15, pagecache
mov eax, cs:dword_3FE4E0
mov [rsp+70h+var_40], eax
xor r13d, r13d
mov [rsp+70h+var_48], r13d
xorps xmm0, xmm0
movups [rsp+70h+var_58], xmm0
mov [rsp+70h+var_60], r13d
mov [rsp+70h+var_70], r13d
mov dword ptr [rsp+70h+var_68], 1
lea r12, file1
mov rdi, r15
mov rsi, r12
xor edx, edx
mov ecx, 3
mov r8, rbx
mov r9d, 1
call pagecache_write_part
mov rdi, r15
mov rsi, r12
mov edx, 3
xor ecx, ecx
xor r8d, r8d
call flush_pagecache_blocks_with_filter
test eax, eax
jnz loc_305C9
mov [rsp+70h+var_68], r13
mov [rsp+70h+var_70], 4
lea r15, pagecache
lea r12, file1
mov rdi, r15
mov rsi, r12
xor edx, edx
mov ecx, 3
mov r8, rbx
mov r9d, 1
call pagecache_read
mov edx, 200h
mov rdi, rbx
mov esi, 35h ; '5'
call _memset
mov eax, cs:dword_3FE4E0
mov [rsp+70h+var_40], eax
mov [rsp+70h+var_48], r13d
xorps xmm0, xmm0
movups [rsp+70h+var_58], xmm0
mov [rsp+70h+var_60], r13d
mov dword ptr [rsp+70h+var_68], 3
mov [rsp+70h+var_70], 6
mov rdi, r15
mov rsi, r12
xor edx, edx
mov ecx, 3
mov r8, rbx
mov r9d, 1
call pagecache_write_part
mov [rsp+70h+var_68], r13
mov [rsp+70h+var_70], r13d
mov rdi, r15
mov rsi, r12
xor edx, edx
mov ecx, 3
mov r8, r14
mov r9d, 1
call pagecache_read
mov edx, 400h
mov rdi, r14
mov rsi, rbx
call _bcmp
mov r13d, eax
xor edi, edi
test eax, eax
setz dil
lea rsi, aSimpleReadChan; "Simple read-change-write-read page "
xor eax, eax
call ok
mov rdi, r15
mov rsi, r12
mov edx, 3
xor ecx, ecx
xor r8d, r8d
call flush_pagecache_blocks_with_filter
test eax, eax
jnz loc_305C9
test r13d, r13d
setz r12b
lea rsi, file1
mov ecx, 9
mov rdi, rsp
rep movsq
lea rdi, file1_name
lea rcx, simple_read_change_write_read_test_file
mov esi, 400h
mov edx, 400h
call test_file
xor r15d, r15d
test eax, eax
setnz r15b
lea rsi, aSimpleReadChan_0; "Simple read-change-write-read page file"
mov edi, r15d
xor eax, eax
call ok
and r15b, r12b
cmp r15b, 1
jnz short loc_305A6
lea rdi, file1
lea rsi, file1_name
call reset_file
loc_305A6:
mov rdi, rbx
call _free
mov rdi, r14
call _free
movzx eax, r15b
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_305C9:
lea rdi, aGotErrorDuring_0; "Got error during flushing pagecache\n"
xor eax, eax
call diag
mov edi, 1
call _exit
|
_BOOL8 simple_read_change_write_read_test()
{
long long v0; // rbx
long long v1; // r14
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // r13d
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
BOOL v11; // r15d
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
bool v16; // r15
_QWORD v18[9]; // [rsp+0h] [rbp-70h] BYREF
v0 = malloc(1024LL);
v1 = malloc(1024LL);
memset(v0, 1LL, 1024LL);
pagecache_write_part((unsigned int)&pagecache, (unsigned int)&file1, 0, 3, v0, 1, 0, 1, 0, 0LL, 0LL, 0, dword_3FE4E0);
if ( (unsigned int)flush_pagecache_blocks_with_filter(&pagecache, &file1, 3LL, 0LL, 0LL)
|| (pagecache_read((unsigned int)&pagecache, (unsigned int)&file1, 0, 3, v0, 1, 4, 0LL),
memset(v0, 53LL, 512LL),
pagecache_write_part(
(unsigned int)&pagecache,
(unsigned int)&file1,
0,
3,
v0,
1,
6,
3,
0,
0LL,
0LL,
0,
dword_3FE4E0),
pagecache_read((unsigned int)&pagecache, (unsigned int)&file1, 0, 3, v1, 1, 0, 0LL),
v6 = bcmp(v1, v0, 1024LL),
ok(v6 == 0, (unsigned int)"Simple read-change-write-read page ", v7, v8, v9, v10, v18[0]),
(unsigned int)flush_pagecache_blocks_with_filter(&pagecache, &file1, 3LL, 0LL, 0LL)) )
{
diag((unsigned int)"Got error during flushing pagecache\n", (unsigned int)&file1, v2, v3, v4, v5);
exit(1LL);
}
qmemcpy(v18, &file1, sizeof(v18));
v11 = test_file(
(unsigned int)&file1_name,
1024,
1024,
(unsigned int)&simple_read_change_write_read_test_file,
v4,
v5,
v18[0]) != 0;
ok(v11, (unsigned int)"Simple read-change-write-read page file", v12, v13, v14, v15, v18[0]);
v16 = v6 == 0 && v11;
if ( v16 )
reset_file((long long)&file1, (long long)&file1_name);
free(v0);
free(v1);
return v16;
}
|
simple_read_change_write_read_test:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EDI,0x400
CALL 0x00129710
MOV RBX,RAX
MOV EDI,0x400
CALL 0x00129710
MOV R14,RAX
MOV EDX,0x400
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001292c0
LEA R15,[0x4fe460]
MOV EAX,dword ptr [0x004fe4e0]
MOV dword ptr [RSP + 0x30],EAX
XOR R13D,R13D
MOV dword ptr [RSP + 0x28],R13D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R13D
MOV dword ptr [RSP],R13D
MOV dword ptr [RSP + 0x8],0x1
LEA R12,[0x4fe680]
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV ECX,0x3
MOV R8,RBX
MOV R9D,0x1
CALL 0x0013497a
MOV RDI,R15
MOV RSI,R12
MOV EDX,0x3
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00135070
TEST EAX,EAX
JNZ 0x001305c9
MOV qword ptr [RSP + 0x8],R13
MOV dword ptr [RSP],0x4
LEA R15,[0x4fe460]
LEA R12,[0x4fe680]
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV ECX,0x3
MOV R8,RBX
MOV R9D,0x1
CALL 0x00133516
MOV EDX,0x200
MOV RDI,RBX
MOV ESI,0x35
CALL 0x001292c0
MOV EAX,dword ptr [0x004fe4e0]
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x28],R13D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R13D
MOV dword ptr [RSP + 0x8],0x3
MOV dword ptr [RSP],0x6
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV ECX,0x3
MOV R8,RBX
MOV R9D,0x1
CALL 0x0013497a
MOV qword ptr [RSP + 0x8],R13
MOV dword ptr [RSP],R13D
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV ECX,0x3
MOV R8,R14
MOV R9D,0x1
CALL 0x00133516
MOV EDX,0x400
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129560
MOV R13D,EAX
XOR EDI,EDI
TEST EAX,EAX
SETZ DIL
LEA RSI,[0x1da22f]
XOR EAX,EAX
CALL 0x00192223
MOV RDI,R15
MOV RSI,R12
MOV EDX,0x3
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00135070
TEST EAX,EAX
JNZ 0x001305c9
TEST R13D,R13D
SETZ R12B
LEA RSI,[0x4fe680]
MOV ECX,0x9
MOV RDI,RSP
MOVSQ.REP RDI,RSI
LEA RDI,[0x4fe6d0]
LEA RCX,[0x486020]
MOV ESI,0x400
MOV EDX,0x400
CALL 0x00131b78
XOR R15D,R15D
TEST EAX,EAX
SETNZ R15B
LEA RSI,[0x1da253]
MOV EDI,R15D
XOR EAX,EAX
CALL 0x00192223
AND R15B,R12B
CMP R15B,0x1
JNZ 0x001305a6
LEA RDI,[0x4fe680]
LEA RSI,[0x4fe6d0]
CALL 0x0013016c
LAB_001305a6:
MOV RDI,RBX
CALL 0x00129160
MOV RDI,R14
CALL 0x00129160
MOVZX EAX,R15B
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001305c9:
LEA RDI,[0x1da1ee]
XOR EAX,EAX
CALL 0x00191fc3
MOV EDI,0x1
CALL 0x00129540
|
bool simple_read_change_write_read_test(void)
{
int iVar1;
int iVar2;
void *__s;
void *__s1;
long lVar3;
int8 *puVar4;
int8 *puVar5;
bool bVar6;
byte bVar7;
int4 local_78 [2];
int8 local_70;
int4 local_68;
int8 local_60;
int8 uStack_58;
int4 local_50;
int4 local_48;
bVar7 = 0;
__s = malloc(0x400);
__s1 = malloc(0x400);
memset(__s,1,0x400);
local_48 = pagecache._128_4_;
local_50 = 0;
local_60 = 0;
uStack_58 = 0;
local_68 = 0;
local_78[0] = 0;
local_70 = CONCAT44(local_70._4_4_,1);
pagecache_write_part(pagecache,&file1,0,3,__s,1);
iVar1 = flush_pagecache_blocks_with_filter(pagecache,&file1,3,0,0);
if (iVar1 == 0) {
local_70 = 0;
local_78[0] = 4;
pagecache_read(pagecache,&file1,0,3,__s,1);
memset(__s,0x35,0x200);
local_48 = pagecache._128_4_;
local_50 = 0;
local_60 = 0;
uStack_58 = 0;
local_68 = 0;
local_70 = CONCAT44(local_70._4_4_,3);
local_78[0] = 6;
pagecache_write_part(pagecache,&file1,0,3,__s,1);
local_70 = 0;
local_78[0] = 0;
pagecache_read(pagecache,&file1,0,3,__s1,1);
iVar1 = bcmp(__s1,__s,0x400);
ok(iVar1 == 0,"Simple read-change-write-read page ");
iVar2 = flush_pagecache_blocks_with_filter(pagecache,&file1,3,0,0);
if (iVar2 == 0) {
puVar4 = &file1;
puVar5 = (int8 *)local_78;
for (lVar3 = 9; lVar3 != 0; lVar3 = lVar3 + -1) {
*puVar5 = *puVar4;
puVar4 = puVar4 + (ulong)bVar7 * -2 + 1;
puVar5 = puVar5 + (ulong)bVar7 * -2 + 1;
}
iVar2 = test_file(file1_name,0x400,0x400,simple_read_change_write_read_test_file);
bVar6 = iVar2 != 0;
ok(bVar6,"Simple read-change-write-read page file");
if (bVar6 && iVar1 == 0) {
reset_file(&file1,file1_name);
}
free(__s);
free(__s1);
return bVar6 && iVar1 == 0;
}
}
diag("Got error during flushing pagecache\n");
/* WARNING: Subroutine does not return */
exit(1);
}
|
|
18,304
|
test_ast_create_vector
|
tsotchke[P]eshkol/tests/unit/test_ast.c
|
static void test_ast_create_vector(void) {
printf("Testing vector literal node creation...\n");
// Create an arena
Arena* arena = arena_create(1024);
assert(arena != NULL);
// Create some elements
AstNode* elements[3];
elements[0] = ast_create_number(arena, 1.0, 1, 1);
elements[1] = ast_create_number(arena, 2.0, 1, 3);
elements[2] = ast_create_number(arena, 3.0, 1, 5);
// Create a vector node
AstNode* node = ast_create_vector(arena, elements, 3, 1, 1);
assert(node != NULL);
assert(node->type == AST_LITERAL_VECTOR);
assert(node->line == 1);
assert(node->column == 1);
assert(node->as.vector.count == 3);
assert(node->as.vector.elements[0] == elements[0]);
assert(node->as.vector.elements[1] == elements[1]);
assert(node->as.vector.elements[2] == elements[2]);
// Destroy the arena
arena_destroy(arena);
printf("PASS: ast_create_vector\n");
}
|
O0
|
c
|
test_ast_create_vector:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x79c0(%rip), %rdi # 0x94cf
movb $0x0, %al
callq 0x1070
movl $0x400, %edi # imm = 0x400
callq 0x43a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b2d
jmp 0x1b4c
leaq 0x753f(%rip), %rdi # 0x9073
leaq 0x7546(%rip), %rsi # 0x9081
movl $0xa0, %edx
leaq 0x79b1(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x8(%rbp), %rdi
movsd 0x74c8(%rip), %xmm0 # 0x9020
movl $0x1, %edx
movq %rdx, %rsi
callq 0x54b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x74a3(%rip), %xmm0 # 0x9018
movl $0x1, %esi
movl $0x3, %edx
callq 0x54b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x747c(%rip), %xmm0 # 0x9010
movl $0x1, %esi
movl $0x5, %edx
callq 0x54b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x3, %edx
movl $0x1, %r8d
movq %r8, %rcx
callq 0x5670
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1bcf
jmp 0x1bee
leaq 0x751b(%rip), %rdi # 0x90f1
leaq 0x74a4(%rip), %rsi # 0x9081
movl $0xaa, %edx
leaq 0x790f(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x1bf9
jmp 0x1c18
leaq 0x791a(%rip), %rdi # 0x951a
leaq 0x747a(%rip), %rsi # 0x9081
movl $0xab, %edx
leaq 0x78e5(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x1c25
jmp 0x1c44
leaq 0x74f3(%rip), %rdi # 0x911f
leaq 0x744e(%rip), %rsi # 0x9081
movl $0xac, %edx
leaq 0x78b9(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jne 0x1c51
jmp 0x1c70
leaq 0x74d7(%rip), %rdi # 0x912f
leaq 0x7422(%rip), %rsi # 0x9081
movl $0xad, %edx
leaq 0x788d(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
cmpq $0x3, 0x50(%rax)
jne 0x1c7d
jmp 0x1c9c
leaq 0x78b7(%rip), %rdi # 0x953b
leaq 0x73f6(%rip), %rsi # 0x9081
movl $0xae, %edx
leaq 0x7861(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x1caf
jmp 0x1cce
leaq 0x78a0(%rip), %rdi # 0x9556
leaq 0x73c4(%rip), %rsi # 0x9081
movl $0xaf, %edx
leaq 0x782f(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1ce2
jmp 0x1d01
leaq 0x7898(%rip), %rdi # 0x9581
leaq 0x7391(%rip), %rsi # 0x9081
movl $0xb0, %edx
leaq 0x77fc(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1d15
jmp 0x1d34
leaq 0x7890(%rip), %rdi # 0x95ac
leaq 0x735e(%rip), %rsi # 0x9081
movl $0xb1, %edx
leaq 0x77c9(%rip), %rcx # 0x94f8
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x4980
leaq 0x7893(%rip), %rdi # 0x95d7
movb $0x0, %al
callq 0x1070
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
test_ast_create_vector:
push rbp
mov rbp, rsp
sub rsp, 30h
lea rdi, aTestingVectorL; "Testing vector literal node creation..."...
mov al, 0
call _printf
mov edi, 400h
call arena_create
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jz short loc_1B2D
jmp short loc_1B4C
loc_1B2D:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0A0h
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1B4C:
mov rdi, [rbp+var_8]
movsd xmm0, cs:qword_9020
mov edx, 1
mov rsi, rdx
call ast_create_number
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
movsd xmm0, cs:qword_9018
mov esi, 1
mov edx, 3
call ast_create_number
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
movsd xmm0, cs:qword_9010
mov esi, 1
mov edx, 5
call ast_create_number
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_20]
mov edx, 3
mov r8d, 1
mov rcx, r8
call ast_create_vector
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_1BCF
jmp short loc_1BEE
loc_1BCF:
lea rdi, aNodeNull; "node != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0AAh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1BEE:
mov rax, [rbp+var_28]
cmp dword ptr [rax], 4
jnz short loc_1BF9
jmp short loc_1C18
loc_1BF9:
lea rdi, aNodeTypeAstLit_2; "node->type == AST_LITERAL_VECTOR"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0ABh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1C18:
mov rax, [rbp+var_28]
cmp qword ptr [rax+8], 1
jnz short loc_1C25
jmp short loc_1C44
loc_1C25:
lea rdi, aNodeLine1; "node->line == 1"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0ACh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1C44:
mov rax, [rbp+var_28]
cmp qword ptr [rax+10h], 1
jnz short loc_1C51
jmp short loc_1C70
loc_1C51:
lea rdi, aNodeColumn1; "node->column == 1"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0ADh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1C70:
mov rax, [rbp+var_28]
cmp qword ptr [rax+50h], 3
jnz short loc_1C7D
jmp short loc_1C9C
loc_1C7D:
lea rdi, aNodeAsVectorCo; "node->as.vector.count == 3"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0AEh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1C9C:
mov rax, [rbp+var_28]
mov rax, [rax+48h]
mov rax, [rax]
cmp rax, [rbp+var_20]
jnz short loc_1CAF
jmp short loc_1CCE
loc_1CAF:
lea rdi, aNodeAsVectorEl; "node->as.vector.elements[0] == elements"...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0AFh
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1CCE:
mov rax, [rbp+var_28]
mov rax, [rax+48h]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jnz short loc_1CE2
jmp short loc_1D01
loc_1CE2:
lea rdi, aNodeAsVectorEl_0; "node->as.vector.elements[1] == elements"...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0B0h
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1D01:
mov rax, [rbp+var_28]
mov rax, [rax+48h]
mov rax, [rax+10h]
cmp rax, [rbp+var_10]
jnz short loc_1D15
jmp short loc_1D34
loc_1D15:
lea rdi, aNodeAsVectorEl_1; "node->as.vector.elements[2] == elements"...
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0B1h
lea rcx, aVoidTestAstCre_4; "void test_ast_create_vector(void)"
call ___assert_fail
loc_1D34:
mov rdi, [rbp+var_8]
call arena_destroy
lea rdi, aPassAstCreateV; "PASS: ast_create_vector\n"
mov al, 0
call _printf
add rsp, 30h
pop rbp
retn
|
long long test_ast_create_vector(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long v5; // [rsp+8h] [rbp-28h]
long long number; // [rsp+10h] [rbp-20h] BYREF
long long v7; // [rsp+18h] [rbp-18h]
long long v8; // [rsp+20h] [rbp-10h]
long long v9; // [rsp+28h] [rbp-8h]
printf("Testing vector literal node creation...\n", a2, a3);
v9 = arena_create(1024LL);
if ( !v9 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
160LL,
"void test_ast_create_vector(void)");
number = ast_create_number(v9, 1LL, 1.0);
v7 = ast_create_number(v9, 1LL, 2.0);
v8 = ast_create_number(v9, 1LL, 3.0);
v5 = ast_create_vector(v9, &number, 3LL, 1LL);
if ( !v5 )
__assert_fail(
"node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
170LL,
"void test_ast_create_vector(void)");
if ( *(_DWORD *)v5 != 4 )
__assert_fail(
"node->type == AST_LITERAL_VECTOR",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
171LL,
"void test_ast_create_vector(void)");
if ( *(_QWORD *)(v5 + 8) != 1LL )
__assert_fail(
"node->line == 1",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
172LL,
"void test_ast_create_vector(void)");
if ( *(_QWORD *)(v5 + 16) != 1LL )
__assert_fail(
"node->column == 1",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
173LL,
"void test_ast_create_vector(void)");
if ( *(_QWORD *)(v5 + 80) != 3LL )
__assert_fail(
"node->as.vector.count == 3",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
174LL,
"void test_ast_create_vector(void)");
if ( **(_QWORD **)(v5 + 72) != number )
__assert_fail(
"node->as.vector.elements[0] == elements[0]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
175LL,
"void test_ast_create_vector(void)");
if ( *(_QWORD *)(*(_QWORD *)(v5 + 72) + 8LL) != v7 )
__assert_fail(
"node->as.vector.elements[1] == elements[1]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
176LL,
"void test_ast_create_vector(void)");
if ( *(_QWORD *)(*(_QWORD *)(v5 + 72) + 16LL) != v8 )
__assert_fail(
"node->as.vector.elements[2] == elements[2]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
177LL,
"void test_ast_create_vector(void)");
arena_destroy(v9);
return printf("PASS: ast_create_vector\n", &number, v3);
}
|
test_ast_create_vector:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
LEA RDI,[0x1094cf]
MOV AL,0x0
CALL 0x00101070
MOV EDI,0x400
CALL 0x001043a0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00101b2d
JMP 0x00101b4c
LAB_00101b2d:
LEA RDI,[0x109073]
LEA RSI,[0x109081]
MOV EDX,0xa0
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101b4c:
MOV RDI,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00109020]
MOV EDX,0x1
MOV RSI,RDX
CALL 0x001054b0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00109018]
MOV ESI,0x1
MOV EDX,0x3
CALL 0x001054b0
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [0x00109010]
MOV ESI,0x1
MOV EDX,0x5
CALL 0x001054b0
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x20]
MOV EDX,0x3
MOV R8D,0x1
MOV RCX,R8
CALL 0x00105670
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00101bcf
JMP 0x00101bee
LAB_00101bcf:
LEA RDI,[0x1090f1]
LEA RSI,[0x109081]
MOV EDX,0xaa
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101bee:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX],0x4
JNZ 0x00101bf9
JMP 0x00101c18
LAB_00101bf9:
LEA RDI,[0x10951a]
LEA RSI,[0x109081]
MOV EDX,0xab
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101c18:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x8],0x1
JNZ 0x00101c25
JMP 0x00101c44
LAB_00101c25:
LEA RDI,[0x10911f]
LEA RSI,[0x109081]
MOV EDX,0xac
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101c44:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x10],0x1
JNZ 0x00101c51
JMP 0x00101c70
LAB_00101c51:
LEA RDI,[0x10912f]
LEA RSI,[0x109081]
MOV EDX,0xad
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101c70:
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x50],0x3
JNZ 0x00101c7d
JMP 0x00101c9c
LAB_00101c7d:
LEA RDI,[0x10953b]
LEA RSI,[0x109081]
MOV EDX,0xae
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101c9c:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00101caf
JMP 0x00101cce
LAB_00101caf:
LEA RDI,[0x109556]
LEA RSI,[0x109081]
MOV EDX,0xaf
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101cce:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x00101ce2
JMP 0x00101d01
LAB_00101ce2:
LEA RDI,[0x109581]
LEA RSI,[0x109081]
MOV EDX,0xb0
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101d01:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x00101d15
JMP 0x00101d34
LAB_00101d15:
LEA RDI,[0x1095ac]
LEA RSI,[0x109081]
MOV EDX,0xb1
LEA RCX,[0x1094f8]
CALL 0x00101080
LAB_00101d34:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00104980
LEA RDI,[0x1095d7]
MOV AL,0x0
CALL 0x00101070
ADD RSP,0x30
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void test_ast_create_vector(void)
{
int *piVar1;
long local_28;
long local_20;
long local_18;
long local_10;
printf("Testing vector literal node creation...\n");
local_10 = arena_create(0x400);
if (local_10 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xa0,"void test_ast_create_vector(void)");
}
local_28 = ast_create_number(_DAT_00109020,local_10,1);
local_20 = ast_create_number(DAT_00109018,local_10,1,3);
local_18 = ast_create_number(DAT_00109010,local_10,1,5);
piVar1 = (int *)ast_create_vector(local_10,&local_28,3,1);
if (piVar1 == (int *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xaa,"void test_ast_create_vector(void)");
}
if (*piVar1 != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("node->type == AST_LITERAL_VECTOR",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xab,"void test_ast_create_vector(void)");
}
if (*(long *)(piVar1 + 2) != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("node->line == 1",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xac,"void test_ast_create_vector(void)");
}
if (*(long *)(piVar1 + 4) != 1) {
/* WARNING: Subroutine does not return */
__assert_fail("node->column == 1",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xad,"void test_ast_create_vector(void)");
}
if (*(long *)(piVar1 + 0x14) != 3) {
/* WARNING: Subroutine does not return */
__assert_fail("node->as.vector.count == 3",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xae,"void test_ast_create_vector(void)");
}
if (**(long **)(piVar1 + 0x12) != local_28) {
/* WARNING: Subroutine does not return */
__assert_fail("node->as.vector.elements[0] == elements[0]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xaf,"void test_ast_create_vector(void)");
}
if (*(long *)(*(long *)(piVar1 + 0x12) + 8) == local_20) {
if (*(long *)(*(long *)(piVar1 + 0x12) + 0x10) == local_18) {
arena_destroy(local_10);
printf("PASS: ast_create_vector\n");
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("node->as.vector.elements[2] == elements[2]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xb1,"void test_ast_create_vector(void)");
}
/* WARNING: Subroutine does not return */
__assert_fail("node->as.vector.elements[1] == elements[1]",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/tests/unit/test_ast.c",
0xb0,"void test_ast_create_vector(void)");
}
|
|
18,305
|
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/arg.cpp
|
bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
}
|
O0
|
cpp
|
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x88(%rax)
jne 0x69278
movb $0x0, 0x27(%rsp)
jmp 0x692b0
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x5ad60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x692ab
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x5a6e0
movb $0x1, 0x27(%rsp)
jmp 0x692b0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
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_28], rax
cmp qword ptr [rax+88h], 0
jnz short loc_69278
mov [rsp+28h+var_1], 0
jmp short loc_692B0
loc_69278:
mov rax, [rsp+28h+var_28]
mov rdi, [rax+88h]
call _getenv
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jz short loc_692AB
mov rsi, [rsp+28h+var_20]
mov rdi, [rsp+28h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
mov [rsp+28h+var_1], 1
jmp short loc_692B0
loc_692AB:
mov [rsp+28h+var_1], 0
loc_692B0:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
|
char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v3 = getenv(*(_QWORD *)(a1 + 136));
if ( !v3 )
return 0;
std::string::operator=(a2, v3);
return 1;
}
|
get_value_from_env:
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],RAX
CMP qword ptr [RAX + 0x88],0x0
JNZ 0x00169278
MOV byte ptr [RSP + 0x27],0x0
JMP 0x001692b0
LAB_00169278:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x0015ad60
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001692ab
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0015a6e0
MOV byte ptr [RSP + 0x27],0x1
JMP 0x001692b0
LAB_001692ab:
MOV byte ptr [RSP + 0x27],0x0
LAB_001692b0:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
int1 __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
int1 local_1;
if (*(long *)(this + 0x88) == 0) {
local_1 = 0;
}
else {
pcVar1 = getenv(*(char **)(this + 0x88));
if (pcVar1 == (char *)0x0) {
local_1 = 0;
}
else {
std::__cxx11::string::operator=(param_1,pcVar1);
local_1 = 1;
}
}
return local_1;
}
|
|
18,306
|
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/arg.cpp
|
bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
}
|
O2
|
cpp
|
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x28d05
pushq %rbx
movq %rsi, %rbx
callq 0x23ae0
testq %rax, %rax
je 0x28d08
movq %rbx, %rdi
movq %rax, %rsi
callq 0x24140
movb $0x1, %al
jmp 0x28d0a
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
|
_ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
mov rdi, [rdi+88h]
test rdi, rdi
jz short loc_28D05
push rbx
mov rbx, rsi
call _getenv
test rax, rax
jz short loc_28D08
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
mov al, 1
jmp short loc_28D0A
loc_28D05:
xor eax, eax
retn
loc_28D08:
xor eax, eax
loc_28D0A:
pop rbx
retn
|
char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v2; // rax
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v2 = getenv();
if ( !v2 )
return 0;
std::string::assign(a2, v2);
return 1;
}
|
get_value_from_env:
MOV RDI,qword ptr [RDI + 0x88]
TEST RDI,RDI
JZ 0x00128d05
PUSH RBX
MOV RBX,RSI
CALL 0x00123ae0
TEST RAX,RAX
JZ 0x00128d08
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00124140
MOV AL,0x1
JMP 0x00128d0a
LAB_00128d05:
XOR EAX,EAX
RET
LAB_00128d08:
XOR EAX,EAX
LAB_00128d0a:
POP RBX
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
bool __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
if (*(char **)(this + 0x88) == (char *)0x0) {
return false;
}
pcVar1 = getenv(*(char **)(this + 0x88));
if (pcVar1 != (char *)0x0) {
std::__cxx11::string::assign((char *)param_1);
}
return pcVar1 != (char *)0x0;
}
|
|
18,307
|
js_malloc_rt
|
bluesky950520[P]quickjs/quickjs.c
|
void *js_malloc_rt(JSRuntime *rt, size_t size)
{
void *ptr;
JSMallocState *s;
/* Do not allocate zero bytes: behavior is platform dependent */
assert(size != 0);
s = &rt->malloc_state;
/* When malloc_limit is 0 (unlimited), malloc_limit - 1 will be SIZE_MAX. */
if (unlikely(s->malloc_size + size > s->malloc_limit - 1))
return NULL;
ptr = rt->mf.js_malloc(s->opaque, size);
if (!ptr)
return NULL;
s->malloc_count++;
s->malloc_size += rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
return ptr;
}
|
O0
|
c
|
js_malloc_rt:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
addq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x218e6
movq $0x0, 0x20(%rsp)
jmp 0x21951
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x21916
movq $0x0, 0x20(%rsp)
jmp 0x21951
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, %rcx
addq $0x8, %rcx
movq (%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
js_malloc_rt:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
add rax, 28h ; '('
mov [rsp+28h+var_28], rax
mov rax, [rsp+28h+var_28]
mov rax, [rax+8]
add rax, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_28]
mov rcx, [rcx+10h]
sub rcx, 1
cmp rax, rcx
setnbe al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_218E6
mov [rsp+28h+var_8], 0
jmp short loc_21951
loc_218E6:
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
mov rcx, [rsp+28h+var_28]
mov rdi, [rcx+18h]
mov rsi, [rsp+28h+var_18]
call rax
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jnz short loc_21916
mov [rsp+28h+var_8], 0
jmp short loc_21951
loc_21916:
mov rax, [rsp+28h+var_28]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rsp+28h+var_10]
mov rax, [rax+20h]
mov rdi, [rsp+28h+var_20]
call rax
mov rcx, rax
add rcx, 8
mov rax, [rsp+28h+var_28]
add rcx, [rax+8]
mov [rax+8], rcx
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
loc_21951:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long js_malloc_rt(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
if ( a2 + *(_QWORD *)(a1 + 48) > (unsigned long long)(*(_QWORD *)(a1 + 56) - 1LL) )
return 0LL;
v3 = (*(long long ( **)(_QWORD, long long))(a1 + 8))(*(_QWORD *)(a1 + 64), a2);
if ( !v3 )
return 0LL;
++*(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 48) += (*(long long ( **)(long long))(a1 + 32))(v3) + 8;
return v3;
}
|
js_malloc_rt:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x28
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP]
MOV RCX,qword ptr [RCX + 0x10]
SUB RCX,0x1
CMP RAX,RCX
SETA AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001218e6
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00121951
LAB_001218e6:
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP]
MOV RDI,qword ptr [RCX + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
CALL RAX
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00121916
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00121951
LAB_00121916:
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RSP + 0x8]
CALL RAX
MOV RCX,RAX
ADD RCX,0x8
MOV RAX,qword ptr [RSP]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_00121951:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
long js_malloc_rt(long param_1,long param_2)
{
long lVar1;
int8 local_8;
if (*(long *)(param_1 + 0x38) - 1U < (ulong)(*(long *)(param_1 + 0x30) + param_2)) {
local_8 = 0;
}
else {
local_8 = (**(code **)(param_1 + 8))(*(int8 *)(param_1 + 0x40),param_2);
if (local_8 == 0) {
local_8 = 0;
}
else {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
lVar1 = (**(code **)(param_1 + 0x20))(local_8);
*(long *)(param_1 + 0x30) = lVar1 + 8 + *(long *)(param_1 + 0x30);
}
}
return local_8;
}
|
|
18,308
|
js_malloc_rt
|
bluesky950520[P]quickjs/quickjs.c
|
void *js_malloc_rt(JSRuntime *rt, size_t size)
{
void *ptr;
JSMallocState *s;
/* Do not allocate zero bytes: behavior is platform dependent */
assert(size != 0);
s = &rt->malloc_state;
/* When malloc_limit is 0 (unlimited), malloc_limit - 1 will be SIZE_MAX. */
if (unlikely(s->malloc_size + size > s->malloc_limit - 1))
return NULL;
ptr = rt->mf.js_malloc(s->opaque, size);
if (!ptr)
return NULL;
s->malloc_count++;
s->malloc_size += rt->mf.js_malloc_usable_size(ptr) + MALLOC_OVERHEAD;
return ptr;
}
|
O2
|
c
|
js_malloc_rt:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
addq %rsi, %rax
movq 0x38(%rdi), %rcx
decq %rcx
cmpq %rcx, %rax
ja 0x170bd
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq *0x8(%rbx)
testq %rax, %rax
je 0x170bd
movq %rax, %r14
incq 0x28(%rbx)
movq %rax, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, 0x30(%rbx)
jmp 0x170c0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
js_malloc_rt:
push r14
push rbx
push rax
mov rax, [rdi+30h]
add rax, rsi
mov rcx, [rdi+38h]
dec rcx
cmp rax, rcx
ja short loc_170BD
mov rbx, rdi
mov rdi, [rdi+40h]
call qword ptr [rbx+8]
test rax, rax
jz short loc_170BD
mov r14, rax
inc qword ptr [rbx+28h]
mov rdi, rax
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
add rax, rcx
add rax, 8
mov [rbx+30h], rax
jmp short loc_170C0
loc_170BD:
xor r14d, r14d
loc_170C0:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
|
long long js_malloc_rt(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r14
if ( a2 + *(_QWORD *)(a1 + 48) > (unsigned long long)(*(_QWORD *)(a1 + 56) - 1LL) )
return 0LL;
v2 = (*(long long ( **)(_QWORD))(a1 + 8))(*(_QWORD *)(a1 + 64));
if ( !v2 )
return 0LL;
v3 = v2;
++*(_QWORD *)(a1 + 40);
*(_QWORD *)(a1 + 48) += (*(long long ( **)(long long))(a1 + 32))(v2) + 8;
return v3;
}
|
js_malloc_rt:
PUSH R14
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI + 0x30]
ADD RAX,RSI
MOV RCX,qword ptr [RDI + 0x38]
DEC RCX
CMP RAX,RCX
JA 0x001170bd
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x40]
CALL qword ptr [RBX + 0x8]
TEST RAX,RAX
JZ 0x001170bd
MOV R14,RAX
INC qword ptr [RBX + 0x28]
MOV RDI,RAX
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
ADD RAX,RCX
ADD RAX,0x8
MOV qword ptr [RBX + 0x30],RAX
JMP 0x001170c0
LAB_001170bd:
XOR R14D,R14D
LAB_001170c0:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
long js_malloc_rt(long param_1,long param_2)
{
long lVar1;
long lVar2;
if (((ulong)(*(long *)(param_1 + 0x30) + param_2) <= *(long *)(param_1 + 0x38) - 1U) &&
(lVar1 = (**(code **)(param_1 + 8))(*(int8 *)(param_1 + 0x40)), lVar1 != 0)) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
lVar2 = (**(code **)(param_1 + 0x20))(lVar1);
*(long *)(param_1 + 0x30) = lVar2 + *(long *)(param_1 + 0x30) + 8;
return lVar1;
}
return 0;
}
|
|
18,309
|
common_embd_normalize(float const*, float*, int, int)
|
monkey531[P]llama/common/common.cpp
|
void common_embd_normalize(const float * inp, float * out, int n, int embd_norm) {
double sum = 0.0;
switch (embd_norm) {
case -1: // no normalisation
sum = 1.0;
break;
case 0: // max absolute
for (int i = 0; i < n; i++) {
if (sum < std::abs(inp[i])) {
sum = std::abs(inp[i]);
}
}
sum /= 32760.0; // make an int16 range
break;
case 2: // euclidean
for (int i = 0; i < n; i++) {
sum += inp[i] * inp[i];
}
sum = std::sqrt(sum);
break;
default: // p-norm (euclidean is p-norm p=2)
for (int i = 0; i < n; i++) {
sum += std::pow(std::abs(inp[i]), embd_norm);
}
sum = std::pow(sum, 1.0 / embd_norm);
break;
}
const float norm = sum > 0.0 ? 1.0 / sum : 0.0f;
for (int i = 0; i < n; i++) {
out[i] = inp[i] * norm;
}
}
|
O2
|
cpp
|
common_embd_normalize(float const*, float*, int, int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %ecx
je 0x57ba7
testl %ecx, %ecx
je 0x57b65
cmpl $-0x1, %ecx
jne 0x57be2
xorl %r15d, %r15d
testl %edx, %edx
cmovgl %edx, %r15d
movsd 0x5ad68(%rip), %xmm0 # 0xb28c8
jmp 0x57c58
xorl %eax, %eax
testl %edx, %edx
movl %edx, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
movaps 0x5ad15(%rip), %xmm1 # 0xb2890
cmpq %rax, %r15
je 0x57b9a
movss (%r14,%rax,4), %xmm2
andps %xmm1, %xmm2
cvtss2sd %xmm2, %xmm2
maxsd %xmm0, %xmm2
incq %rax
movapd %xmm2, %xmm0
jmp 0x57b7b
divsd 0x5ad1e(%rip), %xmm0 # 0xb28c0
jmp 0x57c58
xorl %eax, %eax
testl %edx, %edx
movl %edx, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
cmpq %rax, %r15
je 0x57bd2
movss (%r14,%rax,4), %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x57bb6
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x57c53
sqrtsd %xmm0, %xmm0
jmp 0x57c58
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
testl %edx, %edx
movl %edx, %r15d
cmovlel %r12d, %r15d
xorpd %xmm0, %xmm0
cmpq %r12, %r15
je 0x57c3e
movsd %xmm0, 0x8(%rsp)
movss (%r14,%r12,4), %xmm0
andps 0x5ac7c(%rip), %xmm0 # 0xb2890
cvtss2sd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x23f80
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r12
jmp 0x57bfc
movsd 0x5ac82(%rip), %xmm1 # 0xb28c8
divsd 0x10(%rsp), %xmm1
callq 0x23f80
jmp 0x57c58
callq 0x23730
movsd 0x5ac68(%rip), %xmm1 # 0xb28c8
divsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpltsd %xmm0, %xmm2
andpd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm0
xorl %eax, %eax
cmpq %rax, %r15
je 0x57c90
movss (%r14,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx,%rax,4)
incq %rax
jmp 0x57c77
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_Z21common_embd_normalizePKfPfii:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
cmp ecx, 2
jz short loc_57BA7
test ecx, ecx
jz short loc_57B65
cmp ecx, 0FFFFFFFFh
jnz loc_57BE2
xor r15d, r15d
test edx, edx
cmovg r15d, edx
movsd xmm0, cs:qword_B28C8
jmp loc_57C58
loc_57B65:
xor eax, eax
test edx, edx
mov r15d, edx
cmovle r15d, eax
xorpd xmm0, xmm0
movaps xmm1, cs:xmmword_B2890
loc_57B7B:
cmp r15, rax
jz short loc_57B9A
movss xmm2, dword ptr [r14+rax*4]
andps xmm2, xmm1
cvtss2sd xmm2, xmm2
maxsd xmm2, xmm0
inc rax
movapd xmm0, xmm2
jmp short loc_57B7B
loc_57B9A:
divsd xmm0, cs:qword_B28C0
jmp loc_57C58
loc_57BA7:
xor eax, eax
test edx, edx
mov r15d, edx
cmovle r15d, eax
xorpd xmm0, xmm0
loc_57BB6:
cmp r15, rax
jz short loc_57BD2
movss xmm1, dword ptr [r14+rax*4]
mulss xmm1, xmm1
cvtss2sd xmm1, xmm1
addsd xmm0, xmm1
inc rax
jmp short loc_57BB6
loc_57BD2:
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_57C53
sqrtsd xmm0, xmm0
jmp short loc_57C58
loc_57BE2:
cvtsi2sd xmm0, ecx
movsd [rsp+38h+var_28], xmm0
xor r12d, r12d
test edx, edx
mov r15d, edx
cmovle r15d, r12d
xorpd xmm0, xmm0
loc_57BFC:
cmp r15, r12
jz short loc_57C3E
movsd [rsp+38h+var_30], xmm0
movss xmm0, dword ptr [r14+r12*4]
andps xmm0, cs:xmmword_B2890
cvtss2sd xmm0, xmm0
movsd xmm1, [rsp+38h+var_28]
call _pow
movsd xmm1, [rsp+38h+var_30]
addsd xmm1, xmm0
movsd [rsp+38h+var_30], xmm1
movsd xmm0, [rsp+38h+var_30]
inc r12
jmp short loc_57BFC
loc_57C3E:
movsd xmm1, cs:qword_B28C8
divsd xmm1, [rsp+38h+var_28]
call _pow
jmp short loc_57C58
loc_57C53:
call _sqrt
loc_57C58:
movsd xmm1, cs:qword_B28C8
divsd xmm1, xmm0
xorpd xmm2, xmm2
cmpltsd xmm2, xmm0
andpd xmm2, xmm1
cvtsd2ss xmm0, xmm2
xor eax, eax
loc_57C77:
cmp r15, rax
jz short loc_57C90
movss xmm1, dword ptr [r14+rax*4]
mulss xmm1, xmm0
movss dword ptr [rbx+rax*4], xmm1
inc rax
jmp short loc_57C77
loc_57C90:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long common_embd_normalize(const float *a1, float *a2, int a3, int a4)
{
long long v4; // r15
__m128d v5; // xmm0
long long v6; // rax
double v7; // xmm0_8
double v8; // xmm2_8
long long v9; // rax
double v10; // xmm0_8
long long v11; // r12
double v12; // xmm0_8
float v13; // xmm0_4
long long result; // rax
double v15; // [rsp+10h] [rbp-28h]
if ( a4 == 2 )
{
v9 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v10 = 0.0;
while ( v4 != v9 )
{
v10 = v10 + (float)(a1[v9] * a1[v9]);
++v9;
}
if ( v10 < 0.0 )
v5.m128d_f64[0] = sqrt(v10);
else
v5.m128d_f64[0] = sqrt(v10);
}
else if ( a4 )
{
if ( a4 == -1 )
{
v4 = 0LL;
if ( a3 > 0 )
v4 = (unsigned int)a3;
v5.m128d_f64[0] = 1.0;
}
else
{
v15 = (double)a4;
v11 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v12 = 0.0;
while ( v4 != v11 )
v12 = v12 + pow(fabs(a1[v11++]), v15);
v5.m128d_f64[0] = pow(v12, 1.0 / v15);
}
}
else
{
v6 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v7 = 0.0;
while ( v4 != v6 )
{
v8 = fmax(fabs(a1[v6++]), v7);
v7 = v8;
}
v5.m128d_f64[0] = v7 / 32760.0;
}
v13 = COERCE_DOUBLE(*(_OWORD *)&_mm_cmplt_sd((__m128d)0LL, v5) & COERCE_UNSIGNED_INT64(1.0 / v5.m128d_f64[0]));
for ( result = 0LL; v4 != result; ++result )
a2[result] = a1[result] * v13;
return result;
}
|
common_embd_normalize:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
CMP ECX,0x2
JZ 0x00157ba7
TEST ECX,ECX
JZ 0x00157b65
CMP ECX,-0x1
JNZ 0x00157be2
XOR R15D,R15D
TEST EDX,EDX
CMOVG R15D,EDX
MOVSD XMM0,qword ptr [0x001b28c8]
JMP 0x00157c58
LAB_00157b65:
XOR EAX,EAX
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,EAX
XORPD XMM0,XMM0
MOVAPS XMM1,xmmword ptr [0x001b2890]
LAB_00157b7b:
CMP R15,RAX
JZ 0x00157b9a
MOVSS XMM2,dword ptr [R14 + RAX*0x4]
ANDPS XMM2,XMM1
CVTSS2SD XMM2,XMM2
MAXSD XMM2,XMM0
INC RAX
MOVAPD XMM0,XMM2
JMP 0x00157b7b
LAB_00157b9a:
DIVSD XMM0,qword ptr [0x001b28c0]
JMP 0x00157c58
LAB_00157ba7:
XOR EAX,EAX
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,EAX
XORPD XMM0,XMM0
LAB_00157bb6:
CMP R15,RAX
JZ 0x00157bd2
MOVSS XMM1,dword ptr [R14 + RAX*0x4]
MULSS XMM1,XMM1
CVTSS2SD XMM1,XMM1
ADDSD XMM0,XMM1
INC RAX
JMP 0x00157bb6
LAB_00157bd2:
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x00157c53
SQRTSD XMM0,XMM0
JMP 0x00157c58
LAB_00157be2:
CVTSI2SD XMM0,ECX
MOVSD qword ptr [RSP + 0x10],XMM0
XOR R12D,R12D
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,R12D
XORPD XMM0,XMM0
LAB_00157bfc:
CMP R15,R12
JZ 0x00157c3e
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSS XMM0,dword ptr [R14 + R12*0x4]
ANDPS XMM0,xmmword ptr [0x001b2890]
CVTSS2SD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x10]
CALL 0x00123f80
MOVSD XMM1,qword ptr [RSP + 0x8]
ADDSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
MOVSD XMM0,qword ptr [RSP + 0x8]
INC R12
JMP 0x00157bfc
LAB_00157c3e:
MOVSD XMM1,qword ptr [0x001b28c8]
DIVSD XMM1,qword ptr [RSP + 0x10]
CALL 0x00123f80
JMP 0x00157c58
LAB_00157c53:
CALL 0x00123730
LAB_00157c58:
MOVSD XMM1,qword ptr [0x001b28c8]
DIVSD XMM1,XMM0
XORPD XMM2,XMM2
CMPLTSD XMM2,XMM0
ANDPD XMM2,XMM1
CVTSD2SS XMM0,XMM2
XOR EAX,EAX
LAB_00157c77:
CMP R15,RAX
JZ 0x00157c90
MOVSS XMM1,dword ptr [R14 + RAX*0x4]
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + RAX*0x4],XMM1
INC RAX
JMP 0x00157c77
LAB_00157c90:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_normalize(float const*, float*, int, int) */
void common_embd_normalize(float *param_1,float *param_2,int param_3,int param_4)
{
ulong uVar1;
ulong uVar2;
double dVar3;
double dVar4;
if (param_4 == 2) {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar3 = dVar3 + (double)(param_1[uVar1] * param_1[uVar1]);
}
if (dVar3 < 0.0) {
dVar3 = sqrt(dVar3);
}
else {
dVar3 = SQRT(dVar3);
}
}
else if (param_4 == 0) {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar4 = (double)(float)((uint)param_1[uVar1] & _DAT_001b2890);
if ((double)(float)((uint)param_1[uVar1] & _DAT_001b2890) <= dVar3) {
dVar4 = dVar3;
}
dVar3 = dVar4;
}
dVar3 = dVar3 / _DAT_001b28c0;
}
else if (param_4 == -1) {
uVar2 = 0;
dVar3 = DAT_001b28c8;
if (0 < param_3) {
uVar2 = (ulong)(uint)param_3;
}
}
else {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar4 = pow((double)(float)((uint)param_1[uVar1] & _DAT_001b2890),(double)param_4);
dVar3 = dVar3 + dVar4;
}
dVar3 = pow(dVar3,DAT_001b28c8 / (double)param_4);
}
dVar4 = DAT_001b28c8 / dVar3;
for (uVar1 = 0; uVar2 != uVar1; uVar1 = uVar1 + 1) {
param_2[uVar1] = param_1[uVar1] * (float)(double)(-(ulong)(0.0 < dVar3) & (ulong)dVar4);
}
return;
}
|
|
18,310
|
mysql_stmt_prepare_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_prepare_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_prepare,
(parms->stmt, parms->query, parms->length),
parms->stmt->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_stmt_prepare_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x38(%rax), %rcx
movq 0x480(%rcx), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x2195c
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_prepare_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+38h]
mov rcx, [rcx+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_stmt_prepare
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_prepare_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_prepare(*a1, a1[1], a1[2]);
v1[2] = result;
*v1 = 0;
return result;
}
|
mysql_stmt_prepare_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 + 0x38]
MOV RCX,qword ptr [RCX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x0012195c
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_prepare_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_prepare(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
18,311
|
lunasvg::SVGLinearGradientElement::SVGLinearGradientElement(lunasvg::Document*)
|
dmazzella[P]pylunasvg/lunasvg/source/svgpaintelement.cpp
|
SVGLinearGradientElement::SVGLinearGradientElement(Document* document)
: SVGGradientElement(document, ElementID::LinearGradient)
, m_x1(PropertyID::X1, LengthDirection::Horizontal, LengthNegativeMode::Allow, 0.f, LengthUnits::Percent)
, m_y1(PropertyID::Y1, LengthDirection::Vertical, LengthNegativeMode::Allow, 0.f, LengthUnits::Percent)
, m_x2(PropertyID::X2, LengthDirection::Horizontal, LengthNegativeMode::Allow, 100.f, LengthUnits::Percent)
, m_y2(PropertyID::Y2, LengthDirection::Vertical, LengthNegativeMode::Allow, 0.f, LengthUnits::Percent)
{
addProperty(m_x1);
addProperty(m_y1);
addProperty(m_x2);
addProperty(m_y2);
}
|
O1
|
cpp
|
lunasvg::SVGLinearGradientElement::SVGLinearGradientElement(lunasvg::Document*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x9, %edx
callq 0x1793c
leaq 0x42617(%rip), %rax # 0x5a138
movq %rax, (%rbx)
leaq 0xe8(%rbx), %r14
movq %r14, %rdi
movl $0x4c, %esi
callq 0x1f3bc
leaq 0x432d1(%rip), %rbp # 0x5ae10
addq $0x10, %rbp
movq %rbp, 0xe8(%rbx)
movw $0x0, 0xf1(%rbx)
movl $0x0, 0xf4(%rbx)
movb $0x1, 0xf8(%rbx)
leaq 0x100(%rbx), %r15
movq %r15, %rdi
movl $0x4f, %esi
callq 0x1f3bc
movq %rbp, 0x100(%rbx)
movw $0x1, 0x109(%rbx)
movl $0x0, 0x10c(%rbx)
movb $0x1, 0x110(%rbx)
leaq 0x118(%rbx), %r12
movq %r12, %rdi
movl $0x4d, %esi
callq 0x1f3bc
movq %rbp, 0x118(%rbx)
movw $0x0, 0x121(%rbx)
movl $0x42c80000, 0x124(%rbx) # imm = 0x42C80000
movb $0x1, 0x128(%rbx)
leaq 0x130(%rbx), %r13
movq %r13, %rdi
movl $0x50, %esi
callq 0x1f3bc
movq %rbp, 0x130(%rbx)
movw $0x1, 0x139(%rbx)
movl $0x0, 0x13c(%rbx)
movb $0x1, 0x140(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfbfe
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfbfe
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfbfe
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfbfe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17c46
jmp 0x17c46
jmp 0x17c46
jmp 0x17c46
movq %rax, %r14
movq %rbx, %rdi
callq 0x1927e
movq %r14, %rdi
callq 0xa5c0
nop
|
_ZN7lunasvg24SVGLinearGradientElementC2EPNS_8DocumentE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov edx, 9
call _ZN7lunasvg18SVGGradientElementC2EPNS_8DocumentENS_9ElementIDE; lunasvg::SVGGradientElement::SVGGradientElement(lunasvg::Document *,lunasvg::ElementID)
lea rax, off_5A138
mov [rbx], rax
lea r14, [rbx+0E8h]
mov rdi, r14
mov esi, 4Ch ; 'L'
call _ZN7lunasvg11SVGPropertyC2ENS_10PropertyIDE; lunasvg::SVGProperty::SVGProperty(lunasvg::PropertyID)
lea rbp, _ZTVN7lunasvg9SVGLengthE; `vtable for'lunasvg::SVGLength
add rbp, 10h
mov [rbx+0E8h], rbp
mov word ptr [rbx+0F1h], 0
mov dword ptr [rbx+0F4h], 0
mov byte ptr [rbx+0F8h], 1
lea r15, [rbx+100h]
mov rdi, r15
mov esi, 4Fh ; 'O'
call _ZN7lunasvg11SVGPropertyC2ENS_10PropertyIDE; lunasvg::SVGProperty::SVGProperty(lunasvg::PropertyID)
mov [rbx+100h], rbp
mov word ptr [rbx+109h], 1
mov dword ptr [rbx+10Ch], 0
mov byte ptr [rbx+110h], 1
lea r12, [rbx+118h]
mov rdi, r12
mov esi, 4Dh ; 'M'
call _ZN7lunasvg11SVGPropertyC2ENS_10PropertyIDE; lunasvg::SVGProperty::SVGProperty(lunasvg::PropertyID)
mov [rbx+118h], rbp
mov word ptr [rbx+121h], 0
mov dword ptr [rbx+124h], 42C80000h
mov byte ptr [rbx+128h], 1
lea r13, [rbx+130h]
mov rdi, r13
mov esi, 50h ; 'P'
call _ZN7lunasvg11SVGPropertyC2ENS_10PropertyIDE; lunasvg::SVGProperty::SVGProperty(lunasvg::PropertyID)
mov [rbx+130h], rbp
mov word ptr [rbx+139h], 1
mov dword ptr [rbx+13Ch], 0
mov byte ptr [rbx+140h], 1
mov rdi, rbx; this
mov rsi, r14; lunasvg::SVGProperty *
call _ZN7lunasvg10SVGElement11addPropertyERNS_11SVGPropertyE; lunasvg::SVGElement::addProperty(lunasvg::SVGProperty &)
mov rdi, rbx; this
mov rsi, r15; lunasvg::SVGProperty *
call _ZN7lunasvg10SVGElement11addPropertyERNS_11SVGPropertyE; lunasvg::SVGElement::addProperty(lunasvg::SVGProperty &)
mov rdi, rbx; this
mov rsi, r12; lunasvg::SVGProperty *
call _ZN7lunasvg10SVGElement11addPropertyERNS_11SVGPropertyE; lunasvg::SVGElement::addProperty(lunasvg::SVGProperty &)
mov rdi, rbx; this
mov rsi, r13; lunasvg::SVGProperty *
call _ZN7lunasvg10SVGElement11addPropertyERNS_11SVGPropertyE; lunasvg::SVGElement::addProperty(lunasvg::SVGProperty &)
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_17C46
jmp short loc_17C46
jmp short loc_17C46
jmp short $+2
loc_17C46:
mov r14, rax
mov rdi, rbx; this
call _ZN7lunasvg18SVGGradientElementD2Ev; lunasvg::SVGGradientElement::~SVGGradientElement()
mov rdi, r14
call __Unwind_Resume
|
_QWORD * lunasvg::SVGLinearGradientElement::SVGLinearGradientElement(
lunasvg::SVGLinearGradientElement *this,
lunasvg::Document *a2)
{
lunasvg::SVGGradientElement::SVGGradientElement(this, (long long)a2, 9);
*(_QWORD *)this = off_5A138;
lunasvg::SVGProperty::SVGProperty((char *)this + 232, 76LL);
*((_QWORD *)this + 29) = &`vtable for'lunasvg::SVGLength + 2;
*(_WORD *)((char *)this + 241) = 0;
*((_DWORD *)this + 61) = 0;
*((_BYTE *)this + 248) = 1;
lunasvg::SVGProperty::SVGProperty((char *)this + 256, 79LL);
*((_QWORD *)this + 32) = &`vtable for'lunasvg::SVGLength + 2;
*(_WORD *)((char *)this + 265) = 1;
*((_DWORD *)this + 67) = 0;
*((_BYTE *)this + 272) = 1;
lunasvg::SVGProperty::SVGProperty((char *)this + 280, 77LL);
*((_QWORD *)this + 35) = &`vtable for'lunasvg::SVGLength + 2;
*(_WORD *)((char *)this + 289) = 0;
*((_DWORD *)this + 73) = 1120403456;
*((_BYTE *)this + 296) = 1;
lunasvg::SVGProperty::SVGProperty((char *)this + 304, 80LL);
*((_QWORD *)this + 38) = &`vtable for'lunasvg::SVGLength + 2;
*(_WORD *)((char *)this + 313) = 1;
*((_DWORD *)this + 79) = 0;
*((_BYTE *)this + 320) = 1;
lunasvg::SVGElement::addProperty(this, (lunasvg::SVGLinearGradientElement *)((char *)this + 232));
lunasvg::SVGElement::addProperty(this, (lunasvg::SVGLinearGradientElement *)((char *)this + 256));
lunasvg::SVGElement::addProperty(this, (lunasvg::SVGLinearGradientElement *)((char *)this + 280));
return lunasvg::SVGElement::addProperty(this, (lunasvg::SVGLinearGradientElement *)((char *)this + 304));
}
|
SVGLinearGradientElement:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EDX,0x9
CALL 0x0011793c
LEA RAX,[0x15a138]
MOV qword ptr [RBX],RAX
LEA R14,[RBX + 0xe8]
LAB_00117b2b:
MOV RDI,R14
MOV ESI,0x4c
CALL 0x0011f3bc
LEA RBP,[0x15ae10]
ADD RBP,0x10
MOV qword ptr [RBX + 0xe8],RBP
MOV word ptr [RBX + 0xf1],0x0
MOV dword ptr [RBX + 0xf4],0x0
MOV byte ptr [RBX + 0xf8],0x1
LEA R15,[RBX + 0x100]
LAB_00117b6b:
MOV RDI,R15
MOV ESI,0x4f
CALL 0x0011f3bc
MOV qword ptr [RBX + 0x100],RBP
MOV word ptr [RBX + 0x109],0x1
MOV dword ptr [RBX + 0x10c],0x0
MOV byte ptr [RBX + 0x110],0x1
LEA R12,[RBX + 0x118]
LAB_00117ba0:
MOV RDI,R12
MOV ESI,0x4d
CALL 0x0011f3bc
MOV qword ptr [RBX + 0x118],RBP
MOV word ptr [RBX + 0x121],0x0
MOV dword ptr [RBX + 0x124],0x42c80000
MOV byte ptr [RBX + 0x128],0x1
LEA R13,[RBX + 0x130]
LAB_00117bd5:
MOV RDI,R13
MOV ESI,0x50
CALL 0x0011f3bc
MOV qword ptr [RBX + 0x130],RBP
MOV word ptr [RBX + 0x139],0x1
MOV dword ptr [RBX + 0x13c],0x0
MOV byte ptr [RBX + 0x140],0x1
LAB_00117c03:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010fbfe
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010fbfe
MOV RDI,RBX
MOV RSI,R12
CALL 0x0010fbfe
MOV RDI,RBX
MOV RSI,R13
CALL 0x0010fbfe
LAB_00117c2f:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* lunasvg::SVGLinearGradientElement::SVGLinearGradientElement(lunasvg::Document*) */
void __thiscall
lunasvg::SVGLinearGradientElement::SVGLinearGradientElement
(SVGLinearGradientElement *this,Document *param_1)
{
SVGGradientElement::SVGGradientElement((SVGGradientElement *)this,param_1,9);
*(int ***)this = &PTR__SVGLinearGradientElement_0015a138;
/* try { // try from 00117b2b to 00117b37 has its CatchHandler @ 00117c44 */
SVGProperty::SVGProperty((SVGProperty *)(this + 0xe8),0x4c);
*(int ***)(this + 0xe8) = &PTR__SVGProperty_0015ae20;
*(int2 *)(this + 0xf1) = 0;
*(int4 *)(this + 0xf4) = 0;
this[0xf8] = (SVGLinearGradientElement)0x1;
/* try { // try from 00117b6b to 00117b77 has its CatchHandler @ 00117c42 */
SVGProperty::SVGProperty((SVGProperty *)(this + 0x100),0x4f);
*(int ***)(this + 0x100) = &PTR__SVGProperty_0015ae20;
*(int2 *)(this + 0x109) = 1;
*(int4 *)(this + 0x10c) = 0;
this[0x110] = (SVGLinearGradientElement)0x1;
/* try { // try from 00117ba0 to 00117bac has its CatchHandler @ 00117c40 */
SVGProperty::SVGProperty((SVGProperty *)(this + 0x118),0x4d);
*(int ***)(this + 0x118) = &PTR__SVGProperty_0015ae20;
*(int2 *)(this + 0x121) = 0;
*(int4 *)(this + 0x124) = 0x42c80000;
this[0x128] = (SVGLinearGradientElement)0x1;
/* try { // try from 00117bd5 to 00117be1 has its CatchHandler @ 00117c3e */
SVGProperty::SVGProperty((SVGProperty *)(this + 0x130),0x50);
*(int ***)(this + 0x130) = &PTR__SVGProperty_0015ae20;
*(int2 *)(this + 0x139) = 1;
*(int4 *)(this + 0x13c) = 0;
this[0x140] = (SVGLinearGradientElement)0x1;
/* try { // try from 00117c03 to 00117c2e has its CatchHandler @ 00117c46 */
SVGElement::addProperty((SVGElement *)this,(SVGProperty *)(this + 0xe8));
SVGElement::addProperty((SVGElement *)this,(SVGProperty *)(this + 0x100));
SVGElement::addProperty((SVGElement *)this,(SVGProperty *)(this + 0x118));
SVGElement::addProperty((SVGElement *)this,(SVGProperty *)(this + 0x130));
return;
}
|
|
18,312
|
mysql_cset_escape_quotes
|
eloqsql/libmariadb/libmariadb/ma_charset.c
|
size_t mysql_cset_escape_quotes(const MARIADB_CHARSET_INFO *cset, char *newstr,
const char * escapestr, size_t escapestr_len )
{
const char *newstr_s = newstr;
const char *newstr_e = newstr + 2 * escapestr_len;
const char *end = escapestr + escapestr_len;
my_bool escape_overflow = FALSE;
for (;escapestr < end; escapestr++) {
unsigned int len = 0;
/* check unicode characters */
if (cset->char_maxlen > 1 && (len = cset->mb_valid(escapestr, end))) {
/* check possible overflow */
if ((newstr + len) > newstr_e) {
escape_overflow = TRUE;
break;
}
/* copy mb char without escaping it */
while (len--) {
*newstr++ = *escapestr++;
}
escapestr--;
continue;
}
if (*escapestr == '\'') {
if (newstr + 2 > newstr_e) {
escape_overflow = TRUE;
break;
}
*newstr++ = '\'';
*newstr++ = '\'';
} else {
if (newstr + 1 > newstr_e) {
escape_overflow = TRUE;
break;
}
*newstr++ = *escapestr;
}
}
*newstr = '\0';
if (escape_overflow) {
return((size_t)~0);
}
return((size_t)(newstr - newstr_s));
}
|
O0
|
c
|
mysql_cset_escape_quotes:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x5ea3c
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x34(%rax)
jbe 0x5e9b8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x48(%rbp)
cmpl $0x0, %eax
je 0x5e9b8
movq -0x18(%rbp), %rax
movl -0x48(%rbp), %ecx
addq %rcx, %rax
cmpq -0x38(%rbp), %rax
jbe 0x5e974
movb $0x1, -0x41(%rbp)
jmp 0x5ea3c
jmp 0x5e976
movl -0x48(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x48(%rbp)
cmpl $0x0, %eax
je 0x5e9aa
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x5e976
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5ea2b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x5e9fe
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x38(%rbp), %rax
jbe 0x5e9d8
movb $0x1, -0x41(%rbp)
jmp 0x5ea3c
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x27, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x27, (%rax)
jmp 0x5ea29
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x38(%rbp), %rax
jbe 0x5ea12
movb $0x1, -0x41(%rbp)
jmp 0x5ea3c
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x5ea2b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5e922
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpb $0x0, -0x41(%rbp)
je 0x5ea53
movq $-0x1, -0x8(%rbp)
jmp 0x5ea62
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
mysql_cset_escape_quotes:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
shl rcx, 1
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_40], rax
mov [rbp+var_41], 0
loc_5E922:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jnb loc_5EA3C
mov [rbp+var_48], 0
mov rax, [rbp+var_10]
cmp dword ptr [rax+34h], 1
jbe short loc_5E9B8
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_40]
call rax
mov [rbp+var_48], eax
cmp eax, 0
jz short loc_5E9B8
mov rax, [rbp+var_18]
mov ecx, [rbp+var_48]
add rax, rcx
cmp rax, [rbp+var_38]
jbe short loc_5E974
mov [rbp+var_41], 1
jmp loc_5EA3C
loc_5E974:
jmp short $+2
loc_5E976:
mov eax, [rbp+var_48]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_48], ecx
cmp eax, 0
jz short loc_5E9AA
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov cl, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
jmp short loc_5E976
loc_5E9AA:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp short loc_5EA2B
loc_5E9B8:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 27h ; '''
jnz short loc_5E9FE
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_38]
jbe short loc_5E9D8
mov [rbp+var_41], 1
jmp short loc_5EA3C
loc_5E9D8:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 27h ; '''
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 27h ; '''
jmp short loc_5EA29
loc_5E9FE:
mov rax, [rbp+var_18]
add rax, 1
cmp rax, [rbp+var_38]
jbe short loc_5EA12
mov [rbp+var_41], 1
jmp short loc_5EA3C
loc_5EA12:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
loc_5EA29:
jmp short $+2
loc_5EA2B:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_5E922
loc_5EA3C:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
cmp [rbp+var_41], 0
jz short loc_5EA53
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_5EA62
loc_5EA53:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
loc_5EA62:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
long long mysql_cset_escape_quotes(long long a1, char *a2, char *a3, long long a4)
{
char *v5; // rax
char v6; // cl
char *v7; // rax
_BYTE *v8; // rax
char *v9; // rax
int v11; // [rsp+8h] [rbp-48h]
char v12; // [rsp+Fh] [rbp-41h]
unsigned long long v13; // [rsp+10h] [rbp-40h]
unsigned long long v14; // [rsp+18h] [rbp-38h]
char *v15; // [rsp+30h] [rbp-20h]
char *v16; // [rsp+38h] [rbp-18h]
v16 = a2;
v15 = a3;
v14 = (unsigned long long)&a2[2 * a4];
v13 = (unsigned long long)&a3[a4];
v12 = 0;
while ( (unsigned long long)v15 < v13 )
{
if ( *(_DWORD *)(a1 + 52) > 1u
&& (v11 = (*(long long ( **)(char *, unsigned long long))(a1 + 64))(v15, v13)) != 0 )
{
if ( (unsigned long long)&v16[v11] > v14 )
{
v12 = 1;
break;
}
while ( v11-- )
{
v5 = v15++;
v6 = *v5;
v7 = v16++;
*v7 = v6;
}
--v15;
}
else if ( *v15 == 39 )
{
if ( (unsigned long long)(v16 + 2) > v14 )
{
v12 = 1;
break;
}
*v16 = 39;
v8 = v16 + 1;
v16 += 2;
*v8 = 39;
}
else
{
if ( (unsigned long long)(v16 + 1) > v14 )
{
v12 = 1;
break;
}
v9 = v16++;
*v9 = *v15;
}
++v15;
}
*v16 = 0;
if ( v12 )
return -1LL;
else
return v16 - a2;
}
|
mysql_cset_escape_quotes:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV byte ptr [RBP + -0x41],0x0
LAB_0015e922:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0015ea3c
MOV dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x34],0x1
JBE 0x0015e9b8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x48],EAX
CMP EAX,0x0
JZ 0x0015e9b8
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x48]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x0015e974
MOV byte ptr [RBP + -0x41],0x1
JMP 0x0015ea3c
LAB_0015e974:
JMP 0x0015e976
LAB_0015e976:
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x48],ECX
CMP EAX,0x0
JZ 0x0015e9aa
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],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
JMP 0x0015e976
LAB_0015e9aa:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015ea2b
LAB_0015e9b8:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x27
JNZ 0x0015e9fe
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x0015e9d8
MOV byte ptr [RBP + -0x41],0x1
JMP 0x0015ea3c
LAB_0015e9d8:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x27
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x27
JMP 0x0015ea29
LAB_0015e9fe:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x0015ea12
MOV byte ptr [RBP + -0x41],0x1
JMP 0x0015ea3c
LAB_0015ea12:
MOV RAX,qword ptr [RBP + -0x20]
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
LAB_0015ea29:
JMP 0x0015ea2b
LAB_0015ea2b:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015e922
LAB_0015ea3c:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
CMP byte ptr [RBP + -0x41],0x0
JZ 0x0015ea53
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0015ea62
LAB_0015ea53:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_0015ea62:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long mysql_cset_escape_quotes(long param_1,char *param_2,char *param_3,long param_4)
{
bool bVar1;
char *pcVar2;
uint local_50;
char *local_28;
char *local_20;
long local_10;
pcVar2 = param_2 + param_4 * 2;
bVar1 = false;
local_28 = param_3;
local_20 = param_2;
do {
if (param_3 + param_4 <= local_28) {
LAB_0015ea3c:
*local_20 = '\0';
if (bVar1) {
local_10 = -1;
}
else {
local_10 = (long)local_20 - (long)param_2;
}
return local_10;
}
if ((*(uint *)(param_1 + 0x34) < 2) ||
(local_50 = (**(code **)(param_1 + 0x40))(local_28,param_3 + param_4), local_50 == 0)) {
if (*local_28 == '\'') {
if (pcVar2 < local_20 + 2) {
bVar1 = true;
goto LAB_0015ea3c;
}
*local_20 = '\'';
local_20[1] = '\'';
local_20 = local_20 + 2;
}
else {
if (pcVar2 < local_20 + 1) {
bVar1 = true;
goto LAB_0015ea3c;
}
*local_20 = *local_28;
local_20 = local_20 + 1;
}
}
else {
if (pcVar2 < local_20 + local_50) {
bVar1 = true;
goto LAB_0015ea3c;
}
while (local_50 != 0) {
*local_20 = *local_28;
local_50 = local_50 - 1;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
local_28 = local_28 + -1;
}
local_28 = local_28 + 1;
} while( true );
}
|
|
18,313
|
JS_AutoInitProperty
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
JSProperty *pr, JSShapeProperty *prs)
{
JSValue val;
JSContext *realm;
JSAutoInitFunc *func;
if (js_shape_prepare_update(ctx, p, &prs))
return -1;
realm = js_autoinit_get_realm(pr);
func = js_autoinit_func_table[js_autoinit_get_id(pr)];
/* 'func' shall not modify the object properties 'pr' */
val = func(realm, p, prop, pr->u.init.opaque);
js_autoinit_free(ctx->rt, pr);
prs->flags &= ~JS_PROP_TMASK;
pr->u.value = JS_UNDEFINED;
if (JS_IsException(val))
return -1;
pr->u.value = val;
return 0;
}
|
O1
|
c
|
JS_AutoInitProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rsp, %rdx
movq %r8, (%rdx)
callq 0x2570a
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x256fd
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdi
andq $-0x4, %rdi
andl $0x3, %eax
leaq 0xa0db6(%rip), %r8 # 0xc6470
movq %r15, %rsi
movl %r14d, %edx
callq *(%r8,%rax,8)
movq %rax, %r14
movq %rdx, %r15
movq (%rbx), %rdi
andq $-0x4, %rdi
callq 0x1ee8c
movq (%rsp), %rax
andl $0x3fffffff, (%rax) # imm = 0x3FFFFFFF
movl $0x0, (%rbx)
movq $0x3, 0x8(%rbx)
cmpl $0x6, %r15d
je 0x256fd
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
JS_AutoInitProperty:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14d, edx
mov r15, rsi
mov rdx, rsp
mov [rdx], r8
call js_shape_prepare_update
mov ebp, 0FFFFFFFFh
test eax, eax
jnz short loc_256FD
mov rax, [rbx]
mov rcx, [rbx+8]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFFCh
and eax, 3
lea r8, js_autoinit_func_table
mov rsi, r15
mov edx, r14d
call ds:(js_autoinit_func_table - 0C6470h)[r8+rax*8]
mov r14, rax
mov r15, rdx
mov rdi, [rbx]
and rdi, 0FFFFFFFFFFFFFFFCh
call JS_FreeContext
mov rax, [rsp+28h+var_28]
and dword ptr [rax], 3FFFFFFFh
mov dword ptr [rbx], 0
mov qword ptr [rbx+8], 3
cmp r15d, 6
jz short loc_256FD
mov [rbx], r14
mov [rbx+8], r15
xor ebp, ebp
loc_256FD:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long JS_AutoInitProperty(long long a1, long long a2, unsigned int a3, long long *a4, _DWORD *a5)
{
unsigned int v7; // ebp
long long v8; // r14
long long v9; // rdx
long long v10; // r15
_DWORD *v12; // [rsp+0h] [rbp-28h] BYREF
v12 = a5;
v7 = -1;
if ( !(unsigned int)js_shape_prepare_update(a1, a2, &v12) )
{
v8 = ((long long ( *)(unsigned long long, long long, _QWORD, long long))js_autoinit_func_table[*a4 & 3])(
*a4 & 0xFFFFFFFFFFFFFFFCLL,
a2,
a3,
a4[1]);
v10 = v9;
JS_FreeContext((unsigned int *)(*a4 & 0xFFFFFFFFFFFFFFFCLL));
*v12 &= 0x3FFFFFFFu;
*(_DWORD *)a4 = 0;
a4[1] = 3LL;
if ( (_DWORD)v10 != 6 )
{
*a4 = v8;
a4[1] = v10;
return 0;
}
}
return v7;
}
|
JS_AutoInitProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14D,EDX
MOV R15,RSI
MOV RDX,RSP
MOV qword ptr [RDX],R8
CALL 0x0012570a
MOV EBP,0xffffffff
TEST EAX,EAX
JNZ 0x001256fd
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
MOV RDI,RAX
AND RDI,-0x4
AND EAX,0x3
LEA R8,[0x1c6470]
MOV RSI,R15
MOV EDX,R14D
CALL qword ptr [R8 + RAX*0x8]
MOV R14,RAX
MOV R15,RDX
MOV RDI,qword ptr [RBX]
AND RDI,-0x4
CALL 0x0011ee8c
MOV RAX,qword ptr [RSP]
AND dword ptr [RAX],0x3fffffff
MOV dword ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x3
CMP R15D,0x6
JZ 0x001256fd
MOV qword ptr [RBX],R14
MOV qword ptr [RBX + 0x8],R15
XOR EBP,EBP
LAB_001256fd:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8
JS_AutoInitProperty(int8 param_1,int8 param_2,int4 param_3,
int1 (*param_4) [16],uint *param_5)
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
iVar1 = js_shape_prepare_update();
uVar2 = 0xffffffff;
if (iVar1 == 0) {
auVar3 = (**(code **)(js_autoinit_func_table + (ulong)((uint)*(ulong *)*param_4 & 3) * 8))
(*(ulong *)*param_4 & 0xfffffffffffffffc,param_2,param_3,
*(int8 *)(*param_4 + 8));
JS_FreeContext(*(ulong *)*param_4 & 0xfffffffffffffffc);
*param_5 = *param_5 & 0x3fffffff;
*(int4 *)*param_4 = 0;
*(int8 *)(*param_4 + 8) = 3;
if (auVar3._8_4_ != 6) {
*param_4 = auVar3;
uVar2 = 0;
}
}
return uVar2;
}
|
|
18,314
|
JS_AutoInitProperty
|
bluesky950520[P]quickjs/quickjs.c
|
static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
JSProperty *pr, JSShapeProperty *prs)
{
JSValue val;
JSContext *realm;
JSAutoInitFunc *func;
if (js_shape_prepare_update(ctx, p, &prs))
return -1;
realm = js_autoinit_get_realm(pr);
func = js_autoinit_func_table[js_autoinit_get_id(pr)];
/* 'func' shall not modify the object properties 'pr' */
val = func(realm, p, prop, pr->u.init.opaque);
js_autoinit_free(ctx->rt, pr);
prs->flags &= ~JS_PROP_TMASK;
pr->u.value = JS_UNDEFINED;
if (JS_IsException(val))
return -1;
pr->u.value = val;
return 0;
}
|
O3
|
c
|
JS_AutoInitProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rsp, %rdx
movq %r8, (%rdx)
callq 0x25d55
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x25d48
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdi
andq $-0x4, %rdi
andl $0x3, %eax
leaq 0xa376b(%rip), %r8 # 0xc9470
movq %r15, %rsi
movl %r14d, %edx
callq *(%r8,%rax,8)
movq %rax, %r14
movq %rdx, %r15
movq (%rbx), %rdi
andq $-0x4, %rdi
callq 0x1f4a7
movq (%rsp), %rax
andl $0x3fffffff, (%rax) # imm = 0x3FFFFFFF
movl $0x0, (%rbx)
movq $0x3, 0x8(%rbx)
cmpl $0x6, %r15d
je 0x25d48
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
JS_AutoInitProperty:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14d, edx
mov r15, rsi
mov rdx, rsp
mov [rdx], r8
call js_shape_prepare_update
mov ebp, 0FFFFFFFFh
test eax, eax
jnz short loc_25D48
mov rax, [rbx]
mov rcx, [rbx+8]
mov rdi, rax
and rdi, 0FFFFFFFFFFFFFFFCh
and eax, 3
lea r8, js_autoinit_func_table
mov rsi, r15
mov edx, r14d
call ds:(js_autoinit_func_table - 0C9470h)[r8+rax*8]
mov r14, rax
mov r15, rdx
mov rdi, [rbx]
and rdi, 0FFFFFFFFFFFFFFFCh
call JS_FreeContext
mov rax, [rsp+28h+var_28]
and dword ptr [rax], 3FFFFFFFh
mov dword ptr [rbx], 0
mov qword ptr [rbx+8], 3
cmp r15d, 6
jz short loc_25D48
mov [rbx], r14
mov [rbx+8], r15
xor ebp, ebp
loc_25D48:
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long JS_AutoInitProperty(long long a1, long long a2, unsigned int a3, long long *a4, _DWORD *a5)
{
unsigned int v7; // ebp
long long v8; // r14
long long v9; // rdx
long long v10; // r15
_DWORD *v12; // [rsp+0h] [rbp-28h] BYREF
v12 = a5;
v7 = -1;
if ( !(unsigned int)js_shape_prepare_update(a1, a2, &v12) )
{
v8 = ((long long ( *)(unsigned long long, long long, _QWORD, long long))js_autoinit_func_table[*a4 & 3])(
*a4 & 0xFFFFFFFFFFFFFFFCLL,
a2,
a3,
a4[1]);
v10 = v9;
JS_FreeContext((unsigned int *)(*a4 & 0xFFFFFFFFFFFFFFFCLL));
*v12 &= 0x3FFFFFFFu;
*(_DWORD *)a4 = 0;
a4[1] = 3LL;
if ( (_DWORD)v10 != 6 )
{
*a4 = v8;
a4[1] = v10;
return 0;
}
}
return v7;
}
|
JS_AutoInitProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14D,EDX
MOV R15,RSI
MOV RDX,RSP
MOV qword ptr [RDX],R8
CALL 0x00125d55
MOV EBP,0xffffffff
TEST EAX,EAX
JNZ 0x00125d48
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
MOV RDI,RAX
AND RDI,-0x4
AND EAX,0x3
LEA R8,[0x1c9470]
MOV RSI,R15
MOV EDX,R14D
CALL qword ptr [R8 + RAX*0x8]
MOV R14,RAX
MOV R15,RDX
MOV RDI,qword ptr [RBX]
AND RDI,-0x4
CALL 0x0011f4a7
MOV RAX,qword ptr [RSP]
AND dword ptr [RAX],0x3fffffff
MOV dword ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x3
CMP R15D,0x6
JZ 0x00125d48
MOV qword ptr [RBX],R14
MOV qword ptr [RBX + 0x8],R15
XOR EBP,EBP
LAB_00125d48:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8
JS_AutoInitProperty(int8 param_1,int8 param_2,int4 param_3,
int1 (*param_4) [16],uint *param_5)
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
iVar1 = js_shape_prepare_update();
uVar2 = 0xffffffff;
if (iVar1 == 0) {
auVar3 = (**(code **)(js_autoinit_func_table + (ulong)((uint)*(ulong *)*param_4 & 3) * 8))
(*(ulong *)*param_4 & 0xfffffffffffffffc,param_2,param_3,
*(int8 *)(*param_4 + 8));
JS_FreeContext(*(ulong *)*param_4 & 0xfffffffffffffffc);
*param_5 = *param_5 & 0x3fffffff;
*(int4 *)*param_4 = 0;
*(int8 *)(*param_4 + 8) = 3;
if (auVar3._8_4_ != 6) {
*param_4 = auVar3;
uVar2 = 0;
}
}
return uVar2;
}
|
|
18,315
|
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O3
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, -0x48(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %r11d
orl $0xf, %r11d
testb $0xf, %al
cmovnel %eax, %r11d
movslq %r9d, %rdx
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x50(%rbp)
xorl %ecx, %ecx
leaq 0x2ce21c(%rip), %r13 # 0x37c310
movq %r8, %r14
xorl %r12d, %r12d
movq %rbx, -0x38(%rbp)
movl %r11d, -0x2c(%rbp)
movl $0x1, %esi
shll %cl, %esi
movq %r8, %rax
subq %r15, %rax
cmpq %rdx, %rax
jge 0xae193
movslq %ecx, %rax
movq %rax, -0x58(%rbp)
movq (%r13,%rax,8), %r9
movzbl (%r8), %eax
movzbl (%r9,%rax), %eax
testl %eax, %eax
je 0xae162
cmpl $0x2, %eax
jne 0xae1c7
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
cmpq %rdx, %rax
jge 0xae170
movzbl (%r10), %edi
cmpb $0x2, (%r9,%rdi)
jne 0xae170
incq %r10
incq %rax
movq %r10, %rdi
cmpq %rdx, %rax
jl 0xae147
jmp 0xae173
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
jmp 0xae18c
movq %r8, %rdi
cmpl $0x3, %ecx
cmovgeq %rdi, %r10
movq %r10, %rax
subq %r15, %rax
cmpq %rdx, %rax
jl 0xae248
movq %r10, %r8
cmpq %rdx, %rax
jl 0xae120
jmp 0xae196
movq %r8, %r10
cmpl $0x3, %ecx
jne 0xae1ae
xorl %r9d, %r9d
movl $0x3, %ecx
movq %r14, %rax
movq %r10, %r8
jmp 0xae2a0
testl %ecx, %ecx
movq %r15, %r8
cmoveq %r14, %r8
incl %ecx
movl $0x1, %r9d
movq %r14, %rax
jmp 0xae2a0
cmpl $0xff, %eax
jne 0xae296
movq %r12, -0x40(%rbp)
movq %r8, %r9
subq %r15, %r9
movq -0x50(%rbp), %rax
addq %r8, %rax
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
movq %rbx, %r11
shlq $0x4, %r11
leaq 0x2ce139(%rip), %rax # 0x37c330
movq (%r11,%rax), %r13
movb (%r13), %al
testb %al, %al
je 0xae234
cmpq %rdx, %r9
jge 0xae234
incq %r13
movq -0x60(%rbp), %r10
movq %r8, %r12
cmpb %al, (%r12)
jne 0xae23b
incq %r12
movb (%r13), %al
testb %al, %al
je 0xae237
incq %r13
leaq 0x1(%r10), %rdi
cmpq %rdx, %r10
movq %rdi, %r10
jl 0xae212
jmp 0xae237
movq %r8, %r12
testb %al, %al
je 0xae268
incq %rbx
cmpq $0x50, %rbx
jne 0xae1e9
movb $-0x1, %al
jmp 0xae283
movl $0x2, %r9d
cmpl $0x1, %ecx
jg 0xae1a3
movl $0x1, %edi
subl %ecx, %edi
movq %r10, %rax
movl %edi, %ecx
movq %r14, %r8
jmp 0xae2a0
leaq 0x2ce0c1(%rip), %rax # 0x37c330
addq %rax, %r11
movq 0x8(%r11), %rax
movq -0x58(%rbp), %rdi
movb (%rax,%rdi), %al
decq %r12
movq %r12, %r8
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r11d
movq -0x40(%rbp), %r12
leaq 0x2ce07a(%rip), %r13 # 0x37c310
movzbl %al, %r9d
incq %r8
movq %r14, %rax
testl %r11d, %esi
setne %r10b
cmpq %rbx, %r12
setb %dil
andb %r10b, %dil
cmpb $0x1, %dil
jne 0xae2c2
movq -0x48(%rbp), %rsi
movb %r9b, (%rsi,%r12)
incq %r12
movq %rax, %r14
testl %r9d, %r9d
jne 0xae102
testb %r11b, %r11b
sets %al
movq %rbx, %rdx
subq %r12, %rdx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xae2f7
movq -0x48(%rbp), %rdi
addq %r12, %rdi
movl $0x20, %esi
callq 0x292a0
jmp 0xae2fa
movq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov rbx, rdx
mov [rbp+var_48], rsi
mov eax, [rbp+arg_0]
mov r11d, eax
or r11d, 0Fh
test al, 0Fh
cmovnz r11d, eax
movsxd rdx, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_50], rax
xor ecx, ecx
lea r13, CZ_SORT_TABLE
mov r14, r8
xor r12d, r12d
mov [rbp+var_38], rbx
mov [rbp+var_2C], r11d
loc_AE102:
mov esi, 1
shl esi, cl
mov rax, r8
sub rax, r15
cmp rax, rdx
jge short loc_AE193
movsxd rax, ecx
mov [rbp+var_58], rax
mov r9, [r13+rax*8+0]
loc_AE120:
movzx eax, byte ptr [r8]
movzx eax, byte ptr [r9+rax]
test eax, eax
jz short loc_AE162
cmp eax, 2
jnz loc_AE1C7
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
cmp rax, rdx
jge short loc_AE170
loc_AE147:
movzx edi, byte ptr [r10]
cmp byte ptr [r9+rdi], 2
jnz short loc_AE170
inc r10
inc rax
mov rdi, r10
cmp rax, rdx
jl short loc_AE147
jmp short loc_AE173
loc_AE162:
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
jmp short loc_AE18C
loc_AE170:
mov rdi, r8
loc_AE173:
cmp ecx, 3
cmovge r10, rdi
mov rax, r10
sub rax, r15
cmp rax, rdx
jl loc_AE248
mov r8, r10
loc_AE18C:
cmp rax, rdx
jl short loc_AE120
jmp short loc_AE196
loc_AE193:
mov r10, r8
loc_AE196:
cmp ecx, 3
jnz short loc_AE1AE
xor r9d, r9d
mov ecx, 3
loc_AE1A3:
mov rax, r14
mov r8, r10
jmp loc_AE2A0
loc_AE1AE:
test ecx, ecx
mov r8, r15
cmovz r8, r14
inc ecx
mov r9d, 1
mov rax, r14
jmp loc_AE2A0
loc_AE1C7:
cmp eax, 0FFh
jnz loc_AE296
mov [rbp+var_40], r12
mov r9, r8
sub r9, r15
mov rax, [rbp+var_50]
add rax, r8
mov [rbp+var_60], rax
xor ebx, ebx
loc_AE1E9:
mov r11, rbx
shl r11, 4
lea rax, doubles
mov r13, [r11+rax]
mov al, [r13+0]
test al, al
jz short loc_AE234
cmp r9, rdx
jge short loc_AE234
inc r13
mov r10, [rbp+var_60]
mov r12, r8
loc_AE212:
cmp [r12], al
jnz short loc_AE23B
inc r12
mov al, [r13+0]
test al, al
jz short loc_AE237
inc r13
lea rdi, [r10+1]
cmp r10, rdx
mov r10, rdi
jl short loc_AE212
jmp short loc_AE237
loc_AE234:
mov r12, r8
loc_AE237:
test al, al
jz short loc_AE268
loc_AE23B:
inc rbx
cmp rbx, 50h ; 'P'
jnz short loc_AE1E9
mov al, 0FFh
jmp short loc_AE283
loc_AE248:
mov r9d, 2
cmp ecx, 1
jg loc_AE1A3
mov edi, 1
sub edi, ecx
mov rax, r10
mov ecx, edi
mov r8, r14
jmp short loc_AE2A0
loc_AE268:
lea rax, doubles
add r11, rax
mov rax, [r11+8]
mov rdi, [rbp+var_58]
mov al, [rax+rdi]
dec r12
mov r8, r12
loc_AE283:
mov rbx, [rbp+var_38]
mov r11d, [rbp+var_2C]
mov r12, [rbp+var_40]
lea r13, CZ_SORT_TABLE
loc_AE296:
movzx r9d, al
inc r8
mov rax, r14
loc_AE2A0:
test esi, r11d
setnz r10b
cmp r12, rbx
setb dil
and dil, r10b
cmp dil, 1
jnz short loc_AE2C2
mov rsi, [rbp+var_48]
mov [rsi+r12], r9b
inc r12
loc_AE2C2:
mov r14, rax
test r9d, r9d
jnz loc_AE102
test r11b, r11b
sets al
mov rdx, rbx
sub rdx, r12
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_AE2F7
mov rdi, [rbp+var_48]
add rdi, r12
mov esi, 20h ; ' '
call _memset
jmp short loc_AE2FA
loc_AE2F7:
mov rbx, r12
loc_AE2FA:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
unsigned __int8 *v7; // r15
int v9; // r11d
long long v10; // rdx
int v11; // ecx
unsigned __int8 *v12; // r14
unsigned long long v13; // r12
int v14; // esi
long long v15; // r9
int v16; // eax
unsigned __int8 *v17; // r8
long long v18; // rax
unsigned __int8 *v19; // r10
unsigned __int8 *v20; // rdi
unsigned __int8 *v21; // rax
int v22; // r9d
unsigned __int8 *v23; // rax
long long v24; // rbx
char *v25; // r13
char v26; // al
char *v27; // r13
unsigned __int8 *v28; // r10
_BYTE *v29; // r12
long long v32; // [rsp+10h] [rbp-50h]
unsigned long long v34; // [rsp+20h] [rbp-40h]
unsigned long long v35; // [rsp+28h] [rbp-38h]
int v36; // [rsp+34h] [rbp-2Ch]
v7 = a5;
v9 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v9 = a7;
v10 = a6;
v32 = 1LL - (_QWORD)a5;
v11 = 0;
v12 = a5;
v13 = 0LL;
v35 = a3;
v36 = v9;
do
{
v14 = 1 << v11;
if ( a5 - v7 >= v10 )
{
v19 = a5;
LABEL_21:
if ( v11 != 3 )
{
a5 = v7;
if ( !v11 )
a5 = v12;
++v11;
v22 = 1;
v23 = v12;
goto LABEL_45;
}
v22 = 0;
v11 = 3;
LABEL_23:
v23 = v12;
a5 = v19;
goto LABEL_45;
}
v15 = (long long)*(&CZ_SORT_TABLE + v11);
while ( 1 )
{
v16 = *(unsigned __int8 *)(v15 + *a5);
if ( !*(_BYTE *)(v15 + *a5) )
{
v21 = (unsigned __int8 *)(++a5 - v7);
v19 = a5;
goto LABEL_18;
}
if ( v16 != 2 )
break;
v17 = a5 + 1;
v18 = v17 - v7;
v19 = v17;
if ( v17 - v7 < v10 )
{
while ( *(_BYTE *)(v15 + *v19) == 2 )
{
++v19;
++v18;
v20 = v19;
if ( v18 >= v10 )
goto LABEL_14;
}
}
v20 = v17;
LABEL_14:
if ( v11 >= 3 )
v19 = v20;
v21 = (unsigned __int8 *)(v19 - v7);
if ( v19 - v7 < v10 )
{
v22 = 2;
if ( v11 <= 1 )
{
v23 = v19;
v11 = 1 - v11;
a5 = v12;
goto LABEL_45;
}
goto LABEL_23;
}
a5 = v19;
LABEL_18:
if ( (long long)v21 >= v10 )
goto LABEL_21;
}
if ( v16 != 255 )
goto LABEL_44;
v34 = v13;
v24 = 0LL;
while ( 2 )
{
v25 = (char *)*(&doubles + 2 * v24);
v26 = *v25;
if ( *v25 && a5 - v7 < v10 )
{
v27 = v25 + 1;
v28 = &a5[v32];
v29 = a5;
while ( *v29 == v26 )
{
++v29;
v26 = *v27;
if ( *v27 )
{
++v27;
if ( (long long)v28++ < v10 )
continue;
}
goto LABEL_37;
}
goto LABEL_38;
}
v29 = a5;
LABEL_37:
if ( v26 )
{
LABEL_38:
if ( ++v24 == 80 )
{
LOBYTE(v16) = -1;
goto LABEL_43;
}
continue;
}
break;
}
LOBYTE(v16) = *((_BYTE *)*(&doubles + 2 * v24 + 1) + v11);
a5 = v29 - 1;
LABEL_43:
a3 = v35;
v9 = v36;
v13 = v34;
LABEL_44:
v22 = (unsigned __int8)v16;
++a5;
v23 = v12;
LABEL_45:
if ( (v9 & v14) != 0 && v13 < a3 )
*(_BYTE *)(a2 + v13++) = v22;
v12 = v23;
}
while ( v22 );
if ( (v9 & 0x80u) == 0 || a3 <= v13 )
return v13;
memset(v13 + a2, 32LL, a3 - v13);
return a3;
}
|
my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,R8
MOV RBX,RDX
MOV qword ptr [RBP + -0x48],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV R11D,EAX
OR R11D,0xf
TEST AL,0xf
CMOVNZ R11D,EAX
MOVSXD RDX,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x50],RAX
XOR ECX,ECX
LEA R13,[0x47c310]
MOV R14,R8
XOR R12D,R12D
MOV qword ptr [RBP + -0x38],RBX
MOV dword ptr [RBP + -0x2c],R11D
LAB_001ae102:
MOV ESI,0x1
SHL ESI,CL
MOV RAX,R8
SUB RAX,R15
CMP RAX,RDX
JGE 0x001ae193
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x58],RAX
MOV R9,qword ptr [R13 + RAX*0x8]
LAB_001ae120:
MOVZX EAX,byte ptr [R8]
MOVZX EAX,byte ptr [R9 + RAX*0x1]
TEST EAX,EAX
JZ 0x001ae162
CMP EAX,0x2
JNZ 0x001ae1c7
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
CMP RAX,RDX
JGE 0x001ae170
LAB_001ae147:
MOVZX EDI,byte ptr [R10]
CMP byte ptr [R9 + RDI*0x1],0x2
JNZ 0x001ae170
INC R10
INC RAX
MOV RDI,R10
CMP RAX,RDX
JL 0x001ae147
JMP 0x001ae173
LAB_001ae162:
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
JMP 0x001ae18c
LAB_001ae170:
MOV RDI,R8
LAB_001ae173:
CMP ECX,0x3
CMOVGE R10,RDI
MOV RAX,R10
SUB RAX,R15
CMP RAX,RDX
JL 0x001ae248
MOV R8,R10
LAB_001ae18c:
CMP RAX,RDX
JL 0x001ae120
JMP 0x001ae196
LAB_001ae193:
MOV R10,R8
LAB_001ae196:
CMP ECX,0x3
JNZ 0x001ae1ae
XOR R9D,R9D
MOV ECX,0x3
LAB_001ae1a3:
MOV RAX,R14
MOV R8,R10
JMP 0x001ae2a0
LAB_001ae1ae:
TEST ECX,ECX
MOV R8,R15
CMOVZ R8,R14
INC ECX
MOV R9D,0x1
MOV RAX,R14
JMP 0x001ae2a0
LAB_001ae1c7:
CMP EAX,0xff
JNZ 0x001ae296
MOV qword ptr [RBP + -0x40],R12
MOV R9,R8
SUB R9,R15
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,R8
MOV qword ptr [RBP + -0x60],RAX
XOR EBX,EBX
LAB_001ae1e9:
MOV R11,RBX
SHL R11,0x4
LEA RAX,[0x47c330]
MOV R13,qword ptr [R11 + RAX*0x1]
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x001ae234
CMP R9,RDX
JGE 0x001ae234
INC R13
MOV R10,qword ptr [RBP + -0x60]
MOV R12,R8
LAB_001ae212:
CMP byte ptr [R12],AL
JNZ 0x001ae23b
INC R12
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x001ae237
INC R13
LEA RDI,[R10 + 0x1]
CMP R10,RDX
MOV R10,RDI
JL 0x001ae212
JMP 0x001ae237
LAB_001ae234:
MOV R12,R8
LAB_001ae237:
TEST AL,AL
JZ 0x001ae268
LAB_001ae23b:
INC RBX
CMP RBX,0x50
JNZ 0x001ae1e9
MOV AL,0xff
JMP 0x001ae283
LAB_001ae248:
MOV R9D,0x2
CMP ECX,0x1
JG 0x001ae1a3
MOV EDI,0x1
SUB EDI,ECX
MOV RAX,R10
MOV ECX,EDI
MOV R8,R14
JMP 0x001ae2a0
LAB_001ae268:
LEA RAX,[0x47c330]
ADD R11,RAX
MOV RAX,qword ptr [R11 + 0x8]
MOV RDI,qword ptr [RBP + -0x58]
MOV AL,byte ptr [RAX + RDI*0x1]
DEC R12
MOV R8,R12
LAB_001ae283:
MOV RBX,qword ptr [RBP + -0x38]
MOV R11D,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
LEA R13,[0x47c310]
LAB_001ae296:
MOVZX R9D,AL
INC R8
MOV RAX,R14
LAB_001ae2a0:
TEST ESI,R11D
SETNZ R10B
CMP R12,RBX
SETC DIL
AND DIL,R10B
CMP DIL,0x1
JNZ 0x001ae2c2
MOV RSI,qword ptr [RBP + -0x48]
MOV byte ptr [RSI + R12*0x1],R9B
INC R12
LAB_001ae2c2:
MOV R14,RAX
TEST R9D,R9D
JNZ 0x001ae102
TEST R11B,R11B
SETS AL
MOV RDX,RBX
SUB RDX,R12
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x001ae2f7
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,R12
MOV ESI,0x20
CALL 0x001292a0
JMP 0x001ae2fa
LAB_001ae2f7:
MOV RBX,R12
LAB_001ae2fa:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte bVar4;
char cVar5;
long lVar6;
byte *pbVar7;
byte bVar8;
int iVar9;
long lVar10;
byte *pbVar11;
byte *pbVar12;
byte *pbVar13;
ulong uVar14;
byte *pbVar15;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
lVar10 = (long)param_6;
iVar9 = 0;
uVar14 = 0;
pbVar13 = param_5;
pbVar15 = param_5;
LAB_001ae102:
bVar8 = (byte)iVar9;
pbVar7 = pbVar15;
if ((long)pbVar13 - (long)param_5 < lVar10) {
do {
cVar5 = (&CZ_SORT_TABLE)[iVar9][*pbVar13];
if (cVar5 == '\0') {
pbVar13 = pbVar13 + 1;
lVar6 = (long)pbVar13 - (long)param_5;
}
else {
if (cVar5 != '\x02') {
if (cVar5 != -1) goto LAB_001ae296;
lVar6 = 0;
goto LAB_001ae1e9;
}
pbVar12 = pbVar13 + 1;
lVar6 = (long)pbVar12 - (long)param_5;
pbVar13 = pbVar12;
while ((pbVar11 = pbVar13, lVar6 < lVar10 &&
(pbVar11 = pbVar12, (&CZ_SORT_TABLE)[iVar9][*pbVar13] == '\x02'))) {
pbVar13 = pbVar13 + 1;
lVar6 = lVar6 + 1;
}
if (2 < iVar9) {
pbVar13 = pbVar11;
}
lVar6 = (long)pbVar13 - (long)param_5;
if (lVar6 < lVar10) {
cVar5 = '\x02';
if (iVar9 < 2) {
iVar9 = 1 - iVar9;
pbVar7 = pbVar13;
pbVar13 = pbVar15;
}
goto LAB_001ae2a0;
}
}
} while (lVar6 < lVar10);
}
if (iVar9 == 3) {
cVar5 = '\0';
iVar9 = 3;
}
else {
pbVar13 = param_5;
if (iVar9 == 0) {
pbVar13 = pbVar15;
}
iVar9 = iVar9 + 1;
cVar5 = '\x01';
}
goto LAB_001ae2a0;
LAB_001ae1e9:
do {
pbVar15 = (&doubles)[lVar6 * 2];
bVar4 = *pbVar15;
pbVar12 = pbVar13;
pbVar3 = pbVar13 + (1 - (long)param_5);
pbVar11 = pbVar13 + -(long)param_5;
if (bVar4 != 0) {
while (pbVar2 = pbVar3, (long)pbVar11 < lVar10) {
pbVar15 = pbVar15 + 1;
if (*pbVar12 != bVar4) goto LAB_001ae23b;
pbVar12 = pbVar12 + 1;
bVar4 = *pbVar15;
if (bVar4 == 0) break;
pbVar3 = pbVar2 + 1;
pbVar11 = pbVar2;
}
}
if (bVar4 == 0) {
cVar5 = (&PTR_DAT_0047c338)[lVar6 * 2][iVar9];
pbVar13 = pbVar12 + -1;
goto LAB_001ae296;
}
LAB_001ae23b:
lVar6 = lVar6 + 1;
} while (lVar6 != 0x50);
cVar5 = -1;
LAB_001ae296:
pbVar13 = pbVar13 + 1;
LAB_001ae2a0:
if (uVar14 < param_3 && (1 << (bVar8 & 0x1f) & uVar1) != 0) {
*(char *)(param_2 + uVar14) = cVar5;
uVar14 = uVar14 + 1;
}
pbVar15 = pbVar7;
if (cVar5 == '\0') {
if ((uVar14 <= param_3 && param_3 - uVar14 != 0) && (char)uVar1 < '\0') {
memset((void *)(param_2 + uVar14),0x20,param_3 - uVar14);
uVar14 = param_3;
}
return uVar14;
}
goto LAB_001ae102;
}
|
|
18,316
|
my_hash_sort_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
void my_hash_sort_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end;
register ulong m1= *nr1, m2= *nr2;
/*
Remove end space. We have to do this to be able to compare
'AE' and 'Ä' as identical
*/
end= skip_trailing_space(key, len);
for (; key < end ; key++)
{
uint X= (uint) combo1map[(uint) *key];
MY_HASH_ADD(m1, m2, X);
if ((X= combo2map[*key]))
{
MY_HASH_ADD(m1, m2, X);
}
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f720
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x3f701
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xff3ed(%rip), %rax # 0x13ea50
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xff4a4(%rip), %rax # 0x13eb50
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x3f6ee
jmp 0x3f6ba
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movl -0x44(%rbp), %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x3f6ee
jmp 0x3f6f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3f643
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
my_hash_sort_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call skip_trailing_space_0
mov [rbp+var_30], rax
loc_3F643:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb loc_3F701
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov eax, eax
mov ecx, eax
lea rax, combo1map
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_44], eax
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov ecx, [rbp+var_44]
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_44], eax
cmp eax, 0
jz short loc_3F6EE
jmp short $+2
loc_3F6BA:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov ecx, [rbp+var_44]
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_3F6EE:
jmp short $+2
loc_3F6F0:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp loc_3F643
loc_3F701:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 50h
pop rbp
retn
|
_QWORD * my_hash_sort_latin1_de(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+10h] [rbp-40h]
long long v7; // [rsp+18h] [rbp-38h]
unsigned long long v8; // [rsp+20h] [rbp-30h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
v11 = a2;
v7 = *a4;
v6 = *a5;
v8 = skip_trailing_space_0(a2, a3);
while ( (unsigned long long)v11 < v8 )
{
v7 ^= (v7 << 8) + combo1map[*v11] * (v6 + (v7 & 0x3F));
v6 += 3LL;
if ( combo2map[*v11] )
{
v7 ^= (v7 << 8) + combo2map[*v11] * (v6 + (v7 & 0x3F));
v6 += 3LL;
}
++v11;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
|
my_hash_sort_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0013f720
MOV qword ptr [RBP + -0x30],RAX
LAB_0013f643:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0013f701
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x23ea50]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x44]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23eb50]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JZ 0x0013f6ee
JMP 0x0013f6ba
LAB_0013f6ba:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x44]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013f6ee
LAB_0013f6ee:
JMP 0x0013f6f0
LAB_0013f6f0:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0013f643
LAB_0013f701:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x50
POP RBP
RET
|
void my_hash_sort_latin1_de
(int8 param_1,byte *param_2,int8 param_3,ulong *param_4,long *param_5)
{
long lVar1;
byte *pbVar2;
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
pbVar2 = (byte *)skip_trailing_space(param_2,param_3);
for (local_18 = param_2; local_18 < pbVar2; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)(byte)combo1map[*local_18] + local_40 * 0x100
^ local_40;
lVar1 = local_48 + 3;
if ((byte)combo2map[*local_18] != 0) {
local_40 = ((local_40 & 0x3f) + local_48 + 3) * (ulong)(uint)(byte)combo2map[*local_18] +
local_40 * 0x100 ^ local_40;
lVar1 = local_48 + 6;
}
local_48 = lVar1;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
|
|
18,317
|
coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l>>)
|
AlayaLite/build_O3/_deps/libcoro-src/src/io_scheduler.cpp
|
auto io_scheduler::process_events_execute(std::chrono::milliseconds timeout) -> void
{
auto event_count = epoll_wait(m_epoll_fd, m_events.data(), m_max_events, timeout.count());
if (event_count > 0)
{
for (std::size_t i = 0; i < static_cast<std::size_t>(event_count); ++i)
{
epoll_event& event = m_events[i];
void* handle_ptr = event.data.ptr;
if (handle_ptr == m_timer_ptr)
{
// Process all events that have timed out.
process_timeout_execute();
}
else if (handle_ptr == m_schedule_ptr)
{
// Process scheduled coroutines.
process_scheduled_execute_inline();
}
else if (handle_ptr == m_shutdown_ptr) [[unlikely]]
{
// Nothing to do , just needed to wake-up and smell the flowers
}
else
{
// Individual poll task wake-up.
process_event_execute(static_cast<detail::poll_info*>(handle_ptr), event_to_poll_status(event.events));
}
}
}
// Its important to not resume any handles until the full set is accounted for. If a timeout
// and an event for the same handle happen in the same epoll_wait() call then inline processing
// will destruct the poll_info object before the second event is handled. This is also possible
// with thread pool processing, but probably has an extremely low chance of occuring due to
// the thread switch required. If m_max_events == 1 this would be unnecessary.
if (!m_handles_to_resume.empty())
{
if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)
{
for (auto& handle : m_handles_to_resume)
{
handle.resume();
}
}
else
{
m_thread_pool->resume(m_handles_to_resume);
}
m_handles_to_resume.clear();
}
}
|
O3
|
cpp
|
coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l>>):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movl 0xa8(%rdi), %edi
leaq 0x178(%rbx), %r14
movq %r14, %rsi
movl $0x10, %edx
callq 0x3140
testl %eax, %eax
jg 0x73e7
movq 0x238(%rbx), %r14
movq 0x240(%rbx), %r15
cmpq %r15, %r14
je 0x73e1
cmpl $0x1, 0xa0(%rbx)
jne 0x73b7
movq (%r14), %rdi
callq *(%rdi)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x73a7
jmp 0x73ca
leaq 0x238(%rbx), %rsi
movq 0xd0(%rbx), %rdi
callq 0x8184
movq 0x238(%rbx), %rax
cmpq %rax, 0x240(%rbx)
je 0x73e1
movq %rax, 0x240(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3554
jmp 0x738b
|
_ZN4coro12io_scheduler22process_events_executeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE:
push r15
push r14
push rbx
mov rcx, rsi
mov rbx, rdi
mov edi, [rdi+0A8h]
lea r14, [rbx+178h]
mov rsi, r14
mov edx, 10h
call _epoll_wait
test eax, eax
jg short loc_73E7
loc_738B:
mov r14, [rbx+238h]
mov r15, [rbx+240h]
cmp r14, r15
jz short loc_73E1
cmp dword ptr [rbx+0A0h], 1
jnz short loc_73B7
loc_73A7:
mov rdi, [r14]
call qword ptr [rdi]
add r14, 8
cmp r14, r15
jnz short loc_73A7
jmp short loc_73CA
loc_73B7:
lea rsi, [rbx+238h]
mov rdi, [rbx+0D0h]
call _ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_
loc_73CA:
mov rax, [rbx+238h]
cmp [rbx+240h], rax
jz short loc_73E1
mov [rbx+240h], rax
loc_73E1:
pop rbx
pop r14
pop r15
retn
loc_73E7:
mov edi, eax
mov rsi, rbx
mov rdx, r14
call _ZN4coro12io_scheduler22process_events_executeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE_cold_1; coro::io_scheduler::process_events_execute(std::chrono::duration<long,std::ratio<1l,1000l>>) [clone]
jmp short loc_738B
|
long long coro::io_scheduler::process_events_execute(long long a1, long long a2)
{
long long result; // rax
void (***v3)(void); // r14
void (***v4)(void); // r15
result = epoll_wait(*(unsigned int *)(a1 + 168), a1 + 376, 16LL, a2);
if ( (int)result > 0 )
result = coro::io_scheduler::process_events_execute(result, (coro::io_scheduler *)a1, a1 + 376);
v3 = *(void (****)(void))(a1 + 568);
v4 = *(void (****)(void))(a1 + 576);
if ( v3 != v4 )
{
if ( *(_DWORD *)(a1 + 160) == 1 )
{
do
(**v3++)();
while ( v3 != v4 );
}
else
{
ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_(
*(_QWORD *)(a1 + 208),
a1 + 568);
}
result = *(_QWORD *)(a1 + 568);
if ( *(_QWORD *)(a1 + 576) != result )
*(_QWORD *)(a1 + 576) = result;
}
return result;
}
|
process_events_execute:
PUSH R15
PUSH R14
PUSH RBX
MOV RCX,RSI
MOV RBX,RDI
MOV EDI,dword ptr [RDI + 0xa8]
LEA R14,[RBX + 0x178]
MOV RSI,R14
MOV EDX,0x10
CALL 0x00103140
TEST EAX,EAX
JG 0x001073e7
LAB_0010738b:
MOV R14,qword ptr [RBX + 0x238]
MOV R15,qword ptr [RBX + 0x240]
CMP R14,R15
JZ 0x001073e1
CMP dword ptr [RBX + 0xa0],0x1
JNZ 0x001073b7
LAB_001073a7:
MOV RDI,qword ptr [R14]
CALL qword ptr [RDI]
ADD R14,0x8
CMP R14,R15
JNZ 0x001073a7
JMP 0x001073ca
LAB_001073b7:
LEA RSI,[RBX + 0x238]
MOV RDI,qword ptr [RBX + 0xd0]
CALL 0x00108184
LAB_001073ca:
MOV RAX,qword ptr [RBX + 0x238]
CMP qword ptr [RBX + 0x240],RAX
JZ 0x001073e1
MOV qword ptr [RBX + 0x240],RAX
LAB_001073e1:
POP RBX
POP R14
POP R15
RET
LAB_001073e7:
MOV EDI,EAX
MOV RSI,RBX
MOV RDX,R14
CALL 0x00103554
JMP 0x0010738b
|
/* coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l> >)
*/
void __thiscall coro::io_scheduler::process_events_execute(io_scheduler *this,int param_2)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
iVar2 = epoll_wait(*(int *)(this + 0xa8),(epoll_event *)(this + 0x178),0x10,param_2);
if (0 < iVar2) {
process_events_execute(iVar2,this,(epoll_event *)(this + 0x178));
}
puVar3 = *(int8 **)(this + 0x238);
puVar1 = *(int8 **)(this + 0x240);
if (puVar3 != puVar1) {
if (*(int *)(this + 0xa0) == 1) {
do {
(**(code **)*puVar3)();
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
}
else {
_ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_
(*(int8 *)(this + 0xd0),this + 0x238);
}
if (*(long *)(this + 0x240) != *(long *)(this + 0x238)) {
*(long *)(this + 0x240) = *(long *)(this + 0x238);
}
}
return;
}
|
|
18,318
|
inline_mysql_file_pread
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_pread:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x2109a4(%rip), %rax # 0x2cb4e0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x6, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xbac4f
leaq 0x21095a(%rip), %rax # 0x2cb4e0
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xfce20
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xbabfa
cmpq $0x0, -0x38(%rbp)
jne 0xbabdf
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xbabea
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xbabea
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xbac27
cmpq $-0x1, -0x38(%rbp)
je 0xbac0e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xbac19
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xbac19
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x2108b2(%rip), %rax # 0x2cb4e0
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbac73
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xfce20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
|
inline_mysql_file_pread_7:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 6
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_BAC4F
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_BABFA
cmp [rbp+var_38], 0
jnz short loc_BABDF
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_BABEA
loc_BABDF:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_BABEA:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_BAC27
loc_BABFA:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_BAC0E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_BAC19
loc_BAC0E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_BAC19:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_BAC27:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_BAC73
loc_BAC4F:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_BAC73:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
|
long long inline_mysql_file_pread_7(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 6LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pread(v16, v15, v14, v13, a7);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pread(v16, v15, v14, v13, a7);
}
}
|
inline_mysql_file_pread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3cb4e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x6
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001bac4f
LEA RAX,[0x3cb4e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001fce20
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001babfa
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001babdf
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001babea
LAB_001babdf:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001babea
LAB_001babea:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001bac27
LAB_001babfa:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001bac0e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001bac19
LAB_001bac0e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001bac19
LAB_001bac19:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001bac27:
LEA RAX,[0x3cb4e0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bac73
LAB_001bac4f:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001fce20
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001bac73:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pread
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,6);
if (local_48 == 0) {
local_10 = my_pread(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pread(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
|
|
18,319
|
js_string_localeCompare
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_localeCompare(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int i, n, an, bn, cmp;
uint32_t *as, *bs, *ts;
JSValue a, b, ret;
ret = JS_EXCEPTION;
as = NULL;
bs = NULL;
a = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(a))
return JS_EXCEPTION;
b = JS_ToString(ctx, argv[0]);
if (JS_IsException(b))
goto exception;
an = to_utf32_buf(ctx, JS_VALUE_GET_STRING(a), &as);
if (an == -1)
goto exception;
bn = to_utf32_buf(ctx, JS_VALUE_GET_STRING(b), &bs);
if (bn == -1)
goto exception;
// TODO(bnoordhuis) skip normalization when input is latin1
an = unicode_normalize(&ts, as, an, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (an == -1)
goto exception;
js_free(ctx, as);
as = ts;
// TODO(bnoordhuis) skip normalization when input is latin1
bn = unicode_normalize(&ts, bs, bn, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (bn == -1)
goto exception;
js_free(ctx, bs);
bs = ts;
n = min_int(an, bn);
for (i = 0; i < n; i++)
if (as[i] != bs[i])
break;
if (i < n)
cmp = compare_u32(as[i], bs[i]);
else
cmp = compare_u32(an, bn);
ret = js_int32(cmp);
exception:
JS_FreeValue(ctx, a);
JS_FreeValue(ctx, b);
js_free(ctx, as);
js_free(ctx, bs);
return ret;
}
|
O0
|
c
|
js_string_localeCompare:
subq $0xd8, %rsp
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rdi, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq %r8, 0xa0(%rsp)
movl $0x0, 0x30(%rsp)
movq $0x6, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xc0(%rsp), %rdx
callq 0x76ac0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xdcdf3
movl $0x0, 0xc8(%rsp)
movq $0x6, 0xd0(%rsp)
jmp 0xdd0c1
movq 0xb0(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x30030
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xdce46
jmp 0xdd052
movq 0xb0(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0xdde80
movl %eax, 0x94(%rsp)
cmpl $-0x1, 0x94(%rsp)
jne 0xdce76
jmp 0xdd052
movq 0xb0(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0xdde80
movl %eax, 0x90(%rsp)
cmpl $-0x1, 0x90(%rsp)
jne 0xdcea3
jmp 0xdd052
movq 0x80(%rsp), %rsi
movl 0x94(%rsp), %edx
movq 0xb0(%rsp), %r8
leaq 0x70(%rsp), %rdi
xorl %ecx, %ecx
leaq -0xb4df8(%rip), %r9 # 0x280d0
callq 0x10b270
movl %eax, 0x94(%rsp)
cmpl $-0x1, 0x94(%rsp)
jne 0xdcee3
jmp 0xdd052
movq 0xb0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x280a0
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x78(%rsp), %rsi
movl 0x90(%rsp), %edx
movq 0xb0(%rsp), %r8
leaq 0x70(%rsp), %rdi
xorl %ecx, %ecx
leaq -0xb4e57(%rip), %r9 # 0x280d0
callq 0x10b270
movl %eax, 0x90(%rsp)
cmpl $-0x1, 0x90(%rsp)
jne 0xdcf42
jmp 0xdd052
movq 0xb0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x280a0
movq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x94(%rsp), %edi
movl 0x90(%rsp), %esi
callq 0x56ff0
movl %eax, 0x98(%rsp)
movl $0x0, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
cmpl 0x98(%rsp), %eax
jge 0xdcfcf
movq 0x80(%rsp), %rax
movslq 0x9c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x78(%rsp), %rcx
movslq 0x9c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0xdcfba
jmp 0xdcfcf
jmp 0xdcfbc
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0xdcf83
movl 0x9c(%rsp), %eax
cmpl 0x98(%rsp), %eax
jge 0xdd010
movq 0x80(%rsp), %rax
movslq 0x9c(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movq 0x78(%rsp), %rax
movslq 0x9c(%rsp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x78090
movl %eax, 0x8c(%rsp)
jmp 0xdd02a
movl 0x94(%rsp), %edi
movl 0x90(%rsp), %esi
callq 0x78090
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %edi
callq 0x39fb0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0xb0(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x29f80
movq 0xb0(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x29f80
movq 0xb0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x280a0
movq 0xb0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x280a0
movq 0x40(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xc8(%rsp), %rax
movq 0xd0(%rsp), %rdx
addq $0xd8, %rsp
retq
nopl (%rax)
|
js_string_localeCompare:
sub rsp, 0D8h
mov [rsp+0D8h+var_20], rsi
mov [rsp+0D8h+var_18], rdx
mov [rsp+0D8h+var_28], rdi
mov [rsp+0D8h+var_2C], ecx
mov [rsp+0D8h+var_38], r8
mov dword ptr [rsp+0D8h+var_A8], 0
mov [rsp+0D8h+var_A0], 6
mov rax, [rsp+0D8h+var_A8]
mov [rsp+0D8h+var_98], rax
mov rax, [rsp+0D8h+var_A0]
mov [rsp+0D8h+var_90], rax
mov [rsp+0D8h+var_58], 0
mov [rsp+0D8h+var_60], 0
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_20]
mov rdx, [rsp+0D8h+var_18]
call JS_ToStringCheckObject
mov [rsp+0D8h+var_B8], rax
mov [rsp+0D8h+var_B0], rdx
mov rax, [rsp+0D8h+var_B8]
mov [rsp+0D8h+var_78], rax
mov rax, [rsp+0D8h+var_B0]
mov [rsp+0D8h+var_70], rax
mov rdi, [rsp+0D8h+var_78]
mov rsi, [rsp+0D8h+var_70]
call JS_IsException_1
cmp eax, 0
jz short loc_DCDF3
mov dword ptr [rsp+0D8h+var_10], 0
mov [rsp+0D8h+var_8], 6
jmp loc_DD0C1
loc_DCDF3:
mov rdi, [rsp+0D8h+var_28]
mov rax, [rsp+0D8h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToString
mov [rsp+0D8h+var_C8], rax
mov [rsp+0D8h+var_C0], rdx
mov rax, [rsp+0D8h+var_C8]
mov [rsp+0D8h+var_88], rax
mov rax, [rsp+0D8h+var_C0]
mov [rsp+0D8h+var_80], rax
mov rdi, [rsp+0D8h+var_88]
mov rsi, [rsp+0D8h+var_80]
call JS_IsException_1
cmp eax, 0
jz short loc_DCE46
jmp loc_DD052
loc_DCE46:
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_78]
lea rdx, [rsp+0D8h+var_58]
call to_utf32_buf
mov [rsp+0D8h+var_44], eax
cmp [rsp+0D8h+var_44], 0FFFFFFFFh
jnz short loc_DCE76
jmp loc_DD052
loc_DCE76:
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_88]
lea rdx, [rsp+0D8h+var_60]
call to_utf32_buf
mov [rsp+0D8h+var_48], eax
cmp [rsp+0D8h+var_48], 0FFFFFFFFh
jnz short loc_DCEA3
jmp loc_DD052
loc_DCEA3:
mov rsi, [rsp+0D8h+var_58]
mov edx, [rsp+0D8h+var_44]
mov r8, [rsp+0D8h+var_28]
lea rdi, [rsp+0D8h+var_68]
xor ecx, ecx
lea r9, js_realloc
call unicode_normalize
mov [rsp+0D8h+var_44], eax
cmp [rsp+0D8h+var_44], 0FFFFFFFFh
jnz short loc_DCEE3
jmp loc_DD052
loc_DCEE3:
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_58]
call js_free
mov rax, [rsp+0D8h+var_68]
mov [rsp+0D8h+var_58], rax
mov rsi, [rsp+0D8h+var_60]
mov edx, [rsp+0D8h+var_48]
mov r8, [rsp+0D8h+var_28]
lea rdi, [rsp+0D8h+var_68]
xor ecx, ecx
lea r9, js_realloc
call unicode_normalize
mov [rsp+0D8h+var_48], eax
cmp [rsp+0D8h+var_48], 0FFFFFFFFh
jnz short loc_DCF42
jmp loc_DD052
loc_DCF42:
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_60]
call js_free
mov rax, [rsp+0D8h+var_68]
mov [rsp+0D8h+var_60], rax
mov edi, [rsp+0D8h+var_44]
mov esi, [rsp+0D8h+var_48]
call min_int_1
mov [rsp+0D8h+var_40], eax
mov [rsp+0D8h+var_3C], 0
loc_DCF83:
mov eax, [rsp+0D8h+var_3C]
cmp eax, [rsp+0D8h+var_40]
jge short loc_DCFCF
mov rax, [rsp+0D8h+var_58]
movsxd rcx, [rsp+0D8h+var_3C]
mov eax, [rax+rcx*4]
mov rcx, [rsp+0D8h+var_60]
movsxd rdx, [rsp+0D8h+var_3C]
cmp eax, [rcx+rdx*4]
jz short loc_DCFBA
jmp short loc_DCFCF
loc_DCFBA:
jmp short $+2
loc_DCFBC:
mov eax, [rsp+0D8h+var_3C]
add eax, 1
mov [rsp+0D8h+var_3C], eax
jmp short loc_DCF83
loc_DCFCF:
mov eax, [rsp+0D8h+var_3C]
cmp eax, [rsp+0D8h+var_40]
jge short loc_DD010
mov rax, [rsp+0D8h+var_58]
movsxd rcx, [rsp+0D8h+var_3C]
mov edi, [rax+rcx*4]
mov rax, [rsp+0D8h+var_60]
movsxd rcx, [rsp+0D8h+var_3C]
mov esi, [rax+rcx*4]
call compare_u32
mov [rsp+0D8h+var_4C], eax
jmp short loc_DD02A
loc_DD010:
mov edi, [rsp+0D8h+var_44]
mov esi, [rsp+0D8h+var_48]
call compare_u32
mov [rsp+0D8h+var_4C], eax
loc_DD02A:
mov edi, [rsp+0D8h+var_4C]
call js_int32
mov [rsp+0D8h+var_D8], rax
mov [rsp+0D8h+var_D0], rdx
mov rax, [rsp+0D8h+var_D8]
mov [rsp+0D8h+var_98], rax
mov rax, [rsp+0D8h+var_D0]
mov [rsp+0D8h+var_90], rax
loc_DD052:
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_78]
mov rdx, [rsp+0D8h+var_70]
call JS_FreeValue
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_88]
mov rdx, [rsp+0D8h+var_80]
call JS_FreeValue
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_58]
call js_free
mov rdi, [rsp+0D8h+var_28]
mov rsi, [rsp+0D8h+var_60]
call js_free
mov rax, [rsp+0D8h+var_98]
mov [rsp+0D8h+var_10], rax
mov rax, [rsp+0D8h+var_90]
mov [rsp+0D8h+var_8], rax
loc_DD0C1:
mov rax, [rsp+0D8h+var_10]
mov rdx, [rsp+0D8h+var_8]
add rsp, 0D8h
retn
|
long long js_string_localeCompare(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // rdx
long long v19; // rdx
long long v21; // [rsp+10h] [rbp-C8h]
long long v22; // [rsp+20h] [rbp-B8h]
long long v23; // [rsp+30h] [rbp-A8h]
long long v24; // [rsp+40h] [rbp-98h]
long long v25; // [rsp+48h] [rbp-90h]
long long v26; // [rsp+58h] [rbp-80h]
long long v27; // [rsp+68h] [rbp-70h]
long long v28; // [rsp+70h] [rbp-68h] BYREF
long long v29; // [rsp+78h] [rbp-60h] BYREF
long long v30; // [rsp+80h] [rbp-58h] BYREF
int v31; // [rsp+8Ch] [rbp-4Ch]
unsigned int v32; // [rsp+90h] [rbp-48h]
unsigned int v33; // [rsp+94h] [rbp-44h]
int v34; // [rsp+98h] [rbp-40h]
int i; // [rsp+9Ch] [rbp-3Ch]
long long *v36; // [rsp+A0h] [rbp-38h]
int v37; // [rsp+ACh] [rbp-2Ch]
long long v38; // [rsp+B0h] [rbp-28h]
long long v39; // [rsp+B8h] [rbp-20h]
long long v40; // [rsp+C0h] [rbp-18h]
long long v41; // [rsp+C8h] [rbp-10h]
long long v42; // [rsp+D0h] [rbp-8h]
v39 = a2;
v40 = a3;
v38 = a1;
v37 = a4;
v36 = (long long *)a5;
LODWORD(v23) = 0;
v24 = v23;
v25 = 6LL;
v30 = 0LL;
v29 = 0LL;
v22 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v27 = v14;
if ( JS_IsException_1(v22, v14) )
{
LODWORD(v41) = 0;
v42 = 6LL;
}
else
{
v21 = JS_ToString(v38, *v36, v36[1], v15, v16, v17);
v26 = v18;
if ( !JS_IsException_1(v21, v18) )
{
v33 = to_utf32_buf(v38, v22, &v30);
if ( v33 != -1 )
{
v32 = to_utf32_buf(v38, v21, &v29);
if ( v32 != -1 )
{
v33 = unicode_normalize(&v28, v30, v33, 0LL, v38, js_realloc);
if ( v33 != -1 )
{
js_free(v38, v30);
v30 = v28;
v32 = unicode_normalize(&v28, v29, v32, 0LL, v38, js_realloc);
if ( v32 != -1 )
{
js_free(v38, v29);
v29 = v28;
v34 = min_int_1(v33, v32);
for ( i = 0; i < v34 && *(_DWORD *)(v30 + 4LL * i) == *(_DWORD *)(v29 + 4LL * i); ++i )
;
if ( i >= v34 )
v31 = compare_u32(v33, v32);
else
v31 = compare_u32(*(_DWORD *)(v30 + 4LL * i), *(_DWORD *)(v29 + 4LL * i));
v24 = js_int32(v31);
v25 = v19;
}
}
}
}
}
JS_FreeValue(v38, v22, v27);
JS_FreeValue(v38, v21, v26);
js_free(v38, v30);
js_free(v38, v29);
v41 = v24;
v42 = v25;
}
return v41;
}
|
js_string_localeCompare:
SUB RSP,0xd8
MOV qword ptr [RSP + 0xb8],RSI
MOV qword ptr [RSP + 0xc0],RDX
MOV qword ptr [RSP + 0xb0],RDI
MOV dword ptr [RSP + 0xac],ECX
MOV qword ptr [RSP + 0xa0],R8
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x6
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x80],0x0
MOV qword ptr [RSP + 0x78],0x0
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xc0]
CALL 0x00176ac0
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001dcdf3
MOV dword ptr [RSP + 0xc8],0x0
MOV qword ptr [RSP + 0xd0],0x6
JMP 0x001dd0c1
LAB_001dcdf3:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RAX,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00130030
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001dce46
JMP 0x001dd052
LAB_001dce46:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x60]
LEA RDX,[RSP + 0x80]
CALL 0x001dde80
MOV dword ptr [RSP + 0x94],EAX
CMP dword ptr [RSP + 0x94],-0x1
JNZ 0x001dce76
JMP 0x001dd052
LAB_001dce76:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x50]
LEA RDX,[RSP + 0x78]
CALL 0x001dde80
MOV dword ptr [RSP + 0x90],EAX
CMP dword ptr [RSP + 0x90],-0x1
JNZ 0x001dcea3
JMP 0x001dd052
LAB_001dcea3:
MOV RSI,qword ptr [RSP + 0x80]
MOV EDX,dword ptr [RSP + 0x94]
MOV R8,qword ptr [RSP + 0xb0]
LEA RDI,[RSP + 0x70]
XOR ECX,ECX
LEA R9,[0x1280d0]
CALL 0x0020b270
MOV dword ptr [RSP + 0x94],EAX
CMP dword ptr [RSP + 0x94],-0x1
JNZ 0x001dcee3
JMP 0x001dd052
LAB_001dcee3:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001280a0
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x80],RAX
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,dword ptr [RSP + 0x90]
MOV R8,qword ptr [RSP + 0xb0]
LEA RDI,[RSP + 0x70]
XOR ECX,ECX
LEA R9,[0x1280d0]
CALL 0x0020b270
MOV dword ptr [RSP + 0x90],EAX
CMP dword ptr [RSP + 0x90],-0x1
JNZ 0x001dcf42
JMP 0x001dd052
LAB_001dcf42:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x001280a0
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x78],RAX
MOV EDI,dword ptr [RSP + 0x94]
MOV ESI,dword ptr [RSP + 0x90]
CALL 0x00156ff0
MOV dword ptr [RSP + 0x98],EAX
MOV dword ptr [RSP + 0x9c],0x0
LAB_001dcf83:
MOV EAX,dword ptr [RSP + 0x9c]
CMP EAX,dword ptr [RSP + 0x98]
JGE 0x001dcfcf
MOV RAX,qword ptr [RSP + 0x80]
MOVSXD RCX,dword ptr [RSP + 0x9c]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV RCX,qword ptr [RSP + 0x78]
MOVSXD RDX,dword ptr [RSP + 0x9c]
CMP EAX,dword ptr [RCX + RDX*0x4]
JZ 0x001dcfba
JMP 0x001dcfcf
LAB_001dcfba:
JMP 0x001dcfbc
LAB_001dcfbc:
MOV EAX,dword ptr [RSP + 0x9c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x9c],EAX
JMP 0x001dcf83
LAB_001dcfcf:
MOV EAX,dword ptr [RSP + 0x9c]
CMP EAX,dword ptr [RSP + 0x98]
JGE 0x001dd010
MOV RAX,qword ptr [RSP + 0x80]
MOVSXD RCX,dword ptr [RSP + 0x9c]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RSP + 0x78]
MOVSXD RCX,dword ptr [RSP + 0x9c]
MOV ESI,dword ptr [RAX + RCX*0x4]
CALL 0x00178090
MOV dword ptr [RSP + 0x8c],EAX
JMP 0x001dd02a
LAB_001dd010:
MOV EDI,dword ptr [RSP + 0x94]
MOV ESI,dword ptr [RSP + 0x90]
CALL 0x00178090
MOV dword ptr [RSP + 0x8c],EAX
LAB_001dd02a:
MOV EDI,dword ptr [RSP + 0x8c]
CALL 0x00139fb0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x48],RAX
LAB_001dd052:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001280a0
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x001280a0
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xc8],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xd0],RAX
LAB_001dd0c1:
MOV RAX,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
ADD RSP,0xd8
RET
|
int1 [16]
js_string_localeCompare
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int iVar6;
int8 uVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
uint uStack_a4;
int8 local_90;
long local_68;
long local_60;
long local_58;
int4 local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
int8 uVar7;
lVar1 = (ulong)uStack_a4 << 0x20;
auVar11._8_8_ = 6;
auVar11._0_8_ = lVar1;
auVar5._8_8_ = 6;
auVar5._0_8_ = lVar1;
auVar4._8_8_ = 6;
auVar4._0_8_ = lVar1;
auVar3._8_8_ = 6;
auVar3._0_8_ = lVar1;
auVar2._8_8_ = 6;
auVar2._0_8_ = lVar1;
local_58 = 0;
local_60 = 0;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
auVar9 = JS_ToStringCheckObject(param_1,param_2,param_3);
uVar7 = auVar9._0_8_;
iVar6 = JS_IsException(uVar7,auVar9._8_8_);
if (iVar6 == 0) {
auVar10 = JS_ToString(local_28,*local_38,local_38[1]);
uVar8 = auVar10._0_8_;
iVar6 = JS_IsException(uVar8,auVar10._8_8_);
if ((((iVar6 == 0) &&
(local_44 = to_utf32_buf(local_28,uVar7,&local_58), auVar11 = auVar5, local_44 != -1)) &&
(local_48 = to_utf32_buf(local_28,uVar8,&local_60), auVar11 = auVar4, local_48 != -1)) &&
(local_44 = unicode_normalize(&local_68,local_58,local_44,0,local_28,js_realloc),
auVar11 = auVar3, local_44 != -1)) {
js_free(local_28,local_58);
local_58 = local_68;
local_48 = unicode_normalize(&local_68,local_60,local_48,0,local_28,js_realloc);
auVar11 = auVar2;
if (local_48 != -1) {
js_free(local_28,local_60);
local_60 = local_68;
local_40 = min_int(local_44,local_48);
local_3c = 0;
while ((local_3c < local_40 &&
(*(int *)(local_58 + (long)local_3c * 4) == *(int *)(local_60 + (long)local_3c * 4)))
) {
local_3c = local_3c + 1;
}
if (local_3c < local_40) {
local_4c = compare_u32(*(int4 *)(local_58 + (long)local_3c * 4),
*(int4 *)(local_60 + (long)local_3c * 4));
}
else {
local_4c = compare_u32(local_44,local_48);
}
auVar11 = js_int32(local_4c);
}
}
local_90 = auVar11._8_8_;
JS_FreeValue(local_28,uVar7,auVar9._8_8_);
JS_FreeValue(local_28,uVar8,auVar10._8_8_);
js_free(local_28,local_58);
js_free(local_28,local_60);
local_10 = auVar11._0_4_;
uStack_c = auVar11._4_4_;
local_8 = local_90;
}
else {
local_10 = 0;
local_8 = 6;
}
auVar9._4_4_ = uStack_c;
auVar9._0_4_ = local_10;
auVar9._8_8_ = local_8;
return auVar9;
}
|
|
18,320
|
js_string_localeCompare
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_localeCompare(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int i, n, an, bn, cmp;
uint32_t *as, *bs, *ts;
JSValue a, b, ret;
ret = JS_EXCEPTION;
as = NULL;
bs = NULL;
a = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(a))
return JS_EXCEPTION;
b = JS_ToString(ctx, argv[0]);
if (JS_IsException(b))
goto exception;
an = to_utf32_buf(ctx, JS_VALUE_GET_STRING(a), &as);
if (an == -1)
goto exception;
bn = to_utf32_buf(ctx, JS_VALUE_GET_STRING(b), &bs);
if (bn == -1)
goto exception;
// TODO(bnoordhuis) skip normalization when input is latin1
an = unicode_normalize(&ts, as, an, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (an == -1)
goto exception;
js_free(ctx, as);
as = ts;
// TODO(bnoordhuis) skip normalization when input is latin1
bn = unicode_normalize(&ts, bs, bn, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (bn == -1)
goto exception;
js_free(ctx, bs);
bs = ts;
n = min_int(an, bn);
for (i = 0; i < n; i++)
if (as[i] != bs[i])
break;
if (i < n)
cmp = compare_u32(as[i], bs[i]);
else
cmp = compare_u32(an, bn);
ret = js_int32(cmp);
exception:
JS_FreeValue(ctx, a);
JS_FreeValue(ctx, b);
js_free(ctx, as);
js_free(ctx, bs);
return ret;
}
|
O1
|
c
|
js_string_localeCompare:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r13
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x8(%rsp)
movq %r12, (%rsp)
callq 0x4665b
movq %rdx, %r15
movq %rax, 0x40(%rsp)
movl $0x6, %ebp
cmpl $0x6, %r15d
je 0x80f31
movq %rax, %r14
movq (%r13), %rsi
movq 0x8(%r13), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x2bb39
movq %rdx, %r13
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movl $0x6, %ebp
cmpl $0x6, %r13d
jne 0x80f46
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21922
movq 0x18(%rbx), %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0x21922
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20bf5
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x20bf5
movq %r12, %rax
movq %rbp, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x12a67
cmpl $-0x1, %eax
jne 0x80f62
xorl %r12d, %r12d
jmp 0x80ef8
movl %eax, %r12d
movq 0x38(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x12a67
cmpl $-0x1, %eax
je 0x80f5d
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
leaq -0x60356(%rip), %r9 # 0x20c34
leaq 0x20(%rsp), %rdi
movl %r12d, %edx
xorl %r12d, %r12d
movq %rsi, 0x10(%rsp)
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x9ca17
cmpl $-0x1, %eax
je 0x80ef8
movl %eax, 0x18(%rsp)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x20bf5
leaq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq (%rsp), %rsi
leaq -0x603a7(%rip), %r9 # 0x20c34
xorl %r12d, %r12d
movq %rsi, 0x28(%rsp)
movl 0x1c(%rsp), %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x9ca17
cmpl $-0x1, %eax
je 0x80ef8
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movl %eax, %ebp
callq 0x20bf5
movl %ebp, %r10d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x18(%rsp), %r8d
cmpl %ebp, %r8d
movl %ebp, %ecx
cmovll %r8d, %ecx
testl %ecx, %ecx
movq 0x10(%rsp), %r9
jle 0x81043
movl %ecx, %ecx
xorl %edx, %edx
movl (%r9,%rdx,4), %esi
movl (%rax,%rdx,4), %edi
cmpl %edi, %esi
jne 0x81046
incq %rdx
cmpq %rdx, %rcx
jne 0x81030
cmpl %r10d, %r8d
setb %al
seta %cl
movzbl %al, %eax
movzbl %cl, %r12d
subl %eax, %r12d
xorl %ebp, %ebp
jmp 0x80ef8
|
js_string_localeCompare:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, r8
mov rbx, rdi
xor r12d, r12d
mov [rsp+78h+var_70], r12
mov [rsp+78h+var_78], r12
call JS_ToStringCheckObject
mov r15, rdx
mov [rsp+78h+var_38], rax
mov ebp, 6
cmp r15d, 6
jz short loc_80F31
mov r14, rax
mov rsi, [r13+0]
mov rdx, [r13+8]
xor r12d, r12d
mov rdi, rbx
xor ecx, ecx
call JS_ToStringInternal
mov r13, rdx
mov [rsp+78h+var_48], rax
mov [rsp+78h+var_40], rax
mov ebp, 6
cmp r13d, 6
jnz short loc_80F46
loc_80EF8:
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, [rsp+78h+var_48]
mov rdx, r13
call JS_FreeValueRT
mov rsi, [rsp+78h+var_70]
mov rdi, rbx
call js_free
mov rsi, [rsp+78h+var_78]
mov rdi, rbx
call js_free
loc_80F31:
mov rax, r12
mov rdx, rbp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_80F46:
mov rsi, [rsp+78h+var_38]
lea rdx, [rsp+78h+var_70]
mov rdi, rbx
call to_utf32_buf
cmp eax, 0FFFFFFFFh
jnz short loc_80F62
loc_80F5D:
xor r12d, r12d
jmp short loc_80EF8
loc_80F62:
mov r12d, eax
mov rsi, [rsp+78h+var_40]
mov rdx, rsp
mov rdi, rbx
call to_utf32_buf
cmp eax, 0FFFFFFFFh
jz short loc_80F5D
mov [rsp+78h+var_5C], eax
mov rsi, [rsp+78h+var_70]
lea r9, js_realloc
lea rdi, [rsp+78h+var_58]
mov edx, r12d
xor r12d, r12d
mov [rsp+78h+var_68], rsi
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz loc_80EF8
mov [rsp+78h+var_60], eax
mov rdi, rbx
mov rsi, [rsp+78h+var_68]
call js_free
lea rdi, [rsp+78h+var_58]
mov rax, [rdi]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_70], rax
mov rsi, [rsp+78h+var_78]
lea r9, js_realloc
xor r12d, r12d
mov [rsp+78h+var_50], rsi
mov edx, [rsp+78h+var_5C]
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz loc_80EF8
mov rdi, rbx
mov rsi, [rsp+78h+var_50]
mov ebp, eax
call js_free
mov r10d, ebp
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_78], rax
mov r8d, [rsp+78h+var_60]
cmp r8d, ebp
mov ecx, ebp
cmovl ecx, r8d
test ecx, ecx
mov r9, [rsp+78h+var_68]
jle short loc_81043
mov ecx, ecx
xor edx, edx
loc_81030:
mov esi, [r9+rdx*4]
mov edi, [rax+rdx*4]
cmp esi, edi
jnz short loc_81046
inc rdx
cmp rcx, rdx
jnz short loc_81030
loc_81043:
cmp r8d, r10d
loc_81046:
setb al
setnbe cl
movzx eax, al
movzx r12d, cl
sub r12d, eax
xor ebp, ebp
jmp loc_80EF8
|
long long js_string_localeCompare(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v16; // r12
unsigned long long v17; // rax
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
long long v23; // r15
_DWORD *v24; // r14
_DWORD *v25; // rax
long long v26; // rdx
long long v27; // r13
unsigned int v29; // eax
unsigned int v30; // r12d
unsigned int v31; // eax
long long v32; // rdx
int v33; // eax
int v34; // eax
int v35; // ebp
int v36; // ecx
long long v37; // rdx
unsigned int v38; // esi
unsigned int v39; // edi
bool v40; // cf
bool v41; // zf
long long v42; // [rsp+0h] [rbp-78h] BYREF
long long v43; // [rsp+8h] [rbp-70h] BYREF
long long v44; // [rsp+10h] [rbp-68h]
int v45; // [rsp+18h] [rbp-60h]
unsigned int v46; // [rsp+1Ch] [rbp-5Ch]
long long v47; // [rsp+20h] [rbp-58h] BYREF
long long v48; // [rsp+28h] [rbp-50h]
_DWORD *v49; // [rsp+30h] [rbp-48h]
_DWORD *v50; // [rsp+38h] [rbp-40h]
unsigned long long v51; // [rsp+40h] [rbp-38h]
v16 = 0LL;
v43 = 0LL;
v42 = 0LL;
v17 = JS_ToStringCheckObject(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v23 = v22;
v51 = v17;
if ( (_DWORD)v22 != 6 )
{
v24 = (_DWORD *)v17;
v16 = 0LL;
v25 = (_DWORD *)JS_ToStringInternal(a1, *a5, a5[1], 0, v18, v19, a7, a8, a9, a10, v20, v21, a13, a14);
v27 = v26;
v49 = v25;
v50 = v25;
if ( (_DWORD)v26 != 6 )
{
v29 = to_utf32_buf(a1, v51, &v43);
if ( v29 == -1 || (v30 = v29, v31 = to_utf32_buf(a1, (long long)v50, &v42), v31 == -1) )
{
v16 = 0LL;
}
else
{
v46 = v31;
v32 = v30;
v16 = 0LL;
v44 = v43;
v33 = unicode_normalize(&v47, v43, v32, 0LL, a1, js_realloc);
if ( v33 != -1 )
{
v45 = v33;
js_free(a1, v44);
v44 = v47;
v43 = v47;
v16 = 0LL;
v48 = v42;
v34 = unicode_normalize(&v47, v42, v46, 0LL, a1, js_realloc);
if ( v34 != -1 )
{
v35 = v34;
js_free(a1, v48);
v42 = v47;
v36 = v35;
if ( v45 < v35 )
v36 = v45;
if ( v36 <= 0 )
{
LABEL_16:
v40 = v45 < (unsigned int)v35;
v41 = v45 == v35;
}
else
{
v37 = 0LL;
while ( 1 )
{
v38 = *(_DWORD *)(v44 + 4 * v37);
v39 = *(_DWORD *)(v47 + 4 * v37);
v40 = v38 < v39;
v41 = v38 == v39;
if ( v38 != v39 )
break;
if ( v36 == ++v37 )
goto LABEL_16;
}
}
v16 = (!v40 && !v41) - (unsigned int)v40;
}
}
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v24, v23);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v49, v27);
js_free(a1, v43);
js_free(a1, v42);
}
return v16;
}
|
js_string_localeCompare:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,R8
MOV RBX,RDI
XOR R12D,R12D
MOV qword ptr [RSP + 0x8],R12
MOV qword ptr [RSP],R12
CALL 0x0014665b
MOV R15,RDX
MOV qword ptr [RSP + 0x40],RAX
MOV EBP,0x6
CMP R15D,0x6
JZ 0x00180f31
MOV R14,RAX
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
XOR R12D,R12D
MOV RDI,RBX
XOR ECX,ECX
CALL 0x0012bb39
MOV R13,RDX
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RAX
MOV EBP,0x6
CMP R13D,0x6
JNZ 0x00180f46
LAB_00180ef8:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,R15
CALL 0x00121922
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,R13
CALL 0x00121922
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x00120bf5
MOV RSI,qword ptr [RSP]
MOV RDI,RBX
CALL 0x00120bf5
LAB_00180f31:
MOV RAX,R12
MOV RDX,RBP
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00180f46:
MOV RSI,qword ptr [RSP + 0x40]
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00112a67
CMP EAX,-0x1
JNZ 0x00180f62
LAB_00180f5d:
XOR R12D,R12D
JMP 0x00180ef8
LAB_00180f62:
MOV R12D,EAX
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,RSP
MOV RDI,RBX
CALL 0x00112a67
CMP EAX,-0x1
JZ 0x00180f5d
MOV dword ptr [RSP + 0x1c],EAX
MOV RSI,qword ptr [RSP + 0x8]
LEA R9,[0x120c34]
LEA RDI,[RSP + 0x20]
MOV EDX,R12D
XOR R12D,R12D
MOV qword ptr [RSP + 0x10],RSI
XOR ECX,ECX
MOV R8,RBX
CALL 0x0019ca17
CMP EAX,-0x1
JZ 0x00180ef8
MOV dword ptr [RSP + 0x18],EAX
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00120bf5
LEA RDI,[RSP + 0x20]
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP]
LEA R9,[0x120c34]
XOR R12D,R12D
MOV qword ptr [RSP + 0x28],RSI
MOV EDX,dword ptr [RSP + 0x1c]
XOR ECX,ECX
MOV R8,RBX
CALL 0x0019ca17
CMP EAX,-0x1
JZ 0x00180ef8
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x28]
MOV EBP,EAX
CALL 0x00120bf5
MOV R10D,EBP
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV R8D,dword ptr [RSP + 0x18]
CMP R8D,EBP
MOV ECX,EBP
CMOVL ECX,R8D
TEST ECX,ECX
MOV R9,qword ptr [RSP + 0x10]
JLE 0x00181043
MOV ECX,ECX
XOR EDX,EDX
LAB_00181030:
MOV ESI,dword ptr [R9 + RDX*0x4]
MOV EDI,dword ptr [RAX + RDX*0x4]
CMP ESI,EDI
JNZ 0x00181046
INC RDX
CMP RCX,RDX
JNZ 0x00181030
LAB_00181043:
CMP R8D,R10D
LAB_00181046:
SETC AL
SETA CL
MOVZX EAX,AL
MOVZX R12D,CL
SUB R12D,EAX
XOR EBP,EBP
JMP 0x00180ef8
|
int js_string_localeCompare(long param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
int8 *in_R8;
int iVar8;
bool bVar9;
bool bVar10;
int1 auVar11 [16];
int1 auVar12 [16];
long local_78;
long local_70;
long local_68;
uint local_60;
int local_5c;
long local_58;
long local_50;
int8 local_48;
int8 local_40;
int8 local_38;
local_70 = 0;
local_78 = 0;
auVar11 = JS_ToStringCheckObject();
if (auVar11._8_4_ == 6) {
return 0;
}
iVar8 = 0;
local_38 = auVar11._0_8_;
auVar12 = JS_ToStringInternal(param_1,*in_R8,in_R8[1],0);
local_48 = auVar12._0_8_;
local_40 = local_48;
if (auVar12._8_4_ != 6) {
iVar3 = to_utf32_buf(param_1,local_38,&local_70);
if ((iVar3 == -1) || (iVar4 = to_utf32_buf(param_1,local_40,&local_78), iVar4 == -1)) {
iVar8 = 0;
}
else {
iVar8 = 0;
local_68 = local_70;
local_5c = iVar4;
uVar5 = unicode_normalize(&local_58,local_70,iVar3,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
local_60 = uVar5;
js_free(param_1,local_68);
local_68 = local_58;
local_70 = local_58;
iVar8 = 0;
local_50 = local_78;
uVar5 = unicode_normalize(&local_58,local_78,local_5c,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
js_free(param_1,local_50);
local_78 = local_58;
uVar6 = uVar5;
if ((int)local_60 < (int)uVar5) {
uVar6 = local_60;
}
if (0 < (int)uVar6) {
uVar7 = 0;
do {
uVar1 = *(uint *)(local_68 + uVar7 * 4);
uVar2 = *(uint *)(local_58 + uVar7 * 4);
bVar9 = uVar1 < uVar2;
bVar10 = uVar1 == uVar2;
if (!bVar10) goto LAB_00181046;
uVar7 = uVar7 + 1;
} while (uVar6 != uVar7);
}
bVar9 = local_60 < uVar5;
bVar10 = local_60 == uVar5;
LAB_00181046:
iVar8 = (uint)(!bVar9 && !bVar10) - (uint)bVar9;
}
}
}
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar11._0_8_,auVar11._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_48,auVar12._8_8_);
js_free(param_1,local_70);
js_free(param_1,local_78);
return iVar8;
}
|
|
18,321
|
js_string_localeCompare
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_localeCompare(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int i, n, an, bn, cmp;
uint32_t *as, *bs, *ts;
JSValue a, b, ret;
ret = JS_EXCEPTION;
as = NULL;
bs = NULL;
a = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(a))
return JS_EXCEPTION;
b = JS_ToString(ctx, argv[0]);
if (JS_IsException(b))
goto exception;
an = to_utf32_buf(ctx, JS_VALUE_GET_STRING(a), &as);
if (an == -1)
goto exception;
bn = to_utf32_buf(ctx, JS_VALUE_GET_STRING(b), &bs);
if (bn == -1)
goto exception;
// TODO(bnoordhuis) skip normalization when input is latin1
an = unicode_normalize(&ts, as, an, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (an == -1)
goto exception;
js_free(ctx, as);
as = ts;
// TODO(bnoordhuis) skip normalization when input is latin1
bn = unicode_normalize(&ts, bs, bn, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (bn == -1)
goto exception;
js_free(ctx, bs);
bs = ts;
n = min_int(an, bn);
for (i = 0; i < n; i++)
if (as[i] != bs[i])
break;
if (i < n)
cmp = compare_u32(as[i], bs[i]);
else
cmp = compare_u32(an, bn);
ret = js_int32(cmp);
exception:
JS_FreeValue(ctx, a);
JS_FreeValue(ctx, b);
js_free(ctx, as);
js_free(ctx, bs);
return ret;
}
|
O2
|
c
|
js_string_localeCompare:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
callq 0x3de40
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x6ca31
pushq $0x6
popq %r12
xorl %r13d, %r13d
jmp 0x6cbab
movq %rax, %r13
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1ebec
movq %rax, %r14
pushq $0x6
popq %r12
xorl %ebp, %ebp
movq %rdx, 0x28(%rsp)
cmpl $0x6, %edx
movq %r13, 0x30(%rsp)
jne 0x6ca63
xorl %r13d, %r13d
jmp 0x6cb73
movq %r14, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6d3c6
cmpl $-0x1, %eax
je 0x6cb4f
movl %eax, %r14d
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x6d3c6
movq 0x10(%rsp), %rbp
cmpl $-0x1, %eax
je 0x6cb54
movl %eax, 0x1c(%rsp)
leaq -0x51c86(%rip), %r9 # 0x1ae27
leaq 0x20(%rsp), %rdi
xorl %r13d, %r13d
movq %rbp, %rsi
movl %r14d, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x832f7
cmpl $-0x1, %eax
je 0x6cb6f
movl %eax, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1ae1e
leaq 0x20(%rsp), %rdi
movq (%rdi), %rbp
movq 0x8(%rsp), %r14
leaq -0x51cca(%rip), %r9 # 0x1ae27
xorl %r13d, %r13d
movq %r14, %rsi
movl 0x1c(%rsp), %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x832f7
cmpl $-0x1, %eax
je 0x6cb6f
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %r14d
callq 0x1ae1e
movl %r14d, %r8d
movq 0x20(%rsp), %rax
movl 0x18(%rsp), %edi
cmpl %r14d, %edi
movl %r14d, %ecx
cmovll %edi, %ecx
movq %rax, 0x8(%rsp)
testl %ecx, %ecx
cmovlel %r13d, %ecx
cmpq %r13, %rcx
je 0x6cb59
movl (%rbp,%r13,4), %edx
movl (%rax,%r13,4), %esi
incq %r13
cmpl %esi, %edx
je 0x6cb38
jmp 0x6cb5c
movq 0x10(%rsp), %rbp
xorl %r13d, %r13d
jmp 0x6cb6f
cmpl %r8d, %edi
setb %al
seta %cl
movzbl %al, %eax
movzbl %cl, %r13d
subl %eax, %r13d
xorl %r12d, %r12d
movq (%rsp), %r14
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0x1bbce
movq %rbx, %rdi
movq %r14, %rsi
movq 0x28(%rsp), %rdx
callq 0x1bbce
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1ae1e
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ae1e
movq %r13, %rax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_string_localeCompare:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, r8
and [rsp+68h+var_58], 0
mov rbx, rdi
and [rsp+68h+var_60], 0
call JS_ToStringCheckObject
mov r15, rdx
cmp r15d, 6
jnz short loc_6CA31
push 6
pop r12
xor r13d, r13d
jmp loc_6CBAB
loc_6CA31:
mov r13, rax
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call JS_ToString
mov r14, rax
push 6
pop r12
xor ebp, ebp
mov [rsp+68h+var_40], rdx
cmp edx, 6
mov [rsp+68h+var_38], r13
jnz short loc_6CA63
xor r13d, r13d
jmp loc_6CB73
loc_6CA63:
mov [rsp+68h+var_68], r14
lea rdx, [rsp+68h+var_58]
mov rdi, rbx
mov rsi, r13
call to_utf32_buf
cmp eax, 0FFFFFFFFh
jz loc_6CB4F
mov r14d, eax
lea rdx, [rsp+68h+var_60]
mov rdi, rbx
mov rsi, [rsp+68h+var_68]
call to_utf32_buf
mov rbp, [rsp+68h+var_58]
cmp eax, 0FFFFFFFFh
jz loc_6CB54
mov [rsp+68h+var_4C], eax
lea r9, js_realloc
lea rdi, [rsp+68h+var_48]
xor r13d, r13d
mov rsi, rbp
mov edx, r14d
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz loc_6CB6F
mov [rsp+68h+var_50], eax
mov rdi, rbx
mov rsi, rbp
call js_free
lea rdi, [rsp+68h+var_48]
mov rbp, [rdi]
mov r14, [rsp+68h+var_60]
lea r9, js_realloc
xor r13d, r13d
mov rsi, r14
mov edx, [rsp+68h+var_4C]
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz short loc_6CB6F
mov rdi, rbx
mov rsi, r14
mov r14d, eax
call js_free
mov r8d, r14d
mov rax, [rsp+68h+var_48]
mov edi, [rsp+68h+var_50]
cmp edi, r14d
mov ecx, r14d
cmovl ecx, edi
mov [rsp+68h+var_60], rax
test ecx, ecx
cmovle ecx, r13d
loc_6CB38:
cmp rcx, r13
jz short loc_6CB59
mov edx, [rbp+r13*4+0]
mov esi, [rax+r13*4]
inc r13
cmp edx, esi
jz short loc_6CB38
jmp short loc_6CB5C
loc_6CB4F:
mov rbp, [rsp+68h+var_58]
loc_6CB54:
xor r13d, r13d
jmp short loc_6CB6F
loc_6CB59:
cmp edi, r8d
loc_6CB5C:
setb al
setnbe cl
movzx eax, al
movzx r13d, cl
sub r13d, eax
xor r12d, r12d
loc_6CB6F:
mov r14, [rsp+68h+var_68]
loc_6CB73:
mov rdi, rbx
mov rsi, [rsp+68h+var_38]
mov rdx, r15
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
mov rdx, [rsp+68h+var_40]
call JS_FreeValue
mov rdi, rbx
mov rsi, rbp
call js_free
mov rsi, [rsp+68h+var_60]
mov rdi, rbx
call js_free
loc_6CBAB:
mov rax, r13
mov rdx, r12
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_string_localeCompare(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // rax
long long v16; // rdx
long long v17; // r15
long long v18; // r13
long long v19; // r13
long long v20; // rax
long long v21; // r14
long long v22; // rbp
long long v23; // rdx
unsigned int v24; // eax
unsigned int v25; // r14d
unsigned int v26; // eax
unsigned int v27; // eax
long long v28; // r14
unsigned int v29; // eax
long long v30; // rsi
unsigned int v31; // r14d
long long v32; // rcx
unsigned int v33; // edx
unsigned int v34; // esi
bool v35; // cf
bool v36; // zf
long long v38; // [rsp+0h] [rbp-68h]
long long v39; // [rsp+8h] [rbp-60h] BYREF
long long v40; // [rsp+10h] [rbp-58h] BYREF
unsigned int v41; // [rsp+18h] [rbp-50h]
unsigned int v42; // [rsp+1Ch] [rbp-4Ch]
long long v43; // [rsp+20h] [rbp-48h] BYREF
long long v44; // [rsp+28h] [rbp-40h]
long long v45; // [rsp+30h] [rbp-38h]
v40 = 0LL;
v39 = 0LL;
v15 = JS_ToStringCheckObject(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v17 = v16;
if ( (_DWORD)v16 != 6 )
{
v19 = v15;
v20 = JS_ToString(a1, *a5, a5[1]);
v21 = v20;
v22 = 0LL;
v44 = v23;
v45 = v19;
if ( (_DWORD)v23 == 6 )
{
v18 = 0LL;
LABEL_21:
JS_FreeValue(a1, v45, v17);
JS_FreeValue(a1, v21, v44);
js_free(a1, v22);
js_free(a1, v39);
return v18;
}
v38 = v20;
v24 = to_utf32_buf(a1, v19, &v40);
if ( v24 == -1 )
{
v22 = v40;
}
else
{
v25 = v24;
v26 = to_utf32_buf(a1, v38, &v39);
v22 = v40;
if ( v26 != -1 )
{
v42 = v26;
v18 = 0LL;
v27 = unicode_normalize(&v43, v40, v25, 0LL, a1, js_realloc);
if ( v27 != -1 )
{
v41 = v27;
js_free(a1, v22);
v22 = v43;
v28 = v39;
v18 = 0LL;
v29 = unicode_normalize(&v43, v39, v42, 0LL, a1, js_realloc);
if ( v29 != -1 )
{
v30 = v28;
v31 = v29;
js_free(a1, v30);
v32 = v31;
if ( (int)v41 < (int)v31 )
v32 = v41;
v39 = v43;
if ( (int)v32 <= 0 )
v32 = 0LL;
while ( v32 != v18 )
{
v33 = *(_DWORD *)(v22 + 4 * v18);
v34 = *(_DWORD *)(v43 + 4 * v18++);
v35 = v33 < v34;
v36 = v33 == v34;
if ( v33 != v34 )
goto LABEL_19;
}
v35 = v41 < v31;
v36 = v41 == v31;
LABEL_19:
v18 = (!v35 && !v36) - (unsigned int)v35;
}
}
goto LABEL_20;
}
}
v18 = 0LL;
LABEL_20:
v21 = v38;
goto LABEL_21;
}
return 0LL;
}
|
js_string_localeCompare:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,R8
AND qword ptr [RSP + 0x10],0x0
MOV RBX,RDI
AND qword ptr [RSP + 0x8],0x0
CALL 0x0013de40
MOV R15,RDX
CMP R15D,0x6
JNZ 0x0016ca31
PUSH 0x6
POP R12
XOR R13D,R13D
JMP 0x0016cbab
LAB_0016ca31:
MOV R13,RAX
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011ebec
MOV R14,RAX
PUSH 0x6
POP R12
XOR EBP,EBP
MOV qword ptr [RSP + 0x28],RDX
CMP EDX,0x6
MOV qword ptr [RSP + 0x30],R13
JNZ 0x0016ca63
XOR R13D,R13D
JMP 0x0016cb73
LAB_0016ca63:
MOV qword ptr [RSP],R14
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R13
CALL 0x0016d3c6
CMP EAX,-0x1
JZ 0x0016cb4f
MOV R14D,EAX
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,qword ptr [RSP]
CALL 0x0016d3c6
MOV RBP,qword ptr [RSP + 0x10]
CMP EAX,-0x1
JZ 0x0016cb54
MOV dword ptr [RSP + 0x1c],EAX
LEA R9,[0x11ae27]
LEA RDI,[RSP + 0x20]
XOR R13D,R13D
MOV RSI,RBP
MOV EDX,R14D
XOR ECX,ECX
MOV R8,RBX
CALL 0x001832f7
CMP EAX,-0x1
JZ 0x0016cb6f
MOV dword ptr [RSP + 0x18],EAX
MOV RDI,RBX
MOV RSI,RBP
CALL 0x0011ae1e
LEA RDI,[RSP + 0x20]
MOV RBP,qword ptr [RDI]
MOV R14,qword ptr [RSP + 0x8]
LEA R9,[0x11ae27]
XOR R13D,R13D
MOV RSI,R14
MOV EDX,dword ptr [RSP + 0x1c]
XOR ECX,ECX
MOV R8,RBX
CALL 0x001832f7
CMP EAX,-0x1
JZ 0x0016cb6f
MOV RDI,RBX
MOV RSI,R14
MOV R14D,EAX
CALL 0x0011ae1e
MOV R8D,R14D
MOV RAX,qword ptr [RSP + 0x20]
MOV EDI,dword ptr [RSP + 0x18]
CMP EDI,R14D
MOV ECX,R14D
CMOVL ECX,EDI
MOV qword ptr [RSP + 0x8],RAX
TEST ECX,ECX
CMOVLE ECX,R13D
LAB_0016cb38:
CMP RCX,R13
JZ 0x0016cb59
MOV EDX,dword ptr [RBP + R13*0x4]
MOV ESI,dword ptr [RAX + R13*0x4]
INC R13
CMP EDX,ESI
JZ 0x0016cb38
JMP 0x0016cb5c
LAB_0016cb4f:
MOV RBP,qword ptr [RSP + 0x10]
LAB_0016cb54:
XOR R13D,R13D
JMP 0x0016cb6f
LAB_0016cb59:
CMP EDI,R8D
LAB_0016cb5c:
SETC AL
SETA CL
MOVZX EAX,AL
MOVZX R13D,CL
SUB R13D,EAX
XOR R12D,R12D
LAB_0016cb6f:
MOV R14,qword ptr [RSP]
LAB_0016cb73:
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,R15
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,RBP
CALL 0x0011ae1e
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x0011ae1e
LAB_0016cbab:
MOV RAX,R13
MOV RDX,R12
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_string_localeCompare(int8 param_1)
{
uint uVar1;
long lVar2;
int iVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
long lVar8;
int8 *in_R8;
int8 uVar9;
ulong uVar10;
bool bVar11;
bool bVar12;
int1 auVar13 [16];
int1 auVar14 [16];
long local_60;
long local_58;
uint local_50;
int local_4c;
long local_48;
int8 local_40;
int8 local_38;
local_58 = 0;
local_60 = 0;
auVar13 = JS_ToStringCheckObject();
local_38 = auVar13._0_8_;
if (auVar13._8_4_ == 6) {
uVar9 = 6;
uVar10 = 0;
}
else {
auVar14 = JS_ToString(param_1,*in_R8,in_R8[1]);
local_40 = auVar14._8_8_;
uVar9 = 6;
if (auVar14._8_4_ == 6) {
uVar10 = 0;
lVar8 = 0;
}
else {
iVar3 = to_utf32_buf(param_1,local_38,&local_58);
if ((iVar3 == -1) ||
(iVar4 = to_utf32_buf(param_1,auVar14._0_8_,&local_60), lVar8 = local_58, iVar4 == -1)) {
uVar10 = 0;
lVar8 = local_58;
}
else {
uVar10 = 0;
local_4c = iVar4;
uVar5 = unicode_normalize(&local_48,local_58,iVar3,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
local_50 = uVar5;
js_free(param_1,lVar8);
lVar8 = local_48;
lVar2 = local_60;
uVar10 = 0;
uVar5 = unicode_normalize(&local_48,local_60,local_4c,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
js_free(param_1,lVar2);
uVar6 = uVar5;
if ((int)local_50 < (int)uVar5) {
uVar6 = local_50;
}
local_60 = local_48;
uVar7 = (ulong)uVar6;
if ((int)uVar6 < 1) {
uVar7 = uVar10;
}
do {
if (uVar7 == uVar10) {
bVar11 = local_50 < uVar5;
bVar12 = local_50 == uVar5;
break;
}
uVar6 = *(uint *)(lVar8 + uVar10 * 4);
uVar1 = *(uint *)(local_48 + uVar10 * 4);
uVar10 = uVar10 + 1;
bVar11 = uVar6 < uVar1;
bVar12 = uVar6 == uVar1;
} while (bVar12);
uVar10 = (ulong)((uint)(!bVar11 && !bVar12) - (uint)bVar11);
uVar9 = 0;
}
}
}
}
JS_FreeValue(param_1,local_38,auVar13._8_8_);
JS_FreeValue(param_1,auVar14._0_8_,local_40);
js_free(param_1,lVar8);
js_free(param_1,local_60);
}
auVar13._8_8_ = uVar9;
auVar13._0_8_ = uVar10;
return auVar13;
}
|
|
18,322
|
js_string_localeCompare
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_string_localeCompare(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int i, n, an, bn, cmp;
uint32_t *as, *bs, *ts;
JSValue a, b, ret;
ret = JS_EXCEPTION;
as = NULL;
bs = NULL;
a = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(a))
return JS_EXCEPTION;
b = JS_ToString(ctx, argv[0]);
if (JS_IsException(b))
goto exception;
an = to_utf32_buf(ctx, JS_VALUE_GET_STRING(a), &as);
if (an == -1)
goto exception;
bn = to_utf32_buf(ctx, JS_VALUE_GET_STRING(b), &bs);
if (bn == -1)
goto exception;
// TODO(bnoordhuis) skip normalization when input is latin1
an = unicode_normalize(&ts, as, an, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (an == -1)
goto exception;
js_free(ctx, as);
as = ts;
// TODO(bnoordhuis) skip normalization when input is latin1
bn = unicode_normalize(&ts, bs, bn, UNICODE_NFC, ctx,
(DynBufReallocFunc *)js_realloc);
if (bn == -1)
goto exception;
js_free(ctx, bs);
bs = ts;
n = min_int(an, bn);
for (i = 0; i < n; i++)
if (as[i] != bs[i])
break;
if (i < n)
cmp = compare_u32(as[i], bs[i]);
else
cmp = compare_u32(an, bn);
ret = js_int32(cmp);
exception:
JS_FreeValue(ctx, a);
JS_FreeValue(ctx, b);
js_free(ctx, as);
js_free(ctx, bs);
return ret;
}
|
O3
|
c
|
js_string_localeCompare:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x10(%rsp)
movq %r14, 0x8(%rsp)
callq 0x48153
movq %rdx, %r13
movl $0x6, %ebp
cmpl $0x6, %r13d
je 0x83a75
movq %rax, %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x2c160
movq %rdx, %r15
movl $0x6, %ebp
cmpl $0x6, %r15d
jne 0x83a8a
movq 0x18(%rbx), %rdi
cmpl $-0x9, %r13d
jb 0x83a3e
movl (%r12), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%r12)
cmpl $0x1, %edx
jg 0x83a3e
movq %r12, %rsi
movq %r15, %r12
movq %rax, %r15
movq %r13, %rdx
callq 0x259d8
movq %r15, %rax
movq %r12, %r15
movq 0x18(%rbx), %rdi
cmpl $-0x9, %r15d
jb 0x83a5b
movl (%rax), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%rax)
cmpl $0x1, %edx
jg 0x83a5b
movq %rax, %rsi
movq %r15, %rdx
callq 0x259d8
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2148d
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2148d
movq %r14, %rax
movq %rbp, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x13114
cmpl $-0x1, %eax
jne 0x83aaf
xorl %r14d, %r14d
movq (%rsp), %rax
jmp 0x83a09
movl %eax, %r14d
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x13114
cmpl $-0x1, %eax
je 0x83aa3
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rsi
leaq -0x6260c(%rip), %r9 # 0x214cc
leaq 0x28(%rsp), %rdi
movl %r14d, %edx
xorl %r14d, %r14d
movq %rsi, 0x18(%rsp)
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x9f2dd
cmpl $-0x1, %eax
je 0x83aa6
movl %eax, 0x20(%rsp)
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x2148d
leaq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rsi
leaq -0x6265a(%rip), %r9 # 0x214cc
xorl %r14d, %r14d
movq %rsi, 0x30(%rsp)
movl 0x24(%rsp), %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x9f2dd
cmpl $-0x1, %eax
je 0x83aa6
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movl %eax, %ebp
callq 0x2148d
movl %ebp, %r10d
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %r8d
cmpl %ebp, %r8d
movl %ebp, %ecx
cmovll %r8d, %ecx
testl %ecx, %ecx
movq 0x18(%rsp), %r9
jle 0x83b8f
movl %ecx, %ecx
xorl %edx, %edx
movl (%r9,%rdx,4), %esi
movl (%rax,%rdx,4), %edi
cmpl %edi, %esi
jne 0x83b92
incq %rdx
cmpq %rdx, %rcx
jne 0x83b7c
cmpl %r10d, %r8d
setb %al
seta %cl
movzbl %al, %eax
movzbl %cl, %r14d
subl %eax, %r14d
xorl %ebp, %ebp
jmp 0x83aa6
|
js_string_localeCompare:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov rbx, rdi
xor r14d, r14d
mov [rsp+68h+var_58], r14
mov [rsp+68h+var_60], r14
call JS_ToStringCheckObject
mov r13, rdx
mov ebp, 6
cmp r13d, 6
jz loc_83A75
mov r12, rax
mov rsi, [r15]
mov rdx, [r15+8]
xor r14d, r14d
mov rdi, rbx
xor ecx, ecx
call JS_ToStringInternal
mov r15, rdx
mov ebp, 6
cmp r15d, 6
jnz loc_83A8A
loc_83A09:
mov rdi, [rbx+18h]
cmp r13d, 0FFFFFFF7h
jb short loc_83A3E
mov edx, [r12]
lea ecx, [rdx-1]
mov [r12], ecx
cmp edx, 1
jg short loc_83A3E
mov rsi, r12
mov r12, r15
mov r15, rax
mov rdx, r13
call js_free_value_rt
mov rax, r15
mov r15, r12
mov rdi, [rbx+18h]
loc_83A3E:
cmp r15d, 0FFFFFFF7h
jb short loc_83A5B
mov edx, [rax]
lea ecx, [rdx-1]
mov [rax], ecx
cmp edx, 1
jg short loc_83A5B
mov rsi, rax
mov rdx, r15
call js_free_value_rt
loc_83A5B:
mov rsi, [rsp+68h+var_58]
mov rdi, rbx
call js_free
mov rsi, [rsp+68h+var_60]
mov rdi, rbx
call js_free
loc_83A75:
mov rax, r14
mov rdx, rbp
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83A8A:
mov [rsp+68h+var_68], rax
lea rdx, [rsp+68h+var_58]
mov rdi, rbx
mov rsi, r12
call to_utf32_buf
cmp eax, 0FFFFFFFFh
jnz short loc_83AAF
loc_83AA3:
xor r14d, r14d
loc_83AA6:
mov rax, [rsp+68h+var_68]
jmp loc_83A09
loc_83AAF:
mov r14d, eax
lea rdx, [rsp+68h+var_60]
mov rdi, rbx
mov rsi, [rsp+68h+var_68]
call to_utf32_buf
cmp eax, 0FFFFFFFFh
jz short loc_83AA3
mov [rsp+68h+var_44], eax
mov rsi, [rsp+68h+var_58]
lea r9, js_realloc
lea rdi, [rsp+68h+var_40]
mov edx, r14d
xor r14d, r14d
mov [rsp+68h+var_50], rsi
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz short loc_83AA6
mov [rsp+68h+var_48], eax
mov rdi, rbx
mov rsi, [rsp+68h+var_50]
call js_free
lea rdi, [rsp+68h+var_40]
mov rax, [rdi]
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_58], rax
mov rsi, [rsp+68h+var_60]
lea r9, js_realloc
xor r14d, r14d
mov [rsp+68h+var_38], rsi
mov edx, [rsp+68h+var_44]
xor ecx, ecx
mov r8, rbx
call unicode_normalize
cmp eax, 0FFFFFFFFh
jz loc_83AA6
mov rdi, rbx
mov rsi, [rsp+68h+var_38]
mov ebp, eax
call js_free
mov r10d, ebp
mov rax, [rsp+68h+var_40]
mov [rsp+68h+var_60], rax
mov r8d, [rsp+68h+var_48]
cmp r8d, ebp
mov ecx, ebp
cmovl ecx, r8d
test ecx, ecx
mov r9, [rsp+68h+var_50]
jle short loc_83B8F
mov ecx, ecx
xor edx, edx
loc_83B7C:
mov esi, [r9+rdx*4]
mov edi, [rax+rdx*4]
cmp esi, edi
jnz short loc_83B92
inc rdx
cmp rcx, rdx
jnz short loc_83B7C
loc_83B8F:
cmp r8d, r10d
loc_83B92:
setb al
setnbe cl
movzx eax, al
movzx r14d, cl
sub r14d, eax
xor ebp, ebp
jmp loc_83AA6
|
long long js_string_localeCompare(
long long a1,
_DWORD *a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v16; // r14
unsigned long long v17; // rax
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
long long v23; // r13
int *v24; // r12
_QWORD *v25; // rax
long long v26; // r8
long long v27; // r9
long long v28; // rdx
long long v29; // r15
long long v30; // rdi
int v31; // edx
long long v32; // rcx
int *v33; // rsi
long long v34; // r12
_QWORD *v35; // r15
int v36; // edx
long long v37; // rcx
unsigned int v39; // eax
unsigned int v40; // r14d
unsigned int v41; // eax
long long v42; // rdx
unsigned int v43; // eax
int v44; // eax
int v45; // ebp
int v46; // ecx
long long v47; // rdx
unsigned int v48; // esi
unsigned int v49; // edi
bool v50; // cf
bool v51; // zf
long long v52; // [rsp+0h] [rbp-68h]
long long v53; // [rsp+8h] [rbp-60h] BYREF
long long v54; // [rsp+10h] [rbp-58h] BYREF
long long v55; // [rsp+18h] [rbp-50h]
unsigned int v56; // [rsp+20h] [rbp-48h]
unsigned int v57; // [rsp+24h] [rbp-44h]
long long v58; // [rsp+28h] [rbp-40h] BYREF
long long v59; // [rsp+30h] [rbp-38h]
v16 = 0LL;
v54 = 0LL;
v53 = 0LL;
v17 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v23 = v22;
if ( (_DWORD)v22 != 6 )
{
v24 = (int *)v17;
v16 = 0LL;
v25 = (_QWORD *)JS_ToStringInternal(
a1,
*(_DWORD **)a5,
*(_QWORD *)(a5 + 8),
0LL,
v18,
v19,
a7,
a8,
a9,
a10,
v20,
v21,
a13,
a14);
v29 = v28;
if ( (_DWORD)v28 != 6 )
{
v52 = (long long)v25;
v39 = to_utf32_buf(a1, (long long)v24, &v54);
if ( v39 == -1 || (v40 = v39, v41 = to_utf32_buf(a1, v52, &v53), v41 == -1) )
{
v16 = 0LL;
}
else
{
v57 = v41;
v42 = v40;
v16 = 0LL;
v55 = v54;
v43 = unicode_normalize(&v58, v54, v42, 0LL, a1, js_realloc);
if ( v43 != -1 )
{
v56 = v43;
js_free(a1, v55);
v55 = v58;
v54 = v58;
v16 = 0LL;
v59 = v53;
v44 = unicode_normalize(&v58, v53, v57, 0LL, a1, js_realloc);
if ( v44 != -1 )
{
v45 = v44;
js_free(a1, v59);
v53 = v58;
v26 = v56;
v46 = v45;
if ( (int)v56 < v45 )
v46 = v56;
v27 = v55;
if ( v46 <= 0 )
{
LABEL_23:
v50 = v56 < v45;
v51 = v56 == v45;
}
else
{
v47 = 0LL;
while ( 1 )
{
v48 = *(_DWORD *)(v55 + 4 * v47);
v49 = *(_DWORD *)(v58 + 4 * v47);
v50 = v48 < v49;
v51 = v48 == v49;
if ( v48 != v49 )
break;
if ( v46 == ++v47 )
goto LABEL_23;
}
}
v16 = (!v50 && !v51) - (unsigned int)v50;
}
}
}
v25 = (_QWORD *)v52;
}
v30 = *(_QWORD *)(a1 + 24);
if ( (unsigned int)v23 >= 0xFFFFFFF7 )
{
v31 = *v24;
v32 = (unsigned int)(*v24 - 1);
*v24 = v32;
if ( v31 <= 1 )
{
v33 = v24;
v34 = v29;
v35 = v25;
js_free_value_rt(v30, v33, v23, v32, v26, v27);
v25 = v35;
v29 = v34;
v30 = *(_QWORD *)(a1 + 24);
}
}
if ( (unsigned int)v29 >= 0xFFFFFFF7 )
{
v36 = *(_DWORD *)v25;
v37 = (unsigned int)(*(_DWORD *)v25 - 1);
*(_DWORD *)v25 = v37;
if ( v36 <= 1 )
js_free_value_rt(v30, v25, v29, v37, v26, v27);
}
js_free(a1, v54);
js_free(a1, v53);
}
return v16;
}
|
js_string_localeCompare:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,R8
MOV RBX,RDI
XOR R14D,R14D
MOV qword ptr [RSP + 0x10],R14
MOV qword ptr [RSP + 0x8],R14
CALL 0x00148153
MOV R13,RDX
MOV EBP,0x6
CMP R13D,0x6
JZ 0x00183a75
MOV R12,RAX
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
XOR R14D,R14D
MOV RDI,RBX
XOR ECX,ECX
CALL 0x0012c160
MOV R15,RDX
MOV EBP,0x6
CMP R15D,0x6
JNZ 0x00183a8a
LAB_00183a09:
MOV RDI,qword ptr [RBX + 0x18]
CMP R13D,-0x9
JC 0x00183a3e
MOV EDX,dword ptr [R12]
LEA ECX,[RDX + -0x1]
MOV dword ptr [R12],ECX
CMP EDX,0x1
JG 0x00183a3e
MOV RSI,R12
MOV R12,R15
MOV R15,RAX
MOV RDX,R13
CALL 0x001259d8
MOV RAX,R15
MOV R15,R12
MOV RDI,qword ptr [RBX + 0x18]
LAB_00183a3e:
CMP R15D,-0x9
JC 0x00183a5b
MOV EDX,dword ptr [RAX]
LEA ECX,[RDX + -0x1]
MOV dword ptr [RAX],ECX
CMP EDX,0x1
JG 0x00183a5b
MOV RSI,RAX
MOV RDX,R15
CALL 0x001259d8
LAB_00183a5b:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,RBX
CALL 0x0012148d
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,RBX
CALL 0x0012148d
LAB_00183a75:
MOV RAX,R14
MOV RDX,RBP
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183a8a:
MOV qword ptr [RSP],RAX
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R12
CALL 0x00113114
CMP EAX,-0x1
JNZ 0x00183aaf
LAB_00183aa3:
XOR R14D,R14D
LAB_00183aa6:
MOV RAX,qword ptr [RSP]
JMP 0x00183a09
LAB_00183aaf:
MOV R14D,EAX
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,qword ptr [RSP]
CALL 0x00113114
CMP EAX,-0x1
JZ 0x00183aa3
MOV dword ptr [RSP + 0x24],EAX
MOV RSI,qword ptr [RSP + 0x10]
LEA R9,[0x1214cc]
LEA RDI,[RSP + 0x28]
MOV EDX,R14D
XOR R14D,R14D
MOV qword ptr [RSP + 0x18],RSI
XOR ECX,ECX
MOV R8,RBX
CALL 0x0019f2dd
CMP EAX,-0x1
JZ 0x00183aa6
MOV dword ptr [RSP + 0x20],EAX
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0012148d
LEA RDI,[RSP + 0x28]
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],RAX
MOV RSI,qword ptr [RSP + 0x8]
LEA R9,[0x1214cc]
XOR R14D,R14D
MOV qword ptr [RSP + 0x30],RSI
MOV EDX,dword ptr [RSP + 0x24]
XOR ECX,ECX
MOV R8,RBX
CALL 0x0019f2dd
CMP EAX,-0x1
JZ 0x00183aa6
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x30]
MOV EBP,EAX
CALL 0x0012148d
MOV R10D,EBP
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
MOV R8D,dword ptr [RSP + 0x20]
CMP R8D,EBP
MOV ECX,EBP
CMOVL ECX,R8D
TEST ECX,ECX
MOV R9,qword ptr [RSP + 0x18]
JLE 0x00183b8f
MOV ECX,ECX
XOR EDX,EDX
LAB_00183b7c:
MOV ESI,dword ptr [R9 + RDX*0x4]
MOV EDI,dword ptr [RAX + RDX*0x4]
CMP ESI,EDI
JNZ 0x00183b92
INC RDX
CMP RCX,RDX
JNZ 0x00183b7c
LAB_00183b8f:
CMP R8D,R10D
LAB_00183b92:
SETC AL
SETA CL
MOVZX EAX,AL
MOVZX R14D,CL
SUB R14D,EAX
XOR EBP,EBP
JMP 0x00183aa6
|
int js_string_localeCompare(long param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uint uVar5;
int *piVar6;
int *piVar7;
uint uVar8;
ulong uVar9;
int8 uVar10;
int8 *in_R8;
int iVar11;
bool bVar12;
bool bVar13;
int1 auVar14 [16];
int1 auVar15 [16];
long local_60;
long local_58;
long local_50;
uint local_48;
int local_44;
long local_40;
long local_38;
iVar11 = 0;
local_58 = 0;
local_60 = 0;
auVar14 = JS_ToStringCheckObject();
piVar6 = auVar14._0_8_;
if (auVar14._8_4_ != 6) {
iVar11 = 0;
auVar15 = JS_ToStringInternal(param_1,*in_R8,in_R8[1],0);
piVar7 = auVar15._0_8_;
if (auVar15._8_4_ != 6) {
iVar3 = to_utf32_buf(param_1,piVar6,&local_58);
if ((iVar3 == -1) || (iVar4 = to_utf32_buf(param_1,piVar7,&local_60), iVar4 == -1)) {
iVar11 = 0;
}
else {
iVar11 = 0;
local_50 = local_58;
local_44 = iVar4;
uVar5 = unicode_normalize(&local_40,local_58,iVar3,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
local_48 = uVar5;
js_free(param_1,local_50);
local_50 = local_40;
local_58 = local_40;
iVar11 = 0;
local_38 = local_60;
uVar5 = unicode_normalize(&local_40,local_60,local_44,0,param_1,js_realloc);
if (uVar5 != 0xffffffff) {
js_free(param_1,local_38);
local_60 = local_40;
uVar8 = uVar5;
if ((int)local_48 < (int)uVar5) {
uVar8 = local_48;
}
if (0 < (int)uVar8) {
uVar9 = 0;
do {
uVar1 = *(uint *)(local_50 + uVar9 * 4);
uVar2 = *(uint *)(local_40 + uVar9 * 4);
bVar12 = uVar1 < uVar2;
bVar13 = uVar1 == uVar2;
if (!bVar13) goto LAB_00183b92;
uVar9 = uVar9 + 1;
} while (uVar8 != uVar9);
}
bVar12 = local_48 < uVar5;
bVar13 = local_48 == uVar5;
LAB_00183b92:
iVar11 = (uint)(!bVar12 && !bVar13) - (uint)bVar12;
}
}
}
}
uVar10 = *(int8 *)(param_1 + 0x18);
if ((0xfffffff6 < auVar14._8_4_) && (iVar3 = *piVar6, *piVar6 = iVar3 + -1, iVar3 < 2)) {
js_free_value_rt(uVar10,piVar6,auVar14._8_8_);
uVar10 = *(int8 *)(param_1 + 0x18);
}
if ((0xfffffff6 < auVar15._8_4_) && (iVar3 = *piVar7, *piVar7 = iVar3 + -1, iVar3 < 2)) {
js_free_value_rt(uVar10,piVar7,auVar15._8_8_);
}
js_free(param_1,local_58);
js_free(param_1,local_60);
}
return iVar11;
}
|
|
18,323
|
my_fill_utf8mb3_mb
|
eloqsql/strings/ctype-utf8.c
|
static void
my_fill_utf8mb3_mb(CHARSET_INFO *cs, char *str, size_t length, int fill)
{
char *end= str + length;
char buf[10];
char buflen= my_ci_native_to_mb(cs, (my_wc_t) fill, (uchar*) buf,
(uchar*) buf + sizeof(buf));
DBUG_ASSERT(buflen > 0);
for ( ; str + buflen <= end ; )
{
memcpy(str, buf, buflen);
str+= buflen;
}
for ( ; str < end; )
*str++= ' ';
}
|
O0
|
c
|
my_fill_utf8mb3_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0xd8(%rax), %rax
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
leaq -0x12(%rbp), %rdx
leaq -0x12(%rbp), %rcx
addq $0xa, %rcx
callq *%rax
movb %al, -0x41(%rbp)
jmp 0x75dad
jmp 0x75daf
movq -0x28(%rbp), %rax
movsbl -0x41(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
cmpq -0x40(%rbp), %rax
ja 0x75de9
movq -0x28(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movsbq -0x41(%rbp), %rdx
callq 0x25260
movsbl -0x41(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x75daf
jmp 0x75deb
movq -0x28(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x75e09
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x20, (%rax)
jmp 0x75deb
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x75e21
addq $0x50, %rsp
popq %rbp
retq
callq 0x25380
nopw %cs:(%rax,%rax)
|
my_fill_utf8mb3_mb:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov [rbp+var_30], rdx
mov [rbp+var_34], ecx
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rax, [rax+0B8h]
mov rax, [rax+0D8h]
mov rdi, [rbp+var_20]
movsxd rsi, [rbp+var_34]
lea rdx, [rbp+var_12]
lea rcx, [rbp+var_12]
add rcx, 0Ah
call rax
mov [rbp+var_41], al
jmp short $+2
loc_75DAD:
jmp short $+2
loc_75DAF:
mov rax, [rbp+var_28]
movsx ecx, [rbp+var_41]
movsxd rcx, ecx
add rax, rcx
cmp rax, [rbp+var_40]
ja short loc_75DE9
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_12]
movsx rdx, [rbp+var_41]
call _memcpy
movsx ecx, [rbp+var_41]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_75DAF
loc_75DE9:
jmp short $+2
loc_75DEB:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_40]
jnb short loc_75E09
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov byte ptr [rax], 20h ; ' '
jmp short loc_75DEB
loc_75E09:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_75E21
add rsp, 50h
pop rbp
retn
loc_75E21:
call ___stack_chk_fail
|
unsigned long long my_fill_utf8mb3_mb(long long a1, _BYTE *a2, long long a3, int a4)
{
_BYTE *v4; // rax
char i; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
_BYTE *v8; // [rsp+28h] [rbp-28h]
_BYTE v9[10]; // [rsp+3Eh] [rbp-12h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h] BYREF
v10 = __readfsqword(0x28u);
v8 = a2;
v7 = (unsigned long long)&a2[a3];
for ( i = (*(long long ( **)(long long, _QWORD, _BYTE *, unsigned long long *))(*(_QWORD *)(a1 + 184) + 216LL))(
a1,
a4,
v9,
&v10); (unsigned long long)&v8[i] <= v7; v8 += i )
memcpy(v8, v9, i);
while ( (unsigned long long)v8 < v7 )
{
v4 = v8++;
*v4 = 32;
}
return __readfsqword(0x28u);
}
|
my_fill_utf8mb3_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV dword ptr [RBP + -0x34],ECX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RDI,qword ptr [RBP + -0x20]
MOVSXD RSI,dword ptr [RBP + -0x34]
LEA RDX,[RBP + -0x12]
LEA RCX,[RBP + -0x12]
ADD RCX,0xa
CALL RAX
MOV byte ptr [RBP + -0x41],AL
JMP 0x00175dad
LAB_00175dad:
JMP 0x00175daf
LAB_00175daf:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RBP + -0x41]
MOVSXD RCX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x40]
JA 0x00175de9
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x12]
MOVSX RDX,byte ptr [RBP + -0x41]
CALL 0x00125260
MOVSX ECX,byte ptr [RBP + -0x41]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00175daf
LAB_00175de9:
JMP 0x00175deb
LAB_00175deb:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00175e09
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RAX],0x20
JMP 0x00175deb
LAB_00175e09:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00175e21
ADD RSP,0x50
POP RBP
RET
LAB_00175e21:
CALL 0x00125380
|
void my_fill_utf8mb3_mb(long param_1,int1 *param_2,long param_3,int param_4)
{
char cVar1;
long in_FS_OFFSET;
int1 *local_30;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
cVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xd8))(param_1,(long)param_4,local_1a,&local_10);
for (local_30 = param_2; local_30 + (int)cVar1 <= param_2 + param_3;
local_30 = local_30 + (int)cVar1) {
memcpy(local_30,local_1a,(long)cVar1);
}
while (local_30 < param_2 + param_3) {
*local_30 = 0x20;
local_30 = local_30 + 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
18,324
|
minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&)
|
monkey531[P]llama/common/minja.hpp
|
Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
}
|
O1
|
cpp
|
minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x7d843(%rip), %rax # 0xde150
addq $0x10, %rax
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
xorl %r13d, %r13d
movq %r13, 0x30(%rdi)
movups 0x10(%rsi), %xmm0
movq %r13, 0x18(%rsi)
movups %xmm0, 0x28(%rdi)
movq %r13, 0x10(%rsi)
movq %r13, 0x40(%rdi)
movups 0x20(%rsi), %xmm0
movq %r13, 0x28(%rsi)
movups %xmm0, 0x38(%rdi)
movq %r13, 0x20(%rsi)
movq %r13, 0x50(%rdi)
movups 0x30(%rsi), %xmm0
movq %r13, 0x38(%rsi)
movups %xmm0, 0x48(%rdi)
movq %r13, 0x30(%rsi)
leaq 0x58(%rdi), %r12
leaq 0x40(%rsi), %rdi
movups 0x40(%rsi), %xmm0
movups %xmm0, 0x58(%rbx)
xorl %esi, %esi
callq 0x3dcd2
movb $0x0, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %r12, %rdi
movl $0x1, %esi
callq 0x3dcd2
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x609ad
movq 0x7e5f9(%rip), %rcx # 0xdef98
cmpb $0x0, (%rcx)
je 0x609a9
incl 0x8(%rax)
jmp 0x609ad
lock
incl 0x8(%rax)
cmpq $0x0, 0x38(%rbx)
je 0x609c3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r14
movl $0x10, %edi
callq 0x18350
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dfda
leaq 0x4df9b(%rip), %rsi # 0xae98a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x248bf
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x7e5d9(%rip), %rsi # 0xdeff0
movq 0x7e552(%rip), %rdx # 0xdef70
movq %r15, %rdi
callq 0x18b30
movq %rax, %r12
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a4c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x60a4c
movq %rax, %r12
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x60a6f
movq %rax, %r12
movb $0x1, %bpl
testb %bpl, %bpl
je 0x60a7c
movq %r15, %rdi
callq 0x184f0
movq 0x70(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x60a8e
callq 0x2fde4
movq %r14, %rdi
callq 0x3dc46
movq %rbx, %rdi
callq 0x60aa6
movq %r12, %rdi
callq 0x18bb0
|
_ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
movups xmmword ptr [rdi+18h], xmm0
xor r13d, r13d
mov [rdi+30h], r13
movups xmm0, xmmword ptr [rsi+10h]
mov [rsi+18h], r13
movups xmmword ptr [rdi+28h], xmm0
mov [rsi+10h], r13
mov [rdi+40h], r13
movups xmm0, xmmword ptr [rsi+20h]
mov [rsi+28h], r13
movups xmmword ptr [rdi+38h], xmm0
mov [rsi+20h], r13
mov [rdi+50h], r13
movups xmm0, xmmword ptr [rsi+30h]
mov [rsi+38h], r13
movups xmmword ptr [rdi+48h], xmm0
mov [rsi+30h], r13
lea r12, [rdi+58h]
lea rdi, [rsi+40h]
movups xmm0, xmmword ptr [rsi+40h]
movups xmmword ptr [rbx+58h], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r15+40h], 0
mov [r15+48h], r13
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rax, [r14]
mov [rbx+68h], rax
mov rax, [r14+8]
mov [rbx+70h], rax
test rax, rax
jz short loc_609AD
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_609A9
inc dword ptr [rax+8]
jmp short loc_609AD
loc_609A9:
lock inc dword ptr [rax+8]
loc_609AD:
cmp qword ptr [rbx+38h], 0
jz short loc_609C3
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_609C3:
lea r14, [rbx+18h]
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+var_50]
mov rdi, r15
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, r15; void *
call ___cxa_throw
mov r12, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_60A4C
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_60A4C
mov r12, rax
mov bpl, 1
loc_60A4C:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_60A6F
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_60A6F
mov r12, rax
mov bpl, 1
loc_60A6F:
test bpl, bpl
jz short loc_60A7C
mov rdi, r15; void *
call ___cxa_free_exception
loc_60A7C:
mov rdi, [rbx+70h]
add rbx, 8
test rdi, rdi
jz short loc_60A8E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_60A8E:
mov rdi, r14; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
mov rdi, r12
call __Unwind_Resume
|
long long minja::Context::Context(long long a1, long long a2, _QWORD *a3)
{
__int128 v4; // xmm0
__int128 v5; // xmm0
__int128 v6; // xmm0
long long result; // rax
void *exception; // r15
_BYTE v9[16]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v10[16]; // [rsp+28h] [rbp-50h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'minja::Context + 2;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
v4 = *(_OWORD *)(a2 + 16);
*(_QWORD *)(a2 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = v4;
*(_QWORD *)(a2 + 16) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
v5 = *(_OWORD *)(a2 + 32);
*(_QWORD *)(a2 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = v5;
*(_QWORD *)(a2 + 32) = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v6 = *(_OWORD *)(a2 + 48);
*(_QWORD *)(a2 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = v6;
*(_QWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a1 + 88) = *(_OWORD *)(a2 + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a2 + 64));
*(_BYTE *)(a2 + 64) = 0;
*(_QWORD *)(a2 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 88));
*(_QWORD *)(a1 + 104) = *a3;
result = a3[1];
*(_QWORD *)(a1 + 112) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
if ( !*(_QWORD *)(a1 + 56) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v9, a1 + 24, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Context values must be an object: ", (long long)v9);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
|
Context:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x1de150]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOVUPS xmmword ptr [RDI + 0x18],XMM0
XOR R13D,R13D
MOV qword ptr [RDI + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x10]
MOV qword ptr [RSI + 0x18],R13
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RSI + 0x10],R13
MOV qword ptr [RDI + 0x40],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x20]
MOV qword ptr [RSI + 0x28],R13
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV qword ptr [RSI + 0x20],R13
MOV qword ptr [RDI + 0x50],R13
MOVUPS XMM0,xmmword ptr [RSI + 0x30]
MOV qword ptr [RSI + 0x38],R13
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RSI + 0x30],R13
LEA R12,[RDI + 0x58]
LEA RDI,[RSI + 0x40]
MOVUPS XMM0,xmmword ptr [RSI + 0x40]
MOVUPS xmmword ptr [RBX + 0x58],XMM0
XOR ESI,ESI
CALL 0x0013dcd2
MOV byte ptr [R15 + 0x40],0x0
MOV qword ptr [R15 + 0x48],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x0013dcd2
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x001609ad
MOV RCX,qword ptr [0x001def98]
CMP byte ptr [RCX],0x0
JZ 0x001609a9
INC dword ptr [RAX + 0x8]
JMP 0x001609ad
LAB_001609a9:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001609ad:
CMP qword ptr [RBX + 0x38],0x0
JZ 0x001609c3
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001609c3:
LEA R14,[RBX + 0x18]
MOV EDI,0x10
CALL 0x00118350
MOV R15,RAX
LAB_001609d4:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dfda
LAB_001609e8:
LEA RSI,[0x1ae98a]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x001248bf
MOV BPL,0x1
LAB_00160a01:
LEA RSI,[RSP + 0x28]
MOV RDI,R15
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001deff0]
MOV RDX,qword ptr [0x001def70]
MOV RDI,R15
CALL 0x00118b30
|
/* minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) */
void __thiscall minja::Context::Context(Context *this,Value *param_1,shared_ptr *param_2)
{
long lVar1;
int8 uVar2;
runtime_error *this_00;
int1 local_70 [32];
string local_50 [32];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__Context_001de160;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x18);
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(this + 0x28) = *(int8 *)(param_1 + 0x10);
*(int8 *)(this + 0x30) = uVar2;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(this + 0x40) = 0;
uVar2 = *(int8 *)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(this + 0x38) = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x40) = uVar2;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(this + 0x50) = 0;
uVar2 = *(int8 *)(param_1 + 0x38);
*(int8 *)(param_1 + 0x38) = 0;
*(int8 *)(this + 0x48) = *(int8 *)(param_1 + 0x30);
*(int8 *)(this + 0x50) = uVar2;
*(int8 *)(param_1 + 0x30) = 0;
uVar2 = *(int8 *)(param_1 + 0x48);
*(int8 *)(this + 0x58) = *(int8 *)(param_1 + 0x40);
*(int8 *)(this + 0x60) = uVar2;
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)param_1 + '@'));
param_1[0x40] = (Value)0x0;
*(int8 *)(param_1 + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + 'X'));
*(int8 *)(this + 0x68) = *(int8 *)param_2;
lVar1 = *(long *)(param_2 + 8);
*(long *)(this + 0x70) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001def98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
if (*(long *)(this + 0x38) != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001609d4 to 001609e7 has its CatchHandler @ 00160a69 */
Value::dump_abi_cxx11_((int)local_70,(bool)((char)this + '\x18'));
/* try { // try from 001609e8 to 001609fd has its CatchHandler @ 00160a46 */
std::operator+((char *)local_50,(string *)"Context values must be an object: ");
/* try { // try from 00160a01 to 00160a25 has its CatchHandler @ 00160a26 */
std::runtime_error::runtime_error(this_00,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001deff0,PTR__runtime_error_001def70);
}
|
|
18,325
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesFromVertexVertices()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarRefinement.cpp
|
void
FVarRefinement::populateChildValuesFromVertexVertices() {
Index cVert = _refinement.getFirstChildVertexFromVertices();
Index cVertEnd = cVert + _refinement.getNumChildVerticesFromVertices();
for ( ; cVert < cVertEnd; ++cVert) {
Index pVert = _refinement.getChildVertexParentIndex(cVert);
_childFVar._vertSiblingOffsets[cVert] = _childFVar._valueCount;
if (_parentFVar.valueTopologyMatches(_parentFVar.getVertexValueOffset(pVert))) {
_childFVar._vertSiblingCounts[cVert] = 1;
_childFVar._valueCount ++;
} else {
int cValueCount = populateChildValuesForVertexVertex(cVert, pVert);
_childFVar._vertSiblingCounts[cVert] = (LocalIndex)cValueCount;
_childFVar._valueCount += cValueCount;
}
}
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesFromVertexVertices():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movslq 0x3c(%rax), %rcx
testq %rcx, %rcx
jle 0x41f38
movslq 0x54(%rax), %rdx
addq %rdx, %rcx
movq 0x138(%rax), %rsi
movq 0x10(%rdi), %r8
movq 0x20(%rdi), %r9
movq 0x60(%r9), %r10
movq 0x60(%r8), %r11
movq 0xa8(%r8), %rbx
movq 0x28(%rdi), %rdi
movq %rdi, (%rsp)
movl 0x10(%r9), %ebp
movdqa 0x7347e(%rip), %xmm0 # 0xb5030
movdqa 0x73486(%rip), %xmm1 # 0xb5040
movdqa 0x7348e(%rip), %xmm2 # 0xb5050
movdqa 0x73496(%rip), %xmm3 # 0xb5060
movdqa 0x7349e(%rip), %xmm4 # 0xb5070
pcmpeqd %xmm5, %xmm5
movslq (%rsi,%rdx,4), %r15
movl %ebp, (%r10,%rdx,4)
movslq (%r11,%r15,4), %r14
testb $0x1, (%rbx,%r14)
jne 0x41bf8
movl $0x1, %ebp
movw $0x1, %r14w
jmp 0x41f1b
movq 0x180(%rax), %r14
testb $0x1, (%r14,%rdx)
jne 0x41f47
movq 0x48(%r8), %r14
movzwl (%r14,%r15,2), %r14d
cmpq $0x2, %r14
jb 0x41f18
movslq %ebp, %r13
leal 0x6(%r14), %r12d
andl $-0x8, %r12d
leaq -0x2(%r14), %rbp
movq %rbp, %xmm6
pshufd $0x44, %xmm6, %xmm6 # xmm6 = xmm6[0,1,0,1]
movq (%rsp), %rdi
leaq (%rdi,%r13,2), %r13
addq $0x10, %r13
pxor %xmm4, %xmm6
xorl %ebp, %ebp
movq %rbp, %xmm7
pshufd $0x44, %xmm7, %xmm7 # xmm7 = xmm7[0,1,0,1]
movdqa %xmm7, %xmm8
por %xmm3, %xmm8
pxor %xmm4, %xmm8
movdqa %xmm8, %xmm10
pcmpgtd %xmm6, %xmm10
pshufd $0xa0, %xmm10, %xmm9 # xmm9 = xmm10[0,0,2,2]
pshuflw $0xe8, %xmm9, %xmm11 # xmm11 = xmm9[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm8
pshufd $0xf5, %xmm8, %xmm8 # xmm8 = xmm8[1,1,3,3]
pshuflw $0xe8, %xmm8, %xmm12 # xmm12 = xmm8[0,2,2,3,4,5,6,7]
pand %xmm11, %xmm12
pshufd $0xf5, %xmm10, %xmm10 # xmm10 = xmm10[1,1,3,3]
pshuflw $0xe8, %xmm10, %xmm11 # xmm11 = xmm10[0,2,2,3,4,5,6,7]
por %xmm12, %xmm11
pxor %xmm5, %xmm11
packssdw %xmm11, %xmm11
movd %xmm11, %edi
testb $0x1, %dil
je 0x41cbc
leal 0x1(%rbp), %edi
movw %di, -0xe(%r13,%rbp,2)
pand %xmm9, %xmm8
por %xmm10, %xmm8
packssdw %xmm8, %xmm8
pxor %xmm5, %xmm8
packssdw %xmm8, %xmm8
movd %xmm8, %edi
shrl $0x10, %edi
testb $0x1, %dil
je 0x41cec
leal 0x2(%rbp), %edi
movw %di, -0xc(%r13,%rbp,2)
movdqa %xmm7, %xmm9
por %xmm2, %xmm9
pxor %xmm4, %xmm9
movdqa %xmm9, %xmm10
pcmpgtd %xmm6, %xmm10
pshufd $0xa0, %xmm10, %xmm8 # xmm8 = xmm10[0,0,2,2]
pcmpeqd %xmm6, %xmm9
pshufd $0xf5, %xmm9, %xmm9 # xmm9 = xmm9[1,1,3,3]
movdqa %xmm9, %xmm11
pand %xmm8, %xmm11
pshufd $0xf5, %xmm10, %xmm10 # xmm10 = xmm10[1,1,3,3]
por %xmm10, %xmm11
packssdw %xmm11, %xmm11
pxor %xmm5, %xmm11
packssdw %xmm11, %xmm11
pextrw $0x2, %xmm11, %edi
testb $0x1, %dil
je 0x41d4f
leal 0x3(%rbp), %edi
movw %di, -0xa(%r13,%rbp,2)
pshufhw $0x84, %xmm8, %xmm8 # xmm8 = xmm8[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm9, %xmm9 # xmm9 = xmm9[0,1,2,3,4,5,4,6]
pand %xmm8, %xmm9
pshufhw $0x84, %xmm10, %xmm8 # xmm8 = xmm10[0,1,2,3,4,5,4,6]
por %xmm9, %xmm8
pxor %xmm5, %xmm8
packssdw %xmm8, %xmm8
pextrw $0x3, %xmm8, %edi
testb $0x1, %dil
je 0x41d8a
leal 0x4(%rbp), %edi
movw %di, -0x8(%r13,%rbp,2)
movdqa %xmm7, %xmm8
por %xmm1, %xmm8
pxor %xmm4, %xmm8
movdqa %xmm8, %xmm10
pcmpgtd %xmm6, %xmm10
pshufd $0xa0, %xmm10, %xmm9 # xmm9 = xmm10[0,0,2,2]
pshuflw $0xe8, %xmm9, %xmm11 # xmm11 = xmm9[0,2,2,3,4,5,6,7]
pcmpeqd %xmm6, %xmm8
pshufd $0xf5, %xmm8, %xmm8 # xmm8 = xmm8[1,1,3,3]
pshuflw $0xe8, %xmm8, %xmm12 # xmm12 = xmm8[0,2,2,3,4,5,6,7]
pand %xmm11, %xmm12
pshufd $0xf5, %xmm10, %xmm10 # xmm10 = xmm10[1,1,3,3]
pshuflw $0xe8, %xmm10, %xmm11 # xmm11 = xmm10[0,2,2,3,4,5,6,7]
por %xmm12, %xmm11
pxor %xmm5, %xmm11
packssdw %xmm11, %xmm11
pextrw $0x4, %xmm11, %edi
testb $0x1, %dil
je 0x41df5
leal 0x5(%rbp), %edi
movw %di, -0x6(%r13,%rbp,2)
pand %xmm9, %xmm8
por %xmm10, %xmm8
packssdw %xmm8, %xmm8
pxor %xmm5, %xmm8
packssdw %xmm8, %xmm8
pextrw $0x5, %xmm8, %edi
testb $0x1, %dil
je 0x41e23
leal 0x6(%rbp), %edi
movw %di, -0x4(%r13,%rbp,2)
por %xmm0, %xmm7
pxor %xmm4, %xmm7
movdqa %xmm7, %xmm9
pcmpgtd %xmm6, %xmm9
pshufd $0xa0, %xmm9, %xmm8 # xmm8 = xmm9[0,0,2,2]
pcmpeqd %xmm6, %xmm7
pshufd $0xf5, %xmm7, %xmm7 # xmm7 = xmm7[1,1,3,3]
movdqa %xmm7, %xmm10
pand %xmm8, %xmm10
pshufd $0xf5, %xmm9, %xmm9 # xmm9 = xmm9[1,1,3,3]
por %xmm9, %xmm10
packssdw %xmm10, %xmm10
pxor %xmm5, %xmm10
packssdw %xmm10, %xmm10
pextrw $0x6, %xmm10, %edi
testb $0x1, %dil
je 0x41e7d
leal 0x7(%rbp), %edi
movw %di, -0x2(%r13,%rbp,2)
pshufhw $0x84, %xmm8, %xmm8 # xmm8 = xmm8[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm7, %xmm7 # xmm7 = xmm7[0,1,2,3,4,5,4,6]
pand %xmm8, %xmm7
pshufhw $0x84, %xmm9, %xmm8 # xmm8 = xmm9[0,1,2,3,4,5,4,6]
por %xmm7, %xmm8
pxor %xmm5, %xmm8
packssdw %xmm8, %xmm7
pextrw $0x7, %xmm7, %edi
testb $0x1, %dil
je 0x41eb6
leal 0x8(%rbp), %edi
movw %di, (%r13,%rbp,2)
addq $0x8, %rbp
cmpq %rbp, %r12
jne 0x41c48
movq (%r9), %rdi
movq 0x108(%rdi), %r13
movslq (%r13,%rdx,8), %r12
testq %r12, %r12
jle 0x41f18
movq (%r8), %rdi
movq 0x108(%rdi), %rdi
leal 0x1(,%r15,2), %ebp
movslq %ebp, %r15
movslq (%rdi,%r15,4), %r15
addq %r15, %r15
addq 0x78(%r8), %r15
movslq 0x4(%r13,%rdx,8), %r13
addq %r13, %r13
addq 0x78(%r9), %r13
xorl %ebp, %ebp
movzwl (%r15,%rbp,2), %edi
movw %di, (%r13,%rbp,2)
incq %rbp
cmpq %rbp, %r12
jne 0x41f05
movl %r14d, %ebp
movq 0x48(%r9), %rdi
movw %r14w, (%rdi,%rdx,2)
addl 0x10(%r9), %ebp
movl %ebp, 0x10(%r9)
incq %rdx
cmpq %rcx, %rdx
jl 0x41bd6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x736e2(%rip), %rdi # 0xb5630
leaq 0x73704(%rip), %rsi # 0xb5659
leaq 0x73929(%rip), %rcx # 0xb5885
movl $0xfb, %edx
callq 0x39540
|
_ZN10OpenSubdiv6v3_6_03Vtr8internal14FVarRefinement37populateChildValuesFromVertexVerticesEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rax, [rdi]
movsxd rcx, dword ptr [rax+3Ch]
test rcx, rcx
jle loc_41F38
movsxd rdx, dword ptr [rax+54h]
add rcx, rdx
mov rsi, [rax+138h]
mov r8, [rdi+10h]
mov r9, [rdi+20h]
mov r10, [r9+60h]
mov r11, [r8+60h]
mov rbx, [r8+0A8h]
mov rdi, [rdi+28h]
mov [rsp+38h+var_38], rdi
mov ebp, [r9+10h]
movdqa xmm0, cs:xmmword_B5030
movdqa xmm1, cs:xmmword_B5040
movdqa xmm2, cs:xmmword_B5050
movdqa xmm3, cs:xmmword_B5060
movdqa xmm4, cs:xmmword_B5070
pcmpeqd xmm5, xmm5
loc_41BD6:
movsxd r15, dword ptr [rsi+rdx*4]
mov [r10+rdx*4], ebp
movsxd r14, dword ptr [r11+r15*4]
test byte ptr [rbx+r14], 1
jnz short loc_41BF8
mov ebp, 1
mov r14w, 1
jmp loc_41F1B
loc_41BF8:
mov r14, [rax+180h]
test byte ptr [r14+rdx], 1
jnz loc_41F47
mov r14, [r8+48h]
movzx r14d, word ptr [r14+r15*2]
cmp r14, 2
jb loc_41F18
movsxd r13, ebp
lea r12d, [r14+6]
and r12d, 0FFFFFFF8h
lea rbp, [r14-2]
movq xmm6, rbp
pshufd xmm6, xmm6, 44h ; 'D'
mov rdi, [rsp+38h+var_38]
lea r13, [rdi+r13*2]
add r13, 10h
pxor xmm6, xmm4
xor ebp, ebp
loc_41C48:
movq xmm7, rbp
pshufd xmm7, xmm7, 44h ; 'D'
movdqa xmm8, xmm7
por xmm8, xmm3
pxor xmm8, xmm4
movdqa xmm10, xmm8
pcmpgtd xmm10, xmm6
pshufd xmm9, xmm10, 0A0h
pshuflw xmm11, xmm9, 0E8h
pcmpeqd xmm8, xmm6
pshufd xmm8, xmm8, 0F5h
pshuflw xmm12, xmm8, 0E8h
pand xmm12, xmm11
pshufd xmm10, xmm10, 0F5h
pshuflw xmm11, xmm10, 0E8h
por xmm11, xmm12
pxor xmm11, xmm5
packssdw xmm11, xmm11
movd edi, xmm11
test dil, 1
jz short loc_41CBC
lea edi, [rbp+1]
mov [r13+rbp*2-0Eh], di
loc_41CBC:
pand xmm8, xmm9
por xmm8, xmm10
packssdw xmm8, xmm8
pxor xmm8, xmm5
packssdw xmm8, xmm8
movd edi, xmm8
shr edi, 10h
test dil, 1
jz short loc_41CEC
lea edi, [rbp+2]
mov [r13+rbp*2-0Ch], di
loc_41CEC:
movdqa xmm9, xmm7
por xmm9, xmm2
pxor xmm9, xmm4
movdqa xmm10, xmm9
pcmpgtd xmm10, xmm6
pshufd xmm8, xmm10, 0A0h
pcmpeqd xmm9, xmm6
pshufd xmm9, xmm9, 0F5h
movdqa xmm11, xmm9
pand xmm11, xmm8
pshufd xmm10, xmm10, 0F5h
por xmm11, xmm10
packssdw xmm11, xmm11
pxor xmm11, xmm5
packssdw xmm11, xmm11
pextrw edi, xmm11, 2
test dil, 1
jz short loc_41D4F
lea edi, [rbp+3]
mov [r13+rbp*2-0Ah], di
loc_41D4F:
pshufhw xmm8, xmm8, 84h
pshufhw xmm9, xmm9, 84h
pand xmm9, xmm8
pshufhw xmm8, xmm10, 84h
por xmm8, xmm9
pxor xmm8, xmm5
packssdw xmm8, xmm8
pextrw edi, xmm8, 3
test dil, 1
jz short loc_41D8A
lea edi, [rbp+4]
mov [r13+rbp*2-8], di
loc_41D8A:
movdqa xmm8, xmm7
por xmm8, xmm1
pxor xmm8, xmm4
movdqa xmm10, xmm8
pcmpgtd xmm10, xmm6
pshufd xmm9, xmm10, 0A0h
pshuflw xmm11, xmm9, 0E8h
pcmpeqd xmm8, xmm6
pshufd xmm8, xmm8, 0F5h
pshuflw xmm12, xmm8, 0E8h
pand xmm12, xmm11
pshufd xmm10, xmm10, 0F5h
pshuflw xmm11, xmm10, 0E8h
por xmm11, xmm12
pxor xmm11, xmm5
packssdw xmm11, xmm11
pextrw edi, xmm11, 4
test dil, 1
jz short loc_41DF5
lea edi, [rbp+5]
mov [r13+rbp*2-6], di
loc_41DF5:
pand xmm8, xmm9
por xmm8, xmm10
packssdw xmm8, xmm8
pxor xmm8, xmm5
packssdw xmm8, xmm8
pextrw edi, xmm8, 5
test dil, 1
jz short loc_41E23
lea edi, [rbp+6]
mov [r13+rbp*2-4], di
loc_41E23:
por xmm7, xmm0
pxor xmm7, xmm4
movdqa xmm9, xmm7
pcmpgtd xmm9, xmm6
pshufd xmm8, xmm9, 0A0h
pcmpeqd xmm7, xmm6
pshufd xmm7, xmm7, 0F5h
movdqa xmm10, xmm7
pand xmm10, xmm8
pshufd xmm9, xmm9, 0F5h
por xmm10, xmm9
packssdw xmm10, xmm10
pxor xmm10, xmm5
packssdw xmm10, xmm10
pextrw edi, xmm10, 6
test dil, 1
jz short loc_41E7D
lea edi, [rbp+7]
mov [r13+rbp*2-2], di
loc_41E7D:
pshufhw xmm8, xmm8, 84h
pshufhw xmm7, xmm7, 84h
pand xmm7, xmm8
pshufhw xmm8, xmm9, 84h
por xmm8, xmm7
pxor xmm8, xmm5
packssdw xmm7, xmm8
pextrw edi, xmm7, 7
test dil, 1
jz short loc_41EB6
lea edi, [rbp+8]
mov [r13+rbp*2+0], di
loc_41EB6:
add rbp, 8
cmp r12, rbp
jnz loc_41C48
mov rdi, [r9]
mov r13, [rdi+108h]
movsxd r12, dword ptr [r13+rdx*8+0]
test r12, r12
jle short loc_41F18
mov rdi, [r8]
mov rdi, [rdi+108h]
lea ebp, ds:1[r15*2]
movsxd r15, ebp
movsxd r15, dword ptr [rdi+r15*4]
add r15, r15
add r15, [r8+78h]
movsxd r13, dword ptr [r13+rdx*8+4]
add r13, r13
add r13, [r9+78h]
xor ebp, ebp
loc_41F05:
movzx edi, word ptr [r15+rbp*2]
mov [r13+rbp*2+0], di
inc rbp
cmp r12, rbp
jnz short loc_41F05
loc_41F18:
mov ebp, r14d
loc_41F1B:
mov rdi, [r9+48h]
mov [rdi+rdx*2], r14w
add ebp, [r9+10h]
mov [r9+10h], ebp
inc rdx
cmp rdx, rcx
jl loc_41BD6
loc_41F38:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_41F47:
lea rdi, aRefinementIsch; "_refinement.isChildVertexComplete(cVert"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIntOpensubdivV; "int OpenSubdiv::v3_6_0::Vtr::internal::"...
mov edx, 0FBh
call ___assert_fail
|
long long OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesFromVertexVertices(
OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement *this)
{
long long result; // rax
long long v2; // rcx
long long v3; // rdx
long long v4; // rcx
long long v5; // rsi
_QWORD *v6; // r8
long long v7; // r9
long long v8; // r10
long long v9; // r11
long long v10; // rbx
int v11; // ebp
__m128i si128; // xmm0
__m128i v13; // xmm1
__m128i v14; // xmm2
__m128i v15; // xmm3
__m128i v16; // xmm4
long long v17; // r15
int v18; // ebp
unsigned long long v19; // r14
long long v20; // r13
__m128i v21; // xmm6
unsigned long long v22; // rbp
__m128i v23; // xmm7
__m128i v24; // xmm8
__m128i v25; // xmm10
__m128i v26; // xmm9
__m128i v27; // xmm8
__m128i v28; // xmm10
__m128i v29; // xmm11
__m128i v30; // xmm8
__m128i v31; // xmm8
__m128i v32; // xmm9
__m128i v33; // xmm10
__m128i v34; // xmm8
__m128i v35; // xmm9
__m128i v36; // xmm10
__m128i v37; // xmm11
__m128i v38; // xmm11
__m128i v39; // xmm8
__m128i v40; // xmm8
__m128i v41; // xmm10
__m128i v42; // xmm9
__m128i v43; // xmm8
__m128i v44; // xmm10
__m128i v45; // xmm11
__m128i v46; // xmm8
__m128i v47; // xmm8
__m128i v48; // xmm7
__m128i v49; // xmm9
__m128i v50; // xmm8
__m128i v51; // xmm7
__m128i v52; // xmm9
__m128i v53; // xmm10
__m128i v54; // xmm10
__m128i v55; // xmm7
long long v56; // r13
long long v57; // r12
long long v58; // r15
long long v59; // r13
long long i; // rbp
long long v61; // [rsp+0h] [rbp-38h]
result = *(_QWORD *)this;
v2 = *(int *)(*(_QWORD *)this + 60LL);
if ( v2 > 0 )
{
v3 = *(int *)(result + 84);
v4 = v3 + v2;
v5 = *(_QWORD *)(result + 312);
v6 = (_QWORD *)*((_QWORD *)this + 2);
v7 = *((_QWORD *)this + 4);
v8 = *(_QWORD *)(v7 + 96);
v9 = v6[12];
v10 = v6[21];
v61 = *((_QWORD *)this + 5);
v11 = *(_DWORD *)(v7 + 16);
si128 = _mm_load_si128((const __m128i *)&xmmword_B5030);
v13 = _mm_load_si128((const __m128i *)&xmmword_B5040);
v14 = _mm_load_si128((const __m128i *)&xmmword_B5050);
v15 = _mm_load_si128((const __m128i *)&xmmword_B5060);
v16 = _mm_load_si128((const __m128i *)&xmmword_B5070);
do
{
v17 = *(int *)(v5 + 4 * v3);
*(_DWORD *)(v8 + 4 * v3) = v11;
if ( (*(_BYTE *)(v10 + *(int *)(v9 + 4 * v17)) & 1) != 0 )
{
if ( (*(_BYTE *)(*(_QWORD *)(result + 384) + v3) & 1) != 0 )
__assert_fail(
"_refinement.isChildVertexComplete(cVert)",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarRefinement.cpp",
251LL,
"int OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesForVertexVertex(Index, Index)");
v19 = *(unsigned __int16 *)(v6[9] + 2 * v17);
if ( v19 >= 2 )
{
v20 = v61 + 2LL * v11 + 16;
v21 = _mm_xor_si128(_mm_shuffle_epi32((__m128i)(v19 - 2), 68), v16);
v22 = 0LL;
do
{
v23 = _mm_shuffle_epi32((__m128i)v22, 68);
v24 = _mm_xor_si128(_mm_or_si128(v23, v15), v16);
v25 = _mm_cmpgt_epi32(v24, v21);
v26 = _mm_shuffle_epi32(v25, 160);
v27 = _mm_shuffle_epi32(_mm_cmpeq_epi32(v24, v21), 245);
v28 = _mm_shuffle_epi32(v25, 245);
v29 = _mm_xor_si128(
_mm_or_si128(
_mm_shufflelo_epi16(v28, 232),
_mm_and_si128(_mm_shufflelo_epi16(v27, 232), _mm_shufflelo_epi16(v26, 232))),
(__m128i)-1LL);
if ( (_mm_cvtsi128_si32(_mm_packs_epi32(v29, v29)) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 14) = v22 + 1;
v30 = _mm_or_si128(_mm_and_si128(v27, v26), v28);
v31 = _mm_xor_si128(_mm_packs_epi32(v30, v30), (__m128i)-1LL);
if ( (_mm_cvtsi128_si32(_mm_packs_epi32(v31, v31)) & 0x10000) != 0 )
*(_WORD *)(v20 + 2 * v22 - 12) = v22 + 2;
v32 = _mm_xor_si128(_mm_or_si128(v23, v14), v16);
v33 = _mm_cmpgt_epi32(v32, v21);
v34 = _mm_shuffle_epi32(v33, 160);
v35 = _mm_shuffle_epi32(_mm_cmpeq_epi32(v32, v21), 245);
v36 = _mm_shuffle_epi32(v33, 245);
v37 = _mm_or_si128(_mm_and_si128(v35, v34), v36);
v38 = _mm_xor_si128(_mm_packs_epi32(v37, v37), (__m128i)-1LL);
if ( (_mm_extract_epi16(_mm_packs_epi32(v38, v38), 2) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 10) = v22 + 3;
v39 = _mm_xor_si128(
_mm_or_si128(
_mm_shufflehi_epi16(v36, 132),
_mm_and_si128(_mm_shufflehi_epi16(v35, 132), _mm_shufflehi_epi16(v34, 132))),
(__m128i)-1LL);
if ( (_mm_extract_epi16(_mm_packs_epi32(v39, v39), 3) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 8) = v22 + 4;
v40 = _mm_xor_si128(_mm_or_si128(v23, v13), v16);
v41 = _mm_cmpgt_epi32(v40, v21);
v42 = _mm_shuffle_epi32(v41, 160);
v43 = _mm_shuffle_epi32(_mm_cmpeq_epi32(v40, v21), 245);
v44 = _mm_shuffle_epi32(v41, 245);
v45 = _mm_xor_si128(
_mm_or_si128(
_mm_shufflelo_epi16(v44, 232),
_mm_and_si128(_mm_shufflelo_epi16(v43, 232), _mm_shufflelo_epi16(v42, 232))),
(__m128i)-1LL);
if ( (_mm_extract_epi16(_mm_packs_epi32(v45, v45), 4) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 6) = v22 + 5;
v46 = _mm_or_si128(_mm_and_si128(v43, v42), v44);
v47 = _mm_xor_si128(_mm_packs_epi32(v46, v46), (__m128i)-1LL);
if ( (_mm_extract_epi16(_mm_packs_epi32(v47, v47), 5) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 4) = v22 + 6;
v48 = _mm_xor_si128(_mm_or_si128(v23, si128), v16);
v49 = _mm_cmpgt_epi32(v48, v21);
v50 = _mm_shuffle_epi32(v49, 160);
v51 = _mm_shuffle_epi32(_mm_cmpeq_epi32(v48, v21), 245);
v52 = _mm_shuffle_epi32(v49, 245);
v53 = _mm_or_si128(_mm_and_si128(v51, v50), v52);
v54 = _mm_xor_si128(_mm_packs_epi32(v53, v53), (__m128i)-1LL);
if ( (_mm_extract_epi16(_mm_packs_epi32(v54, v54), 6) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22 - 2) = v22 + 7;
v55 = _mm_and_si128(_mm_shufflehi_epi16(v51, 132), _mm_shufflehi_epi16(v50, 132));
if ( (_mm_extract_epi16(
_mm_packs_epi32(v55, _mm_xor_si128(_mm_or_si128(_mm_shufflehi_epi16(v52, 132), v55), (__m128i)-1LL)),
7) & 1) != 0 )
*(_WORD *)(v20 + 2 * v22) = v22 + 8;
v22 += 8LL;
}
while ( (((_DWORD)v19 + 6) & 0xFFFFFFF8) != v22 );
v56 = *(_QWORD *)(*(_QWORD *)v7 + 264LL);
v57 = *(int *)(v56 + 8 * v3);
if ( v57 > 0 )
{
v58 = v6[15] + 2LL * *(int *)(*(_QWORD *)(*v6 + 264LL) + 4LL * (2 * (int)v17 + 1));
v59 = *(_QWORD *)(v7 + 120) + 2LL * *(int *)(v56 + 8 * v3 + 4);
for ( i = 0LL; i != v57; ++i )
*(_WORD *)(v59 + 2 * i) = *(_WORD *)(v58 + 2 * i);
}
}
v18 = v19;
}
else
{
v18 = 1;
LOWORD(v19) = 1;
}
*(_WORD *)(*(_QWORD *)(v7 + 72) + 2 * v3) = v19;
v11 = *(_DWORD *)(v7 + 16) + v18;
*(_DWORD *)(v7 + 16) = v11;
++v3;
}
while ( v3 < v4 );
}
return result;
}
|
populateChildValuesFromVertexVertices:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOVSXD RCX,dword ptr [RAX + 0x3c]
TEST RCX,RCX
JLE 0x00141f38
MOVSXD RDX,dword ptr [RAX + 0x54]
ADD RCX,RDX
MOV RSI,qword ptr [RAX + 0x138]
MOV R8,qword ptr [RDI + 0x10]
MOV R9,qword ptr [RDI + 0x20]
MOV R10,qword ptr [R9 + 0x60]
MOV R11,qword ptr [R8 + 0x60]
MOV RBX,qword ptr [R8 + 0xa8]
MOV RDI,qword ptr [RDI + 0x28]
MOV qword ptr [RSP],RDI
MOV EBP,dword ptr [R9 + 0x10]
MOVDQA XMM0,xmmword ptr [0x001b5030]
MOVDQA XMM1,xmmword ptr [0x001b5040]
MOVDQA XMM2,xmmword ptr [0x001b5050]
MOVDQA XMM3,xmmword ptr [0x001b5060]
MOVDQA XMM4,xmmword ptr [0x001b5070]
PCMPEQD XMM5,XMM5
LAB_00141bd6:
MOVSXD R15,dword ptr [RSI + RDX*0x4]
MOV dword ptr [R10 + RDX*0x4],EBP
MOVSXD R14,dword ptr [R11 + R15*0x4]
TEST byte ptr [RBX + R14*0x1],0x1
JNZ 0x00141bf8
MOV EBP,0x1
MOV R14W,0x1
JMP 0x00141f1b
LAB_00141bf8:
MOV R14,qword ptr [RAX + 0x180]
TEST byte ptr [R14 + RDX*0x1],0x1
JNZ 0x00141f47
MOV R14,qword ptr [R8 + 0x48]
MOVZX R14D,word ptr [R14 + R15*0x2]
CMP R14,0x2
JC 0x00141f18
MOVSXD R13,EBP
LEA R12D,[R14 + 0x6]
AND R12D,0xfffffff8
LEA RBP,[R14 + -0x2]
MOVQ XMM6,RBP
PSHUFD XMM6,XMM6,0x44
MOV RDI,qword ptr [RSP]
LEA R13,[RDI + R13*0x2]
ADD R13,0x10
PXOR XMM6,XMM4
XOR EBP,EBP
LAB_00141c48:
MOVQ XMM7,RBP
PSHUFD XMM7,XMM7,0x44
MOVDQA XMM8,XMM7
POR XMM8,XMM3
PXOR XMM8,XMM4
MOVDQA XMM10,XMM8
PCMPGTD XMM10,XMM6
PSHUFD XMM9,XMM10,0xa0
PSHUFLW XMM11,XMM9,0xe8
PCMPEQD XMM8,XMM6
PSHUFD XMM8,XMM8,0xf5
PSHUFLW XMM12,XMM8,0xe8
PAND XMM12,XMM11
PSHUFD XMM10,XMM10,0xf5
PSHUFLW XMM11,XMM10,0xe8
POR XMM11,XMM12
PXOR XMM11,XMM5
PACKSSDW XMM11,XMM11
MOVD EDI,XMM11
TEST DIL,0x1
JZ 0x00141cbc
LEA EDI,[RBP + 0x1]
MOV word ptr [R13 + RBP*0x2 + -0xe],DI
LAB_00141cbc:
PAND XMM8,XMM9
POR XMM8,XMM10
PACKSSDW XMM8,XMM8
PXOR XMM8,XMM5
PACKSSDW XMM8,XMM8
MOVD EDI,XMM8
SHR EDI,0x10
TEST DIL,0x1
JZ 0x00141cec
LEA EDI,[RBP + 0x2]
MOV word ptr [R13 + RBP*0x2 + -0xc],DI
LAB_00141cec:
MOVDQA XMM9,XMM7
POR XMM9,XMM2
PXOR XMM9,XMM4
MOVDQA XMM10,XMM9
PCMPGTD XMM10,XMM6
PSHUFD XMM8,XMM10,0xa0
PCMPEQD XMM9,XMM6
PSHUFD XMM9,XMM9,0xf5
MOVDQA XMM11,XMM9
PAND XMM11,XMM8
PSHUFD XMM10,XMM10,0xf5
POR XMM11,XMM10
PACKSSDW XMM11,XMM11
PXOR XMM11,XMM5
PACKSSDW XMM11,XMM11
PEXTRW EDI,XMM11,0x2
TEST DIL,0x1
JZ 0x00141d4f
LEA EDI,[RBP + 0x3]
MOV word ptr [R13 + RBP*0x2 + -0xa],DI
LAB_00141d4f:
PSHUFHW XMM8,XMM8,0x84
PSHUFHW XMM9,XMM9,0x84
PAND XMM9,XMM8
PSHUFHW XMM8,XMM10,0x84
POR XMM8,XMM9
PXOR XMM8,XMM5
PACKSSDW XMM8,XMM8
PEXTRW EDI,XMM8,0x3
TEST DIL,0x1
JZ 0x00141d8a
LEA EDI,[RBP + 0x4]
MOV word ptr [R13 + RBP*0x2 + -0x8],DI
LAB_00141d8a:
MOVDQA XMM8,XMM7
POR XMM8,XMM1
PXOR XMM8,XMM4
MOVDQA XMM10,XMM8
PCMPGTD XMM10,XMM6
PSHUFD XMM9,XMM10,0xa0
PSHUFLW XMM11,XMM9,0xe8
PCMPEQD XMM8,XMM6
PSHUFD XMM8,XMM8,0xf5
PSHUFLW XMM12,XMM8,0xe8
PAND XMM12,XMM11
PSHUFD XMM10,XMM10,0xf5
PSHUFLW XMM11,XMM10,0xe8
POR XMM11,XMM12
PXOR XMM11,XMM5
PACKSSDW XMM11,XMM11
PEXTRW EDI,XMM11,0x4
TEST DIL,0x1
JZ 0x00141df5
LEA EDI,[RBP + 0x5]
MOV word ptr [R13 + RBP*0x2 + -0x6],DI
LAB_00141df5:
PAND XMM8,XMM9
POR XMM8,XMM10
PACKSSDW XMM8,XMM8
PXOR XMM8,XMM5
PACKSSDW XMM8,XMM8
PEXTRW EDI,XMM8,0x5
TEST DIL,0x1
JZ 0x00141e23
LEA EDI,[RBP + 0x6]
MOV word ptr [R13 + RBP*0x2 + -0x4],DI
LAB_00141e23:
POR XMM7,XMM0
PXOR XMM7,XMM4
MOVDQA XMM9,XMM7
PCMPGTD XMM9,XMM6
PSHUFD XMM8,XMM9,0xa0
PCMPEQD XMM7,XMM6
PSHUFD XMM7,XMM7,0xf5
MOVDQA XMM10,XMM7
PAND XMM10,XMM8
PSHUFD XMM9,XMM9,0xf5
POR XMM10,XMM9
PACKSSDW XMM10,XMM10
PXOR XMM10,XMM5
PACKSSDW XMM10,XMM10
PEXTRW EDI,XMM10,0x6
TEST DIL,0x1
JZ 0x00141e7d
LEA EDI,[RBP + 0x7]
MOV word ptr [R13 + RBP*0x2 + -0x2],DI
LAB_00141e7d:
PSHUFHW XMM8,XMM8,0x84
PSHUFHW XMM7,XMM7,0x84
PAND XMM7,XMM8
PSHUFHW XMM8,XMM9,0x84
POR XMM8,XMM7
PXOR XMM8,XMM5
PACKSSDW XMM7,XMM8
PEXTRW EDI,XMM7,0x7
TEST DIL,0x1
JZ 0x00141eb6
LEA EDI,[RBP + 0x8]
MOV word ptr [R13 + RBP*0x2],DI
LAB_00141eb6:
ADD RBP,0x8
CMP R12,RBP
JNZ 0x00141c48
MOV RDI,qword ptr [R9]
MOV R13,qword ptr [RDI + 0x108]
MOVSXD R12,dword ptr [R13 + RDX*0x8]
TEST R12,R12
JLE 0x00141f18
MOV RDI,qword ptr [R8]
MOV RDI,qword ptr [RDI + 0x108]
LEA EBP,[0x1 + R15*0x2]
MOVSXD R15,EBP
MOVSXD R15,dword ptr [RDI + R15*0x4]
ADD R15,R15
ADD R15,qword ptr [R8 + 0x78]
MOVSXD R13,dword ptr [R13 + RDX*0x8 + 0x4]
ADD R13,R13
ADD R13,qword ptr [R9 + 0x78]
XOR EBP,EBP
LAB_00141f05:
MOVZX EDI,word ptr [R15 + RBP*0x2]
MOV word ptr [R13 + RBP*0x2],DI
INC RBP
CMP R12,RBP
JNZ 0x00141f05
LAB_00141f18:
MOV EBP,R14D
LAB_00141f1b:
MOV RDI,qword ptr [R9 + 0x48]
MOV word ptr [RDI + RDX*0x2],R14W
ADD EBP,dword ptr [R9 + 0x10]
MOV dword ptr [R9 + 0x10],EBP
INC RDX
CMP RDX,RCX
JL 0x00141bd6
LAB_00141f38:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00141f47:
LEA RDI,[0x1b5630]
LEA RSI,[0x1b5659]
LEA RCX,[0x1b5885]
MOV EDX,0xfb
CALL 0x00139540
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesFromVertexVertices() */
void __thiscall
OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesFromVertexVertices
(FVarRefinement *this)
{
int iVar1;
long lVar2;
long lVar3;
long *plVar4;
long *plVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
short sVar15;
int1 auVar16 [16];
int1 auVar17 [16];
int1 auVar18 [16];
int1 auVar19 [16];
int1 auVar20 [16];
long lVar21;
long lVar22;
uint uVar23;
int iVar24;
ulong uVar25;
long lVar26;
long lVar27;
ushort uVar28;
int iVar30;
int1 auVar29 [16];
int iVar31;
int1 auVar32 [16];
int1 auVar33 [16];
int1 auVar34 [16];
int1 auVar35 [16];
int1 auVar36 [16];
int1 auVar37 [16];
int1 auVar38 [16];
int1 auVar39 [16];
int1 auVar40 [16];
int1 auVar41 [16];
int iVar46;
int1 auVar42 [16];
int1 auVar43 [16];
int1 auVar44 [16];
int1 auVar45 [16];
int iVar47;
int iVar49;
int1 auVar48 [16];
int1 in_XMM11 [16];
int1 auVar50 [16];
int1 auVar51 [16];
int1 in_XMM12 [16];
int1 auVar52 [16];
auVar20 = _DAT_001b5070;
auVar19 = _DAT_001b5060;
auVar18 = _DAT_001b5050;
auVar17 = _DAT_001b5040;
auVar16 = _DAT_001b5030;
lVar2 = *(long *)this;
if (0 < (long)*(int *)(lVar2 + 0x3c)) {
lVar22 = (long)*(int *)(lVar2 + 0x54);
lVar21 = *(int *)(lVar2 + 0x3c) + lVar22;
lVar3 = *(long *)(lVar2 + 0x138);
plVar4 = *(long **)(this + 0x10);
plVar5 = *(long **)(this + 0x20);
lVar6 = plVar5[0xc];
lVar7 = plVar4[0xc];
lVar8 = plVar4[0x15];
lVar9 = *(long *)(this + 0x28);
iVar24 = (int)plVar5[2];
do {
iVar1 = *(int *)(lVar3 + lVar22 * 4);
*(int *)(lVar6 + lVar22 * 4) = iVar24;
if ((*(byte *)(lVar8 + *(int *)(lVar7 + (long)iVar1 * 4)) & 1) == 0) {
uVar23 = 1;
uVar28 = 1;
}
else {
if ((*(byte *)(*(long *)(lVar2 + 0x180) + lVar22) & 1) != 0) {
/* WARNING: Subroutine does not return */
__assert_fail("_refinement.isChildVertexComplete(cVert)",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/fvarRefinement.cpp"
,0xfb,
"int OpenSubdiv::v3_6_0::Vtr::internal::FVarRefinement::populateChildValuesForVertexVertex(Index, Index)"
);
}
uVar28 = *(ushort *)(plVar4[9] + (long)iVar1 * 2);
if (1 < (ulong)uVar28) {
lVar27 = (ulong)uVar28 - 2;
auVar29._8_4_ = (int)lVar27;
auVar29._0_8_ = lVar27;
auVar29._12_4_ = (int)((ulong)lVar27 >> 0x20);
lVar27 = lVar9 + (long)iVar24 * 2;
auVar29 = auVar29 ^ auVar20;
uVar25 = 0;
do {
auVar41._8_4_ = (int)uVar25;
auVar41._0_8_ = uVar25;
auVar41._12_4_ = (int)(uVar25 >> 0x20);
auVar33 = (auVar41 | auVar19) ^ auVar20;
iVar24 = auVar29._0_4_;
iVar47 = -(uint)(iVar24 < auVar33._0_4_);
iVar30 = auVar29._4_4_;
auVar34._4_4_ = -(uint)(iVar30 < auVar33._4_4_);
iVar46 = auVar29._8_4_;
iVar49 = -(uint)(iVar46 < auVar33._8_4_);
iVar31 = auVar29._12_4_;
auVar34._12_4_ = -(uint)(iVar31 < auVar33._12_4_);
auVar43._4_4_ = iVar47;
auVar43._0_4_ = iVar47;
auVar43._8_4_ = iVar49;
auVar43._12_4_ = iVar49;
auVar50 = pshuflw(in_XMM11,auVar43,0xe8);
auVar36._4_4_ = -(uint)(auVar33._4_4_ == iVar30);
auVar36._12_4_ = -(uint)(auVar33._12_4_ == iVar31);
auVar36._0_4_ = auVar36._4_4_;
auVar36._8_4_ = auVar36._12_4_;
auVar52 = pshuflw(in_XMM12,auVar36,0xe8);
auVar34._0_4_ = auVar34._4_4_;
auVar34._8_4_ = auVar34._12_4_;
auVar51 = pshuflw(auVar50,auVar34,0xe8);
auVar33._8_4_ = 0xffffffff;
auVar33._0_8_ = 0xffffffffffffffff;
auVar33._12_4_ = 0xffffffff;
auVar33 = (auVar51 | auVar52 & auVar50) ^ auVar33;
auVar33 = packssdw(auVar33,auVar33);
sVar15 = (short)uVar25;
if ((auVar33 & (int1 [16])0x1) != (int1 [16])0x0) {
*(short *)(lVar27 + 2 + uVar25 * 2) = sVar15 + 1;
}
auVar34 = auVar36 & auVar43 | auVar34;
auVar33 = packssdw(auVar34,auVar34);
auVar51._8_4_ = 0xffffffff;
auVar51._0_8_ = 0xffffffffffffffff;
auVar51._12_4_ = 0xffffffff;
auVar33 = packssdw(auVar33 ^ auVar51,auVar33 ^ auVar51);
if ((auVar33._0_4_ >> 0x10 & 1) != 0) {
*(short *)(lVar27 + 4 + uVar25 * 2) = sVar15 + 2;
}
auVar33 = (auVar41 | auVar18) ^ auVar20;
iVar47 = -(uint)(iVar24 < auVar33._0_4_);
auVar48._4_4_ = -(uint)(iVar30 < auVar33._4_4_);
iVar49 = -(uint)(iVar46 < auVar33._8_4_);
auVar48._12_4_ = -(uint)(iVar31 < auVar33._12_4_);
auVar35._4_4_ = iVar47;
auVar35._0_4_ = iVar47;
auVar35._8_4_ = iVar49;
auVar35._12_4_ = iVar49;
auVar42._4_4_ = -(uint)(auVar33._4_4_ == iVar30);
auVar42._12_4_ = -(uint)(auVar33._12_4_ == iVar31);
auVar42._0_4_ = auVar42._4_4_;
auVar42._8_4_ = auVar42._12_4_;
auVar48._0_4_ = auVar48._4_4_;
auVar48._8_4_ = auVar48._12_4_;
auVar33 = auVar42 & auVar35 | auVar48;
auVar33 = packssdw(auVar33,auVar33);
auVar12._8_4_ = 0xffffffff;
auVar12._0_8_ = 0xffffffffffffffff;
auVar12._12_4_ = 0xffffffff;
auVar33 = packssdw(auVar33 ^ auVar12,auVar33 ^ auVar12);
if ((auVar33 & (int1 [16])0x100000000) != (int1 [16])0x0) {
*(short *)(lVar27 + 6 + uVar25 * 2) = sVar15 + 3;
}
auVar36 = pshufhw(auVar35,auVar35,0x84);
auVar43 = pshufhw(auVar42,auVar42,0x84);
auVar34 = pshufhw(auVar36,auVar48,0x84);
auVar37._8_4_ = 0xffffffff;
auVar37._0_8_ = 0xffffffffffffffff;
auVar37._12_4_ = 0xffffffff;
auVar37 = (auVar34 | auVar43 & auVar36) ^ auVar37;
auVar36 = packssdw(auVar37,auVar37);
if ((auVar36 & (int1 [16])0x1000000000000) != (int1 [16])0x0) {
*(short *)(lVar27 + 8 + uVar25 * 2) = sVar15 + 4;
}
auVar36 = (auVar41 | auVar17) ^ auVar20;
iVar47 = -(uint)(iVar24 < auVar36._0_4_);
auVar39._4_4_ = -(uint)(iVar30 < auVar36._4_4_);
iVar49 = -(uint)(iVar46 < auVar36._8_4_);
auVar39._12_4_ = -(uint)(iVar31 < auVar36._12_4_);
auVar44._4_4_ = iVar47;
auVar44._0_4_ = iVar47;
auVar44._8_4_ = iVar49;
auVar44._12_4_ = iVar49;
auVar33 = pshuflw(auVar33,auVar44,0xe8);
auVar38._4_4_ = -(uint)(auVar36._4_4_ == iVar30);
auVar38._12_4_ = -(uint)(auVar36._12_4_ == iVar31);
auVar38._0_4_ = auVar38._4_4_;
auVar38._8_4_ = auVar38._12_4_;
auVar36 = pshuflw(auVar52 & auVar50,auVar38,0xe8);
in_XMM12 = auVar36 & auVar33;
auVar39._0_4_ = auVar39._4_4_;
auVar39._8_4_ = auVar39._12_4_;
auVar33 = pshuflw(auVar33,auVar39,0xe8);
auVar50._8_4_ = 0xffffffff;
auVar50._0_8_ = 0xffffffffffffffff;
auVar50._12_4_ = 0xffffffff;
auVar50 = (auVar33 | in_XMM12) ^ auVar50;
in_XMM11 = packssdw(auVar50,auVar50);
if ((in_XMM11 & (int1 [16])0x1) != (int1 [16])0x0) {
*(short *)(lVar27 + 10 + uVar25 * 2) = sVar15 + 5;
}
auVar39 = auVar38 & auVar44 | auVar39;
auVar33 = packssdw(auVar39,auVar39);
auVar52._8_4_ = 0xffffffff;
auVar52._0_8_ = 0xffffffffffffffff;
auVar52._12_4_ = 0xffffffff;
auVar33 = packssdw(auVar33 ^ auVar52,auVar33 ^ auVar52);
if ((auVar33 & (int1 [16])0x10000) != (int1 [16])0x0) {
*(short *)(lVar27 + 0xc + uVar25 * 2) = sVar15 + 6;
}
auVar33 = (auVar41 | auVar16) ^ auVar20;
iVar24 = -(uint)(iVar24 < auVar33._0_4_);
auVar45._4_4_ = -(uint)(iVar30 < auVar33._4_4_);
iVar46 = -(uint)(iVar46 < auVar33._8_4_);
auVar45._12_4_ = -(uint)(iVar31 < auVar33._12_4_);
auVar40._4_4_ = iVar24;
auVar40._0_4_ = iVar24;
auVar40._8_4_ = iVar46;
auVar40._12_4_ = iVar46;
auVar32._4_4_ = -(uint)(auVar33._4_4_ == iVar30);
auVar32._12_4_ = -(uint)(auVar33._12_4_ == iVar31);
auVar32._0_4_ = auVar32._4_4_;
auVar32._8_4_ = auVar32._12_4_;
auVar45._0_4_ = auVar45._4_4_;
auVar45._8_4_ = auVar45._12_4_;
auVar33 = auVar32 & auVar40 | auVar45;
auVar33 = packssdw(auVar33,auVar33);
auVar13._8_4_ = 0xffffffff;
auVar13._0_8_ = 0xffffffffffffffff;
auVar13._12_4_ = 0xffffffff;
auVar33 = packssdw(auVar33 ^ auVar13,auVar33 ^ auVar13);
if ((auVar33 & (int1 [16])0x100000000) != (int1 [16])0x0) {
*(short *)(lVar27 + 0xe + uVar25 * 2) = sVar15 + 7;
}
auVar41 = pshufhw(auVar40,auVar40,0x84);
auVar33 = pshufhw(auVar32,auVar32,0x84);
auVar36 = pshufhw(auVar41,auVar45,0x84);
auVar14._8_4_ = 0xffffffff;
auVar14._0_8_ = 0xffffffffffffffff;
auVar14._12_4_ = 0xffffffff;
auVar33 = packssdw(auVar33 & auVar41,(auVar36 | auVar33 & auVar41) ^ auVar14);
if ((auVar33 & (int1 [16])0x1000000000000) != (int1 [16])0x0) {
*(short *)(lVar27 + 0x10 + uVar25 * 2) = sVar15 + 8;
}
uVar25 = uVar25 + 8;
} while ((uVar28 + 6 & 0xfffffff8) != uVar25);
lVar27 = (long)*(int *)(*(long *)(*plVar5 + 0x108) + lVar22 * 8);
if (0 < lVar27) {
iVar24 = *(int *)(*(long *)(*plVar4 + 0x108) + (long)(iVar1 * 2 + 1) * 4);
lVar10 = plVar4[0xf];
iVar1 = *(int *)(*(long *)(*plVar5 + 0x108) + 4 + lVar22 * 8);
lVar11 = plVar5[0xf];
lVar26 = 0;
do {
*(int2 *)((long)iVar1 * 2 + lVar11 + lVar26 * 2) =
*(int2 *)((long)iVar24 * 2 + lVar10 + lVar26 * 2);
lVar26 = lVar26 + 1;
} while (lVar27 != lVar26);
}
}
uVar23 = (uint)uVar28;
}
*(ushort *)(plVar5[9] + lVar22 * 2) = uVar28;
iVar24 = uVar23 + (int)plVar5[2];
*(int *)(plVar5 + 2) = iVar24;
lVar22 = lVar22 + 1;
} while (lVar22 < lVar21);
}
return;
}
|
|
18,326
|
blst_p1_affine_compress
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/e1.c
|
void blst_p1_affine_compress(unsigned char out[48], const POINTonE1_affine *in)
{
if (vec_is_zero(in->X, 2*sizeof(in->X))) {
bytes_zero(out, 48);
out[0] = 0xc0; /* compressed and infinity bits */
} else {
limb_t sign = POINTonE1_affine_Compress_BE(out, in);
out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));
}
}
|
O2
|
c
|
blst_p1_affine_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x60
popq %rsi
movq %r14, %rdi
callq 0x510f5
testq %rax, %rax
je 0x513b7
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x512c5
movb $-0x40, %al
jmp 0x513cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x513d2
shlb $0x4, %al
andb $0x20, %al
orb (%rbx), %al
orb $-0x80, %al
movb %al, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
blst_p1_affine_compress:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
push 60h ; '`'
pop rsi
mov rdi, r14
call vec_is_zero
test rax, rax
jz short loc_513B7
push 30h ; '0'
pop rsi
mov rdi, rbx
call bytes_zero
mov al, 0C0h
jmp short loc_513CB
loc_513B7:
mov rdi, rbx
mov rsi, r14
call POINTonE1_affine_Compress_BE
shl al, 4
and al, 20h
or al, [rbx]
or al, 80h
loc_513CB:
mov [rbx], al
pop rbx
pop r14
pop rbp
retn
|
char blst_p1_affine_compress(char *a1, long long a2)
{
char result; // al
if ( vec_is_zero(a2, 0x60uLL) )
{
bytes_zero((long long)a1, 48LL);
result = -64;
}
else
{
result = *a1 | (16 * POINTonE1_affine_Compress_BE(a1, a2)) & 0x20 | 0x80;
}
*a1 = result;
return result;
}
|
blst_p1_affine_compress:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
PUSH 0x60
POP RSI
MOV RDI,R14
CALL 0x001510f5
TEST RAX,RAX
JZ 0x001513b7
PUSH 0x30
POP RSI
MOV RDI,RBX
CALL 0x001512c5
MOV AL,0xc0
JMP 0x001513cb
LAB_001513b7:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001513d2
SHL AL,0x4
AND AL,0x20
OR AL,byte ptr [RBX]
OR AL,0x80
LAB_001513cb:
MOV byte ptr [RBX],AL
POP RBX
POP R14
POP RBP
RET
|
void blst_p1_affine_compress(byte *param_1,int8 param_2)
{
long lVar1;
byte bVar2;
lVar1 = vec_is_zero(param_2,0x60);
if (lVar1 == 0) {
bVar2 = POINTonE1_affine_Compress_BE(param_1,param_2);
bVar2 = (bVar2 & 2) << 4 | *param_1 | 0x80;
}
else {
bytes_zero(param_1,0x30);
bVar2 = 0xc0;
}
*param_1 = bVar2;
return;
}
|
|
18,327
|
get_charset_name
|
eloqsql/mysys/charset.c
|
const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
}
|
O0
|
c
|
get_charset_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0xba6e72(%rip), %rdi # 0xc843f4
leaq -0x479(%rip), %rsi # 0xdd110
callq 0x2a220
cmpl $0x800, -0xc(%rbp) # imm = 0x800
jae 0xdd5d8
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xb9eddd(%rip), %rax # 0xc7c380
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xdd5d6
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xdd5d6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xdd5d6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xdd5e3
jmp 0xdd5d8
leaq 0x77e59(%rip), %rax # 0x155438
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
get_charset_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
cmp [rbp+var_C], 800h
jnb short loc_DD5D8
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_DD5D6
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rbp+var_C]
jnz short loc_DD5D6
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_DD5D6
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_DD5E3
loc_DD5D6:
jmp short $+2
loc_DD5D8:
lea rax, asc_155438; "?"
mov [rbp+var_8], rax
loc_DD5E3:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
const char * get_charset_name(unsigned int a1)
{
long long v2; // [rsp+8h] [rbp-18h]
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 < 0x800 && (v2 = all_charsets[a1]) != 0 && *(_DWORD *)v2 == a1 && *(_QWORD *)(v2 + 32) )
return *(const char **)(v2 + 32);
else
return "?";
}
|
get_charset_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
LEA RDI,[0xd843f4]
LEA RSI,[0x1dd110]
CALL 0x0012a220
CMP dword ptr [RBP + -0xc],0x800
JNC 0x001dd5d8
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0xd7c380]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001dd5d6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x001dd5d6
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001dd5d6
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001dd5e3
LAB_001dd5d6:
JMP 0x001dd5d8
LAB_001dd5d8:
LEA RAX,[0x255438]
MOV qword ptr [RBP + -0x8],RAX
LAB_001dd5e3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *local_10;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((param_1 < 0x800) && (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 != (uint *)0x0)) &&
(*puVar1 == param_1)) && (*(long *)(puVar1 + 8) != 0)) {
local_10 = *(int **)(puVar1 + 8);
}
else {
local_10 = &DAT_00255438;
}
return local_10;
}
|
|
18,328
|
my_realpath
|
eloqsql/mysys/my_symlink.c
|
int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
}
|
O3
|
c
|
my_realpath:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp # imm = 0x1010
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x1030(%rbp), %rsi
movq %r14, %rdi
callq 0x240e0
testq %rax, %rax
je 0x2b515
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5df74
xorl %eax, %eax
jmp 0x2b564
callq 0x24050
movl (%rax), %r12d
callq 0x2bd8a
movl %r12d, (%rax)
testb $0x10, %r15b
je 0x2b543
callq 0x2bd8a
movl (%rax), %ecx
movl $0x1a, %edi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x306df
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2fcfc
callq 0x2bd8a
xorl %ecx, %ecx
cmpl $0x2, (%rax)
sete %cl
leal -0x1(,%rcx,2), %eax
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x2b583
addq $0x1010, %rsp # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24350
|
my_realpath:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 1010h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea rsi, [rbp+var_1030]
mov rdi, r14
call _realpath
test rax, rax
jz short loc_2B515
mov edx, 1FFh
mov rdi, rbx
mov rsi, rax
call strmake
xor eax, eax
jmp short loc_2B564
loc_2B515:
call ___errno_location
mov r12d, [rax]
call _my_thread_var
mov [rax], r12d
test r15b, 10h
jz short loc_2B543
call _my_thread_var
mov ecx, [rax]
mov edi, 1Ah
xor esi, esi
mov rdx, r14
xor eax, eax
call my_error
loc_2B543:
mov rdi, rbx
mov rsi, r14
xor edx, edx
call my_load_path
call _my_thread_var
xor ecx, ecx
cmp dword ptr [rax], 2
setz cl
lea eax, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
loc_2B564:
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_2B583
add rsp, 1010h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_2B583:
call ___stack_chk_fail
|
long long my_realpath(long long a1, long long a2, char a3)
{
long long v4; // rax
int v6; // r12d
_DWORD *v7; // rax
int v8; // r8d
int v9; // r9d
_BYTE v10[4104]; // [rsp+0h] [rbp-1030h] BYREF
unsigned long long v11; // [rsp+1008h] [rbp-28h]
v11 = __readfsqword(0x28u);
v4 = realpath(a2, v10);
if ( v4 )
{
strmake(a1, v4, 511LL);
return 0LL;
}
else
{
v6 = *(_DWORD *)__errno_location(a2);
*(_DWORD *)my_thread_var(a2) = v6;
if ( (a3 & 0x10) != 0 )
{
v7 = (_DWORD *)my_thread_var(a2);
my_error(26, 0, a2, *v7, v8, v9);
}
my_load_path(a1, a2, 0LL);
return 2 * (unsigned int)(*(_DWORD *)my_thread_var(a1) == 2) - 1;
}
}
|
my_realpath:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1010
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA RSI,[RBP + -0x1030]
MOV RDI,R14
CALL 0x001240e0
TEST RAX,RAX
JZ 0x0012b515
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0015df74
XOR EAX,EAX
JMP 0x0012b564
LAB_0012b515:
CALL 0x00124050
MOV R12D,dword ptr [RAX]
CALL 0x0012bd8a
MOV dword ptr [RAX],R12D
TEST R15B,0x10
JZ 0x0012b543
CALL 0x0012bd8a
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR ESI,ESI
MOV RDX,R14
XOR EAX,EAX
CALL 0x001306df
LAB_0012b543:
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0012fcfc
CALL 0x0012bd8a
XOR ECX,ECX
CMP dword ptr [RAX],0x2
SETZ CL
LEA EAX,[-0x1 + RCX*0x2]
LAB_0012b564:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x0012b583
ADD RSP,0x1010
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0012b583:
CALL 0x00124350
|
int my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
char local_1038 [4104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = realpath(param_2,local_1038);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
iVar1 = (uint)(*piVar3 == 2) * 2 + -1;
}
else {
strmake(param_1,pcVar2,0x1ff);
iVar1 = 0;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
18,329
|
my_hash_iterate
|
eloqsql/mysys/hash.c
|
my_bool my_hash_iterate(HASH *hash, my_hash_walk_action action, void *argument)
{
uint records, i;
records= hash->records;
for (i= 0 ; i < records ; i++)
{
if ((*action)(dynamic_element(&hash->array, i, HASH_LINK *)->data,
argument))
return 1;
}
return 0;
}
|
O0
|
c
|
my_hash_iterate:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xe35b5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x28(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpb $0x0, %al
je 0xe35a8
movb $0x1, -0x1(%rbp)
jmp 0xe35b9
jmp 0xe35aa
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe3576
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
my_hash_iterate:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_24], eax
mov [rbp+var_28], 0
loc_E3576:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_24]
jnb short loc_E35B5
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx+28h]
mov edx, [rbp+var_28]
shl rdx, 4
add rcx, rdx
mov rdi, [rcx+8]
mov rsi, [rbp+var_20]
call rax
cmp al, 0
jz short loc_E35A8
mov [rbp+var_1], 1
jmp short loc_E35B9
loc_E35A8:
jmp short $+2
loc_E35AA:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_E3576
loc_E35B5:
mov [rbp+var_1], 0
loc_E35B9:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char my_hash_iterate(long long a1, unsigned __int8 ( *a2)(_QWORD, long long), long long a3)
{
unsigned int i; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+Ch] [rbp-24h]
v5 = *(_QWORD *)(a1 + 24);
for ( i = 0; i < v5; ++i )
{
if ( a2(*(_QWORD *)(16LL * i + *(_QWORD *)(a1 + 40) + 8), a3) )
return 1;
}
return 0;
}
|
my_hash_iterate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
LAB_001e3576:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001e35b5
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x28]
MOV EDX,dword ptr [RBP + -0x28]
SHL RDX,0x4
ADD RCX,RDX
MOV RDI,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RBP + -0x20]
CALL RAX
CMP AL,0x0
JZ 0x001e35a8
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001e35b9
LAB_001e35a8:
JMP 0x001e35aa
LAB_001e35aa:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001e3576
LAB_001e35b5:
MOV byte ptr [RBP + -0x1],0x0
LAB_001e35b9:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_hash_iterate(long param_1,code *param_2,int8 param_3)
{
int8 uVar1;
char cVar2;
uint local_30;
uVar1 = *(int8 *)(param_1 + 0x18);
local_30 = 0;
while( true ) {
if ((uint)uVar1 <= local_30) {
return 0;
}
cVar2 = (*param_2)(*(int8 *)(*(long *)(param_1 + 0x28) + (ulong)local_30 * 0x10 + 8),
param_3);
if (cVar2 != '\0') break;
local_30 = local_30 + 1;
}
return 1;
}
|
|
18,330
|
get_charset_name
|
eloqsql/mysys/charset.c
|
const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
}
|
O0
|
c
|
get_charset_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0x37ca12(%rip), %rdi # 0x3a5d04
leaq -0x479(%rip), %rsi # 0x28e80
callq 0x25280
cmpl $0x800, -0xc(%rbp) # imm = 0x800
jae 0x29348
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x37497d(%rip), %rax # 0x39dc90
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29346
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x29346
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x29346
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29353
jmp 0x29348
leaq 0x61591(%rip), %rax # 0x8a8e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
get_charset_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
cmp [rbp+var_C], 800h
jnb short loc_29348
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_29346
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rbp+var_C]
jnz short loc_29346
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jz short loc_29346
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_29353
loc_29346:
jmp short $+2
loc_29348:
lea rax, asc_8A8E0; "?"
mov [rbp+var_8], rax
loc_29353:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
const char * get_charset_name(unsigned int a1)
{
long long v2; // [rsp+8h] [rbp-18h]
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 < 0x800 && (v2 = all_charsets[a1]) != 0 && *(_DWORD *)v2 == a1 && *(_QWORD *)(v2 + 32) )
return *(const char **)(v2 + 32);
else
return "?";
}
|
get_charset_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
LEA RDI,[0x4a5d04]
LEA RSI,[0x128e80]
CALL 0x00125280
CMP dword ptr [RBP + -0xc],0x800
JNC 0x00129348
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0x49dc90]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00129346
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x00129346
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00129346
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00129353
LAB_00129346:
JMP 0x00129348
LAB_00129348:
LEA RAX,[0x18a8e0]
MOV qword ptr [RBP + -0x8],RAX
LAB_00129353:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *local_10;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((param_1 < 0x800) && (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 != (uint *)0x0)) &&
(*puVar1 == param_1)) && (*(long *)(puVar1 + 8) != 0)) {
local_10 = *(int **)(puVar1 + 8);
}
else {
local_10 = &DAT_0018a8e0;
}
return local_10;
}
|
|
18,331
|
wqueue_release_queue
|
eloqsql/mysys/wqueue.c
|
void wqueue_release_queue(WQUEUE *wqueue)
{
struct st_my_thread_var *last= wqueue->last_thread;
struct st_my_thread_var *next= last->next;
struct st_my_thread_var *thread;
do
{
thread= next;
mysql_cond_signal(&thread->suspend);
next= thread->next;
thread->next= NULL;
}
while (thread != last);
wqueue->last_thread= NULL;
}
|
O3
|
c
|
wqueue_release_queue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x88(%r14), %r12
leaq 0x2df8ca(%rip), %r15 # 0x386010
movq 0x38(%r12), %rdi
testq %rdi, %rdi
jne 0xa6778
leaq 0x8(%r12), %rdi
callq 0x295c0
movq 0x88(%r12), %rax
movq $0x0, 0x88(%r12)
cmpq %r14, %r12
movq %rax, %r12
jne 0xa6746
jmp 0xa6783
movq (%r15), %rax
callq *0x170(%rax)
jmp 0xa6750
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
wqueue_release_queue:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
mov r14, [rdi]
mov r12, [r14+88h]
lea r15, PSI_server
loc_A6746:
mov rdi, [r12+38h]
test rdi, rdi
jnz short loc_A6778
loc_A6750:
lea rdi, [r12+8]
call _pthread_cond_signal
mov rax, [r12+88h]
mov qword ptr [r12+88h], 0
cmp r12, r14
mov r12, rax
jnz short loc_A6746
jmp short loc_A6783
loc_A6778:
mov rax, [r15]
call qword ptr [rax+170h]
jmp short loc_A6750
loc_A6783:
mov qword ptr [rbx], 0
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long wqueue_release_queue(long long *a1)
{
long long v1; // r14
long long v2; // r12
long long result; // rax
bool v4; // zf
v1 = *a1;
v2 = *(_QWORD *)(*a1 + 136);
do
{
if ( *(_QWORD *)(v2 + 56) )
PSI_server[46]();
pthread_cond_signal(v2 + 8);
result = *(_QWORD *)(v2 + 136);
*(_QWORD *)(v2 + 136) = 0LL;
v4 = v2 == v1;
v2 = result;
}
while ( !v4 );
*a1 = 0LL;
return result;
}
|
wqueue_release_queue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI]
MOV R12,qword ptr [R14 + 0x88]
LEA R15,[0x486010]
LAB_001a6746:
MOV RDI,qword ptr [R12 + 0x38]
TEST RDI,RDI
JNZ 0x001a6778
LAB_001a6750:
LEA RDI,[R12 + 0x8]
CALL 0x001295c0
MOV RAX,qword ptr [R12 + 0x88]
MOV qword ptr [R12 + 0x88],0x0
CMP R12,R14
MOV R12,RAX
JNZ 0x001a6746
JMP 0x001a6783
LAB_001a6778:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x170]
JMP 0x001a6750
LAB_001a6783:
MOV qword ptr [RBX],0x0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void wqueue_release_queue(long *param_1)
{
long lVar1;
long lVar2;
long lVar3;
bool bVar4;
lVar1 = *param_1;
lVar3 = *(long *)(lVar1 + 0x88);
do {
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
lVar2 = *(long *)(lVar3 + 0x88);
*(int8 *)(lVar3 + 0x88) = 0;
bVar4 = lVar3 != lVar1;
lVar3 = lVar2;
} while (bVar4);
*param_1 = 0;
return;
}
|
|
18,332
|
set_default_charset_by_name
|
eloqsql/libmariadb/libmariadb/mariadb_charset.c
|
my_bool set_default_charset_by_name(const char *cs_name, myf flags __attribute__((unused)))
{
MARIADB_CHARSET_INFO *new_charset;
new_charset = mysql_get_charset_by_name(cs_name);
if (!new_charset)
{
return(TRUE); /* error */
}
ma_default_charset_info = new_charset;
return(FALSE);
}
|
O3
|
c
|
set_default_charset_by_name:
pushq %rbp
movq %rsp, %rbp
callq 0x17ab0
testq %rax, %rax
je 0x1be1e
leaq 0x30e91(%rip), %rcx # 0x4cca8
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x1be20
movb $0x1, %al
popq %rbp
retq
nop
|
set_default_charset_by_name:
push rbp
mov rbp, rsp
call _mysql_get_charset_by_name@libmariadbclient_18
test rax, rax
jz short loc_1BE1E
lea rcx, ma_default_charset_info
mov [rcx], rax
xor eax, eax
jmp short loc_1BE20
loc_1BE1E:
mov al, 1
loc_1BE20:
pop rbp
retn
|
long long set_default_charset_by_name(long long a1)
{
_DWORD *charset_by_name_libmariadbclient_18; // rax
charset_by_name_libmariadbclient_18 = mysql_get_charset_by_name_libmariadbclient_18(a1);
if ( !charset_by_name_libmariadbclient_18 )
return 1LL;
ma_default_charset_info = charset_by_name_libmariadbclient_18;
return 0LL;
}
|
set_default_charset_by_name:
PUSH RBP
MOV RBP,RSP
CALL 0x00117ab0
TEST RAX,RAX
JZ 0x0011be1e
LEA RCX,[0x14cca8]
MOV qword ptr [RCX],RAX
XOR EAX,EAX
JMP 0x0011be20
LAB_0011be1e:
MOV AL,0x1
LAB_0011be20:
POP RBP
RET
|
bool set_default_charset_by_name(void)
{
long lVar1;
lVar1 = mysql_get_charset_by_name();
if (lVar1 != 0) {
ma_default_charset_info = lVar1;
}
return lVar1 == 0;
}
|
|
18,333
|
main
|
ericcurtin[P]linenoise/llama-run-cli.cpp
|
int main(int, char **) {
while (1) {
static const char * prompt_prefix = "> ";
std::unique_ptr<char, decltype(&std::free)> line(const_cast<char *>(linenoise(prompt_prefix)), free);
if (!line) {
break;
}
std::string user_input = line.get();
if (user_input.empty()) {
continue;
}
/* Do something with the string. */
printf("\033[33mecho: '%s'\033[0m\n", line.get());
linenoiseHistoryAdd(line.get()); /* Add to the history. */
}
return 0;
}
|
O2
|
cpp
|
main:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x2af4(%rip), %r14 # 0x5004
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x2ae6(%rip), %r13 # 0x5007
movq %r14, %rdi
callq 0x38c9
testq %rax, %rax
je 0x256e
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x25a0
cmpq $0x0, 0x18(%rsp)
je 0x255c
movq %r13, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2f66
movq %r15, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2200
jmp 0x2521
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x2590
movq %rax, %r14
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2330
|
main:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 30h
lea r14, unk_5004
lea r15, [rsp+58h+var_48]
lea r12, [rsp+58h+var_49]
lea r13, a33mechoS0m; "\x1B[33mecho: '%s'\x1B[0m\n"
loc_2521:
mov rdi, r14
call linenoise
test rax, rax
jz short loc_256E
mov rbx, rax
mov rdi, r15
mov rsi, rax
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
cmp [rsp+58h+var_40], 0
jz short loc_255C
mov rdi, r13
mov rsi, rbx
xor eax, eax
call _printf
mov rdi, rbx
call linenoiseHistoryAdd
loc_255C:
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call _free
jmp short loc_2521
loc_256E:
xor eax, eax
add rsp, 30h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
lea rdi, [rsp+arg_8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_2590
mov r14, rax
loc_2590:
mov rdi, rbx
call _free
mov rdi, r14
call __Unwind_Resume
|
int main(int argc, const char **argv, const char **envp)
{
const char **v3; // rax
const char **v4; // rbx
char v6; // [rsp+Fh] [rbp-49h] BYREF
_BYTE v7[8]; // [rsp+10h] [rbp-48h] BYREF
long long v8; // [rsp+18h] [rbp-40h]
while ( 1 )
{
v3 = (const char **)linenoise(&unk_5004, argv, envp);
if ( !v3 )
break;
v4 = v3;
argv = v3;
std::string::basic_string<std::allocator<char>>(v7, v3, &v6);
if ( v8 )
{
argv = v4;
printf("\x1B[33mecho: '%s'\x1B[0m\n", (const char *)v4);
linenoiseHistoryAdd(v4);
}
std::string::~string(v7);
free(v4);
}
return 0;
}
|
main:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x30
LEA R14,[0x105004]
LEA R15,[RSP + 0x10]
LEA R12,[RSP + 0xf]
LEA R13,[0x105007]
LAB_00102521:
MOV RDI,R14
CALL 0x001038c9
TEST RAX,RAX
JZ 0x0010256e
LAB_0010252e:
MOV RBX,RAX
MOV RDI,R15
MOV RSI,RAX
MOV RDX,R12
CALL 0x001025a0
CMP qword ptr [RSP + 0x18],0x0
JZ 0x0010255c
MOV RDI,R13
MOV RSI,RBX
XOR EAX,EAX
CALL 0x00102050
LAB_00102554:
MOV RDI,RBX
CALL 0x00102f66
LAB_0010255c:
MOV RDI,R15
CALL 0x001020d0
MOV RDI,RBX
CALL 0x00102200
JMP 0x00102521
LAB_0010256e:
XOR EAX,EAX
ADD RSP,0x30
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 main(void)
{
char *__ptr;
allocator local_49;
string local_48 [8];
long local_40;
while( true ) {
__ptr = (char *)linenoise(&DAT_00105004);
if (__ptr == (char *)0x0) break;
/* try { // try from 0010252e to 0010253e has its CatchHandler @ 0010258d */
std::__cxx11::string::string<std::allocator<char>>(local_48,__ptr,&local_49);
if (local_40 != 0) {
printf("\x1b[33mecho: \'%s\'\x1b[0m\n",__ptr);
/* try { // try from 00102554 to 0010255b has its CatchHandler @ 0010257e */
linenoiseHistoryAdd(__ptr);
}
std::__cxx11::string::~string(local_48);
free(__ptr);
}
return 0;
}
|
|
18,334
|
mi_get_key
|
eloqsql/storage/myisam/mi_search.c
|
uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uchar *keypos, uint *return_key_length)
{
uint nod_flag;
DBUG_ENTER("_mi_get_key");
nod_flag=mi_test_if_nod(page);
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
{
bmove((uchar*) key,(uchar*) keypos,keyinfo->keylength+nod_flag);
DBUG_RETURN(keypos+keyinfo->keylength+nod_flag);
}
else
{
page+=2+nod_flag;
key[0]=0; /* safety */
while (page <= keypos)
{
*return_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&page,key);
if (*return_key_length == 0)
{
mi_print_error(info->s, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
}
}
DBUG_PRINT("exit",("page: %p length: %u", page,
*return_key_length));
DBUG_RETURN(page);
}
|
O0
|
c
|
mi_get_key:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xc18b3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xc18ba
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xc18ba
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x28, %eax
cmpl $0x0, %eax
jne 0xc190d
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %eax
addl -0x3c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a130
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0x3c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xc199a
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0xc198a
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq *%rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xc1988
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xae540
callq 0xf6090
movl $0x7e, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xc199a
jmp 0xc1927
jmp 0xc198c
jmp 0xc198e
jmp 0xc1990
jmp 0xc1992
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_mi_get_key:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_C18B3
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_40], eax
jmp short loc_C18BA
loc_C18B3:
xor eax, eax
mov [rbp+var_40], eax
jmp short $+2
loc_C18BA:
mov eax, [rbp+var_40]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+0Ah]
and eax, 28h
cmp eax, 0
jnz short loc_C190D
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+12h]
add eax, [rbp+var_3C]
mov eax, eax
mov edx, eax
call _memmove
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
movzx ecx, word ptr [rcx+12h]
movsxd rcx, ecx
add rax, rcx
mov ecx, [rbp+var_3C]
add rax, rcx
mov [rbp+var_8], rax
jmp loc_C199A
loc_C190D:
mov ecx, [rbp+var_3C]
add ecx, 2
mov rax, [rbp+var_20]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
loc_C1927:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
ja short loc_C198A
mov rax, [rbp+var_18]
mov rax, [rax+48h]
mov rdi, [rbp+var_18]
mov esi, [rbp+var_3C]
mov rcx, [rbp+var_28]
lea rdx, [rbp+var_20]
call rax
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_38]
cmp dword ptr [rax], 0
jnz short loc_C1988
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov [rbp+var_8], 0
jmp short loc_C199A
loc_C1988:
jmp short loc_C1927
loc_C198A:
jmp short $+2
loc_C198C:
jmp short $+2
loc_C198E:
jmp short $+2
loc_C1990:
jmp short $+2
loc_C1992:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_C199A:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
_BYTE * mi_get_key(long long a1, long long a2, _BYTE *a3, _BYTE *a4, unsigned long long a5, _DWORD *a6)
{
const char *v6; // rsi
unsigned int v8; // [rsp+0h] [rbp-40h]
_BYTE *v12; // [rsp+20h] [rbp-20h] BYREF
long long v13; // [rsp+28h] [rbp-18h]
long long v14; // [rsp+30h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
if ( (*a3 & 0x80) != 0 )
v8 = *(_DWORD *)(*(_QWORD *)v14 + 380LL);
else
v8 = 0;
if ( (*(_WORD *)(v13 + 10) & 0x28) != 0 )
{
v12 += v8 + 2;
*a4 = 0;
while ( (unsigned long long)v12 <= a5 )
{
*a6 = (*(long long ( **)(long long, _QWORD, _BYTE **, _BYTE *))(v13 + 72))(v13, v8, &v12, a4);
if ( !*a6 )
{
v6 = *(const char **)(*(_QWORD *)v14 + 616LL);
mi_report_error(126, (long long)v6);
*(_DWORD *)my_thread_var(126LL, v6) = 126;
return 0LL;
}
}
return v12;
}
else
{
memmove(a4, a5, v8 + *(unsigned __int16 *)(v13 + 18));
return (_BYTE *)(v8 + *(unsigned __int16 *)(v13 + 18) + a5);
}
}
|
_mi_get_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001c18b3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001c18ba
LAB_001c18b3:
XOR EAX,EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001c18ba
LAB_001c18ba:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x28
CMP EAX,0x0
JNZ 0x001c190d
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x12]
ADD EAX,dword ptr [RBP + -0x3c]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a130
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RCX + 0x12]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x3c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001c199a
LAB_001c190d:
MOV ECX,dword ptr [RBP + -0x3c]
ADD ECX,0x2
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
LAB_001c1927:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JA 0x001c198a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDX,[RBP + -0x20]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX],0x0
JNZ 0x001c1988
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001ae540
CALL 0x001f6090
MOV dword ptr [RAX],0x7e
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001c199a
LAB_001c1988:
JMP 0x001c1927
LAB_001c198a:
JMP 0x001c198c
LAB_001c198c:
JMP 0x001c198e
LAB_001c198e:
JMP 0x001c1990
LAB_001c1990:
JMP 0x001c1992
LAB_001c1992:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001c199a:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
byte * _mi_get_key(long *param_1,long param_2,byte *param_3,int1 *param_4,byte *param_5,
int *param_6)
{
int iVar1;
int4 *puVar2;
uint local_48;
byte *local_28;
long local_20;
long *local_18;
byte *local_10;
if ((*param_3 & 0x80) == 0) {
local_48 = 0;
}
else {
local_48 = *(uint *)(*param_1 + 0x17c);
}
local_20 = param_2;
local_18 = param_1;
if ((*(ushort *)(param_2 + 10) & 0x28) == 0) {
local_28 = param_3;
memmove(param_4,param_5,(ulong)(*(ushort *)(param_2 + 0x12) + local_48));
local_10 = param_5 + (ulong)local_48 + (long)(int)(uint)*(ushort *)(local_20 + 0x12);
}
else {
local_28 = param_3 + (local_48 + 2);
*param_4 = 0;
do {
if (param_5 < local_28) {
return local_28;
}
iVar1 = (**(code **)(local_20 + 0x48))(local_20,local_48,&local_28,param_4);
*param_6 = iVar1;
} while (*param_6 != 0);
mi_report_error(0x7e,*(int8 *)(*local_18 + 0x268));
puVar2 = (int4 *)_my_thread_var();
*puVar2 = 0x7e;
local_10 = (byte *)0x0;
}
return local_10;
}
|
|
18,335
|
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/minja/minja.hpp
|
Value get_named(const std::string & name) {
for (const auto & [key, value] : kwargs) {
if (key == name) return value;
}
return Value();
}
|
O3
|
cpp
|
minja::ArgumentsValue::get_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r13
cmpq %r13, %r14
je 0x7b5ba
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, 0x8(%r14)
jne 0x7b5b1
testq %r12, %r12
je 0x7b5f8
movq (%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1c880
testl %eax, %eax
je 0x7b5f8
addq $0x70, %r14
cmpq %r13, %r14
jne 0x7b594
leaq 0x40(%rbx), %r14
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
jmp 0x7b607
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74a14
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN5minja14ArgumentsValue9get_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rdi
mov r14, [rsi+18h]
mov r13, [rsi+20h]
cmp r14, r13
jz short loc_7B5BA
mov r15, [rdx]
mov r12, [rdx+8]
loc_7B594:
cmp [r14+8], r12
jnz short loc_7B5B1
test r12, r12
jz short loc_7B5F8
mov rdi, [r14]
mov rsi, r15
mov rdx, r12
call _bcmp
test eax, eax
jz short loc_7B5F8
loc_7B5B1:
add r14, 70h ; 'p'
cmp r14, r13
jnz short loc_7B594
loc_7B5BA:
lea r14, [rbx+40h]
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp short loc_7B607
loc_7B5F8:
add r14, 20h ; ' '
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
loc_7B607:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
minja::Value * minja::ArgumentsValue::get_named(minja::Value *this, long long a2, long long *a3)
{
_QWORD *v3; // r14
_QWORD *v4; // r13
long long v5; // r15
long long v6; // r12
v3 = *(_QWORD **)(a2 + 24);
v4 = *(_QWORD **)(a2 + 32);
if ( v3 == v4 )
{
LABEL_7:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 64);
}
else
{
v5 = *a3;
v6 = a3[1];
while ( v3[1] != v6 || v6 && (unsigned int)bcmp(*v3, v5) )
{
v3 += 14;
if ( v3 == v4 )
goto LABEL_7;
}
minja::Value::Value(this, (const minja::Value *)(v3 + 4));
}
return this;
}
|
get_named:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RSI + 0x18]
MOV R13,qword ptr [RSI + 0x20]
CMP R14,R13
JZ 0x0017b5ba
MOV R15,qword ptr [RDX]
MOV R12,qword ptr [RDX + 0x8]
LAB_0017b594:
CMP qword ptr [R14 + 0x8],R12
JNZ 0x0017b5b1
TEST R12,R12
JZ 0x0017b5f8
MOV RDI,qword ptr [R14]
MOV RSI,R15
MOV RDX,R12
CALL 0x0011c880
TEST EAX,EAX
JZ 0x0017b5f8
LAB_0017b5b1:
ADD R14,0x70
CMP R14,R13
JNZ 0x0017b594
LAB_0017b5ba:
LEA R14,[RBX + 0x40]
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
JMP 0x0017b607
LAB_0017b5f8:
ADD R14,0x20
MOV RDI,RBX
MOV RSI,R14
CALL 0x00174a14
LAB_0017b607:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::get_named(std::__cxx11::string const&) */
string * minja::ArgumentsValue::get_named(string *param_1)
{
int8 *puVar1;
void *__s2;
size_t __n;
int iVar2;
int8 *in_RDX;
long in_RSI;
bool bVar3;
int8 *puVar4;
puVar4 = *(int8 **)(in_RSI + 0x18);
puVar1 = *(int8 **)(in_RSI + 0x20);
if (puVar4 != puVar1) {
__s2 = (void *)*in_RDX;
__n = in_RDX[1];
do {
if ((puVar4[1] == __n) && ((__n == 0 || (iVar2 = bcmp((void *)*puVar4,__s2,__n), iVar2 == 0)))
) {
Value::Value((Value *)param_1,(Value *)(puVar4 + 4));
return param_1;
}
puVar4 = puVar4 + 0xe;
} while (puVar4 != puVar1);
}
bVar3 = (bool)((char)param_1 + '@');
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (string)0x0;
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(bVar3);
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(bVar3);
return param_1;
}
|
|
18,336
|
ac_packet_set_data
|
alca/libalca/packet.c
|
int ac_packet_set_data(ac_packet_handle handle, const uint8_t *data, uint32_t data_len, uint32_t sequence_number)
{
struct ac_packet *packet = handle;
packet->data = ac_alloc(data_len);
memcpy(packet->data, data, data_len);
packet->header.data_len = b2l(data_len);
packet->header.sequence = b2l(sequence_number);
return 0;
}
|
O0
|
c
|
ac_packet_set_data:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x7890
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x7750
movl -0x14(%rbp), %edi
callq 0x7a00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %edi
callq 0x7a00
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ac_packet_set_data:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov edi, [rbp+var_14]
call _ac_alloc
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+18h], rcx
mov rax, [rbp+var_20]
mov rdi, [rax+18h]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _memcpy
mov edi, [rbp+var_14]
call _ac_u32be_to_u32le
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+10h], ecx
mov edi, [rbp+var_18]
call _ac_u32be_to_u32le
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+14h], ecx
xor eax, eax
add rsp, 20h
pop rbp
retn
|
long long ac_packet_set_data(long long a1, long long a2, unsigned int a3, unsigned int a4)
{
*(_QWORD *)(a1 + 24) = ac_alloc(a3);
memcpy(*(_QWORD *)(a1 + 24), a2, a3);
*(_DWORD *)(a1 + 16) = ac_u32be_to_u32le(a3);
*(_DWORD *)(a1 + 20) = ac_u32be_to_u32le(a4);
return 0LL;
}
|
ac_packet_set_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 dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00107890
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x00107750
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00107a00
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x10],ECX
MOV EDI,dword ptr [RBP + -0x18]
CALL 0x00107a00
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
int8 ac_packet_set_data(long param_1,void *param_2,uint param_3,int4 param_4)
{
int4 uVar1;
int8 uVar2;
uVar2 = ac_alloc(param_3);
*(int8 *)(param_1 + 0x18) = uVar2;
memcpy(*(void **)(param_1 + 0x18),param_2,(ulong)param_3);
uVar1 = ac_u32be_to_u32le(param_3);
*(int4 *)(param_1 + 0x10) = uVar1;
uVar1 = ac_u32be_to_u32le(param_4);
*(int4 *)(param_1 + 0x14) = uVar1;
return 0;
}
|
|
18,337
|
my_uca_init_one_contraction
|
eloqsql/strings/ctype-uca.c
|
static uint16 *
my_uca_init_one_contraction(MY_CONTRACTIONS *contractions,
my_wc_t *str, uint length, my_bool with_context)
{
int flag;
uint i;
my_uca_add_contraction_flag(contractions, str[0],
with_context ?
MY_UCA_PREVIOUS_CONTEXT_HEAD :
MY_UCA_CNT_HEAD);
for (i= 1, flag= MY_UCA_CNT_MID1; i < length - 1; i++, flag<<= 1)
my_uca_add_contraction_flag(contractions, str[i], flag);
my_uca_add_contraction_flag(contractions, str[i],
with_context ?
MY_UCA_PREVIOUS_CONTEXT_TAIL :
MY_UCA_CNT_TAIL);
/* Add new contraction to the contraction list */
return my_uca_add_contraction(contractions, str, length,
with_context)->weight;
}
|
O0
|
c
|
my_uca_init_one_contraction:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movsbl -0x15(%rbp), %ecx
movl $0x1, %edx
movl $0x40, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x85770
movl $0x1, -0x20(%rbp)
movl $0x4, -0x1c(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x84cd1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %edx
callq 0x85770
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x84c9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movsbl -0x15(%rbp), %ecx
movl $0x2, %edx
movl $0x80, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x85770
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
movsbl -0x15(%rbp), %ecx
callq 0x857a0
addq $0x30, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
my_uca_init_one_contraction:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_15], al
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov rsi, [rax]
movsx ecx, [rbp+var_15]
mov edx, 1
mov eax, 40h ; '@'
cmp ecx, 0
cmovnz edx, eax
call my_uca_add_contraction_flag
mov [rbp+var_20], 1
mov [rbp+var_1C], 4
loc_84C9A:
mov eax, [rbp+var_20]
mov ecx, [rbp+var_14]
sub ecx, 1
cmp eax, ecx
jnb short loc_84CD1
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_1C]
call my_uca_add_contraction_flag
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_84C9A
loc_84CD1:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
mov rsi, [rax+rcx*8]
movsx ecx, [rbp+var_15]
mov edx, 2
mov eax, 80h
cmp ecx, 0
cmovnz edx, eax
call my_uca_add_contraction_flag
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
movsx ecx, [rbp+var_15]
call my_uca_add_contraction
add rax, 30h ; '0'
add rsp, 20h
pop rbp
retn
|
long long my_uca_init_one_contraction(long long a1, long long *a2, unsigned int a3, char a4)
{
long long v4; // rsi
long long v5; // rdx
long long v6; // rdx
unsigned int v8; // [rsp+0h] [rbp-20h]
unsigned int v9; // [rsp+4h] [rbp-1Ch]
v4 = *a2;
v5 = 1LL;
if ( a4 )
v5 = 64LL;
my_uca_add_contraction_flag(a1, v4, v5);
v8 = 1;
v9 = 4;
while ( v8 < a3 - 1 )
{
my_uca_add_contraction_flag(a1, a2[v8++], v9);
v9 *= 2;
}
v6 = 2LL;
if ( a4 )
v6 = 128LL;
my_uca_add_contraction_flag(a1, a2[v8], v6);
return my_uca_add_contraction(a1, a2, a3, (unsigned int)a4) + 48;
}
|
my_uca_init_one_contraction:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV byte ptr [RBP + -0x15],AL
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x15]
MOV EDX,0x1
MOV EAX,0x40
CMP ECX,0x0
CMOVNZ EDX,EAX
CALL 0x00185770
MOV dword ptr [RBP + -0x20],0x1
MOV dword ptr [RBP + -0x1c],0x4
LAB_00184c9a:
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,0x1
CMP EAX,ECX
JNC 0x00184cd1
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x00185770
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00184c9a
LAB_00184cd1:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOVSX ECX,byte ptr [RBP + -0x15]
MOV EDX,0x2
MOV EAX,0x80
CMP ECX,0x0
CMOVNZ EDX,EAX
CALL 0x00185770
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
MOVSX ECX,byte ptr [RBP + -0x15]
CALL 0x001857a0
ADD RAX,0x30
ADD RSP,0x20
POP RBP
RET
|
long my_uca_init_one_contraction(int8 param_1,int8 *param_2,int param_3,char param_4)
{
long lVar1;
int8 uVar2;
uint local_28;
int local_24;
uVar2 = 1;
if (param_4 != '\0') {
uVar2 = 0x40;
}
my_uca_add_contraction_flag(param_1,*param_2,uVar2);
local_24 = 4;
for (local_28 = 1; local_28 < param_3 - 1U; local_28 = local_28 + 1) {
my_uca_add_contraction_flag(param_1,param_2[local_28],local_24);
local_24 = local_24 << 1;
}
uVar2 = 2;
if (param_4 != '\0') {
uVar2 = 0x80;
}
my_uca_add_contraction_flag(param_1,param_2[local_28],uVar2);
lVar1 = my_uca_add_contraction(param_1,param_2,param_3,(int)param_4);
return lVar1 + 0x30;
}
|
|
18,338
|
minja::ExpressionNode::~ExpressionNode()
|
monkey531[P]llama/common/minja.hpp
|
ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {}
|
O3
|
cpp
|
minja::ExpressionNode::~ExpressionNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8c5e3(%rip), %rax # 0x12b2b8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x9ecea
callq 0x6e4bc
leaq 0x8c2e7(%rip), %rax # 0x12afd8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9ed06
callq 0x6e4bc
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a890
|
_ZN5minja14ExpressionNodeD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+28h]
test rdi, rdi
jz short loc_9ECEA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9ECEA:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9ED06
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9ED06:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::ExpressionNode::~ExpressionNode(minja::ExpressionNode *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionNode + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x30uLL);
}
|
~ExpressionNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22b2b8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x28]
TEST RDI,RDI
JZ 0x0019ecea
CALL 0x0016e4bc
LAB_0019ecea:
LEA RAX,[0x22afd8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019ed06
CALL 0x0016e4bc
LAB_0019ed06:
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x0011a890
|
/* minja::ExpressionNode::~ExpressionNode() */
void __thiscall minja::ExpressionNode::~ExpressionNode(ExpressionNode *this)
{
*(int ***)this = &PTR_do_render_0022b2c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28));
}
*(int ***)this = &PTR___cxa_pure_virtual_0022afe8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x30);
return;
}
|
|
18,339
|
uf_varchar2
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_varchar2(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]=to[1]=0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
int2store(to,length);
decode_bytes(rec,bit_buff,to+2,to+2+length);
}
}
|
O0
|
c
|
uf_varchar2:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x3ace7
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x3ad0b
jmp 0x3ad1f
movq -0x10(%rbp), %rdi
callq 0x39690
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x3ad1f
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3adb5
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x3ad62
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x282586(%rip), %rcx # 0x2bd2e0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x34(%rbp)
jmp 0x3ad75
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x38e40
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
movq -0x18(%rbp), %rcx
addq $0x2, %rcx
addq -0x28(%rbp), %rcx
callq 0x399d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
uf_varchar2:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_3ACE7
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_3AD0B
jmp short loc_3AD1F
loc_3ACE7:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_3AD1F
loc_3AD0B:
mov rax, [rbp+var_18]
mov byte ptr [rax+1], 0
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
jmp loc_3ADB5
loc_3AD1F:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_3AD62
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_34], eax
jmp short loc_3AD75
loc_3AD62:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_34], eax
loc_3AD75:
mov eax, [rbp+var_34]
mov eax, eax
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov cx, ax
mov rax, [rbp+var_30]
mov [rax], cx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
add rdx, 2
mov rcx, [rbp+var_18]
add rcx, 2
add rcx, [rbp+var_28]
call decode_bytes
loc_3ADB5:
add rsp, 40h
pop rbp
retn
|
long long uf_varchar2(long long a1, int *a2, _BYTE *a3)
{
int v3; // eax
int v4; // ecx
long long result; // rax
unsigned int v6; // eax
int v7; // ecx
int bits; // [rsp+Ch] [rbp-34h]
if ( a2[1] )
{
v3 = *a2;
v4 = a2[1] - 1;
a2[1] = v4;
if ( ((1 << v4) & v3) == 0 )
goto LABEL_6;
LABEL_5:
a3[1] = 0;
result = (long long)a3;
*a3 = 0;
return result;
}
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
goto LABEL_5;
LABEL_6:
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits(a2, *(_DWORD *)(a1 + 36));
}
else
{
v6 = *a2;
v7 = a2[1] - *(_DWORD *)(a1 + 36);
a2[1] = v7;
bits = mask[*(unsigned int *)(a1 + 36)] & (v6 >> v7);
}
*(_WORD *)a3 = bits;
return decode_bytes(a1, (long long)a2, a3 + 2, &a3[bits + 2]);
}
|
uf_varchar2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0013ace7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0013ad0b
JMP 0x0013ad1f
LAB_0013ace7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00139690
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x0013ad1f
LAB_0013ad0b:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x1],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
JMP 0x0013adb5
LAB_0013ad1f:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0013ad62
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x24]
MOV EDX,ECX
LEA RCX,[0x3bd2e0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0013ad75
LAB_0013ad62:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x00138e40
MOV dword ptr [RBP + -0x34],EAX
LAB_0013ad75:
MOV EAX,dword ptr [RBP + -0x34]
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOV word ptr [RAX],CX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,0x2
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x2
ADD RCX,qword ptr [RBP + -0x28]
CALL 0x001399d0
LAB_0013adb5:
ADD RSP,0x40
POP RBP
RET
|
void uf_varchar2(long param_1,uint *param_2,int2 *param_3)
{
uint uVar1;
uint local_3c;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_3c = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x24));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_3c = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
*param_3 = (short)local_3c;
decode_bytes(param_1,param_2,param_3 + 1,(int1 *)((long)param_3 + (ulong)local_3c + 2));
}
else {
*(int1 *)((long)param_3 + 1) = 0;
*(int1 *)param_3 = 0;
}
return;
}
|
|
18,340
|
my_string_repertoire
|
eloqsql/strings/ctype.c
|
my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
}
|
O0
|
c
|
my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x98(%rax)
jne 0xa1b28
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
jne 0xa1b28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa18d0
movl %eax, -0x4(%rbp)
jmp 0xa1b8b
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xa1b82
cmpq $0x7f, -0x30(%rbp)
jbe 0xa1b6d
movl $0x3, -0x4(%rbp)
jmp 0xa1b8b
jmp 0xa1b6f
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xa1b34
jmp 0xa1b84
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_string_repertoire:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp dword ptr [rax+98h], 1
jnz short loc_A1B28
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jnz short loc_A1B28
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_string_repertoire_8bit
mov [rbp+var_4], eax
jmp short loc_A1B8B
loc_A1B28:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_A1B34:
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_28]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_A1B82
cmp [rbp+var_30], 7Fh
jbe short loc_A1B6D
mov [rbp+var_4], 3
jmp short loc_A1B8B
loc_A1B6D:
jmp short $+2
loc_A1B6F:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_A1B34
loc_A1B82:
jmp short $+2
loc_A1B84:
mov [rbp+var_4], 1
loc_A1B8B:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long my_string_repertoire(long long a1, unsigned __int8 *a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
unsigned long long v5; // [rsp+10h] [rbp-30h] BYREF
unsigned __int8 *v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
unsigned __int8 *v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_DWORD *)(v9 + 12) & 0x2000) != 0 )
{
v6 = &v8[v7];
while ( 1 )
{
v4 = (*(long long ( **)(long long, unsigned long long *, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(v9 + 184) + 40LL))(
v9,
&v5,
v8,
v6);
if ( v4 <= 0 )
break;
if ( v5 > 0x7F )
return 3;
v8 += v4;
}
return 1;
}
else
{
return (unsigned int)my_string_repertoire_8bit(v9, v8, v7);
}
}
|
my_string_repertoire:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x98],0x1
JNZ 0x001a1b28
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JNZ 0x001a1b28
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001a18d0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a1b8b
LAB_001a1b28:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a1b34:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001a1b82
CMP qword ptr [RBP + -0x30],0x7f
JBE 0x001a1b6d
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001a1b8b
LAB_001a1b6d:
JMP 0x001a1b6f
LAB_001a1b6f:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001a1b34
LAB_001a1b82:
JMP 0x001a1b84
LAB_001a1b84:
MOV dword ptr [RBP + -0x4],0x1
LAB_001a1b8b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 my_string_repertoire(long param_1,long param_2,long param_3)
{
int iVar1;
ulong local_38;
long local_30;
long local_28;
long local_20;
long local_18;
int4 local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(uint *)(param_1 + 0xc) & 0x2000) == 0)) {
local_c = my_string_repertoire_8bit(param_1,param_2,param_3);
}
else {
local_30 = param_2 + param_3;
while (iVar1 = (**(code **)(*(long *)(local_18 + 0xb8) + 0x28))
(local_18,&local_38,local_20,local_30), 0 < iVar1) {
if (0x7f < local_38) {
return 3;
}
local_20 = local_20 + iVar1;
}
local_c = 1;
}
return local_c;
}
|
|
18,341
|
unsigned long testing::internal::(anonymous namespace)::ReadProcFileField<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-port.cc
|
T ReadProcFileField(const std::string& filename, int field) {
std::string dummy;
std::ifstream file(filename.c_str());
while (field-- > 0) {
file >> dummy;
}
T output = 0;
file >> output;
return output;
}
|
O0
|
cpp
|
unsigned long testing::internal::(anonymous namespace)::ReadProcFileField<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int):
subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movl %esi, 0x24c(%rsp)
leaq 0x228(%rsp), %rdi
callq 0x54e40
movq 0x250(%rsp), %rdi
callq 0x20e00
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x15e80
jmp 0xf93c4
jmp 0xf93c6
movl 0x24c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x24c(%rsp)
cmpl $0x0, %eax
jle 0xf941e
leaq 0x20(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0x159d0
jmp 0xf93f2
jmp 0xf93c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xf9464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x15190
jmp 0xf9464
movq $0x0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15b20
jmp 0xf9438
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x15190
leaq 0x228(%rsp), %rdi
callq 0x1c160
movq (%rsp), %rax
addq $0x258, %rsp # imm = 0x258
retq
leaq 0x228(%rsp), %rdi
callq 0x1c160
movq 0x18(%rsp), %rdi
callq 0x15dd0
nopl (%rax,%rax)
|
_ZN7testing8internal12_GLOBAL__N_117ReadProcFileFieldImEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
sub rsp, 258h
mov [rsp+258h+var_8], rdi
mov [rsp+258h+var_C], esi
lea rdi, [rsp+258h+var_30]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2Ev; std::string::basic_string(void)
mov rdi, [rsp+258h+var_8]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rsi, rax
lea rdi, [rsp+258h+var_238]
mov edx, 8
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1EPKcSt13_Ios_Openmode; std::ifstream::basic_ifstream(char const*,std::_Ios_Openmode)
jmp short $+2
loc_F93C4:
jmp short $+2
loc_F93C6:
mov eax, [rsp+258h+var_C]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rsp+258h+var_C], ecx
cmp eax, 0
jle short loc_F941E
lea rdi, [rsp+258h+var_238]
lea rsi, [rsp+258h+var_30]
call __ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator>><char>(std::istream &,std::string &)
jmp short $+2
loc_F93F2:
jmp short loc_F93C6
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
jmp short loc_F9464
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
lea rdi, [rsp+arg_18]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
jmp short loc_F9464
loc_F941E:
mov [rsp+258h+var_250], 0
lea rdi, [rsp+258h+var_238]
lea rsi, [rsp+258h+var_250]
call __ZNSirsERm; std::istream::operator>>(ulong &)
jmp short $+2
loc_F9438:
mov rax, [rsp+258h+var_250]
mov [rsp+258h+var_258], rax
lea rdi, [rsp+258h+var_238]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
lea rdi, [rsp+258h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, [rsp+258h+var_258]
add rsp, 258h
retn
loc_F9464:
lea rdi, [rsp+arg_220]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+arg_10]
call __Unwind_Resume
|
long long testing::internal::`anonymous namespace'::ReadProcFileField<unsigned long>(long long a1, int a2)
{
long long v2; // rax
int v3; // eax
long long v5; // [rsp+0h] [rbp-258h]
long long v6[3]; // [rsp+8h] [rbp-250h] BYREF
_BYTE v7[520]; // [rsp+20h] [rbp-238h] BYREF
_QWORD v8[4]; // [rsp+228h] [rbp-30h] BYREF
int v9; // [rsp+24Ch] [rbp-Ch]
long long v10; // [rsp+250h] [rbp-8h]
v10 = a1;
v9 = a2;
std::string::basic_string(v8);
v2 = std::string::c_str(v10);
std::ifstream::basic_ifstream(v7, v2, 8LL);
while ( 1 )
{
v3 = v9--;
if ( v3 <= 0 )
break;
std::operator>><char>(v7, v8);
}
v6[0] = 0LL;
std::istream::operator>>(v7, v6);
v5 = v6[0];
std::ifstream::~ifstream(v7);
std::string::~string(v8);
return v5;
}
|
ReadProcFileField<unsigned_long>:
SUB RSP,0x258
MOV qword ptr [RSP + 0x250],RDI
MOV dword ptr [RSP + 0x24c],ESI
LEA RDI,[RSP + 0x228]
CALL 0x00154e40
MOV RDI,qword ptr [RSP + 0x250]
CALL 0x00120e00
MOV RSI,RAX
LAB_001f93b3:
LEA RDI,[RSP + 0x20]
MOV EDX,0x8
CALL 0x00115e80
JMP 0x001f93c4
LAB_001f93c4:
JMP 0x001f93c6
LAB_001f93c6:
MOV EAX,dword ptr [RSP + 0x24c]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RSP + 0x24c],ECX
CMP EAX,0x0
JLE 0x001f941e
LAB_001f93de:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x228]
CALL 0x001159d0
JMP 0x001f93f2
LAB_001f93f2:
JMP 0x001f93c6
LAB_001f941e:
MOV qword ptr [RSP + 0x8],0x0
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x8]
CALL 0x00115b20
LAB_001f9436:
JMP 0x001f9438
LAB_001f9438:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x20]
CALL 0x00115190
LEA RDI,[RSP + 0x228]
CALL 0x0011c160
MOV RAX,qword ptr [RSP]
ADD RSP,0x258
RET
|
/* unsigned long testing::internal::(anonymous namespace)::ReadProcFileField<unsigned
long>(std::__cxx11::string const&, int) */
ulong testing::internal::(anonymous_namespace)::ReadProcFileField<unsigned_long>
(string *param_1,int param_2)
{
ulong uVar1;
int8 uVar2;
ulong local_250 [3];
ifstream local_238 [520];
string local_30 [36];
int local_c;
string *local_8;
local_c = param_2;
local_8 = param_1;
std::__cxx11::string::string(local_30);
uVar2 = std::__cxx11::string::c_str(local_8);
/* try { // try from 001f93b3 to 001f93c1 has its CatchHandler @ 001f93f4 */
std::ifstream::ifstream(local_238,uVar2,8);
while (0 < local_c) {
/* try { // try from 001f93de to 001f9435 has its CatchHandler @ 001f9404 */
local_c = local_c + -1;
std::operator>>((istream *)local_238,local_30);
}
local_250[0] = 0;
local_c = local_c + -1;
std::istream::operator>>((istream *)local_238,local_250);
uVar1 = local_250[0];
std::ifstream::~ifstream(local_238);
std::__cxx11::string::~string(local_30);
return uVar1;
}
|
|
18,342
|
bitmap_get_next_set
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_get_next_set(const MY_BITMAP *map, uint bitmap_bit)
{
uint word_pos, byte_to_mask, i;
union { my_bitmap_map bitmap ; uchar bitmap_buff[sizeof(my_bitmap_map)]; }
first_word;
uchar *ptr= &first_word.bitmap_buff[0];
my_bitmap_map *data_ptr, *end= map->last_word_ptr;
DBUG_ASSERT(map->bitmap);
/* Look for the next bit */
bitmap_bit++;
if (bitmap_bit >= map->n_bits)
return MY_BIT_NONE;
word_pos= bitmap_bit / 32;
data_ptr= map->bitmap + word_pos;
first_word.bitmap= *data_ptr;
/* Mask out previous bits from first_word */
byte_to_mask= (bitmap_bit % 32) / 8;
for (i= 0; i < byte_to_mask; i++)
ptr[i]= 0;
ptr[byte_to_mask]&= 0xFFU << (bitmap_bit & 7);
if (data_ptr == end)
{
if (first_word.bitmap & ~map->last_word_mask)
return get_first_set(first_word.bitmap, word_pos);
else
return MY_BIT_NONE;
}
if (first_word.bitmap)
return get_first_set(first_word.bitmap, word_pos);
for (data_ptr++, word_pos++; data_ptr < end; data_ptr++, word_pos++)
if (*data_ptr)
return get_first_set(*data_ptr, word_pos);
if (!(*end & ~map->last_word_mask))
return MY_BIT_NONE;
return get_first_set(*end, word_pos);
}
|
O3
|
c
|
bitmap_get_next_set:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
incl %ebx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpl 0x1c(%rdi), %ebx
jae 0x9dba9
movq %rdi, %r15
movq 0x8(%rdi), %r13
movl %ebx, %eax
shrl $0x5, %eax
movq (%rdi), %rcx
movq %rax, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
leaq (%rcx,%rax,4), %rdx
movl (%rdx), %eax
movl %eax, -0x30(%rbp)
movl %ebx, %r12d
shrl $0x3, %r12d
andl $0x3, %r12d
je 0x9db1a
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movq %rdx, -0x48(%rbp)
movq %r12, %rdx
callq 0x292c0
movq -0x48(%rbp), %rdx
movl %ebx, %ecx
andb $0x7, %cl
movl $0xff, %eax
shll %cl, %eax
andb %al, -0x30(%rbp,%r12)
movl -0x30(%rbp), %eax
cmpq %r13, %rdx
je 0x9db68
testl %eax, %eax
je 0x9dbbb
movl %eax, -0x2c(%rbp)
xorl %edx, %edx
movl $0x0, %ecx
testb %al, %al
jne 0x9db5b
xorl %ecx, %ecx
leaq -0x2b(%rbp), %rsi
movb (%rsi), %al
addl $0x8, %ecx
incq %rsi
testb %al, %al
je 0x9db4f
movzbl %al, %eax
btl %edx, %eax
leal 0x1(%rdx), %edx
jae 0x9db5e
jmp 0x9db9d
movl 0x18(%r15), %ecx
notl %ecx
testl %ecx, %eax
je 0x9dba9
movl %eax, -0x2c(%rbp)
xorl %edx, %edx
movl $0x0, %ecx
testb %al, %al
jne 0x9db92
xorl %ecx, %ecx
leaq -0x2b(%rbp), %rsi
movb (%rsi), %al
addl $0x8, %ecx
incq %rsi
testb %al, %al
je 0x9db86
movzbl %al, %eax
btl %edx, %eax
leal 0x1(%rdx), %edx
jae 0x9db95
andl $-0x20, %ebx
addl %ebx, %ecx
leal (%rdx,%rcx), %r14d
decl %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x40(%rbp), %rcx
movl %ecx, %eax
shll $0x5, %eax
decl %eax
movq -0x38(%rbp), %rdx
leaq (%rdx,%rcx,4), %rcx
addq $0x4, %rcx
cmpq %r13, %rcx
jae 0x9dc1a
movl (%rcx), %edx
addl $0x20, %eax
addq $0x4, %rcx
testl %edx, %edx
je 0x9dbd2
movl %edx, -0x2c(%rbp)
xorl %ecx, %ecx
movl $0x0, %r14d
testb %dl, %dl
jne 0x9dc07
xorl %r14d, %r14d
leaq -0x2b(%rbp), %rsi
movb (%rsi), %dl
addl $0x8, %r14d
incq %rsi
testb %dl, %dl
je 0x9dbfa
movzbl %dl, %edx
btl %ecx, %edx
leal 0x1(%rcx), %ecx
jae 0x9dc0a
addl %eax, %r14d
addl %ecx, %r14d
jmp 0x9dba9
movl (%r13), %esi
movl 0x18(%r15), %ecx
notl %ecx
testl %ecx, %esi
je 0x9dba9
movl %esi, -0x2c(%rbp)
xorl %edx, %edx
movl $0x0, %ecx
testb %sil, %sil
jne 0x9dc4b
xorl %ecx, %ecx
leaq -0x2b(%rbp), %rdi
movb (%rdi), %sil
addl $0x8, %ecx
incq %rdi
testb %sil, %sil
je 0x9dc3d
movzbl %sil, %esi
btl %edx, %esi
leal 0x1(%rdx), %edx
jae 0x9dc4f
addl %eax, %ecx
leal (%rdx,%rcx), %r14d
addl $0x20, %r14d
jmp 0x9dba9
|
bitmap_get_next_set:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, esi
inc ebx
mov r14d, 0FFFFFFFFh
cmp ebx, [rdi+1Ch]
jnb loc_9DBA9
mov r15, rdi
mov r13, [rdi+8]
mov eax, ebx
shr eax, 5
mov rcx, [rdi]
mov [rbp+var_40], rax
mov [rbp+var_38], rcx
lea rdx, [rcx+rax*4]
mov eax, [rdx]
mov [rbp+var_30], eax
mov r12d, ebx
shr r12d, 3
and r12d, 3
jz short loc_9DB1A
lea rdi, [rbp+var_30]
xor esi, esi
mov [rbp+var_48], rdx
mov rdx, r12
call _memset
mov rdx, [rbp+var_48]
loc_9DB1A:
mov ecx, ebx
and cl, 7
mov eax, 0FFh
shl eax, cl
and byte ptr [rbp+r12+var_30], al
mov eax, [rbp+var_30]
cmp rdx, r13
jz short loc_9DB68
test eax, eax
jz loc_9DBBB
mov [rbp+var_2C], eax
xor edx, edx
mov ecx, 0
test al, al
jnz short loc_9DB5B
xor ecx, ecx
lea rsi, [rbp+var_2C+1]
loc_9DB4F:
mov al, [rsi]
add ecx, 8
inc rsi
test al, al
jz short loc_9DB4F
loc_9DB5B:
movzx eax, al
loc_9DB5E:
bt eax, edx
lea edx, [rdx+1]
jnb short loc_9DB5E
jmp short loc_9DB9D
loc_9DB68:
mov ecx, [r15+18h]
not ecx
test eax, ecx
jz short loc_9DBA9
mov [rbp+var_2C], eax
xor edx, edx
mov ecx, 0
test al, al
jnz short loc_9DB92
xor ecx, ecx
lea rsi, [rbp+var_2C+1]
loc_9DB86:
mov al, [rsi]
add ecx, 8
inc rsi
test al, al
jz short loc_9DB86
loc_9DB92:
movzx eax, al
loc_9DB95:
bt eax, edx
lea edx, [rdx+1]
jnb short loc_9DB95
loc_9DB9D:
and ebx, 0FFFFFFE0h
add ecx, ebx
lea r14d, [rdx+rcx]
dec r14d
loc_9DBA9:
mov eax, r14d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9DBBB:
mov rcx, [rbp+var_40]
mov eax, ecx
shl eax, 5
dec eax
mov rdx, [rbp+var_38]
lea rcx, [rdx+rcx*4]
add rcx, 4
loc_9DBD2:
cmp rcx, r13
jnb short loc_9DC1A
mov edx, [rcx]
add eax, 20h ; ' '
add rcx, 4
test edx, edx
jz short loc_9DBD2
mov [rbp+var_2C], edx
xor ecx, ecx
mov r14d, 0
test dl, dl
jnz short loc_9DC07
xor r14d, r14d
lea rsi, [rbp+var_2C+1]
loc_9DBFA:
mov dl, [rsi]
add r14d, 8
inc rsi
test dl, dl
jz short loc_9DBFA
loc_9DC07:
movzx edx, dl
loc_9DC0A:
bt edx, ecx
lea ecx, [rcx+1]
jnb short loc_9DC0A
add r14d, eax
add r14d, ecx
jmp short loc_9DBA9
loc_9DC1A:
mov esi, [r13+0]
mov ecx, [r15+18h]
not ecx
test esi, ecx
jz short loc_9DBA9
mov [rbp+var_2C], esi
xor edx, edx
mov ecx, 0
test sil, sil
jnz short loc_9DC4B
xor ecx, ecx
lea rdi, [rbp+var_2C+1]
loc_9DC3D:
mov sil, [rdi]
add ecx, 8
inc rdi
test sil, sil
jz short loc_9DC3D
loc_9DC4B:
movzx esi, sil
loc_9DC4F:
bt esi, edx
lea edx, [rdx+1]
jnb short loc_9DC4F
add ecx, eax
lea r14d, [rdx+rcx]
add r14d, 20h ; ' '
jmp loc_9DBA9
|
long long bitmap_get_next_set(long long *a1, int a2)
{
unsigned int v2; // ebx
unsigned int v3; // r14d
int *v4; // r13
long long v5; // rcx
int *v6; // rdx
int v7; // eax
unsigned int v8; // edx
int v9; // ecx
_BYTE *v10; // rsi
unsigned __int8 v11; // cf
_BYTE *v12; // rsi
int v14; // eax
int *i; // rcx
int v16; // edx
unsigned int v17; // ecx
int v18; // r14d
_BYTE *v19; // rsi
int v20; // esi
unsigned int v21; // edx
int v22; // ecx
_BYTE *v23; // rdi
int *v24; // [rsp+8h] [rbp-48h]
long long v25; // [rsp+10h] [rbp-40h]
long long v26; // [rsp+18h] [rbp-38h]
int v27; // [rsp+20h] [rbp-30h] BYREF
_DWORD v28[11]; // [rsp+24h] [rbp-2Ch] BYREF
v2 = a2 + 1;
v3 = -1;
if ( (unsigned int)(a2 + 1) < *((_DWORD *)a1 + 7) )
{
v4 = (int *)a1[1];
v5 = *a1;
v25 = v2 >> 5;
v26 = *a1;
v6 = (int *)(*a1 + 4 * v25);
v27 = *v6;
if ( ((v2 >> 3) & 3) != 0 )
{
v24 = (int *)(v5 + 4 * v25);
memset(&v27, 0LL, (v2 >> 3) & 3);
v6 = v24;
}
*((_BYTE *)&v28[-1] + ((v2 >> 3) & 3)) &= 255 << (v2 & 7);
LOBYTE(v7) = v27;
if ( v6 == v4 )
{
if ( (~*((_DWORD *)a1 + 6) & v27) != 0 )
{
v28[0] = v27;
v8 = 0;
v9 = 0;
if ( !(_BYTE)v27 )
{
v9 = 0;
v12 = (char *)v28 + 1;
do
{
LOBYTE(v7) = *v12;
v9 += 8;
++v12;
}
while ( !(_BYTE)v7 );
}
v7 = (unsigned __int8)v7;
do
v11 = _bittest(&v7, v8++);
while ( !v11 );
return v8 + (v2 & 0xFFFFFFE0) + v9 - 1;
}
}
else
{
if ( v27 )
{
v28[0] = v27;
v8 = 0;
v9 = 0;
if ( !(_BYTE)v27 )
{
v9 = 0;
v10 = (char *)v28 + 1;
do
{
LOBYTE(v7) = *v10;
v9 += 8;
++v10;
}
while ( !(_BYTE)v7 );
}
v7 = (unsigned __int8)v7;
do
v11 = _bittest(&v7, v8++);
while ( !v11 );
return v8 + (v2 & 0xFFFFFFE0) + v9 - 1;
}
v14 = 32 * v25 - 1;
for ( i = (int *)(v26 + 4 * v25 + 4); i < v4; ++i )
{
v16 = *i;
v14 += 32;
if ( v16 )
{
v28[0] = v16;
v17 = 0;
v18 = 0;
if ( !(_BYTE)v16 )
{
v18 = 0;
v19 = (char *)v28 + 1;
do
{
LOBYTE(v16) = *v19;
v18 += 8;
++v19;
}
while ( !(_BYTE)v16 );
}
v16 = (unsigned __int8)v16;
do
v11 = _bittest(&v16, v17++);
while ( !v11 );
return v17 + v14 + v18;
}
}
v20 = *v4;
if ( (~*((_DWORD *)a1 + 6) & *v4) != 0 )
{
v28[0] = *v4;
v21 = 0;
v22 = 0;
if ( !(_BYTE)v20 )
{
v22 = 0;
v23 = (char *)v28 + 1;
do
{
LOBYTE(v20) = *v23;
v22 += 8;
++v23;
}
while ( !(_BYTE)v20 );
}
v20 = (unsigned __int8)v20;
do
v11 = _bittest(&v20, v21++);
while ( !v11 );
return v21 + v14 + v22 + 32;
}
}
}
return v3;
}
|
bitmap_get_next_set:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,ESI
INC EBX
MOV R14D,0xffffffff
CMP EBX,dword ptr [RDI + 0x1c]
JNC 0x0019dba9
MOV R15,RDI
MOV R13,qword ptr [RDI + 0x8]
MOV EAX,EBX
SHR EAX,0x5
MOV RCX,qword ptr [RDI]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],RCX
LEA RDX,[RCX + RAX*0x4]
MOV EAX,dword ptr [RDX]
MOV dword ptr [RBP + -0x30],EAX
MOV R12D,EBX
SHR R12D,0x3
AND R12D,0x3
JZ 0x0019db1a
LEA RDI,[RBP + -0x30]
XOR ESI,ESI
MOV qword ptr [RBP + -0x48],RDX
MOV RDX,R12
CALL 0x001292c0
MOV RDX,qword ptr [RBP + -0x48]
LAB_0019db1a:
MOV ECX,EBX
AND CL,0x7
MOV EAX,0xff
SHL EAX,CL
AND byte ptr [RBP + R12*0x1 + -0x30],AL
MOV EAX,dword ptr [RBP + -0x30]
CMP RDX,R13
JZ 0x0019db68
TEST EAX,EAX
JZ 0x0019dbbb
MOV dword ptr [RBP + -0x2c],EAX
XOR EDX,EDX
MOV ECX,0x0
TEST AL,AL
JNZ 0x0019db5b
XOR ECX,ECX
LEA RSI,[RBP + -0x2b]
LAB_0019db4f:
MOV AL,byte ptr [RSI]
ADD ECX,0x8
INC RSI
TEST AL,AL
JZ 0x0019db4f
LAB_0019db5b:
MOVZX EAX,AL
LAB_0019db5e:
BT EAX,EDX
LEA EDX,[RDX + 0x1]
JNC 0x0019db5e
JMP 0x0019db9d
LAB_0019db68:
MOV ECX,dword ptr [R15 + 0x18]
NOT ECX
TEST EAX,ECX
JZ 0x0019dba9
MOV dword ptr [RBP + -0x2c],EAX
XOR EDX,EDX
MOV ECX,0x0
TEST AL,AL
JNZ 0x0019db92
XOR ECX,ECX
LEA RSI,[RBP + -0x2b]
LAB_0019db86:
MOV AL,byte ptr [RSI]
ADD ECX,0x8
INC RSI
TEST AL,AL
JZ 0x0019db86
LAB_0019db92:
MOVZX EAX,AL
LAB_0019db95:
BT EAX,EDX
LEA EDX,[RDX + 0x1]
JNC 0x0019db95
LAB_0019db9d:
AND EBX,0xffffffe0
ADD ECX,EBX
LEA R14D,[RDX + RCX*0x1]
DEC R14D
LAB_0019dba9:
MOV EAX,R14D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019dbbb:
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,ECX
SHL EAX,0x5
DEC EAX
MOV RDX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RCX*0x4]
ADD RCX,0x4
LAB_0019dbd2:
CMP RCX,R13
JNC 0x0019dc1a
MOV EDX,dword ptr [RCX]
ADD EAX,0x20
ADD RCX,0x4
TEST EDX,EDX
JZ 0x0019dbd2
MOV dword ptr [RBP + -0x2c],EDX
XOR ECX,ECX
MOV R14D,0x0
TEST DL,DL
JNZ 0x0019dc07
XOR R14D,R14D
LEA RSI,[RBP + -0x2b]
LAB_0019dbfa:
MOV DL,byte ptr [RSI]
ADD R14D,0x8
INC RSI
TEST DL,DL
JZ 0x0019dbfa
LAB_0019dc07:
MOVZX EDX,DL
LAB_0019dc0a:
BT EDX,ECX
LEA ECX,[RCX + 0x1]
JNC 0x0019dc0a
ADD R14D,EAX
ADD R14D,ECX
JMP 0x0019dba9
LAB_0019dc1a:
MOV ESI,dword ptr [R13]
MOV ECX,dword ptr [R15 + 0x18]
NOT ECX
TEST ESI,ECX
JZ 0x0019dba9
MOV dword ptr [RBP + -0x2c],ESI
XOR EDX,EDX
MOV ECX,0x0
TEST SIL,SIL
JNZ 0x0019dc4b
XOR ECX,ECX
LEA RDI,[RBP + -0x2b]
LAB_0019dc3d:
MOV SIL,byte ptr [RDI]
ADD ECX,0x8
INC RDI
TEST SIL,SIL
JZ 0x0019dc3d
LAB_0019dc4b:
MOVZX ESI,SIL
LAB_0019dc4f:
BT ESI,EDX
LEA EDX,[RDX + 0x1]
JNC 0x0019dc4f
ADD ECX,EAX
LEA R14D,[RDX + RCX*0x1]
ADD R14D,0x20
JMP 0x0019dba9
|
int bitmap_get_next_set(long *param_1,int param_2)
{
byte bVar1;
uint *puVar2;
long lVar3;
uint uVar4;
int iVar5;
uint *puVar6;
uint uVar7;
byte *pbVar8;
uint uVar9;
int iVar10;
uint local_38;
int4 local_34;
uVar7 = param_2 + 1;
iVar5 = -1;
if (uVar7 < *(uint *)((long)param_1 + 0x1c)) {
puVar2 = (uint *)param_1[1];
uVar4 = uVar7 >> 5;
lVar3 = *param_1;
puVar6 = (uint *)(lVar3 + (ulong)uVar4 * 4);
local_38 = *puVar6;
uVar9 = uVar7 >> 3 & 3;
if (uVar9 != 0) {
memset(&local_38,0,(ulong)uVar9);
}
pbVar8 = (byte *)((long)&local_38 + (ulong)uVar9);
*pbVar8 = *pbVar8 & (byte)(0xff << ((byte)uVar7 & 7));
if (puVar6 == puVar2) {
if ((local_38 & ~*(uint *)(param_1 + 3)) == 0) {
return -1;
}
local_34 = local_38;
uVar4 = 0;
iVar5 = 0;
if ((char)local_38 == '\0') {
pbVar8 = (byte *)((long)&local_34 + 1);
do {
bVar1 = *pbVar8;
local_38 = (uint)bVar1;
iVar5 = iVar5 + 8;
pbVar8 = pbVar8 + 1;
} while (bVar1 == 0);
}
do {
uVar9 = uVar4 & 0x1f;
uVar4 = uVar4 + 1;
} while (((local_38 & 0xff) >> uVar9 & 1) == 0);
}
else {
if (local_38 == 0) {
iVar5 = uVar4 * 0x20 + -1;
puVar6 = (uint *)(lVar3 + (ulong)uVar4 * 4);
do {
puVar6 = puVar6 + 1;
if (puVar2 <= puVar6) {
local_34 = *puVar2;
if ((local_34 & ~*(uint *)(param_1 + 3)) == 0) {
return -1;
}
uVar7 = 0;
iVar10 = 0;
if ((char)local_34 == '\0') {
iVar10 = 0;
pbVar8 = (byte *)((long)&local_34 + 1);
do {
bVar1 = *pbVar8;
local_34 = (uint)bVar1;
iVar10 = iVar10 + 8;
pbVar8 = pbVar8 + 1;
} while (bVar1 == 0);
}
do {
uVar4 = uVar7 & 0x1f;
uVar7 = uVar7 + 1;
} while (((local_34 & 0xff) >> uVar4 & 1) == 0);
return uVar7 + iVar10 + iVar5 + 0x20;
}
local_34 = *puVar6;
iVar5 = iVar5 + 0x20;
} while (local_34 == 0);
uVar7 = 0;
iVar10 = 0;
if ((char)local_34 == '\0') {
iVar10 = 0;
pbVar8 = (byte *)((long)&local_34 + 1);
do {
bVar1 = *pbVar8;
local_34 = (uint)bVar1;
iVar10 = iVar10 + 8;
pbVar8 = pbVar8 + 1;
} while (bVar1 == 0);
}
do {
uVar4 = uVar7 & 0x1f;
uVar7 = uVar7 + 1;
} while (((local_34 & 0xff) >> uVar4 & 1) == 0);
return iVar10 + iVar5 + uVar7;
}
local_34 = local_38;
uVar4 = 0;
iVar5 = 0;
if ((char)local_38 == '\0') {
iVar5 = 0;
pbVar8 = (byte *)((long)&local_34 + 1);
do {
bVar1 = *pbVar8;
local_38 = (uint)bVar1;
iVar5 = iVar5 + 8;
pbVar8 = pbVar8 + 1;
} while (bVar1 == 0);
}
do {
uVar9 = uVar4 & 0x1f;
uVar4 = uVar4 + 1;
} while (((local_38 & 0xff) >> uVar9 & 1) == 0);
}
iVar5 = uVar4 + iVar5 + (uVar7 & 0xffffffe0) + -1;
}
return iVar5;
}
|
|
18,343
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace(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&, minja::Value&&)
|
monkey531[P]llama/common/json.hpp
|
std::pair<iterator, bool> emplace(const key_type& key, T&& t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(key, std::forward<T>(t));
return {std::prev(this->end()), true};
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace(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&, minja::Value&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x6e869
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6cd5e
testb %al, %al
jne 0x6e883
addq $0x60, %rbx
jmp 0x6e84e
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6e894
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x6e885
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
loc_6E84E:
cmp rbx, [r14+8]
jz short loc_6E869
mov rdi, rbx
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_6E883
add rbx, 60h ; '`'
jmp short loc_6E84E
loc_6E869:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRSF_SH_EEERSI_DpOT_; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::emplace_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&,minja::Value>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_6E885
loc_6E883:
xor edx, edx
loc_6E885:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::emplace(
char **a1,
char *a2,
long long a3,
__m128d a4)
{
char *i; // rbx
for ( i = *a1; i != a1[1]; i += 96 )
{
if ( nlohmann::json_abi_v3_11_3::operator==(i, a2, a4) )
return (long long)i;
}
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,minja::Value>(
a1,
a2,
a3);
return (long long)(a1[1] - 96);
}
|
emplace:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_0016e84e:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x0016e869
MOV RDI,RBX
MOV RSI,R12
CALL 0x0016cd5e
TEST AL,AL
JNZ 0x0016e883
ADD RBX,0x60
JMP 0x0016e84e
LAB_0016e869:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0016e894
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x0016e885
LAB_0016e883:
XOR EDX,EDX
LAB_0016e885:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, minja::Value&&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::emplace(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,basic_json *param_1,Value *param_2)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
int1 auVar4 [16];
pbVar3 = *(basic_json **)this;
do {
if (pbVar3 == *(basic_json **)(this + 8)) {
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::
emplace_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&,minja::Value>
((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,param_1,param_2);
pbVar3 = (basic_json *)(*(long *)(this + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0016e885:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = pbVar3;
return auVar4;
}
cVar1 = json_abi_v3_11_3::operator==(pbVar3,param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_0016e885;
}
pbVar3 = pbVar3 + 0x60;
} while( true );
}
|
|
18,344
|
my_casedn_str_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_casedn_str_8bit(CHARSET_INFO * cs,char *str)
{
register const uchar *map= cs->to_lower;
char *str_orig= str;
while ((*str= (char) map[(uchar) *str]) != 0)
str++;
return (size_t) (str - str_orig);
}
|
O0
|
c
|
my_casedn_str_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa16fa
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa16d0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
|
my_casedn_str_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_A16D0:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov al, [rax+rcx]
mov rcx, [rbp+var_10]
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_A16FA
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_A16D0
loc_A16FA:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
|
_BYTE * my_casedn_str_8bit(long long a1, _BYTE *a2)
{
char v2; // al
long long v4; // [rsp+8h] [rbp-18h]
_BYTE *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
v4 = *(_QWORD *)(a1 + 72);
while ( 1 )
{
v2 = *(_BYTE *)(v4 + (unsigned __int8)*v5);
*v5 = v2;
if ( !v2 )
break;
++v5;
}
return (_BYTE *)(v5 - a2);
}
|
my_casedn_str_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_001a16d0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001a16fa
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001a16d0
LAB_001a16fa:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
POP RBP
RET
|
long my_casedn_str_8bit(long param_1,byte *param_2)
{
byte bVar1;
long lVar2;
byte *local_18;
lVar2 = *(long *)(param_1 + 0x48);
local_18 = param_2;
while (bVar1 = *(byte *)(lVar2 + (ulong)*local_18), *local_18 = bVar1, bVar1 != 0) {
local_18 = local_18 + 1;
}
return (long)local_18 - (long)param_2;
}
|
|
18,345
|
test_mul_mat_id::test_mul_mat_id(ggml_type, ggml_type, int, int, bool, long, long, long)
|
monkey531[P]llama/tests/test-backend-ops.cpp
|
test_mul_mat_id(ggml_type type_a = GGML_TYPE_F32, ggml_type type_b = GGML_TYPE_F32,
int n_mats = 8, int n_used = 2, bool b = false,
int64_t m = 32, int64_t n = 32, int64_t k = 32)
: type_a(type_a), type_b(type_b), n_mats(n_mats), n_used(n_used), b(b),
m(m), n(n), k(k) {
GGML_ASSERT(n_used <= n_mats);
}
|
O1
|
cpp
|
test_mul_mat_id::test_mul_mat_id(ggml_type, ggml_type, int, int, bool, long, long, long):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rsp), %rax
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movups %xmm1, 0x8(%rdi)
leaq 0x3a22d(%rip), %rdi # 0x53b50
movq %rdi, (%rbx)
movl %esi, 0x38(%rbx)
movl %edx, 0x3c(%rbx)
movl %ecx, 0x40(%rbx)
movl %r8d, 0x44(%rbx)
movb %r9b, 0x48(%rbx)
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
cmpl %ecx, %r8d
jg 0x1994c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c275(%rip), %rdi # 0x45bc8
leaq 0x2c2c3(%rip), %rdx # 0x45c1d
leaq 0x2c72e(%rip), %rcx # 0x4608f
movl $0x7d0, %esi # imm = 0x7D0
xorl %eax, %eax
callq 0xda20
movq %rax, %r14
leaq 0x38e41(%rip), %rax # 0x527b8
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1998f
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0xd5e0
movq %r14, %rdi
callq 0xdb00
nop
|
_ZN15test_mul_mat_idC2E9ggml_typeS0_iiblll:
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rsp+18h+arg_10]
movaps xmm0, [rsp+18h+arg_0]
xorps xmm1, xmm1
movups xmmword ptr [rdi+20h], xmm1
mov qword ptr [rdi+30h], 0
movups xmmword ptr [rdi+8], xmm1
lea rdi, off_53B50
mov [rbx], rdi
mov [rbx+38h], esi
mov [rbx+3Ch], edx
mov [rbx+40h], ecx
mov [rbx+44h], r8d
mov [rbx+48h], r9b
movups xmmword ptr [rbx+50h], xmm0
mov [rbx+60h], rax
cmp r8d, ecx
jg short loc_1994C
add rsp, 8
pop rbx
pop r14
retn
loc_1994C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNUsedNMats; "n_used <= n_mats"
mov esi, 7D0h
xor eax, eax
call _ggml_abort
mov r14, rax
lea rax, off_527B8
mov [rbx], rax
mov rdi, [rbx+20h]; void *
test rdi, rdi
jz short loc_1998F
mov rsi, [rbx+30h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1998F:
mov rdi, r14
call __Unwind_Resume
|
long long test_mul_mat_id::test_mul_mat_id(
long long a1,
int a2,
int a3,
int a4,
int a5,
char a6,
__int128 a7,
long long a8)
{
long long result; // rax
long long v10; // r14
void *v11; // rdi
result = a8;
*(_OWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = off_53B50;
*(_DWORD *)(a1 + 56) = a2;
*(_DWORD *)(a1 + 60) = a3;
*(_DWORD *)(a1 + 64) = a4;
*(_DWORD *)(a1 + 68) = a5;
*(_BYTE *)(a1 + 72) = a6;
*(_OWORD *)(a1 + 80) = a7;
*(_QWORD *)(a1 + 96) = a8;
if ( a5 > a4 )
{
v10 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/tests/test-backend-ops.cpp",
2000LL,
"GGML_ASSERT(%s) failed",
"n_used <= n_mats");
*(_QWORD *)a1 = &off_527B8;
v11 = *(void **)(a1 + 32);
if ( v11 )
operator delete(v11, *(_QWORD *)(a1 + 48) - (_QWORD)v11);
_Unwind_Resume(v10);
}
return result;
}
|
test_mul_mat_id:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RSP + 0x30]
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RDI + 0x20],XMM1
MOV qword ptr [RDI + 0x30],0x0
MOVUPS xmmword ptr [RDI + 0x8],XMM1
LEA RDI,[0x153b50]
MOV qword ptr [RBX],RDI
MOV dword ptr [RBX + 0x38],ESI
MOV dword ptr [RBX + 0x3c],EDX
MOV dword ptr [RBX + 0x40],ECX
MOV dword ptr [RBX + 0x44],R8D
MOV byte ptr [RBX + 0x48],R9B
MOVUPS xmmword ptr [RBX + 0x50],XMM0
MOV qword ptr [RBX + 0x60],RAX
CMP R8D,ECX
JG 0x0011994c
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0011994c:
LEA RDI,[0x145bc8]
LEA RDX,[0x145c1d]
LEA RCX,[0x14608f]
MOV ESI,0x7d0
XOR EAX,EAX
CALL 0x0010da20
|
/* test_mul_mat_id::test_mul_mat_id(ggml_type, ggml_type, int, int, bool, long, long, long) */
void __thiscall
test_mul_mat_id::test_mul_mat_id
(test_mul_mat_id *this,int4 param_2,int4 param_3,int param_4,int param_5,
test_mul_mat_id param_6,int8 param_7,int8 param_8,int8 param_9)
{
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__test_case_00153b50;
*(int4 *)(this + 0x38) = param_2;
*(int4 *)(this + 0x3c) = param_3;
*(int *)(this + 0x40) = param_4;
*(int *)(this + 0x44) = param_5;
this[0x48] = param_6;
*(int4 *)(this + 0x50) = (int4)param_7;
*(int4 *)(this + 0x54) = param_7._4_4_;
*(int4 *)(this + 0x58) = (int4)param_8;
*(int4 *)(this + 0x5c) = param_8._4_4_;
*(int8 *)(this + 0x60) = param_9;
if (param_5 <= param_4) {
return;
}
/* try { // try from 0011994c to 0011996c has its CatchHandler @ 0011996d */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/tests/test-backend-ops.cpp",
2000,"GGML_ASSERT(%s) failed","n_used <= n_mats");
}
|
|
18,346
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11])
|
monkey531[P]llama/common/./json.hpp
|
size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
}
|
O0
|
cpp
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa2a90
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa2ac0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xa2af0
testb $0x1, %al
jne 0x128159
jmp 0x128231
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xbbbe0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0x126ed0
testb $0x1, %al
jne 0x12818c
jmp 0x128220
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa2b70
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xa2ac0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xa2af0
testb $0x1, %al
jne 0x1281c9
jmp 0x12820b
leaq 0x38(%rsp), %rdi
callq 0xbbbe0
movq %rax, %rdi
callq 0xa3e00
leaq 0x38(%rsp), %rdi
callq 0xa2b30
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xa2b30
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbc220
leaq 0x38(%rsp), %rdi
callq 0xa2b70
jmp 0x128196
movq 0x18(%rsp), %rdi
callq 0x128250
movq $0x1, 0x50(%rsp)
jmp 0x12823a
jmp 0x128222
leaq 0x38(%rsp), %rdi
callq 0xa2b70
jmp 0x128132
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rdi, [rsp+58h+var_10]
mov [rsp+58h+var_40], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; 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>>>::begin(void)
mov [rsp+58h+var_20], rax
loc_128132:
mov rdi, [rsp+58h+var_40]
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 [rsp+58h+var_28], rax
lea rdi, [rsp+58h+var_20]
lea rsi, [rsp+58h+var_28]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__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_128159
jmp loc_128231
loc_128159:
mov rax, [rsp+58h+var_40]
add rax, 18h
mov [rsp+58h+var_48], rax
lea rdi, [rsp+58h+var_20]
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)
mov rdi, [rsp+58h+var_48]
mov rsi, rax
mov rdx, [rsp+58h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA11_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_12818C
jmp loc_128220
loc_12818C:
mov rax, [rsp+58h+var_20]
mov [rsp+58h+var_30], rax
loc_128196:
lea rdi, [rsp+58h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __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)
mov rdi, [rsp+58h+var_40]
mov [rsp+58h+var_50], rax
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 rdi, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
lea rsi, [rsp+58h+var_38]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__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_1281C9
jmp short loc_12820B
loc_1281C9:
lea rdi, [rsp+58h+var_20]
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)
mov rdi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; 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>>::~pair()
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __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)
mov [rsp+58h+var_58], rax
lea rdi, [rsp+58h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __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)
mov rdi, [rsp+58h+var_58]
mov rsi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; 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>>::pair(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>>&&)
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __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)
jmp short loc_128196
loc_12820B:
mov rdi, [rsp+58h+var_40]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; 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>>>::pop_back(void)
mov [rsp+58h+var_8], 1
jmp short loc_12823A
loc_128220:
jmp short $+2
loc_128222:
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __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)
jmp loc_128132
loc_128231:
mov [rsp+58h+var_8], 0
loc_12823A:
mov rax, [rsp+58h+var_8]
add rsp, 58h
retn
|
long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long a1,
long long a2)
{
long long v2; // rax
void *v3; // rax
long long v4; // rax
long long v6; // [rsp+0h] [rbp-58h]
_QWORD *v7; // [rsp+8h] [rbp-50h]
long long v8; // [rsp+20h] [rbp-38h] BYREF
long long v9; // [rsp+28h] [rbp-30h] BYREF
long long v10; // [rsp+30h] [rbp-28h] BYREF
long long i; // [rsp+38h] [rbp-20h] BYREF
long long v12; // [rsp+40h] [rbp-18h]
long long v13; // [rsp+48h] [rbp-10h]
v13 = a1;
v12 = a2;
for ( i = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(a1);
;
__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++(&i) )
{
v10 = 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(a1);
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)&i,
(long long)&v10) )
return 0LL;
v2 = __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)&i);
if ( std::equal_to<void>::operator()<std::string const&,char const(&)[11]>(a1 + 24, v2, v12) )
break;
}
v9 = i;
while ( 1 )
{
v7 = __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++(&v9);
v8 = 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(a1);
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)v7,
(long long)&v8) )
break;
v3 = (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,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)&i);
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>>::~pair(v3);
v6 = __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)&i);
v4 = __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)&v9);
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>>::pair(
v6,
v4);
__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++(&i);
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back(a1);
return 1LL;
}
| |||
18,347
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11])
|
monkey531[P]llama/common/./json.hpp
|
size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
}
|
O2
|
cpp
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x63a6b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b25d
testb %al, %al
jne 0x63a3e
addq $0x30, %rbx
jmp 0x63a20
movq %rbx, %r15
leaq 0x30(%r15), %r12
cmpq 0x8(%r14), %r12
je 0x63a63
movq %r15, %rdi
callq 0x3c902
movq %r15, %rdi
movq %r12, %rsi
callq 0x451ce
movq %r12, %r15
jmp 0x63a41
movq %r14, %rdi
callq 0x63a7e
xorl %eax, %eax
cmpq %r13, %rbx
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_63A20:
mov r13, [r14+8]
cmp rbx, r13
jz short loc_63A6B
mov rdi, rbx
mov rsi, r15
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_63A3E
add rbx, 30h ; '0'
jmp short loc_63A20
loc_63A3E:
mov r15, rbx
loc_63A41:
lea r12, [r15+30h]
cmp r12, [r14+8]
jz short loc_63A63
mov rdi, r15; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; 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>>::~pair()
mov rdi, r15
mov rsi, r12
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; 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>>::pair(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>>&&)
mov r15, r12
jmp short loc_63A41
loc_63A63:
mov rdi, r14
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; 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>>>::pop_back(void)
loc_63A6B:
xor eax, eax
cmp rbx, r13
setnz al
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
_BOOL8 ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long *a1,
char *a2)
{
long long i; // rbx
long long v4; // r13
char *v5; // rsi
char *j; // r15
for ( i = *a1; ; i += 48LL )
{
v4 = a1[1];
if ( i == v4 )
break;
v5 = a2;
if ( std::operator==<char>(i) )
{
for ( j = (char *)i; j + 48 != (char *)a1[1]; j += 48 )
{
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>>::~pair(j);
v5 = j + 48;
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>>::pair(
(long long)j,
(long long)(j + 48));
}
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>>>::pop_back(
a1,
v5);
return i != v4;
}
}
return i != v4;
}
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_00163a20:
MOV R13,qword ptr [R14 + 0x8]
CMP RBX,R13
JZ 0x00163a6b
MOV RDI,RBX
MOV RSI,R15
CALL 0x0012b25d
TEST AL,AL
JNZ 0x00163a3e
ADD RBX,0x30
JMP 0x00163a20
LAB_00163a3e:
MOV R15,RBX
LAB_00163a41:
LEA R12,[R15 + 0x30]
CMP R12,qword ptr [R14 + 0x8]
JZ 0x00163a63
MOV RDI,R15
CALL 0x0013c902
MOV RDI,R15
MOV RSI,R12
CALL 0x001451ce
MOV R15,R12
JMP 0x00163a41
LAB_00163a63:
MOV RDI,R14
CALL 0x00163a7e
LAB_00163a6b:
XOR EAX,EAX
CMP RBX,R13
SETNZ AL
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
bool _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
pair *ppVar1;
string *psVar2;
bool bVar3;
string *psVar4;
pair *this;
for (psVar4 = *(string **)param_1; psVar2 = *(string **)(param_1 + 8), psVar4 != psVar2;
psVar4 = psVar4 + 0x30) {
bVar3 = std::operator==(psVar4,param_2);
this = (pair *)psVar4;
if (bVar3) goto LAB_00163a41;
}
LAB_00163a6b:
return psVar4 != psVar2;
LAB_00163a41:
while (ppVar1 = (pair *)((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this + 0x30), ppVar1 != *(pair **)(param_1 + 8)) {
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this);
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this,ppVar1);
this = ppVar1;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::pop_back(param_1);
goto LAB_00163a6b;
}
|
|
18,348
|
my_lengthsp_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_lengthsp_8bit(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t length)
{
const char *end;
end= (const char *) skip_trailing_space((const uchar *)ptr, length);
return (size_t) (end-ptr);
}
|
O3
|
c
|
my_lengthsp_8bit:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %rdi
cmpq $0x15, %rdx
jb 0xd5bdb
movq %rdi, %rdx
andq $-0x4, %rdx
cmpq %rsi, %rdx
jbe 0xd5bdb
leaq 0x3(%rsi), %rax
andq $-0x4, %rax
movq %rdi, %rcx
movb -0x1(%rdi), %r8b
cmpq %rdx, %rdi
jbe 0xd5bfc
leaq -0x1(%rcx), %rdi
cmpb $0x20, %r8b
je 0xd5bc3
jmp 0xd5bde
movq %rdi, %rcx
movq %rcx, %rdx
subq %rsi, %rdx
movq %rdx, %rax
cmpq %rsi, %rcx
jbe 0xd5bfa
cmpb $0x20, -0x1(%rcx)
leaq -0x1(%rcx), %rcx
leaq -0x1(%rax), %rdx
je 0xd5be4
popq %rbp
retq
cmpb $0x20, %r8b
setne %dil
cmpq %rdx, %rax
setae %dl
orb %dil, %dl
jne 0xd5bde
movq %rcx, %rdx
movq %rdx, %rcx
cmpq %rax, %rdx
jbe 0xd5bde
leaq -0x4(%rcx), %rdx
cmpl $0x20202020, -0x4(%rcx) # imm = 0x20202020
je 0xd5c12
jmp 0xd5bde
|
my_lengthsp_8bit:
push rbp
mov rbp, rsp
lea rdi, [rsi+rdx]
cmp rdx, 15h
jb short loc_D5BDB
mov rdx, rdi
and rdx, 0FFFFFFFFFFFFFFFCh
cmp rdx, rsi
jbe short loc_D5BDB
lea rax, [rsi+3]
and rax, 0FFFFFFFFFFFFFFFCh
loc_D5BC3:
mov rcx, rdi
mov r8b, [rdi-1]
cmp rdi, rdx
jbe short loc_D5BFC
lea rdi, [rcx-1]
cmp r8b, 20h ; ' '
jz short loc_D5BC3
jmp short loc_D5BDE
loc_D5BDB:
mov rcx, rdi
loc_D5BDE:
mov rdx, rcx
sub rdx, rsi
loc_D5BE4:
mov rax, rdx
cmp rcx, rsi
jbe short loc_D5BFA
cmp byte ptr [rcx-1], 20h ; ' '
lea rcx, [rcx-1]
lea rdx, [rax-1]
jz short loc_D5BE4
loc_D5BFA:
pop rbp
retn
loc_D5BFC:
cmp r8b, 20h ; ' '
setnz dil
cmp rax, rdx
setnb dl
or dl, dil
jnz short loc_D5BDE
mov rdx, rcx
loc_D5C12:
mov rcx, rdx
cmp rdx, rax
jbe short loc_D5BDE
lea rdx, [rcx-4]
cmp dword ptr [rcx-4], 20202020h
jz short loc_D5C12
jmp short loc_D5BDE
|
unsigned long long my_lengthsp_8bit(long long a1, unsigned long long a2, unsigned long long a3)
{
unsigned long long v3; // rdi
unsigned long long v4; // rdx
unsigned long long v5; // rax
unsigned long long v6; // rcx
char v7; // r8
unsigned long long v8; // rdx
unsigned long long result; // rax
bool v10; // zf
unsigned long long v11; // rdx
v3 = a2 + a3;
if ( a3 < 0x15 || (v4 = v3 & 0xFFFFFFFFFFFFFFFCLL, (v3 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v6 = v3;
}
else
{
v5 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v6 = v3;
v7 = *(_BYTE *)(v3 - 1);
if ( v3 <= v4 )
break;
--v3;
if ( v7 != 32 )
goto LABEL_8;
}
if ( v7 == 32 && v5 < v4 )
{
v11 = v3;
do
{
v6 = v11;
if ( v11 <= v5 )
break;
v11 -= 4LL;
}
while ( *(_DWORD *)(v6 - 4) == 538976288 );
}
}
LABEL_8:
v8 = v6 - a2;
do
{
result = v8;
if ( v6 <= a2 )
break;
v10 = *(_BYTE *)--v6 == 32;
--v8;
}
while ( v10 );
return result;
}
|
my_lengthsp_8bit:
PUSH RBP
MOV RBP,RSP
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001d5bdb
MOV RDX,RDI
AND RDX,-0x4
CMP RDX,RSI
JBE 0x001d5bdb
LEA RAX,[RSI + 0x3]
AND RAX,-0x4
LAB_001d5bc3:
MOV RCX,RDI
MOV R8B,byte ptr [RDI + -0x1]
CMP RDI,RDX
JBE 0x001d5bfc
LEA RDI,[RCX + -0x1]
CMP R8B,0x20
JZ 0x001d5bc3
JMP 0x001d5bde
LAB_001d5bdb:
MOV RCX,RDI
LAB_001d5bde:
MOV RDX,RCX
SUB RDX,RSI
LAB_001d5be4:
MOV RAX,RDX
CMP RCX,RSI
JBE 0x001d5bfa
CMP byte ptr [RCX + -0x1],0x20
LEA RCX,[RCX + -0x1]
LEA RDX,[RAX + -0x1]
JZ 0x001d5be4
LAB_001d5bfa:
POP RBP
RET
LAB_001d5bfc:
CMP R8B,0x20
SETNZ DIL
CMP RAX,RDX
SETNC DL
OR DL,DIL
JNZ 0x001d5bde
MOV RDX,RCX
LAB_001d5c12:
MOV RCX,RDX
CMP RDX,RAX
JBE 0x001d5bde
LEA RDX,[RCX + -0x4]
CMP dword ptr [RCX + -0x4],0x20202020
JZ 0x001d5c12
JMP 0x001d5bde
|
void my_lengthsp_8bit(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar4 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar4 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar3 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar4;
do {
uVar4 = uVar2;
if (uVar4 <= uVar5) {
uVar2 = uVar4;
if (uVar3 < uVar5 && *(char *)(uVar4 - 1) == ' ') goto LAB_001d5c12;
break;
}
uVar2 = uVar4 - 1;
} while (*(char *)(uVar4 - 1) == ' ');
}
goto LAB_001d5be4;
while (uVar2 = uVar4 - 4, *(int *)(uVar4 - 4) == 0x20202020) {
LAB_001d5c12:
uVar4 = uVar2;
if (uVar4 <= uVar3) break;
}
LAB_001d5be4:
do {
if (uVar4 <= param_2) {
return;
}
pcVar1 = (char *)(uVar4 - 1);
uVar4 = uVar4 - 1;
} while (*pcVar1 == ' ');
return;
}
|
|
18,349
|
ma_state_info_read
|
eloqsql/storage/maria/ma_open.c
|
static uchar *_ma_state_info_read(uchar *ptr, MARIA_STATE_INFO *state, myf flag)
{
uint i,keys,key_parts;
DBUG_ENTER("_ma_state_info_read");
memcpy(&state->header,ptr, sizeof(state->header));
ptr+= sizeof(state->header);
keys= (uint) state->header.keys;
key_parts= mi_uint2korr(state->header.key_parts);
/* Allocate memory for key parts if not already done */
if (!state->rec_per_key_part &&
!my_multi_malloc(PSI_INSTRUMENT_ME, MYF(MY_WME | flag),
&state->rec_per_key_part,
sizeof(*state->rec_per_key_part) * key_parts,
&state->nulls_per_key_part,
sizeof(*state->nulls_per_key_part) * key_parts,
NullS))
DBUG_RETURN(0);
state->open_count = mi_uint2korr(ptr); ptr+= 2;
state->changed= mi_uint2korr(ptr); ptr+= 2;
state->create_rename_lsn= lsn_korr(ptr); ptr+= LSN_STORE_SIZE;
state->is_of_horizon= lsn_korr(ptr); ptr+= LSN_STORE_SIZE;
state->skip_redo_lsn= lsn_korr(ptr); ptr+= LSN_STORE_SIZE;
state->state.records= mi_rowkorr(ptr); ptr+= 8;
state->state.del = mi_rowkorr(ptr); ptr+= 8;
state->split = mi_rowkorr(ptr); ptr+= 8;
state->dellink= mi_sizekorr(ptr); ptr+= 8;
state->first_bitmap_with_space= mi_sizekorr(ptr); ptr+= 8;
state->state.key_file_length = mi_sizekorr(ptr); ptr+= 8;
state->state.data_file_length= mi_sizekorr(ptr); ptr+= 8;
state->state.empty = mi_sizekorr(ptr); ptr+= 8;
state->state.key_empty= mi_sizekorr(ptr); ptr+= 8;
state->auto_increment=mi_uint8korr(ptr); ptr+= 8;
state->state.checksum=(ha_checksum) mi_uint8korr(ptr);ptr+= 8;
state->create_trid= mi_uint8korr(ptr); ptr+= 8;
state->status = mi_uint4korr(ptr); ptr+= 4;
state->update_count=mi_uint4korr(ptr); ptr+= 4;
state->sortkey= (uint) *ptr++;
ptr++; /* reserved */
ptr+= state->state_diff_length;
for (i=0; i < keys; i++)
{
state->key_root[i]= mi_sizekorr(ptr); ptr+= 8;
}
state->key_del= mi_sizekorr(ptr); ptr+= 8;
state->sec_index_changed = mi_uint4korr(ptr); ptr+= 4;
state->sec_index_used = mi_uint4korr(ptr); ptr+= 4;
state->version = mi_uint4korr(ptr); ptr+= 4;
state->key_map = mi_uint8korr(ptr); ptr+= 8;
state->create_time = (time_t) mi_sizekorr(ptr); ptr+= 8;
state->recover_time =(time_t) mi_sizekorr(ptr); ptr+= 8;
state->check_time = (time_t) mi_sizekorr(ptr); ptr+= 8;
state->records_at_analyze= mi_sizekorr(ptr); ptr+= 8;
ptr+= keys * 4; /* Skip reserved bytes */
for (i=0 ; i < key_parts ; i++)
{
float8get(state->rec_per_key_part[i], ptr); ptr+= 8;
state->nulls_per_key_part[i]= mi_uint4korr(ptr); ptr+= 4;
}
DBUG_PRINT("info", ("Records: %lld", state->state.records));
DBUG_RETURN(ptr);
}
|
O3
|
c
|
ma_state_info_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsi)
movups (%rdi), %xmm0
movups %xmm0, (%rsi)
movzbl 0x12(%rsi), %r9d
movzbl 0xf(%rsi), %r8d
movzbl 0xe(%rsi), %r12d
shll $0x8, %r12d
leal (%r12,%r8), %r13d
cmpq $0x0, 0x100(%rsi)
jne 0x3972d
leaq 0x100(%rbx), %rax
orq $0x10, %rdx
leal (,%r13,8), %ecx
movq %r8, -0x38(%rbp)
leaq 0x108(%rbx), %r8
movq $0x0, (%rsp)
xorl %r15d, %r15d
xorl %edi, %edi
movq %rdx, %rsi
movq %rax, %rdx
movq %r9, -0x30(%rbp)
movq %rcx, %r9
xorl %eax, %eax
callq 0xa4004
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %r8
testq %rax, %rax
je 0x3996f
movzwl 0x18(%r14), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x16c(%rbx)
movzwl 0x1a(%r14), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x170(%rbx)
movzwl 0x1c(%r14), %eax
shlq $0x20, %rax
movzbl 0x1e(%r14), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x1f(%r14), %eax
orq %rcx, %rax
movq %rax, 0x178(%rbx)
movzwl 0x23(%r14), %eax
shlq $0x20, %rax
movzbl 0x25(%r14), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x26(%r14), %eax
orq %rcx, %rax
movq %rax, 0x180(%rbx)
movzwl 0x2a(%r14), %eax
shlq $0x20, %rax
movzbl 0x2c(%r14), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x2d(%r14), %eax
orq %rcx, %rax
movq %rax, 0x188(%rbx)
movq 0x31(%r14), %rax
bswapq %rax
movq %rax, 0x18(%rbx)
movq 0x39(%r14), %rax
bswapq %rax
movq %rax, 0x20(%rbx)
movq 0x41(%r14), %rax
bswapq %rax
movq %rax, 0xc0(%rbx)
movq 0x49(%r14), %rax
bswapq %rax
movq %rax, 0xc8(%rbx)
movq 0x51(%r14), %rax
bswapq %rax
movq %rax, 0xd0(%rbx)
movq 0x59(%r14), %rax
bswapq %rax
movq %rax, 0x38(%rbx)
movq 0x61(%r14), %rax
bswapq %rax
movq %rax, 0x40(%rbx)
movq 0x69(%r14), %rax
bswapq %rax
movq %rax, 0x28(%rbx)
movq 0x71(%r14), %rax
bswapq %rax
movq %rax, 0x30(%rbx)
movq 0x79(%r14), %rax
bswapq %rax
movq %rax, 0xd8(%rbx)
movl 0x85(%r14), %eax
bswapl %eax
movl %eax, 0x48(%rbx)
movq 0x89(%r14), %rax
bswapq %rax
movq %rax, 0xe0(%rbx)
movl 0x91(%r14), %eax
bswapl %eax
movq %rax, 0xf8(%rbx)
movl 0x95(%r14), %eax
bswapl %eax
movq %rax, 0xf0(%rbx)
movzbl 0x99(%r14), %eax
movl %eax, 0x168(%rbx)
movl 0x19c(%rbx), %eax
addq %r14, %rax
addq $0x9b, %rax
testq %r9, %r9
je 0x398bb
leal (,%r9,8), %edx
xorl %ecx, %ecx
movq (%rax,%rcx), %rsi
bswapq %rsi
movq 0x118(%rbx), %rdi
movq %rsi, (%rdi,%rcx)
addq $0x8, %rcx
cmpq %rcx, %rdx
jne 0x3989d
addq %rcx, %rax
movq (%rax), %rcx
bswapq %rcx
movq %rcx, 0x120(%rbx)
movl 0x8(%rax), %ecx
bswapl %ecx
movq %rcx, 0x130(%rbx)
movl 0xc(%rax), %ecx
bswapl %ecx
movq %rcx, 0x138(%rbx)
movl 0x10(%rax), %ecx
bswapl %ecx
movq %rcx, 0x148(%rbx)
movq 0x14(%rax), %rcx
bswapq %rcx
movq %rcx, 0x140(%rbx)
movq 0x1c(%rax), %rcx
bswapq %rcx
movq %rcx, 0x150(%rbx)
movq 0x24(%rax), %rcx
bswapq %rcx
movq %rcx, 0x158(%rbx)
movq 0x2c(%rax), %rcx
bswapq %rcx
movq %rcx, 0x160(%rbx)
movq 0x34(%rax), %rcx
bswapq %rcx
movq %rcx, 0x128(%rbx)
leaq (%rax,%r9,4), %r15
addq $0x3c, %r15
testl %r13d, %r13d
je 0x3996f
addl %r8d, %r12d
xorl %eax, %eax
movq 0x100(%rbx), %rcx
movq (%r15), %rdx
movq %rdx, (%rcx,%rax,8)
movl 0x8(%r15), %ecx
bswapl %ecx
movq 0x108(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
addq $0xc, %r15
incq %rax
cmpq %rax, %r12
jne 0x39944
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_state_info_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+10h]
mov [rsi+10h], rax
movups xmm0, xmmword ptr [rdi]
movups xmmword ptr [rsi], xmm0
movzx r9d, byte ptr [rsi+12h]
movzx r8d, byte ptr [rsi+0Fh]
movzx r12d, byte ptr [rsi+0Eh]
shl r12d, 8
lea r13d, [r12+r8]
cmp qword ptr [rsi+100h], 0
jnz short loc_3972D
lea rax, [rbx+100h]
or rdx, 10h
lea ecx, ds:0[r13*8]
mov [rbp+var_38], r8
lea r8, [rbx+108h]
mov [rsp+40h+var_40], 0
xor r15d, r15d
xor edi, edi
mov rsi, rdx
mov rdx, rax
mov [rbp+var_30], r9
mov r9, rcx
xor eax, eax
call my_multi_malloc
mov r9, [rbp+var_30]
mov r8, [rbp+var_38]
test rax, rax
jz loc_3996F
loc_3972D:
movzx eax, word ptr [r14+18h]
rol ax, 8
movzx eax, ax
mov [rbx+16Ch], eax
movzx eax, word ptr [r14+1Ah]
rol ax, 8
movzx eax, ax
mov [rbx+170h], eax
movzx eax, word ptr [r14+1Ch]
shl rax, 20h
movzx ecx, byte ptr [r14+1Eh]
shl rcx, 30h
or rcx, rax
mov eax, [r14+1Fh]
or rax, rcx
mov [rbx+178h], rax
movzx eax, word ptr [r14+23h]
shl rax, 20h
movzx ecx, byte ptr [r14+25h]
shl rcx, 30h
or rcx, rax
mov eax, [r14+26h]
or rax, rcx
mov [rbx+180h], rax
movzx eax, word ptr [r14+2Ah]
shl rax, 20h
movzx ecx, byte ptr [r14+2Ch]
shl rcx, 30h
or rcx, rax
mov eax, [r14+2Dh]
or rax, rcx
mov [rbx+188h], rax
mov rax, [r14+31h]
bswap rax
mov [rbx+18h], rax
mov rax, [r14+39h]
bswap rax
mov [rbx+20h], rax
mov rax, [r14+41h]
bswap rax
mov [rbx+0C0h], rax
mov rax, [r14+49h]
bswap rax
mov [rbx+0C8h], rax
mov rax, [r14+51h]
bswap rax
mov [rbx+0D0h], rax
mov rax, [r14+59h]
bswap rax
mov [rbx+38h], rax
mov rax, [r14+61h]
bswap rax
mov [rbx+40h], rax
mov rax, [r14+69h]
bswap rax
mov [rbx+28h], rax
mov rax, [r14+71h]
bswap rax
mov [rbx+30h], rax
mov rax, [r14+79h]
bswap rax
mov [rbx+0D8h], rax
mov eax, [r14+85h]
bswap eax
mov [rbx+48h], eax
mov rax, [r14+89h]
bswap rax
mov [rbx+0E0h], rax
mov eax, [r14+91h]
bswap eax
mov [rbx+0F8h], rax
mov eax, [r14+95h]
bswap eax
mov [rbx+0F0h], rax
movzx eax, byte ptr [r14+99h]
mov [rbx+168h], eax
mov eax, [rbx+19Ch]
add rax, r14
add rax, 9Bh
test r9, r9
jz short loc_398BB
lea edx, ds:0[r9*8]
xor ecx, ecx
loc_3989D:
mov rsi, [rax+rcx]
bswap rsi
mov rdi, [rbx+118h]
mov [rdi+rcx], rsi
add rcx, 8
cmp rdx, rcx
jnz short loc_3989D
add rax, rcx
loc_398BB:
mov rcx, [rax]
bswap rcx
mov [rbx+120h], rcx
mov ecx, [rax+8]
bswap ecx
mov [rbx+130h], rcx
mov ecx, [rax+0Ch]
bswap ecx
mov [rbx+138h], rcx
mov ecx, [rax+10h]
bswap ecx
mov [rbx+148h], rcx
mov rcx, [rax+14h]
bswap rcx
mov [rbx+140h], rcx
mov rcx, [rax+1Ch]
bswap rcx
mov [rbx+150h], rcx
mov rcx, [rax+24h]
bswap rcx
mov [rbx+158h], rcx
mov rcx, [rax+2Ch]
bswap rcx
mov [rbx+160h], rcx
mov rcx, [rax+34h]
bswap rcx
mov [rbx+128h], rcx
lea r15, [rax+r9*4]
add r15, 3Ch ; '<'
test r13d, r13d
jz short loc_3996F
add r12d, r8d
xor eax, eax
loc_39944:
mov rcx, [rbx+100h]
mov rdx, [r15]
mov [rcx+rax*8], rdx
mov ecx, [r15+8]
bswap ecx
mov rdx, [rbx+108h]
mov [rdx+rax*8], rcx
add r15, 0Ch
inc rax
cmp r12, rax
jnz short loc_39944
loc_3996F:
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_state_info_read(long long a1, long long a2, int a3)
{
long long v3; // r9
int v4; // r8d
int v5; // r12d
int v6; // r13d
long long v7; // r15
long long v8; // rax
long long v9; // rax
long long v10; // rcx
long long v11; // r12
long long v12; // rax
int v14; // [rsp+8h] [rbp-38h]
long long v15; // [rsp+10h] [rbp-30h]
*(_QWORD *)(a2 + 16) = *(_QWORD *)(a1 + 16);
*(_OWORD *)a2 = *(_OWORD *)a1;
v3 = *(unsigned __int8 *)(a2 + 18);
v4 = *(unsigned __int8 *)(a2 + 15);
v5 = *(unsigned __int8 *)(a2 + 14) << 8;
v6 = v5 + v4;
if ( *(_QWORD *)(a2 + 256)
|| (v14 = *(unsigned __int8 *)(a2 + 15),
v7 = 0LL,
v15 = *(unsigned __int8 *)(a2 + 18),
v8 = my_multi_malloc(0, a3 | 0x10u, (int)a2 + 256, 8 * v6, (int)a2 + 264, 8 * v6, 0LL),
v3 = v15,
v4 = v14,
v8) )
{
*(_DWORD *)(a2 + 364) = (unsigned __int16)__ROL2__(*(_WORD *)(a1 + 24), 8);
*(_DWORD *)(a2 + 368) = (unsigned __int16)__ROL2__(*(_WORD *)(a1 + 26), 8);
*(_QWORD *)(a2 + 376) = ((unsigned long long)*(unsigned __int16 *)(a1 + 28) << 32) | ((unsigned long long)*(unsigned __int8 *)(a1 + 30) << 48) | *(unsigned int *)(a1 + 31);
*(_QWORD *)(a2 + 384) = ((unsigned long long)*(unsigned __int16 *)(a1 + 35) << 32) | ((unsigned long long)*(unsigned __int8 *)(a1 + 37) << 48) | *(unsigned int *)(a1 + 38);
*(_QWORD *)(a2 + 392) = ((unsigned long long)*(unsigned __int16 *)(a1 + 42) << 32) | ((unsigned long long)*(unsigned __int8 *)(a1 + 44) << 48) | *(unsigned int *)(a1 + 45);
*(_QWORD *)(a2 + 24) = _byteswap_uint64(*(_QWORD *)(a1 + 49));
*(_QWORD *)(a2 + 32) = _byteswap_uint64(*(_QWORD *)(a1 + 57));
*(_QWORD *)(a2 + 192) = _byteswap_uint64(*(_QWORD *)(a1 + 65));
*(_QWORD *)(a2 + 200) = _byteswap_uint64(*(_QWORD *)(a1 + 73));
*(_QWORD *)(a2 + 208) = _byteswap_uint64(*(_QWORD *)(a1 + 81));
*(_QWORD *)(a2 + 56) = _byteswap_uint64(*(_QWORD *)(a1 + 89));
*(_QWORD *)(a2 + 64) = _byteswap_uint64(*(_QWORD *)(a1 + 97));
*(_QWORD *)(a2 + 40) = _byteswap_uint64(*(_QWORD *)(a1 + 105));
*(_QWORD *)(a2 + 48) = _byteswap_uint64(*(_QWORD *)(a1 + 113));
*(_QWORD *)(a2 + 216) = _byteswap_uint64(*(_QWORD *)(a1 + 121));
*(_DWORD *)(a2 + 72) = _byteswap_ulong(*(_DWORD *)(a1 + 133));
*(_QWORD *)(a2 + 224) = _byteswap_uint64(*(_QWORD *)(a1 + 137));
*(_QWORD *)(a2 + 248) = _byteswap_ulong(*(_DWORD *)(a1 + 145));
*(_QWORD *)(a2 + 240) = _byteswap_ulong(*(_DWORD *)(a1 + 149));
*(_DWORD *)(a2 + 360) = *(unsigned __int8 *)(a1 + 153);
v9 = a1 + *(unsigned int *)(a2 + 412) + 155;
if ( v3 )
{
v10 = 0LL;
do
{
*(_QWORD *)(*(_QWORD *)(a2 + 280) + v10) = _byteswap_uint64(*(_QWORD *)(v9 + v10));
v10 += 8LL;
}
while ( 8 * (_DWORD)v3 != v10 );
v9 += v10;
}
*(_QWORD *)(a2 + 288) = _byteswap_uint64(*(_QWORD *)v9);
*(_QWORD *)(a2 + 304) = _byteswap_ulong(*(_DWORD *)(v9 + 8));
*(_QWORD *)(a2 + 312) = _byteswap_ulong(*(_DWORD *)(v9 + 12));
*(_QWORD *)(a2 + 328) = _byteswap_ulong(*(_DWORD *)(v9 + 16));
*(_QWORD *)(a2 + 320) = _byteswap_uint64(*(_QWORD *)(v9 + 20));
*(_QWORD *)(a2 + 336) = _byteswap_uint64(*(_QWORD *)(v9 + 28));
*(_QWORD *)(a2 + 344) = _byteswap_uint64(*(_QWORD *)(v9 + 36));
*(_QWORD *)(a2 + 352) = _byteswap_uint64(*(_QWORD *)(v9 + 44));
*(_QWORD *)(a2 + 296) = _byteswap_uint64(*(_QWORD *)(v9 + 52));
v7 = v9 + 4 * v3 + 60;
if ( v6 )
{
v11 = (unsigned int)(v4 + v5);
v12 = 0LL;
do
{
*(_QWORD *)(*(_QWORD *)(a2 + 256) + 8 * v12) = *(_QWORD *)v7;
*(_QWORD *)(*(_QWORD *)(a2 + 264) + 8 * v12) = _byteswap_ulong(*(_DWORD *)(v7 + 8));
v7 += 12LL;
++v12;
}
while ( v11 != v12 );
}
}
return v7;
}
|
_ma_state_info_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RSI + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RDI]
MOVUPS xmmword ptr [RSI],XMM0
MOVZX R9D,byte ptr [RSI + 0x12]
MOVZX R8D,byte ptr [RSI + 0xf]
MOVZX R12D,byte ptr [RSI + 0xe]
SHL R12D,0x8
LEA R13D,[R12 + R8*0x1]
CMP qword ptr [RSI + 0x100],0x0
JNZ 0x0013972d
LEA RAX,[RBX + 0x100]
OR RDX,0x10
LEA ECX,[R13*0x8]
MOV qword ptr [RBP + -0x38],R8
LEA R8,[RBX + 0x108]
MOV qword ptr [RSP],0x0
XOR R15D,R15D
XOR EDI,EDI
MOV RSI,RDX
MOV RDX,RAX
MOV qword ptr [RBP + -0x30],R9
MOV R9,RCX
XOR EAX,EAX
CALL 0x001a4004
MOV R9,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x38]
TEST RAX,RAX
JZ 0x0013996f
LAB_0013972d:
MOVZX EAX,word ptr [R14 + 0x18]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBX + 0x16c],EAX
MOVZX EAX,word ptr [R14 + 0x1a]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBX + 0x170],EAX
MOVZX EAX,word ptr [R14 + 0x1c]
SHL RAX,0x20
MOVZX ECX,byte ptr [R14 + 0x1e]
SHL RCX,0x30
OR RCX,RAX
MOV EAX,dword ptr [R14 + 0x1f]
OR RAX,RCX
MOV qword ptr [RBX + 0x178],RAX
MOVZX EAX,word ptr [R14 + 0x23]
SHL RAX,0x20
MOVZX ECX,byte ptr [R14 + 0x25]
SHL RCX,0x30
OR RCX,RAX
MOV EAX,dword ptr [R14 + 0x26]
OR RAX,RCX
MOV qword ptr [RBX + 0x180],RAX
MOVZX EAX,word ptr [R14 + 0x2a]
SHL RAX,0x20
MOVZX ECX,byte ptr [R14 + 0x2c]
SHL RCX,0x30
OR RCX,RAX
MOV EAX,dword ptr [R14 + 0x2d]
OR RAX,RCX
MOV qword ptr [RBX + 0x188],RAX
MOV RAX,qword ptr [R14 + 0x31]
BSWAP RAX
MOV qword ptr [RBX + 0x18],RAX
MOV RAX,qword ptr [R14 + 0x39]
BSWAP RAX
MOV qword ptr [RBX + 0x20],RAX
MOV RAX,qword ptr [R14 + 0x41]
BSWAP RAX
MOV qword ptr [RBX + 0xc0],RAX
MOV RAX,qword ptr [R14 + 0x49]
BSWAP RAX
MOV qword ptr [RBX + 0xc8],RAX
MOV RAX,qword ptr [R14 + 0x51]
BSWAP RAX
MOV qword ptr [RBX + 0xd0],RAX
MOV RAX,qword ptr [R14 + 0x59]
BSWAP RAX
MOV qword ptr [RBX + 0x38],RAX
MOV RAX,qword ptr [R14 + 0x61]
BSWAP RAX
MOV qword ptr [RBX + 0x40],RAX
MOV RAX,qword ptr [R14 + 0x69]
BSWAP RAX
MOV qword ptr [RBX + 0x28],RAX
MOV RAX,qword ptr [R14 + 0x71]
BSWAP RAX
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R14 + 0x79]
BSWAP RAX
MOV qword ptr [RBX + 0xd8],RAX
MOV EAX,dword ptr [R14 + 0x85]
BSWAP EAX
MOV dword ptr [RBX + 0x48],EAX
MOV RAX,qword ptr [R14 + 0x89]
BSWAP RAX
MOV qword ptr [RBX + 0xe0],RAX
MOV EAX,dword ptr [R14 + 0x91]
BSWAP EAX
MOV qword ptr [RBX + 0xf8],RAX
MOV EAX,dword ptr [R14 + 0x95]
BSWAP EAX
MOV qword ptr [RBX + 0xf0],RAX
MOVZX EAX,byte ptr [R14 + 0x99]
MOV dword ptr [RBX + 0x168],EAX
MOV EAX,dword ptr [RBX + 0x19c]
ADD RAX,R14
ADD RAX,0x9b
TEST R9,R9
JZ 0x001398bb
LEA EDX,[R9*0x8]
XOR ECX,ECX
LAB_0013989d:
MOV RSI,qword ptr [RAX + RCX*0x1]
BSWAP RSI
MOV RDI,qword ptr [RBX + 0x118]
MOV qword ptr [RDI + RCX*0x1],RSI
ADD RCX,0x8
CMP RDX,RCX
JNZ 0x0013989d
ADD RAX,RCX
LAB_001398bb:
MOV RCX,qword ptr [RAX]
BSWAP RCX
MOV qword ptr [RBX + 0x120],RCX
MOV ECX,dword ptr [RAX + 0x8]
BSWAP ECX
MOV qword ptr [RBX + 0x130],RCX
MOV ECX,dword ptr [RAX + 0xc]
BSWAP ECX
MOV qword ptr [RBX + 0x138],RCX
MOV ECX,dword ptr [RAX + 0x10]
BSWAP ECX
MOV qword ptr [RBX + 0x148],RCX
MOV RCX,qword ptr [RAX + 0x14]
BSWAP RCX
MOV qword ptr [RBX + 0x140],RCX
MOV RCX,qword ptr [RAX + 0x1c]
BSWAP RCX
MOV qword ptr [RBX + 0x150],RCX
MOV RCX,qword ptr [RAX + 0x24]
BSWAP RCX
MOV qword ptr [RBX + 0x158],RCX
MOV RCX,qword ptr [RAX + 0x2c]
BSWAP RCX
MOV qword ptr [RBX + 0x160],RCX
MOV RCX,qword ptr [RAX + 0x34]
BSWAP RCX
MOV qword ptr [RBX + 0x128],RCX
LEA R15,[RAX + R9*0x4]
ADD R15,0x3c
TEST R13D,R13D
JZ 0x0013996f
ADD R12D,R8D
XOR EAX,EAX
LAB_00139944:
MOV RCX,qword ptr [RBX + 0x100]
MOV RDX,qword ptr [R15]
MOV qword ptr [RCX + RAX*0x8],RDX
MOV ECX,dword ptr [R15 + 0x8]
BSWAP ECX
MOV RDX,qword ptr [RBX + 0x108]
MOV qword ptr [RDX + RAX*0x8],RCX
ADD R15,0xc
INC RAX
CMP R12,RAX
JNZ 0x00139944
LAB_0013996f:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * _ma_state_info_read(int4 *param_1,int4 *param_2,ulong param_3)
{
int iVar1;
byte bVar2;
byte bVar3;
byte bVar4;
uint uVar5;
ulong uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
long lVar10;
ulong *puVar11;
ulong uVar12;
int iVar13;
int8 *puVar14;
*(int8 *)(param_2 + 4) = *(int8 *)(param_1 + 4);
uVar7 = param_1[1];
uVar8 = param_1[2];
uVar9 = param_1[3];
*param_2 = *param_1;
param_2[1] = uVar7;
param_2[2] = uVar8;
param_2[3] = uVar9;
bVar2 = *(byte *)((long)param_2 + 0x12);
bVar3 = *(byte *)((long)param_2 + 0xf);
bVar4 = *(byte *)((long)param_2 + 0xe);
iVar13 = (uint)bVar4 * 0x100 + (uint)bVar3;
if ((*(long *)(param_2 + 0x40) == 0) &&
(iVar1 = iVar13 * 8,
lVar10 = my_multi_malloc(0,param_3 | 0x10,param_2 + 0x40,iVar1,param_2 + 0x42,iVar1,0),
lVar10 == 0)) {
return (int8 *)0x0;
}
param_2[0x5b] = (uint)(ushort)(*(ushort *)(param_1 + 6) << 8 | *(ushort *)(param_1 + 6) >> 8);
param_2[0x5c] =
(uint)(ushort)(*(ushort *)((long)param_1 + 0x1a) << 8 |
*(ushort *)((long)param_1 + 0x1a) >> 8);
*(ulong *)(param_2 + 0x5e) =
(ulong)*(uint *)((long)param_1 + 0x1f) |
(ulong)*(byte *)((long)param_1 + 0x1e) << 0x30 | (ulong)*(ushort *)(param_1 + 7) << 0x20;
*(ulong *)(param_2 + 0x60) =
(ulong)*(uint *)((long)param_1 + 0x26) |
(ulong)*(byte *)((long)param_1 + 0x25) << 0x30 |
(ulong)*(ushort *)((long)param_1 + 0x23) << 0x20;
*(ulong *)(param_2 + 0x62) =
(ulong)*(uint *)((long)param_1 + 0x2d) |
(ulong)*(byte *)(param_1 + 0xb) << 0x30 | (ulong)*(ushort *)((long)param_1 + 0x2a) << 0x20;
uVar12 = *(ulong *)((long)param_1 + 0x31);
*(ulong *)(param_2 + 6) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x39);
*(ulong *)(param_2 + 8) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x41);
*(ulong *)(param_2 + 0x30) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x49);
*(ulong *)(param_2 + 0x32) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x51);
*(ulong *)(param_2 + 0x34) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x59);
*(ulong *)(param_2 + 0xe) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x61);
*(ulong *)(param_2 + 0x10) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x69);
*(ulong *)(param_2 + 10) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x71);
*(ulong *)(param_2 + 0xc) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)param_1 + 0x79);
*(ulong *)(param_2 + 0x36) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar5 = *(uint *)((long)param_1 + 0x85);
param_2[0x12] = uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18;
uVar12 = *(ulong *)((long)param_1 + 0x89);
*(ulong *)(param_2 + 0x38) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar5 = *(uint *)((long)param_1 + 0x91);
*(ulong *)(param_2 + 0x3e) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
uVar5 = *(uint *)((long)param_1 + 0x95);
*(ulong *)(param_2 + 0x3c) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
param_2[0x5a] = (uint)*(byte *)((long)param_1 + 0x99);
puVar11 = (ulong *)((long)param_1 + (ulong)(uint)param_2[0x67] + 0x9b);
if ((ulong)bVar2 != 0) {
uVar12 = 0;
do {
uVar6 = *(ulong *)((long)puVar11 + uVar12);
*(ulong *)(*(long *)(param_2 + 0x46) + uVar12) =
uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18 |
(uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 | (uVar6 & 0xff0000) << 0x18 |
(uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
uVar12 = uVar12 + 8;
} while ((uint)bVar2 * 8 != uVar12);
puVar11 = (ulong *)((long)puVar11 + uVar12);
}
uVar12 = *puVar11;
*(ulong *)(param_2 + 0x48) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar5 = (uint)puVar11[1];
*(ulong *)(param_2 + 0x4c) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
uVar5 = *(uint *)((long)puVar11 + 0xc);
*(ulong *)(param_2 + 0x4e) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
uVar5 = (uint)puVar11[2];
*(ulong *)(param_2 + 0x52) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
uVar12 = *(ulong *)((long)puVar11 + 0x14);
*(ulong *)(param_2 + 0x50) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)puVar11 + 0x1c);
*(ulong *)(param_2 + 0x54) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)puVar11 + 0x24);
*(ulong *)(param_2 + 0x56) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)puVar11 + 0x2c);
*(ulong *)(param_2 + 0x58) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
uVar12 = *(ulong *)((long)puVar11 + 0x34);
*(ulong *)(param_2 + 0x4a) =
uVar12 >> 0x38 | (uVar12 & 0xff000000000000) >> 0x28 | (uVar12 & 0xff0000000000) >> 0x18 |
(uVar12 & 0xff00000000) >> 8 | (uVar12 & 0xff000000) << 8 | (uVar12 & 0xff0000) << 0x18 |
(uVar12 & 0xff00) << 0x28 | uVar12 << 0x38;
puVar14 = (int8 *)((long)puVar11 + (ulong)bVar2 * 4 + 0x3c);
if (iVar13 != 0) {
uVar12 = 0;
do {
*(int8 *)(*(long *)(param_2 + 0x40) + uVar12 * 8) = *puVar14;
uVar5 = *(uint *)(puVar14 + 1);
*(ulong *)(*(long *)(param_2 + 0x42) + uVar12 * 8) =
(ulong)(uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18);
puVar14 = (int8 *)((long)puVar14 + 0xc);
uVar12 = uVar12 + 1;
} while (CONCAT11(bVar4,bVar3) != uVar12);
}
return puVar14;
}
|
|
18,350
|
my_init
|
eloqsql/mysys/my_init.c
|
my_bool my_init(void)
{
char *str;
if (my_init_done)
return 0;
my_init_done= 1;
mysys_usage_id++;
my_umask= 0660; /* Default umask for new files */
my_umask_dir= 0700; /* Default umask for new directories */
my_global_flags= 0;
/* Default creation of new files */
if ((str= getenv("UMASK")) != 0)
my_umask= (int) (atoi_octal(str) | 0600);
/* Default creation of new dir's */
if ((str= getenv("UMASK_DIR")) != 0)
my_umask_dir= (int) (atoi_octal(str) | 0700);
init_glob_errs();
instrumented_stdin.m_file= stdin;
instrumented_stdin.m_psi= NULL; /* not yet instrumented */
mysql_stdin= & instrumented_stdin;
my_progname_short= "unknown";
if (my_progname)
my_progname_short= my_progname + dirname_length(my_progname);
/* Initialize our mutex handling */
my_mutex_init();
if (my_thread_global_init())
return 1;
#if defined(SAFEMALLOC) && !defined(DBUG_OFF)
dbug_sanity= sf_sanity;
#endif
/* $HOME is needed early to parse configuration files located in ~/ */
if ((home_dir= getenv("HOME")) != 0)
home_dir= intern_filename(home_dir_buff, home_dir);
{
DBUG_ENTER("my_init");
DBUG_PROCESS((char*) (my_progname ? my_progname : "unknown"));
my_time_init();
my_win_init();
DBUG_PRINT("exit", ("home: '%s'", home_dir));
#ifdef _WIN32
if (win32_init_tcp_ip())
DBUG_RETURN(1);
#endif
#ifdef CHECK_UNLIKELY
init_my_likely();
#endif
DBUG_RETURN(0);
}
}
|
O0
|
c
|
my_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x3c8731(%rip), %rax # 0x445740
cmpb $0x0, (%rax)
je 0x7d01d
movb $0x0, -0x1(%rbp)
jmp 0x7d1a6
leaq 0x3c871c(%rip), %rax # 0x445740
movb $0x1, (%rax)
leaq 0x3c8716(%rip), %rax # 0x445744
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x3c870a(%rip), %rax # 0x445744
movl %ecx, (%rax)
leaq 0x1b8745(%rip), %rax # 0x235788
movl $0x1b0, (%rax) # imm = 0x1B0
leaq 0x1b873c(%rip), %rax # 0x23578c
movl $0x1c0, (%rax) # imm = 0x1C0
leaq 0x3c8bbb(%rip), %rax # 0x445c18
movq $0x0, (%rax)
leaq 0x53f1e(%rip), %rdi # 0xd0f89
callq 0x36780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7d094
movq -0x10(%rbp), %rdi
callq 0x7d1b0
orq $0x180, %rax # imm = 0x180
movl %eax, %ecx
leaq 0x1b86f6(%rip), %rax # 0x235788
movl %ecx, (%rax)
leaq 0x53ef4(%rip), %rdi # 0xd0f8f
callq 0x36780
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7d0c4
movq -0x10(%rbp), %rdi
callq 0x7d1b0
orq $0x1c0, %rax # imm = 0x1C0
movl %eax, %ecx
leaq 0x1b86ca(%rip), %rax # 0x23578c
movl %ecx, (%rax)
callq 0x834b0
movq 0x1b4f20(%rip), %rax # 0x231ff0
movq (%rax), %rax
movq %rax, 0x3c8676(%rip) # 0x445750
movq $0x0, 0x3c8673(%rip) # 0x445758
leaq 0x3c865c(%rip), %rax # 0x445748
leaq 0x3c865d(%rip), %rcx # 0x445750
movq %rcx, (%rax)
leaq 0x3c86fb(%rip), %rax # 0x4457f8
leaq 0x502fc(%rip), %rcx # 0xcd400
movq %rcx, (%rax)
leaq 0x3c86e2(%rip), %rax # 0x4457f0
cmpq $0x0, (%rax)
je 0x7d142
leaq 0x3c86d5(%rip), %rax # 0x4457f0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x3c86c7(%rip), %rax # 0x4457f0
movq (%rax), %rdi
callq 0x76240
movq -0x18(%rbp), %rcx
addq %rax, %rcx
leaq 0x3c86b9(%rip), %rax # 0x4457f8
movq %rcx, (%rax)
callq 0x80600
callq 0x7fa00
cmpb $0x0, %al
je 0x7d156
movb $0x1, -0x1(%rbp)
jmp 0x7d1a6
leaq 0x5272e(%rip), %rdi # 0xcf88b
callq 0x36780
leaq 0x3c867f(%rip), %rcx # 0x4457e8
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x7d195
leaq 0x3c866f(%rip), %rax # 0x4457e8
movq (%rax), %rsi
leaq 0x3c887d(%rip), %rdi # 0x445a00
callq 0x76d80
movq %rax, %rcx
leaq 0x3c8656(%rip), %rax # 0x4457e8
movq %rcx, (%rax)
jmp 0x7d197
jmp 0x7d199
callq 0x85270
jmp 0x7d1a0
jmp 0x7d1a2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
|
my_init:
push rbp
mov rbp, rsp
sub rsp, 20h
lea rax, my_init_done
cmp byte ptr [rax], 0
jz short loc_7D01D
mov [rbp+var_1], 0
jmp loc_7D1A6
loc_7D01D:
lea rax, my_init_done
mov byte ptr [rax], 1
lea rax, mysys_usage_id
mov ecx, [rax]
add ecx, 1
lea rax, mysys_usage_id
mov [rax], ecx
lea rax, my_umask
mov dword ptr [rax], 1B0h
lea rax, my_umask_dir
mov dword ptr [rax], 1C0h
lea rax, my_global_flags
mov qword ptr [rax], 0
lea rdi, aUmask; "UMASK"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_7D094
mov rdi, [rbp+var_10]
call atoi_octal
or rax, 180h
mov ecx, eax
lea rax, my_umask
mov [rax], ecx
loc_7D094:
lea rdi, aUmaskDir; "UMASK_DIR"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_7D0C4
mov rdi, [rbp+var_10]
call atoi_octal
or rax, 1C0h
mov ecx, eax
lea rax, my_umask_dir
mov [rax], ecx
loc_7D0C4:
call init_glob_errs
mov rax, cs:stdin_ptr
mov rax, [rax]
mov cs:instrumented_stdin, rax
mov cs:qword_445758, 0
lea rax, mysql_stdin
lea rcx, instrumented_stdin
mov [rax], rcx
lea rax, my_progname_short
lea rcx, aUnknown; "unknown"
mov [rax], rcx
lea rax, my_progname
cmp qword ptr [rax], 0
jz short loc_7D142
lea rax, my_progname
mov rax, [rax]
mov [rbp+var_18], rax
lea rax, my_progname
mov rdi, [rax]
call dirname_length
mov rcx, [rbp+var_18]
add rcx, rax
lea rax, my_progname_short
mov [rax], rcx
loc_7D142:
call my_mutex_init
call my_thread_global_init
cmp al, 0
jz short loc_7D156
mov [rbp+var_1], 1
jmp short loc_7D1A6
loc_7D156:
lea rdi, aMariadbHome+8; "HOME"
call _getenv
lea rcx, home_dir
mov [rcx], rax
cmp rax, 0
jz short loc_7D195
lea rax, home_dir
mov rsi, [rax]
lea rdi, home_dir_buff
call intern_filename
mov rcx, rax
lea rax, home_dir
mov [rax], rcx
loc_7D195:
jmp short $+2
loc_7D197:
jmp short $+2
loc_7D199:
call my_time_init
jmp short $+2
loc_7D1A0:
jmp short $+2
loc_7D1A2:
mov [rbp+var_1], 0
loc_7D1A6:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char my_init()
{
_BYTE *v1; // [rsp+8h] [rbp-18h]
long long v2; // [rsp+10h] [rbp-10h]
long long v3; // [rsp+10h] [rbp-10h]
if ( my_init_done )
return 0;
my_init_done = 1;
++mysys_usage_id;
my_umask = 432;
my_umask_dir = 448;
my_global_flags = 0LL;
v2 = getenv("UMASK");
if ( v2 )
my_umask = atoi_octal(v2) | 0x180;
v3 = getenv("UMASK_DIR");
if ( v3 )
my_umask_dir = atoi_octal(v3) | 0x1C0;
init_glob_errs();
instrumented_stdin = stdin;
qword_445758 = 0LL;
mysql_stdin = &instrumented_stdin;
my_progname_short = "unknown";
if ( my_progname )
{
v1 = my_progname;
my_progname_short = &v1[dirname_length(my_progname)];
}
my_mutex_init();
if ( (unsigned __int8)my_thread_global_init() )
return 1;
home_dir = (_BYTE *)getenv("HOME");
if ( home_dir )
home_dir = (_BYTE *)intern_filename((long long)&home_dir_buff, home_dir);
my_time_init();
return 0;
}
|
my_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
LEA RAX,[0x545740]
CMP byte ptr [RAX],0x0
JZ 0x0017d01d
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017d1a6
LAB_0017d01d:
LEA RAX,[0x545740]
MOV byte ptr [RAX],0x1
LEA RAX,[0x545744]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x545744]
MOV dword ptr [RAX],ECX
LEA RAX,[0x335788]
MOV dword ptr [RAX],0x1b0
LEA RAX,[0x33578c]
MOV dword ptr [RAX],0x1c0
LEA RAX,[0x545c18]
MOV qword ptr [RAX],0x0
LEA RDI,[0x1d0f89]
CALL 0x00136780
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0017d094
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017d1b0
OR RAX,0x180
MOV ECX,EAX
LEA RAX,[0x335788]
MOV dword ptr [RAX],ECX
LAB_0017d094:
LEA RDI,[0x1d0f8f]
CALL 0x00136780
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x0017d0c4
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017d1b0
OR RAX,0x1c0
MOV ECX,EAX
LEA RAX,[0x33578c]
MOV dword ptr [RAX],ECX
LAB_0017d0c4:
CALL 0x001834b0
MOV RAX,qword ptr [0x00331ff0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x00545750],RAX
MOV qword ptr [0x00545758],0x0
LEA RAX,[0x545748]
LEA RCX,[0x545750]
MOV qword ptr [RAX],RCX
LEA RAX,[0x5457f8]
LEA RCX,[0x1cd400]
MOV qword ptr [RAX],RCX
LEA RAX,[0x5457f0]
CMP qword ptr [RAX],0x0
JZ 0x0017d142
LEA RAX,[0x5457f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x5457f0]
MOV RDI,qword ptr [RAX]
CALL 0x00176240
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,RAX
LEA RAX,[0x5457f8]
MOV qword ptr [RAX],RCX
LAB_0017d142:
CALL 0x00180600
CALL 0x0017fa00
CMP AL,0x0
JZ 0x0017d156
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017d1a6
LAB_0017d156:
LEA RDI,[0x1cf88b]
CALL 0x00136780
LEA RCX,[0x5457e8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x0017d195
LEA RAX,[0x5457e8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x545a00]
CALL 0x00176d80
MOV RCX,RAX
LEA RAX,[0x5457e8]
MOV qword ptr [RAX],RCX
LAB_0017d195:
JMP 0x0017d197
LAB_0017d197:
JMP 0x0017d199
LAB_0017d199:
CALL 0x00185270
JMP 0x0017d1a0
LAB_0017d1a0:
JMP 0x0017d1a2
LAB_0017d1a2:
MOV byte ptr [RBP + -0x1],0x0
LAB_0017d1a6:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_init(void)
{
long lVar1;
char cVar2;
uint uVar3;
char *pcVar4;
long lVar5;
int1 local_9;
if (my_init_done == '\0') {
my_init_done = '\x01';
mysys_usage_id = mysys_usage_id + 1;
my_umask = 0x1b0;
my_umask_dir = 0x1c0;
my_global_flags = 0;
pcVar4 = getenv("UMASK");
if (pcVar4 != (char *)0x0) {
uVar3 = atoi_octal(pcVar4);
my_umask = uVar3 | 0x180;
}
pcVar4 = getenv("UMASK_DIR");
if (pcVar4 != (char *)0x0) {
uVar3 = atoi_octal(pcVar4);
my_umask_dir = uVar3 | 0x1c0;
}
init_glob_errs();
lVar1 = my_progname;
instrumented_stdin._0_8_ = *(int8 *)PTR_stdin_00331ff0;
instrumented_stdin._8_8_ = 0;
mysql_stdin = instrumented_stdin;
my_progname_short = "unknown";
if (my_progname != 0) {
lVar5 = dirname_length(my_progname);
my_progname_short = (char *)(lVar1 + lVar5);
}
my_mutex_init();
cVar2 = my_thread_global_init();
if (cVar2 == '\0') {
home_dir = getenv("HOME");
if (home_dir != (char *)0x0) {
home_dir = (char *)intern_filename(home_dir_buff,home_dir);
}
my_time_init();
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 0;
}
return local_9;
}
|
|
18,351
|
qdevtools::WidgetSelectionBox::qt_static_metacall(QObject*, QMetaObject::Call, int, void**)
|
HuaiminNotSleepYet[P]QDevTools/build_O3/QDevTools_autogen/EWIEGA46WW/moc_qdevtools.cpp
|
void qdevtools::WidgetSelectionBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<WidgetSelectionBox *>(_o);
(void)_t;
switch (_id) {
case 0: _t->setTarget((*reinterpret_cast< std::add_pointer_t<QWidget*>>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
}
break;
}
}
}
|
O3
|
cpp
|
qdevtools::WidgetSelectionBox::qt_static_metacall(QObject*, QMetaObject::Call, int, void**):
cmpl $0x7, %esi
je 0x10bac
testl %esi, %esi
jne 0x10bab
testl %edx, %edx
je 0x10bb5
retq
testl %edx, %edx
je 0x10bc1
movq (%rcx), %rax
jmp 0x10bcd
movq 0x8(%rcx), %rax
movq (%rax), %rsi
jmp 0x140ac
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpl $0x0, (%rcx)
je 0x10bd5
movq $0x0, (%rax)
retq
leaq 0x1cde4(%rip), %rcx # 0x2d9c0
movq %rcx, (%rax)
retq
|
_ZN9qdevtools18WidgetSelectionBox18qt_static_metacallEP7QObjectN11QMetaObject4CallEiPPv:
cmp esi, 7
jz short loc_10BAC
test esi, esi
jnz short locret_10BAB
test edx, edx
jz short loc_10BB5
locret_10BAB:
retn
loc_10BAC:
test edx, edx
jz short loc_10BC1
mov rax, [rcx]
jmp short loc_10BCD
loc_10BB5:
mov rax, [rcx+8]
mov rsi, [rax]; QWidget *
jmp _ZN9qdevtools18WidgetSelectionBox9setTargetEP7QWidget; qdevtools::WidgetSelectionBox::setTarget(QWidget *)
loc_10BC1:
mov rax, [rcx]
mov rcx, [rcx+8]
cmp dword ptr [rcx], 0
jz short loc_10BD5
loc_10BCD:
mov qword ptr [rax], 0
retn
loc_10BD5:
lea rcx, _ZN9QtPrivate25QMetaTypeInterfaceWrapperIP7QWidgetE8metaTypeE; QtPrivate::QMetaTypeInterfaceWrapper<QWidget *>::metaType
mov [rax], rcx
retn
|
void qdevtools::WidgetSelectionBox::qt_static_metacall(
qdevtools::WidgetSelectionBox *a1,
int a2,
int a3,
long long a4)
{
_QWORD *v4; // rax
if ( a2 == 7 )
{
if ( a3 )
{
v4 = *(_QWORD **)a4;
}
else
{
v4 = *(_QWORD **)a4;
if ( !**(_DWORD **)(a4 + 8) )
{
*v4 = &QtPrivate::QMetaTypeInterfaceWrapper<QWidget *>::metaType;
return;
}
}
*v4 = 0LL;
return;
}
if ( !a2 && !a3 )
qdevtools::WidgetSelectionBox::setTarget(a1, **(QWidget ***)(a4 + 8));
}
|
qt_static_metacall:
CMP ESI,0x7
JZ 0x00110bac
TEST ESI,ESI
JNZ 0x00110bab
TEST EDX,EDX
JZ 0x00110bb5
LAB_00110bab:
RET
LAB_00110bac:
TEST EDX,EDX
JZ 0x00110bc1
MOV RAX,qword ptr [RCX]
JMP 0x00110bcd
LAB_00110bb5:
MOV RAX,qword ptr [RCX + 0x8]
MOV RSI,qword ptr [RAX]
JMP 0x001140ac
LAB_00110bc1:
MOV RAX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
CMP dword ptr [RCX],0x0
JZ 0x00110bd5
LAB_00110bcd:
MOV qword ptr [RAX],0x0
RET
LAB_00110bd5:
LEA RCX,[0x12d9c0]
MOV qword ptr [RAX],RCX
RET
|
/* qdevtools::WidgetSelectionBox::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) */
void qdevtools::WidgetSelectionBox::qt_static_metacall
(WidgetSelectionBox *param_1,int param_2,int param_3,int8 *param_4)
{
int8 *puVar1;
if (param_2 == 7) {
if (param_3 == 0) {
puVar1 = (int8 *)*param_4;
if (*(int *)param_4[1] == 0) {
*puVar1 = QtPrivate::QMetaTypeInterfaceWrapper<QWidget*>::metaType;
return;
}
}
else {
puVar1 = (int8 *)*param_4;
}
*puVar1 = 0;
return;
}
if ((param_2 == 0) && (param_3 == 0)) {
setTarget(param_1,*(QWidget **)param_4[1]);
return;
}
return;
}
|
|
18,352
|
remove_key
|
eloqsql/storage/maria/ma_delete.c
|
static uint remove_key(MARIA_KEYDEF *keyinfo, uint page_flag, uint nod_flag,
uchar *keypos, uchar *lastkey,
uchar *page_end, my_off_t *next_block,
MARIA_KEY_PARAM *s_temp)
{
int s_length;
uchar *start;
DBUG_ENTER("remove_key");
DBUG_PRINT("enter", ("keypos:%p page_end: %p",
keypos, page_end));
start= s_temp->key_pos= keypos;
s_temp->changed_length= 0;
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
HA_BINARY_PACK_KEY)) &&
!(page_flag & KEYPAGE_FLAG_HAS_TRANSID))
{
/* Static length key */
s_length=(int) (keyinfo->keylength+nod_flag);
if (next_block && nod_flag)
*next_block= _ma_kpos(nod_flag,keypos+s_length);
}
else
{
/* Let keypos point at next key */
MARIA_KEY key;
/* Calculate length of key */
key.keyinfo= keyinfo;
key.data= lastkey;
if (!(*keyinfo->get_key)(&key, page_flag, nod_flag, &keypos))
DBUG_RETURN(0); /* Error */
if (next_block && nod_flag)
*next_block= _ma_kpos(nod_flag,keypos);
s_length=(int) (keypos-start);
if (keypos != page_end)
{
if (keyinfo->flag & HA_BINARY_PACK_KEY)
{
uchar *old_key= start;
uint next_length,prev_length,prev_pack_length;
/* keypos points here on start of next key */
get_key_length(next_length,keypos);
get_key_pack_length(prev_length,prev_pack_length,old_key);
if (next_length > prev_length)
{
uint diff= (next_length-prev_length);
/* We have to copy data from the current key to the next key */
keypos-= diff + prev_pack_length;
store_key_length(keypos, prev_length);
bmove(keypos + prev_pack_length, lastkey + prev_length, diff);
s_length=(int) (keypos-start);
s_temp->changed_length= diff + prev_pack_length;
}
}
else
{
/* Check if a variable length first key part */
if ((keyinfo->seg->flag & HA_PACK_KEY) && *keypos & 128)
{
/* Next key is packed against the current one */
uint next_length,prev_length,prev_pack_length,lastkey_length,
rest_length;
if (keyinfo->seg[0].length >= 127)
{
if (!(prev_length=mi_uint2korr(start) & 32767))
goto end;
next_length=mi_uint2korr(keypos) & 32767;
keypos+=2;
prev_pack_length=2;
}
else
{
if (!(prev_length= *start & 127))
goto end; /* Same key as previous*/
next_length= *keypos & 127;
keypos++;
prev_pack_length=1;
}
if (!(*start & 128))
prev_length=0; /* prev key not packed */
if (keyinfo->seg[0].flag & HA_NULL_PART)
lastkey++; /* Skip null marker */
get_key_length(lastkey_length,lastkey);
if (!next_length) /* Same key after */
{
next_length=lastkey_length;
rest_length=0;
}
else
get_key_length(rest_length,keypos);
if (next_length >= prev_length)
{
/* Next key is based on deleted key */
uint pack_length;
uint diff= (next_length-prev_length);
/* keypos points to data of next key (after key length) */
bmove(keypos - diff, lastkey + prev_length, diff);
rest_length+= diff;
pack_length= prev_length ? get_pack_length(rest_length): 0;
keypos-= diff + pack_length + prev_pack_length;
s_length=(int) (keypos-start);
if (prev_length) /* Pack against prev key */
{
*keypos++= start[0];
if (prev_pack_length == 2)
*keypos++= start[1];
store_key_length(keypos,rest_length);
}
else
{
/* Next key is not packed anymore */
if (keyinfo->seg[0].flag & HA_NULL_PART)
{
rest_length++; /* Mark not null */
}
if (prev_pack_length == 2)
{
mi_int2store(keypos,rest_length);
}
else
*keypos= rest_length;
}
s_temp->changed_length= diff + pack_length + prev_pack_length;
}
}
}
}
}
end:
bmove(start, start+s_length, (uint) (page_end-start-s_length));
s_temp->move_length= s_length;
DBUG_RETURN((uint) s_length);
}
|
O3
|
c
|
remove_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r13
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %r12
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rbx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x18(%rax)
movl $0x0, 0x40(%rax)
testb $0x2, %sil
jne 0x59d9a
movzwl 0xa2(%r12), %eax
andl $0x2e, %eax
jne 0x59d9a
movzwl 0xaa(%r12), %r13d
addl %r15d, %r13d
testq %rbx, %rbx
sete %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0x59f7f
movslq %r13d, %rsi
addq %r14, %rsi
movl %r15d, %edi
movq %r9, %r15
callq 0x6d16f
movq %r15, %r9
movq %rax, (%rbx)
jmp 0x59f7f
movq %r9, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
movq %r12, 0x8(%rdi)
movq %r13, (%rdi)
leaq -0x30(%rbp), %rcx
movl %r15d, %edx
callq *0xe0(%r12)
testl %eax, %eax
je 0x59e72
movq %r13, -0x40(%rbp)
testq %rbx, %rbx
sete %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0x59de3
movq -0x30(%rbp), %rsi
movl %r15d, %edi
callq 0x6d16f
movq %rax, (%rbx)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %r9
movq %r9, %r13
cmpq %r9, %rax
je 0x59f7c
testb $0x20, 0xa2(%r12)
jne 0x59e7a
movq 0xc0(%r12), %rdx
movzwl 0x12(%rdx), %esi
testb $0x2, %sil
je 0x59f79
movzbl (%rax), %ecx
testb %cl, %cl
jns 0x59f79
movzwl 0x14(%rdx), %edi
cmpw $0x7f, %di
jb 0x59f2b
movzbl 0x1(%r14), %edx
movzbl (%r14), %r11d
movl %r11d, %r8d
andl $0x7f, %r8d
shll $0x8, %r8d
orl %edx, %r8d
movq -0x40(%rbp), %r10
je 0x59f79
movw %di, -0x32(%rbp)
movzbl 0x1(%rax), %edx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %edx, %ecx
movl $0x2, %r15d
movl $0x2, %edi
jmp 0x59f4e
xorl %r13d, %r13d
jmp 0x59f9b
cmpb $-0x1, (%rax)
je 0x59e91
leaq 0x1(%rax), %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %ecx
movl $0x1, %edi
jmp 0x59ea9
movzwl 0x1(%rax), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq 0x3(%rax), %rdx
movq %rdx, -0x30(%rbp)
movl $0x3, %edi
movzbl (%r14), %edx
cmpl $0xff, %edx
movq -0x40(%rbp), %rsi
je 0x59ec1
movl $0x1, %r8d
jmp 0x59ed3
movzwl 0x1(%r14), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movl $0x3, %r8d
subl %edx, %ecx
jbe 0x59f79
addq %rdi, %rax
leal (%rcx,%r8), %r15d
subq %r15, %rax
movq %rax, -0x30(%rbp)
cmpl $0xfe, %edx
ja 0x59ef5
movb %dl, (%rax)
jmp 0x59f06
movb $-0x1, (%rax)
movq -0x30(%rbp), %rax
movb %dl, 0x2(%rax)
movq -0x30(%rbp), %rax
movb %dh, 0x1(%rax)
movl %r8d, %edi
addq -0x30(%rbp), %rdi
movl %edx, %eax
addq %rax, %rsi
movl %ecx, %edx
callq 0x29110
movq -0x30(%rbp), %r13
movq -0x48(%rbp), %r9
movq 0x18(%rbp), %rax
movl %r15d, 0x40(%rax)
jmp 0x59f7c
movzbl (%r14), %r11d
movl %r11d, %r8d
andl $0x7f, %r8d
movq -0x40(%rbp), %r10
je 0x59f79
movw %di, -0x32(%rbp)
andl $0x7f, %ecx
movl $0x1, %r15d
movl $0x1, %edi
addq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %ebx, %ebx
testb %r11b, %r11b
cmovsl %r8d, %ebx
btl $0x4, %esi
adcq $0x0, %r10
movzbl (%r10), %edx
cmpl $0xff, %edx
je 0x59fad
movl $0x1, %esi
jmp 0x59fbe
movq %rax, %r13
subl %r14d, %r13d
movslq %r13d, %rbx
leaq (%r14,%rbx), %rsi
subl %esi, %r9d
movq %r14, %rdi
movq %r9, %rdx
callq 0x29110
movq 0x18(%rbp), %rax
movl %ebx, 0x44(%rax)
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x1(%r10), %esi
rolw $0x8, %si
movzwl %si, %edx
movl $0x3, %esi
testl %ecx, %ecx
je 0x59fda
cmpb $-0x1, (%rdi)
je 0x59fe3
leaq 0x1(%rdi), %r8
movq %r8, -0x30(%rbp)
movzbl (%rdi), %edi
movl %edi, -0x40(%rbp)
movq %r8, %rdi
jmp 0x59ffd
movl $0x0, -0x40(%rbp)
jmp 0x59fff
movzwl 0x1(%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
movl %r8d, -0x40(%rbp)
addq $0x3, %rdi
movq %rdi, -0x30(%rbp)
movl %ecx, %edx
movq %rax, %r13
subl %ebx, %edx
jb 0x59f7c
addq %rsi, %r10
subq %rdx, %rdi
movl %ebx, %esi
addq %r10, %rsi
movl %r11d, %ebx
movq %rdx, %r13
callq 0x29110
movl -0x40(%rbp), %edx
addl %r13d, %edx
xorl %eax, %eax
cmpl $0xff, %edx
setae %al
xorl %ecx, %ecx
testb %bl, %bl
leal 0x1(%rax,%rax), %eax
cmovnsl %ecx, %eax
addl %r13d, %r15d
addl %eax, %r15d
movq -0x30(%rbp), %r13
subq %r15, %r13
movq %r13, -0x30(%rbp)
testb %bl, %bl
js 0x5a07a
movq 0xc0(%r12), %rax
movzwl 0x12(%rax), %eax
btl $0x4, %eax
adcl $0x0, %edx
cmpw $0x7f, -0x32(%rbp)
jb 0x5a0bd
movb %dl, 0x1(%r13)
movq -0x30(%rbp), %rax
movb %dh, (%rax)
jmp 0x59f1d
leaq 0x1(%r13), %rax
movb (%r14), %cl
movq %rax, -0x30(%rbp)
movb %cl, (%r13)
cmpw $0x7f, -0x32(%rbp)
jb 0x5a0a6
movb 0x1(%r14), %al
movq -0x30(%rbp), %rcx
movl %edx, %esi
leaq 0x1(%rcx), %rdx
movq %rdx, -0x30(%rbp)
movl %esi, %edx
movb %al, (%rcx)
cmpl $0xfe, %edx
movq -0x48(%rbp), %r9
ja 0x5a0c6
movq -0x30(%rbp), %rax
movb %dl, (%rax)
jmp 0x59f21
movb %dl, (%r13)
jmp 0x59f1d
movq -0x30(%rbp), %rax
movb $-0x1, (%rax)
movq -0x30(%rbp), %rax
movb %dl, 0x2(%rax)
movq -0x30(%rbp), %rax
movb %dh, 0x1(%rax)
jmp 0x59f21
|
remove_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13, r8
mov r14, rcx
mov r15d, edx
mov r12, rdi
mov rax, [rbp+arg_8]
mov rbx, [rbp+arg_0]
mov [rbp+var_30], rcx
mov [rax+18h], rcx
mov dword ptr [rax+40h], 0
test sil, 2
jnz short loc_59D9A
movzx eax, word ptr [r12+0A2h]
and eax, 2Eh
jnz short loc_59D9A
movzx r13d, word ptr [r12+0AAh]
add r13d, r15d
test rbx, rbx
setz al
test r15d, r15d
setz cl
or cl, al
jnz loc_59F7F
movsxd rsi, r13d
add rsi, r14
mov edi, r15d
mov r15, r9
call _ma_kpos
mov r9, r15
mov [rbx], rax
jmp loc_59F7F
loc_59D9A:
mov [rbp+var_48], r9
lea rdi, [rbp+var_68]
mov [rdi+8], r12
mov [rdi], r13
lea rcx, [rbp+var_30]
mov edx, r15d
call qword ptr [r12+0E0h]
test eax, eax
jz loc_59E72
mov [rbp+var_40], r13
test rbx, rbx
setz al
test r15d, r15d
setz cl
or cl, al
jnz short loc_59DE3
mov rsi, [rbp+var_30]
mov edi, r15d
call _ma_kpos
mov [rbx], rax
loc_59DE3:
mov rax, [rbp+var_30]
mov r9, [rbp+var_48]
mov r13, r9
cmp rax, r9
jz loc_59F7C
test byte ptr [r12+0A2h], 20h
jnz short loc_59E7A
mov rdx, [r12+0C0h]
movzx esi, word ptr [rdx+12h]
test sil, 2
jz loc_59F79
movzx ecx, byte ptr [rax]
test cl, cl
jns loc_59F79
movzx edi, word ptr [rdx+14h]
cmp di, 7Fh
jb loc_59F2B
movzx edx, byte ptr [r14+1]
movzx r11d, byte ptr [r14]
mov r8d, r11d
and r8d, 7Fh
shl r8d, 8
or r8d, edx
mov r10, [rbp+var_40]
jz loc_59F79
mov [rbp+var_32], di
movzx edx, byte ptr [rax+1]
and ecx, 7Fh
shl ecx, 8
or ecx, edx
mov r15d, 2
mov edi, 2
jmp loc_59F4E
loc_59E72:
xor r13d, r13d
jmp loc_59F9B
loc_59E7A:
cmp byte ptr [rax], 0FFh
jz short loc_59E91
lea rcx, [rax+1]
mov [rbp+var_30], rcx
movzx ecx, byte ptr [rax]
mov edi, 1
jmp short loc_59EA9
loc_59E91:
movzx ecx, word ptr [rax+1]
rol cx, 8
movzx ecx, cx
lea rdx, [rax+3]
mov [rbp+var_30], rdx
mov edi, 3
loc_59EA9:
movzx edx, byte ptr [r14]
cmp edx, 0FFh
mov rsi, [rbp+var_40]
jz short loc_59EC1
mov r8d, 1
jmp short loc_59ED3
loc_59EC1:
movzx edx, word ptr [r14+1]
rol dx, 8
movzx edx, dx
mov r8d, 3
loc_59ED3:
sub ecx, edx
jbe loc_59F79
add rax, rdi
lea r15d, [rcx+r8]
sub rax, r15
mov [rbp+var_30], rax
cmp edx, 0FEh
ja short loc_59EF5
mov [rax], dl
jmp short loc_59F06
loc_59EF5:
mov byte ptr [rax], 0FFh
mov rax, [rbp+var_30]
mov [rax+2], dl
mov rax, [rbp+var_30]
mov [rax+1], dh
loc_59F06:
mov edi, r8d
add rdi, [rbp+var_30]
mov eax, edx
add rsi, rax
mov edx, ecx
call _memmove
mov r13, [rbp+var_30]
loc_59F1D:
mov r9, [rbp+var_48]
loc_59F21:
mov rax, [rbp+arg_8]
mov [rax+40h], r15d
jmp short loc_59F7C
loc_59F2B:
movzx r11d, byte ptr [r14]
mov r8d, r11d
and r8d, 7Fh
mov r10, [rbp+var_40]
jz short loc_59F79
mov [rbp+var_32], di
and ecx, 7Fh
mov r15d, 1
mov edi, 1
loc_59F4E:
add rdi, rax
mov [rbp+var_30], rdi
xor ebx, ebx
test r11b, r11b
cmovs ebx, r8d
bt esi, 4
adc r10, 0
movzx edx, byte ptr [r10]
cmp edx, 0FFh
jz short loc_59FAD
mov esi, 1
jmp short loc_59FBE
loc_59F79:
mov r13, rax
loc_59F7C:
sub r13d, r14d
loc_59F7F:
movsxd rbx, r13d
lea rsi, [r14+rbx]
sub r9d, esi
mov rdi, r14
mov rdx, r9
call _memmove
mov rax, [rbp+arg_8]
mov [rax+44h], ebx
loc_59F9B:
mov eax, r13d
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_59FAD:
movzx esi, word ptr [r10+1]
rol si, 8
movzx edx, si
mov esi, 3
loc_59FBE:
test ecx, ecx
jz short loc_59FDA
cmp byte ptr [rdi], 0FFh
jz short loc_59FE3
lea r8, [rdi+1]
mov [rbp+var_30], r8
movzx edi, byte ptr [rdi]
mov dword ptr [rbp+var_40], edi
mov rdi, r8
jmp short loc_59FFD
loc_59FDA:
mov dword ptr [rbp+var_40], 0
jmp short loc_59FFF
loc_59FE3:
movzx r8d, word ptr [rdi+1]
rol r8w, 8
movzx r8d, r8w
mov dword ptr [rbp+var_40], r8d
add rdi, 3
mov [rbp+var_30], rdi
loc_59FFD:
mov edx, ecx
loc_59FFF:
mov r13, rax
sub edx, ebx
jb loc_59F7C
add r10, rsi
sub rdi, rdx
mov esi, ebx
add rsi, r10
mov ebx, r11d
mov r13, rdx
call _memmove
mov edx, dword ptr [rbp+var_40]
add edx, r13d
xor eax, eax
cmp edx, 0FFh
setnb al
xor ecx, ecx
test bl, bl
lea eax, [rax+rax+1]
cmovns eax, ecx
add r15d, r13d
add r15d, eax
mov r13, [rbp+var_30]
sub r13, r15
mov [rbp+var_30], r13
test bl, bl
js short loc_5A07A
mov rax, [r12+0C0h]
movzx eax, word ptr [rax+12h]
bt eax, 4
adc edx, 0
cmp [rbp+var_32], 7Fh
jb short loc_5A0BD
mov [r13+1], dl
mov rax, [rbp+var_30]
mov [rax], dh
jmp loc_59F1D
loc_5A07A:
lea rax, [r13+1]
mov cl, [r14]
mov [rbp+var_30], rax
mov [r13+0], cl
cmp [rbp+var_32], 7Fh
jb short loc_5A0A6
mov al, [r14+1]
mov rcx, [rbp+var_30]
mov esi, edx
lea rdx, [rcx+1]
mov [rbp+var_30], rdx
mov edx, esi
mov [rcx], al
loc_5A0A6:
cmp edx, 0FEh
mov r9, [rbp+var_48]
ja short loc_5A0C6
mov rax, [rbp+var_30]
mov [rax], dl
jmp loc_59F21
loc_5A0BD:
mov [r13+0], dl
jmp loc_59F1D
loc_5A0C6:
mov rax, [rbp+var_30]
mov byte ptr [rax], 0FFh
mov rax, [rbp+var_30]
mov [rax+2], dl
mov rax, [rbp+var_30]
mov [rax+1], dh
jmp loc_59F21
|
long long remove_key(
long long a1,
long long a2,
unsigned int a3,
unsigned __int8 *a4,
long long a5,
unsigned __int8 *a6,
long long *a7,
long long a8)
{
unsigned int v12; // r13d
int v13; // r15d
long long v14; // rax
unsigned __int8 *v15; // rax
char *v16; // r13
long long v17; // rdx
__int16 v18; // si
unsigned __int8 v19; // cl
char v20; // r11
int v21; // r8d
long long v22; // r10
int v23; // ecx
int v24; // r15d
long long v25; // rdi
unsigned int v26; // ecx
long long v27; // rdi
unsigned int v28; // edx
long long v29; // rsi
unsigned int v30; // r8d
bool v31; // cc
unsigned int v32; // ecx
long long v33; // r15
unsigned __int8 *v34; // rax
unsigned __int8 *v35; // rdi
unsigned int v36; // ebx
unsigned __int8 *v37; // r10
unsigned int v38; // edx
long long v39; // rsi
bool v41; // cf
long long v42; // rdx
unsigned __int8 *v43; // rsi
char v44; // bl
int v45; // r13d
unsigned int v46; // edx
int v47; // eax
__int16 v48; // dx
char v49; // cl
unsigned __int8 v50; // al
unsigned __int8 *v51; // rcx
_QWORD v52[4]; // [rsp+8h] [rbp-68h] BYREF
unsigned __int8 *v53; // [rsp+28h] [rbp-48h]
long long v54; // [rsp+30h] [rbp-40h]
unsigned __int16 v55; // [rsp+3Eh] [rbp-32h]
unsigned __int8 *v56; // [rsp+40h] [rbp-30h] BYREF
v56 = a4;
*(_QWORD *)(a8 + 24) = a4;
*(_DWORD *)(a8 + 64) = 0;
if ( (a2 & 2) == 0 && (*(_WORD *)(a1 + 162) & 0x2E) == 0 )
{
v12 = a3 + *(unsigned __int16 *)(a1 + 170);
if ( a7 != 0LL && a3 != 0 )
{
v13 = (int)a6;
v14 = ma_kpos(a3, &a4[v12]);
LODWORD(a6) = v13;
*a7 = v14;
}
goto LABEL_37;
}
v53 = a6;
v52[1] = a1;
v52[0] = a5;
if ( (*(unsigned int ( **)(_QWORD *, long long, _QWORD, unsigned __int8 **))(a1 + 224))(v52, a2, a3, &v56) )
{
v54 = a5;
if ( a7 != 0LL && a3 != 0 )
*a7 = ma_kpos(a3, v56);
v15 = v56;
LODWORD(a6) = (_DWORD)v53;
LODWORD(v16) = (_DWORD)v53;
if ( v56 == v53 )
goto LABEL_36;
if ( (*(_BYTE *)(a1 + 162) & 0x20) != 0 )
{
if ( *v56 == 0xFF )
{
v26 = (unsigned __int16)__ROL2__(*(_WORD *)(v56 + 1), 8);
v56 += 3;
v27 = 3LL;
}
else
{
++v56;
v26 = *v15;
v27 = 1LL;
}
v28 = *a4;
v29 = v54;
if ( v28 == 255 )
{
v28 = (unsigned __int16)__ROL2__(*(_WORD *)(a4 + 1), 8);
v30 = 3;
}
else
{
v30 = 1;
}
v31 = v26 <= v28;
v32 = v26 - v28;
if ( !v31 )
{
v33 = v32 + v30;
v34 = &v15[v27 - v33];
v56 = v34;
if ( v28 > 0xFE )
{
*v34 = -1;
v56[2] = v28;
v56[1] = BYTE1(v28);
}
else
{
*v34 = v28;
}
memmove(&v56[v30], v28 + v29, v32);
LODWORD(v16) = (_DWORD)v56;
goto LABEL_27;
}
}
else
{
v17 = *(_QWORD *)(a1 + 192);
v18 = *(_WORD *)(v17 + 18);
if ( (v18 & 2) != 0 )
{
v19 = *v56;
if ( (*v56 & 0x80u) != 0 )
{
if ( *(_WORD *)(v17 + 20) < 0x7Fu )
{
v20 = *a4;
v21 = *a4 & 0x7F;
v22 = v54;
if ( (*a4 & 0x7F) != 0 )
{
v55 = *(_WORD *)(v17 + 20);
v23 = v19 & 0x7F;
v24 = 1;
v25 = 1LL;
goto LABEL_31;
}
}
else
{
v20 = *a4;
v21 = a4[1] | ((*a4 & 0x7F) << 8);
v22 = v54;
if ( v21 )
{
v55 = *(_WORD *)(v17 + 20);
v23 = v56[1] | ((v19 & 0x7F) << 8);
v24 = 2;
v25 = 2LL;
LABEL_31:
v35 = &v56[v25];
v56 = v35;
v36 = 0;
if ( v20 < 0 )
v36 = v21;
v37 = (unsigned __int8 *)(((v18 & 0x10) != 0) + v22);
v38 = *v37;
if ( v38 == 255 )
{
v38 = (unsigned __int16)__ROL2__(*(_WORD *)(v37 + 1), 8);
v39 = 3LL;
}
else
{
v39 = 1LL;
}
if ( v23 )
{
if ( *v35 == 0xFF )
{
LODWORD(v54) = (unsigned __int16)__ROL2__(*(_WORD *)(v35 + 1), 8);
v35 += 3;
v56 = v35;
}
else
{
v56 = v35 + 1;
LODWORD(v54) = *v35++;
}
v38 = v23;
}
else
{
LODWORD(v54) = 0;
}
LODWORD(v16) = (_DWORD)v15;
v41 = v38 < v36;
v42 = v38 - v36;
if ( v41 )
goto LABEL_36;
v43 = &v37[v39 + v36];
v44 = v20;
v45 = v42;
memmove(&v35[-(unsigned int)v42], v43, v42);
v46 = v45 + v54;
v47 = 2 * ((unsigned int)(v45 + v54) >= 0xFF) + 1;
if ( v44 >= 0 )
v47 = 0;
v33 = (unsigned int)(v47 + v45 + v24);
v16 = (char *)&v56[-v33];
v56 -= v33;
if ( v44 < 0 )
{
v49 = *a4;
v56 = (unsigned __int8 *)(v16 + 1);
*v16 = v49;
if ( v55 >= 0x7Fu )
{
v50 = a4[1];
v51 = v56++;
*v51 = v50;
}
LODWORD(a6) = (_DWORD)v53;
if ( v46 > 0xFE )
{
*v56 = -1;
v56[2] = v46;
v56[1] = BYTE1(v46);
}
else
{
*v56 = v46;
}
goto LABEL_28;
}
v48 = ((*(_WORD *)(*(_QWORD *)(a1 + 192) + 18LL) & 0x10) != 0) + (_WORD)v46;
if ( v55 < 0x7Fu )
{
*v16 = v48;
}
else
{
v16[1] = v48;
*v56 = HIBYTE(v48);
}
LABEL_27:
LODWORD(a6) = (_DWORD)v53;
LABEL_28:
*(_DWORD *)(a8 + 64) = v33;
LABEL_36:
v12 = (_DWORD)v16 - (_DWORD)a4;
LABEL_37:
memmove(a4, &a4[v12], (unsigned int)a6 - ((_DWORD)a4 + v12));
*(_DWORD *)(a8 + 68) = v12;
return v12;
}
}
}
}
}
LODWORD(v16) = (_DWORD)v15;
goto LABEL_36;
}
return 0;
}
|
remove_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13,R8
MOV R14,RCX
MOV R15D,EDX
MOV R12,RDI
MOV RAX,qword ptr [RBP + 0x18]
MOV RBX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RAX + 0x18],RCX
MOV dword ptr [RAX + 0x40],0x0
TEST SIL,0x2
JNZ 0x00159d9a
MOVZX EAX,word ptr [R12 + 0xa2]
AND EAX,0x2e
JNZ 0x00159d9a
MOVZX R13D,word ptr [R12 + 0xaa]
ADD R13D,R15D
TEST RBX,RBX
SETZ AL
TEST R15D,R15D
SETZ CL
OR CL,AL
JNZ 0x00159f7f
MOVSXD RSI,R13D
ADD RSI,R14
MOV EDI,R15D
MOV R15,R9
CALL 0x0016d16f
MOV R9,R15
MOV qword ptr [RBX],RAX
JMP 0x00159f7f
LAB_00159d9a:
MOV qword ptr [RBP + -0x48],R9
LEA RDI,[RBP + -0x68]
MOV qword ptr [RDI + 0x8],R12
MOV qword ptr [RDI],R13
LEA RCX,[RBP + -0x30]
MOV EDX,R15D
CALL qword ptr [R12 + 0xe0]
TEST EAX,EAX
JZ 0x00159e72
MOV qword ptr [RBP + -0x40],R13
TEST RBX,RBX
SETZ AL
TEST R15D,R15D
SETZ CL
OR CL,AL
JNZ 0x00159de3
MOV RSI,qword ptr [RBP + -0x30]
MOV EDI,R15D
CALL 0x0016d16f
MOV qword ptr [RBX],RAX
LAB_00159de3:
MOV RAX,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x48]
MOV R13,R9
CMP RAX,R9
JZ 0x00159f7c
TEST byte ptr [R12 + 0xa2],0x20
JNZ 0x00159e7a
MOV RDX,qword ptr [R12 + 0xc0]
MOVZX ESI,word ptr [RDX + 0x12]
TEST SIL,0x2
JZ 0x00159f79
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JNS 0x00159f79
MOVZX EDI,word ptr [RDX + 0x14]
CMP DI,0x7f
JC 0x00159f2b
MOVZX EDX,byte ptr [R14 + 0x1]
MOVZX R11D,byte ptr [R14]
MOV R8D,R11D
AND R8D,0x7f
SHL R8D,0x8
OR R8D,EDX
MOV R10,qword ptr [RBP + -0x40]
JZ 0x00159f79
MOV word ptr [RBP + -0x32],DI
MOVZX EDX,byte ptr [RAX + 0x1]
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EDX
MOV R15D,0x2
MOV EDI,0x2
JMP 0x00159f4e
LAB_00159e72:
XOR R13D,R13D
JMP 0x00159f9b
LAB_00159e7a:
CMP byte ptr [RAX],0xff
JZ 0x00159e91
LEA RCX,[RAX + 0x1]
MOV qword ptr [RBP + -0x30],RCX
MOVZX ECX,byte ptr [RAX]
MOV EDI,0x1
JMP 0x00159ea9
LAB_00159e91:
MOVZX ECX,word ptr [RAX + 0x1]
ROL CX,0x8
MOVZX ECX,CX
LEA RDX,[RAX + 0x3]
MOV qword ptr [RBP + -0x30],RDX
MOV EDI,0x3
LAB_00159ea9:
MOVZX EDX,byte ptr [R14]
CMP EDX,0xff
MOV RSI,qword ptr [RBP + -0x40]
JZ 0x00159ec1
MOV R8D,0x1
JMP 0x00159ed3
LAB_00159ec1:
MOVZX EDX,word ptr [R14 + 0x1]
ROL DX,0x8
MOVZX EDX,DX
MOV R8D,0x3
LAB_00159ed3:
SUB ECX,EDX
JBE 0x00159f79
ADD RAX,RDI
LEA R15D,[RCX + R8*0x1]
SUB RAX,R15
MOV qword ptr [RBP + -0x30],RAX
CMP EDX,0xfe
JA 0x00159ef5
MOV byte ptr [RAX],DL
JMP 0x00159f06
LAB_00159ef5:
MOV byte ptr [RAX],0xff
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x2],DL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x1],DH
LAB_00159f06:
MOV EDI,R8D
ADD RDI,qword ptr [RBP + -0x30]
MOV EAX,EDX
ADD RSI,RAX
MOV EDX,ECX
CALL 0x00129110
MOV R13,qword ptr [RBP + -0x30]
LAB_00159f1d:
MOV R9,qword ptr [RBP + -0x48]
LAB_00159f21:
MOV RAX,qword ptr [RBP + 0x18]
MOV dword ptr [RAX + 0x40],R15D
JMP 0x00159f7c
LAB_00159f2b:
MOVZX R11D,byte ptr [R14]
MOV R8D,R11D
AND R8D,0x7f
MOV R10,qword ptr [RBP + -0x40]
JZ 0x00159f79
MOV word ptr [RBP + -0x32],DI
AND ECX,0x7f
MOV R15D,0x1
MOV EDI,0x1
LAB_00159f4e:
ADD RDI,RAX
MOV qword ptr [RBP + -0x30],RDI
XOR EBX,EBX
TEST R11B,R11B
CMOVS EBX,R8D
BT ESI,0x4
ADC R10,0x0
MOVZX EDX,byte ptr [R10]
CMP EDX,0xff
JZ 0x00159fad
MOV ESI,0x1
JMP 0x00159fbe
LAB_00159f79:
MOV R13,RAX
LAB_00159f7c:
SUB R13D,R14D
LAB_00159f7f:
MOVSXD RBX,R13D
LEA RSI,[R14 + RBX*0x1]
SUB R9D,ESI
MOV RDI,R14
MOV RDX,R9
CALL 0x00129110
MOV RAX,qword ptr [RBP + 0x18]
MOV dword ptr [RAX + 0x44],EBX
LAB_00159f9b:
MOV EAX,R13D
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00159fad:
MOVZX ESI,word ptr [R10 + 0x1]
ROL SI,0x8
MOVZX EDX,SI
MOV ESI,0x3
LAB_00159fbe:
TEST ECX,ECX
JZ 0x00159fda
CMP byte ptr [RDI],0xff
JZ 0x00159fe3
LEA R8,[RDI + 0x1]
MOV qword ptr [RBP + -0x30],R8
MOVZX EDI,byte ptr [RDI]
MOV dword ptr [RBP + -0x40],EDI
MOV RDI,R8
JMP 0x00159ffd
LAB_00159fda:
MOV dword ptr [RBP + -0x40],0x0
JMP 0x00159fff
LAB_00159fe3:
MOVZX R8D,word ptr [RDI + 0x1]
ROL R8W,0x8
MOVZX R8D,R8W
MOV dword ptr [RBP + -0x40],R8D
ADD RDI,0x3
MOV qword ptr [RBP + -0x30],RDI
LAB_00159ffd:
MOV EDX,ECX
LAB_00159fff:
MOV R13,RAX
SUB EDX,EBX
JC 0x00159f7c
ADD R10,RSI
SUB RDI,RDX
MOV ESI,EBX
ADD RSI,R10
MOV EBX,R11D
MOV R13,RDX
CALL 0x00129110
MOV EDX,dword ptr [RBP + -0x40]
ADD EDX,R13D
XOR EAX,EAX
CMP EDX,0xff
SETNC AL
XOR ECX,ECX
TEST BL,BL
LEA EAX,[RAX + RAX*0x1 + 0x1]
CMOVNS EAX,ECX
ADD R15D,R13D
ADD R15D,EAX
MOV R13,qword ptr [RBP + -0x30]
SUB R13,R15
MOV qword ptr [RBP + -0x30],R13
TEST BL,BL
JS 0x0015a07a
MOV RAX,qword ptr [R12 + 0xc0]
MOVZX EAX,word ptr [RAX + 0x12]
BT EAX,0x4
ADC EDX,0x0
CMP word ptr [RBP + -0x32],0x7f
JC 0x0015a0bd
MOV byte ptr [R13 + 0x1],DL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],DH
JMP 0x00159f1d
LAB_0015a07a:
LEA RAX,[R13 + 0x1]
MOV CL,byte ptr [R14]
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [R13],CL
CMP word ptr [RBP + -0x32],0x7f
JC 0x0015a0a6
MOV AL,byte ptr [R14 + 0x1]
MOV RCX,qword ptr [RBP + -0x30]
MOV ESI,EDX
LEA RDX,[RCX + 0x1]
MOV qword ptr [RBP + -0x30],RDX
MOV EDX,ESI
MOV byte ptr [RCX],AL
LAB_0015a0a6:
CMP EDX,0xfe
MOV R9,qword ptr [RBP + -0x48]
JA 0x0015a0c6
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],DL
JMP 0x00159f21
LAB_0015a0bd:
MOV byte ptr [R13],DL
JMP 0x00159f1d
LAB_0015a0c6:
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0xff
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x2],DL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x1],DH
JMP 0x00159f21
|
int remove_key(long param_1,ulong param_2,int param_3,byte *param_4,long param_5,byte *param_6,
int8 *param_7,long param_8)
{
ushort uVar1;
ushort uVar2;
int8 uVar3;
uint uVar4;
uint uVar5;
byte bVar6;
uint uVar7;
long lVar8;
byte *pbVar9;
uint uVar10;
byte *pbVar11;
byte bVar12;
int iVar13;
int iVar14;
long local_70;
long local_68;
byte *local_50;
int8 local_48;
ushort local_3a;
byte *local_38;
*(byte **)(param_8 + 0x18) = param_4;
*(int4 *)(param_8 + 0x40) = 0;
local_38 = param_4;
if (((param_2 & 2) == 0) && ((*(ushort *)(param_1 + 0xa2) & 0x2e) == 0)) {
iVar13 = (uint)*(ushort *)(param_1 + 0xaa) + param_3;
if (param_3 != 0 && param_7 != (int8 *)0x0) {
uVar3 = _ma_kpos(param_3,param_4 + iVar13);
*param_7 = uVar3;
}
goto LAB_00159f7f;
}
local_70 = param_5;
local_68 = param_1;
local_50 = param_6;
iVar13 = (**(code **)(param_1 + 0xe0))(&local_70,param_2,param_3,&local_38);
if (iVar13 == 0) {
return 0;
}
local_48 = param_5;
if (param_3 != 0 && param_7 != (int8 *)0x0) {
uVar3 = _ma_kpos(param_3,local_38);
*param_7 = uVar3;
}
pbVar11 = local_38;
iVar13 = (int)local_50;
if (local_38 != local_50) {
iVar13 = (int)local_38;
if ((*(byte *)(param_1 + 0xa2) & 0x20) == 0) {
uVar1 = *(ushort *)(*(long *)(param_1 + 0xc0) + 0x12);
if (((uVar1 & 2) != 0) && (bVar6 = *local_38, (char)bVar6 < '\0')) {
uVar2 = *(ushort *)(*(long *)(param_1 + 0xc0) + 0x14);
if (uVar2 < 0x7f) {
bVar12 = *param_4;
uVar10 = bVar12 & 0x7f;
if ((bVar12 & 0x7f) != 0) {
uVar4 = bVar6 & 0x7f;
iVar14 = 1;
lVar8 = 1;
goto LAB_00159f4e;
}
}
else {
bVar12 = *param_4;
uVar10 = (bVar12 & 0x7f) << 8 | (uint)param_4[1];
if (uVar10 != 0) {
uVar4 = (bVar6 & 0x7f) << 8 | (uint)local_38[1];
iVar14 = 2;
lVar8 = 2;
LAB_00159f4e:
local_38 = local_38 + lVar8;
uVar7 = 0;
if ((char)bVar12 < '\0') {
uVar7 = uVar10;
}
pbVar11 = (byte *)(local_48 + (ulong)((uVar1 >> 4 & 1) != 0));
uVar10 = (uint)*pbVar11;
if (*pbVar11 == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(pbVar11 + 1) << 8 | *(ushort *)(pbVar11 + 1) >> 8)
;
lVar8 = 3;
}
else {
lVar8 = 1;
}
if (uVar4 == 0) {
local_48 = (ulong)local_48._4_4_ << 0x20;
}
else {
if (*local_38 == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(local_38 + 1) << 8 |
*(ushort *)(local_38 + 1) >> 8);
pbVar9 = local_38 + 3;
}
else {
pbVar9 = local_38 + 1;
uVar10 = (uint)*local_38;
}
local_48 = CONCAT44(local_48._4_4_,uVar10);
uVar10 = uVar4;
local_38 = pbVar9;
}
uVar4 = uVar10 - uVar7;
local_3a = uVar2;
if (uVar7 <= uVar10) {
memmove(local_38 + -(ulong)uVar4,pbVar11 + (ulong)uVar7 + lVar8,(ulong)uVar4);
uVar7 = (int)local_48 + uVar4;
iVar13 = (0xfe < uVar7) + 1 + (uint)(0xfe < uVar7);
if (-1 < (char)bVar12) {
iVar13 = 0;
}
uVar10 = iVar14 + uVar4 + iVar13;
pbVar11 = local_38 + -(ulong)uVar10;
if ((char)bVar12 < '\0') {
*pbVar11 = *param_4;
local_38 = pbVar11 + 1;
if (0x7e < local_3a) {
local_38 = pbVar11 + 2;
pbVar11[1] = param_4[1];
}
if (uVar7 < 0xff) {
*local_38 = (byte)uVar7;
}
else {
*local_38 = 0xff;
local_38[2] = (byte)uVar7;
local_38[1] = (byte)(uVar7 >> 8);
}
}
else {
iVar13 = uVar7 + ((*(ushort *)(*(long *)(param_1 + 0xc0) + 0x12) >> 4 & 1) != 0);
bVar6 = (byte)iVar13;
local_38 = pbVar11;
if (local_3a < 0x7f) {
*pbVar11 = bVar6;
}
else {
pbVar11[1] = bVar6;
*pbVar11 = (byte)((uint)iVar13 >> 8);
}
}
goto LAB_00159f21;
}
}
}
}
}
else {
if (*local_38 == 0xff) {
uVar10 = (uint)(ushort)(*(ushort *)(local_38 + 1) << 8 | *(ushort *)(local_38 + 1) >> 8);
local_38 = local_38 + 3;
lVar8 = 3;
}
else {
uVar10 = (uint)*local_38;
lVar8 = 1;
local_38 = local_38 + 1;
}
uVar4 = (uint)*param_4;
if (*param_4 == 0xff) {
uVar4 = (uint)(ushort)(*(ushort *)(param_4 + 1) << 8 | *(ushort *)(param_4 + 1) >> 8);
uVar7 = 3;
}
else {
uVar7 = 1;
}
uVar5 = uVar10 - uVar4;
if (uVar4 <= uVar10 && uVar5 != 0) {
uVar10 = uVar5 + uVar7;
local_38 = pbVar11 + (lVar8 - (ulong)uVar10);
if (uVar4 < 0xff) {
*local_38 = (byte)uVar4;
}
else {
*local_38 = 0xff;
local_38[2] = (byte)uVar4;
local_38[1] = (byte)(uVar4 >> 8);
}
memmove(local_38 + uVar7,(void *)(local_48 + (ulong)uVar4),(ulong)uVar5);
pbVar11 = local_38;
LAB_00159f21:
iVar13 = (int)pbVar11;
*(uint *)(param_8 + 0x40) = uVar10;
}
}
}
iVar13 = iVar13 - (int)param_4;
param_6 = local_50;
LAB_00159f7f:
memmove(param_4,param_4 + iVar13,(ulong)(uint)((int)param_6 - (int)(param_4 + iVar13)));
*(int *)(param_8 + 0x44) = iVar13;
return iVar13;
}
|
|
18,353
|
ma_bitmap_flush_all
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_bitmap_flush_all(MARIA_SHARE *share)
{
my_bool res= 0;
uint send_signal= 0;
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
DBUG_ENTER("_ma_bitmap_flush_all");
#ifdef EXTRA_DEBUG_BITMAP
{
char buff[160];
uint len= my_sprintf(buff,
(buff, "bitmap_flush: fd: %d id: %u "
"changed: %d changed_not_flushed: %d "
"flush_all_requested: %d",
share->bitmap.file.file,
share->id,
bitmap->changed,
bitmap->changed_not_flushed,
bitmap->flush_all_requested));
(void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
(uchar*) buff, len);
}
#endif
mysql_mutex_lock(&bitmap->bitmap_lock);
if (!bitmap->changed && !bitmap->changed_not_flushed)
{
mysql_mutex_unlock(&bitmap->bitmap_lock);
DBUG_RETURN(0);
}
_ma_bitmap_mark_file_changed(share, 0);
/*
The following should be true as it was tested above. We have to test
this again as _ma_bitmap_mark_file_changed() did temporarly release
the bitmap mutex.
*/
if (bitmap->changed || bitmap->changed_not_flushed)
{
bitmap->flush_all_requested++;
bitmap->waiting_for_non_flushable++;
#if !WRONG_BITMAP_FLUSH
while (bitmap->non_flushable > 0)
{
DBUG_PRINT("info", ("waiting for bitmap to be flushable"));
mysql_cond_wait(&bitmap->bitmap_cond, &bitmap->bitmap_lock);
}
#endif
bitmap->waiting_for_non_flushable--;
#ifdef EXTRA_DEBUG_BITMAP
{
char tmp[MAX_BITMAP_INFO_LENGTH];
size_t len;
len= _ma_get_bitmap_description(bitmap, bitmap->map, bitmap->page, tmp);
(void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
(uchar*) tmp, len);
}
#endif
DBUG_ASSERT(bitmap->flush_all_requested == 1);
/*
Bitmap is in a flushable state: its contents in memory are reflected by
log records (complete REDO-UNDO groups) and all bitmap pages are
unpinned. We keep the mutex to preserve this situation, and flush to the
file.
*/
if (bitmap->changed)
{
bitmap->changed= FALSE;
res= write_changed_bitmap(share, bitmap);
}
/*
We do NOT use FLUSH_KEEP_LAZY because we must be sure that bitmap
pages have been flushed. That's a condition of correctness of
Recovery: data pages may have been all flushed, if we write the
checkpoint record Recovery will start from after their REDOs. If
bitmap page was not flushed, as the REDOs about it will be skipped, it
will wrongly not be recovered. If bitmap pages had a rec_lsn it would
be different.
There should be no pinned pages as bitmap->non_flushable==0.
*/
if (flush_pagecache_blocks_with_filter(share->pagecache,
&bitmap->file, FLUSH_KEEP,
filter_flush_bitmap_pages,
&bitmap->pages_covered) &
PCFLUSH_PINNED_AND_ERROR)
res= TRUE;
bitmap->changed_not_flushed= FALSE;
bitmap->flush_all_requested--;
/*
Some well-behaved threads may be waiting for flush_all_requested to
become false, wake them up.
*/
DBUG_PRINT("info", ("bitmap flusher waking up others"));
send_signal= (bitmap->waiting_for_flush_all_requested |
bitmap->waiting_for_non_flushable);
}
mysql_mutex_unlock(&bitmap->bitmap_lock);
if (send_signal)
mysql_cond_broadcast(&bitmap->bitmap_cond);
DBUG_RETURN(res);
}
|
O3
|
c
|
ma_bitmap_flush_all:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xa98(%rdi), %r14
cmpq $0x0, 0xad8(%rdi)
jne 0x53e6a
movq %r14, %rdi
callq 0x29200
movb 0xa30(%rbx), %al
testb %al, %al
jne 0x53cb1
cmpb $0x0, 0xa31(%rbx)
je 0x53e37
cmpb $0x0, 0x7df(%rbx)
jne 0x53cc7
testb $0x1, 0x170(%rbx)
jne 0x53eaa
testb %al, %al
jne 0x53cd8
cmpb $0x0, 0xa31(%rbx)
je 0x53e62
incl 0xa40(%rbx)
movl 0xa4c(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xa4c(%rbx)
cmpl $0x0, 0xa48(%rbx)
je 0x53d47
leaq 0xae0(%rbx), %r15
leaq 0x880e2(%rip), %r12 # 0xdbde6
cmpq $0x0, 0xb10(%rbx)
jne 0x53d24
movq %r15, %rdi
movq %r14, %rsi
callq 0x29420
cmpl $0x0, 0xa48(%rbx)
jne 0x53d04
jmp 0x53d39
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl $0x204, %ecx # imm = 0x204
callq 0x2ee90
jmp 0x53d19
movl 0xa4c(%rbx), %ecx
movb 0xa30(%rbx), %al
decl %ecx
movl %ecx, 0xa4c(%rbx)
xorl %r15d, %r15d
testb %al, %al
je 0x53db1
movw $0x100, 0xa30(%rbx) # imm = 0x100
movq 0x600(%rbx), %rdi
leaq 0xa50(%rbx), %rsi
movq 0xa20(%rbx), %rdx
movq 0xa18(%rbx), %r8
movl 0x80(%rdi), %eax
movl %eax, 0x30(%rsp)
movl %r15d, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %r15d, 0x10(%rsp)
movl %r15d, (%rsp)
movl $0x1, 0x8(%rsp)
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x3d9aa
movl %eax, %r15d
movq 0x600(%rbx), %rdi
leaq 0xa50(%rbx), %rsi
leaq 0xb48(%rbx), %r8
leaq 0x158(%rip), %rcx # 0x53f25
xorl %edx, %edx
callq 0x3e0a0
testb $0x3, %al
movzbl %r15b, %eax
movl $0x1, %r15d
cmovel %eax, %r15d
movb $0x0, 0xa31(%rbx)
decl 0xa40(%rbx)
movl 0xa4c(%rbx), %eax
orl 0xa44(%rbx), %eax
sete %r12b
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x53e83
movq %r14, %rdi
callq 0x291c0
testb %r12b, %r12b
jne 0x53e52
movq 0xb10(%rbx), %rdi
addq $0xae0, %rbx # imm = 0xAE0
testq %rdi, %rdi
jne 0x53e98
movq %rbx, %rdi
callq 0x296d0
jmp 0x53e52
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x53ede
movq %r14, %rdi
callq 0x291c0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
xorl %r15d, %r15d
jmp 0x53e01
leaq 0x87f75(%rip), %rsi # 0xdbde6
movq %r14, %rdi
movl $0x1ee, %edx # imm = 0x1EE
callq 0x2eb7f
jmp 0x53c9a
leaq 0x334186(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x53e0d
leaq 0x334171(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x178(%rax)
jmp 0x53e2d
movq 0xad8(%rbx), %rdi
testq %rdi, %rdi
jne 0x53ef3
movq %r14, %rdi
callq 0x291c0
movq %rbx, %rdi
callq 0x43d17
movq %r14, %rdi
movl $0x184, %esi # imm = 0x184
callq 0x53c4b
movb 0xa30(%rbx), %al
jmp 0x53cc7
leaq 0x33412b(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x53e47
leaq 0x334116(%rip), %rax # 0x388010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x53eb6
|
_ma_bitmap_flush_all:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
lea r14, [rdi+0A98h]
cmp qword ptr [rdi+0AD8h], 0
jnz loc_53E6A
mov rdi, r14
call _pthread_mutex_lock
loc_53C9A:
mov al, [rbx+0A30h]
test al, al
jnz short loc_53CB1
cmp byte ptr [rbx+0A31h], 0
jz loc_53E37
loc_53CB1:
cmp byte ptr [rbx+7DFh], 0
jnz short loc_53CC7
test byte ptr [rbx+170h], 1
jnz loc_53EAA
loc_53CC7:
test al, al
jnz short loc_53CD8
cmp byte ptr [rbx+0A31h], 0
jz loc_53E62
loc_53CD8:
inc dword ptr [rbx+0A40h]
mov ecx, [rbx+0A4Ch]
lea edx, [rcx+1]
mov [rbx+0A4Ch], edx
cmp dword ptr [rbx+0A48h], 0
jz short loc_53D47
lea r15, [rbx+0AE0h]
lea r12, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eloqsq"...
loc_53D04:
cmp qword ptr [rbx+0B10h], 0
jnz short loc_53D24
mov rdi, r15
mov rsi, r14
call _pthread_cond_wait
loc_53D19:
cmp dword ptr [rbx+0A48h], 0
jnz short loc_53D04
jmp short loc_53D39
loc_53D24:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov ecx, 204h
call psi_cond_wait
jmp short loc_53D19
loc_53D39:
mov ecx, [rbx+0A4Ch]
mov al, [rbx+0A30h]
dec ecx
loc_53D47:
mov [rbx+0A4Ch], ecx
xor r15d, r15d
test al, al
jz short loc_53DB1
mov word ptr [rbx+0A30h], 100h
mov rdi, [rbx+600h]
lea rsi, [rbx+0A50h]
mov rdx, [rbx+0A20h]
mov r8, [rbx+0A18h]
mov eax, [rdi+80h]
mov [rsp+60h+var_30], eax
mov [rsp+60h+var_38], r15d
xorps xmm0, xmm0
movups [rsp+60h+var_48], xmm0
mov [rsp+60h+var_50], r15d
mov [rsp+60h+var_60], r15d
mov [rsp+60h+var_58], 1
xor ecx, ecx
mov r9d, 1
call pagecache_write_part
mov r15d, eax
loc_53DB1:
mov rdi, [rbx+600h]
lea rsi, [rbx+0A50h]
lea r8, [rbx+0B48h]
lea rcx, filter_flush_bitmap_pages
xor edx, edx
call flush_pagecache_blocks_with_filter
test al, 3
movzx eax, r15b
mov r15d, 1
cmovz r15d, eax
mov byte ptr [rbx+0A31h], 0
dec dword ptr [rbx+0A40h]
mov eax, [rbx+0A4Ch]
or eax, [rbx+0A44h]
setz r12b
loc_53E01:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz short loc_53E83
loc_53E0D:
mov rdi, r14
call _pthread_mutex_unlock
test r12b, r12b
jnz short loc_53E52
mov rdi, [rbx+0B10h]
add rbx, 0AE0h
test rdi, rdi
jnz short loc_53E98
loc_53E2D:
mov rdi, rbx
call _pthread_cond_broadcast
jmp short loc_53E52
loc_53E37:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz loc_53EDE
loc_53E47:
mov rdi, r14
call _pthread_mutex_unlock
xor r15d, r15d
loc_53E52:
mov eax, r15d
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_53E62:
mov r12b, 1
xor r15d, r15d
jmp short loc_53E01
loc_53E6A:
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 1EEh
call psi_mutex_lock
jmp loc_53C9A
loc_53E83:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_53E0D
loc_53E98:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+178h]
jmp short loc_53E2D
loc_53EAA:
mov rdi, [rbx+0AD8h]
test rdi, rdi
jnz short loc_53EF3
loc_53EB6:
mov rdi, r14
call _pthread_mutex_unlock
mov rdi, rbx
call _ma_mark_file_changed_now
mov rdi, r14
mov esi, 184h
call inline_mysql_mutex_lock_1
mov al, [rbx+0A30h]
jmp loc_53CC7
loc_53EDE:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_53E47
loc_53EF3:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_53EB6
|
long long ma_bitmap_flush_all(long long a1)
{
long long v1; // r14
char v2; // al
int v3; // ecx
unsigned __int8 v4; // r15
bool v5; // zf
unsigned int v6; // eax
unsigned int v7; // r15d
bool v8; // r12
v1 = a1 + 2712;
if ( *(_QWORD *)(a1 + 2776) )
psi_mutex_lock(a1 + 2712, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c", 0x1EEu);
else
pthread_mutex_lock(a1 + 2712);
v2 = *(_BYTE *)(a1 + 2608);
if ( v2 || *(_BYTE *)(a1 + 2609) )
{
if ( !*(_BYTE *)(a1 + 2015) && (*(_BYTE *)(a1 + 368) & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
ma_mark_file_changed_now(a1);
inline_mysql_mutex_lock_1(v1, 0x184u);
v2 = *(_BYTE *)(a1 + 2608);
}
if ( v2 || *(_BYTE *)(a1 + 2609) )
{
++*(_DWORD *)(a1 + 2624);
v3 = *(_DWORD *)(a1 + 2636);
*(_DWORD *)(a1 + 2636) = v3 + 1;
if ( *(_DWORD *)(a1 + 2632) )
{
do
{
if ( *(_QWORD *)(a1 + 2832) )
psi_cond_wait(
a1 + 2784,
v1,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x204u);
else
pthread_cond_wait(a1 + 2784, v1);
}
while ( *(_DWORD *)(a1 + 2632) );
v2 = *(_BYTE *)(a1 + 2608);
v3 = *(_DWORD *)(a1 + 2636) - 1;
}
*(_DWORD *)(a1 + 2636) = v3;
v4 = 0;
if ( v2 )
{
*(_WORD *)(a1 + 2608) = 256;
v4 = pagecache_write_part(
*(__m128i **)(a1 + 1536),
(char *)(a1 + 2640),
*(_QWORD *)(a1 + 2592),
0,
*(char **)(a1 + 2584),
1,
0,
1u,
0,
0LL,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(a1 + 1536) + 128LL));
}
v5 = (flush_pagecache_blocks_with_filter(
*(_QWORD *)(a1 + 1536),
a1 + 2640,
0,
(long long ( *)(long long, _QWORD, _QWORD, long long))filter_flush_bitmap_pages,
a1 + 2888) & 3) == 0;
v6 = v4;
v7 = 1;
if ( v5 )
v7 = v6;
*(_BYTE *)(a1 + 2609) = 0;
--*(_DWORD *)(a1 + 2624);
v8 = (*(_DWORD *)(a1 + 2628) | *(_DWORD *)(a1 + 2636)) == 0;
}
else
{
v8 = 1;
v7 = 0;
}
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
if ( !v8 )
{
if ( *(_QWORD *)(a1 + 2832) )
PSI_server[47]();
pthread_cond_broadcast(a1 + 2784);
}
}
else
{
if ( *(_QWORD *)(a1 + 2776) )
PSI_server[44]();
pthread_mutex_unlock(v1);
return 0;
}
return v7;
}
|
_ma_bitmap_flush_all:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R14,[RDI + 0xa98]
CMP qword ptr [RDI + 0xad8],0x0
JNZ 0x00153e6a
MOV RDI,R14
CALL 0x00129200
LAB_00153c9a:
MOV AL,byte ptr [RBX + 0xa30]
TEST AL,AL
JNZ 0x00153cb1
CMP byte ptr [RBX + 0xa31],0x0
JZ 0x00153e37
LAB_00153cb1:
CMP byte ptr [RBX + 0x7df],0x0
JNZ 0x00153cc7
TEST byte ptr [RBX + 0x170],0x1
JNZ 0x00153eaa
LAB_00153cc7:
TEST AL,AL
JNZ 0x00153cd8
CMP byte ptr [RBX + 0xa31],0x0
JZ 0x00153e62
LAB_00153cd8:
INC dword ptr [RBX + 0xa40]
MOV ECX,dword ptr [RBX + 0xa4c]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX + 0xa4c],EDX
CMP dword ptr [RBX + 0xa48],0x0
JZ 0x00153d47
LEA R15,[RBX + 0xae0]
LEA R12,[0x1dbde6]
LAB_00153d04:
CMP qword ptr [RBX + 0xb10],0x0
JNZ 0x00153d24
MOV RDI,R15
MOV RSI,R14
CALL 0x00129420
LAB_00153d19:
CMP dword ptr [RBX + 0xa48],0x0
JNZ 0x00153d04
JMP 0x00153d39
LAB_00153d24:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV ECX,0x204
CALL 0x0012ee90
JMP 0x00153d19
LAB_00153d39:
MOV ECX,dword ptr [RBX + 0xa4c]
MOV AL,byte ptr [RBX + 0xa30]
DEC ECX
LAB_00153d47:
MOV dword ptr [RBX + 0xa4c],ECX
XOR R15D,R15D
TEST AL,AL
JZ 0x00153db1
MOV word ptr [RBX + 0xa30],0x100
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[RBX + 0xa50]
MOV RDX,qword ptr [RBX + 0xa20]
MOV R8,qword ptr [RBX + 0xa18]
MOV EAX,dword ptr [RDI + 0x80]
MOV dword ptr [RSP + 0x30],EAX
MOV dword ptr [RSP + 0x28],R15D
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],R15D
MOV dword ptr [RSP],R15D
MOV dword ptr [RSP + 0x8],0x1
XOR ECX,ECX
MOV R9D,0x1
CALL 0x0013d9aa
MOV R15D,EAX
LAB_00153db1:
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[RBX + 0xa50]
LEA R8,[RBX + 0xb48]
LEA RCX,[0x153f25]
XOR EDX,EDX
CALL 0x0013e0a0
TEST AL,0x3
MOVZX EAX,R15B
MOV R15D,0x1
CMOVZ R15D,EAX
MOV byte ptr [RBX + 0xa31],0x0
DEC dword ptr [RBX + 0xa40]
MOV EAX,dword ptr [RBX + 0xa4c]
OR EAX,dword ptr [RBX + 0xa44]
SETZ R12B
LAB_00153e01:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x00153e83
LAB_00153e0d:
MOV RDI,R14
CALL 0x001291c0
TEST R12B,R12B
JNZ 0x00153e52
MOV RDI,qword ptr [RBX + 0xb10]
ADD RBX,0xae0
TEST RDI,RDI
JNZ 0x00153e98
LAB_00153e2d:
MOV RDI,RBX
CALL 0x001296d0
JMP 0x00153e52
LAB_00153e37:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x00153ede
LAB_00153e47:
MOV RDI,R14
CALL 0x001291c0
XOR R15D,R15D
LAB_00153e52:
MOV EAX,R15D
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00153e62:
MOV R12B,0x1
XOR R15D,R15D
JMP 0x00153e01
LAB_00153e6a:
LEA RSI,[0x1dbde6]
MOV RDI,R14
MOV EDX,0x1ee
CALL 0x0012eb7f
JMP 0x00153c9a
LAB_00153e83:
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00153e0d
LAB_00153e98:
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x178]
JMP 0x00153e2d
LAB_00153eaa:
MOV RDI,qword ptr [RBX + 0xad8]
TEST RDI,RDI
JNZ 0x00153ef3
LAB_00153eb6:
MOV RDI,R14
CALL 0x001291c0
MOV RDI,RBX
CALL 0x00143d17
MOV RDI,R14
MOV ESI,0x184
CALL 0x00153c4b
MOV AL,byte ptr [RBX + 0xa30]
JMP 0x00153cc7
LAB_00153ede:
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00153e47
LAB_00153ef3:
LEA RAX,[0x488010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00153eb6
|
int1 _ma_bitmap_flush_all(long param_1)
{
pthread_mutex_t *__mutex;
char cVar1;
int1 uVar2;
ulong uVar3;
int iVar4;
int1 uVar5;
bool bVar6;
__mutex = (pthread_mutex_t *)(param_1 + 0xa98);
if (*(long *)(param_1 + 0xad8) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x1ee);
}
cVar1 = *(char *)(param_1 + 0xa30);
if ((cVar1 == '\0') && (*(char *)(param_1 + 0xa31) == '\0')) {
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar5 = 0;
}
else {
if ((*(char *)(param_1 + 0x7df) == '\0') && ((*(byte *)(param_1 + 0x170) & 1) != 0)) {
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
_ma_mark_file_changed_now(param_1);
inline_mysql_mutex_lock(__mutex,0x184);
cVar1 = *(char *)(param_1 + 0xa30);
}
if ((cVar1 == '\0') && (*(char *)(param_1 + 0xa31) == '\0')) {
bVar6 = true;
uVar5 = 0;
}
else {
*(int *)(param_1 + 0xa40) = *(int *)(param_1 + 0xa40) + 1;
iVar4 = *(int *)(param_1 + 0xa4c);
*(int *)(param_1 + 0xa4c) = iVar4 + 1;
if (*(int *)(param_1 + 0xa48) != 0) {
do {
if (*(long *)(param_1 + 0xb10) == 0) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)(param_1 + 0xae0),__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",0x204
);
}
} while (*(int *)(param_1 + 0xa48) != 0);
cVar1 = *(char *)(param_1 + 0xa30);
iVar4 = *(int *)(param_1 + 0xa4c) + -1;
}
*(int *)(param_1 + 0xa4c) = iVar4;
uVar2 = 0;
if (cVar1 != '\0') {
*(int2 *)(param_1 + 0xa30) = 0x100;
uVar2 = pagecache_write_part
(*(long *)(param_1 + 0x600),param_1 + 0xa50,
*(int8 *)(param_1 + 0xa20),0,*(int8 *)(param_1 + 0xa18),1,0,1
,0,0,0,0,*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
}
uVar3 = flush_pagecache_blocks_with_filter
(*(int8 *)(param_1 + 0x600),param_1 + 0xa50,0,
filter_flush_bitmap_pages,param_1 + 0xb48);
uVar5 = 1;
if ((uVar3 & 3) == 0) {
uVar5 = uVar2;
}
*(int1 *)(param_1 + 0xa31) = 0;
*(int *)(param_1 + 0xa40) = *(int *)(param_1 + 0xa40) + -1;
bVar6 = *(int *)(param_1 + 0xa4c) == 0 && *(int *)(param_1 + 0xa44) == 0;
}
if (*(long *)(param_1 + 0xad8) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
if (!bVar6) {
if (*(long *)(param_1 + 0xb10) != 0) {
(**(code **)(PSI_server + 0x178))();
}
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 0xae0));
}
}
return uVar5;
}
|
|
18,354
|
string_table_resize
|
tsotchke[P]eshkol/src/core/utils/string_table.c
|
static void string_table_resize(StringTable* table) {
assert(table != NULL);
// Double the capacity
size_t new_capacity = table->bucket_count * 2;
size_t new_buckets_size = new_capacity * sizeof(Entry*);
// Allocate new buckets
Entry** new_buckets = arena_alloc(table->arena, new_buckets_size);
if (!new_buckets) return; // Failed to resize
// Initialize new buckets
memset(new_buckets, 0, new_buckets_size);
// Rehash all entries
for (size_t i = 0; i < table->bucket_count; i++) {
Entry* entry = table->buckets[i];
while (entry) {
Entry* next = entry->next;
// Compute new bucket index
size_t bucket = entry->hash & (new_capacity - 1);
// Add to new bucket
entry->next = new_buckets[bucket];
new_buckets[bucket] = entry;
entry = next;
}
}
// Update table
table->buckets = new_buckets;
table->bucket_count = new_capacity;
table->resize_threshold = new_capacity * 3 / 4;
}
|
O0
|
c
|
string_table_resize:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2575
jmp 0x2594
leaq 0xb74(%rip), %rdi # 0x30f0
leaq 0x1130(%rip), %rsi # 0x36b3
movl $0x56, %edx
leaq 0x12a7(%rip), %rcx # 0x3836
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1be0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x25cf
jmp 0x269b
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x1090
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2672
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x265f
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2608
jmp 0x2661
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25e6
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
imulq $0x3, -0x10(%rbp), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
string_table_resize:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz short loc_2575
jmp short loc_2594
loc_2575:
lea rdi, aTableNull; "table != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 56h ; 'V'
lea rcx, aVoidStringTabl; "void string_table_resize(StringTable *)"
call ___assert_fail
loc_2594:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
shl rax, 1
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
shl rax, 3
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rdi, [rax]
mov rsi, [rbp+var_18]
call arena_alloc
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_25CF
jmp loc_269B
loc_25CF:
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_18]
xor esi, esi
call _memset
mov [rbp+var_28], 0
loc_25E6:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb short loc_2672
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_28]
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
loc_2608:
cmp [rbp+var_30], 0
jz short loc_265F
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov eax, [rax+10h]
mov rcx, [rbp+var_10]
sub rcx, 1
and rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_40]
mov rcx, [rax+rcx*8]
mov rax, [rbp+var_30]
mov [rax+18h], rcx
mov rdx, [rbp+var_30]
mov rax, [rbp+var_20]
mov rcx, [rbp+var_40]
mov [rax+rcx*8], rdx
mov rax, [rbp+var_38]
mov [rbp+var_30], rax
jmp short loc_2608
loc_265F:
jmp short $+2
loc_2661:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp loc_25E6
loc_2672:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
imul rcx, [rbp+var_10], 3
shr rcx, 2
mov rax, [rbp+var_8]
mov [rax+20h], rcx
loc_269B:
add rsp, 40h
pop rbp
retn
|
long long string_table_resize(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-40h]
long long v3; // [rsp+8h] [rbp-38h]
long long j; // [rsp+10h] [rbp-30h]
unsigned long long i; // [rsp+18h] [rbp-28h]
long long v6; // [rsp+20h] [rbp-20h]
long long v7; // [rsp+28h] [rbp-18h]
long long v8; // [rsp+30h] [rbp-10h]
if ( !a1 )
__assert_fail(
"table != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/string_table.c",
86LL,
"void string_table_resize(StringTable *)");
v8 = 2 * a1[2];
v7 = 16 * a1[2];
result = arena_alloc(*a1, v7);
v6 = result;
if ( result )
{
memset(result, 0LL, v7);
for ( i = 0LL; i < a1[2]; ++i )
{
for ( j = *(_QWORD *)(a1[1] + 8 * i); j; j = v3 )
{
v3 = *(_QWORD *)(j + 24);
v2 = (v8 - 1) & *(unsigned int *)(j + 16);
*(_QWORD *)(j + 24) = *(_QWORD *)(v6 + 8 * v2);
*(_QWORD *)(v6 + 8 * v2) = j;
}
}
a1[1] = v6;
a1[2] = v8;
result = (long long)a1;
a1[4] = (unsigned long long)(3 * v8) >> 2;
}
return result;
}
|
string_table_resize:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00102575
JMP 0x00102594
LAB_00102575:
LEA RDI,[0x1030de]
LEA RSI,[0x10368f]
MOV EDX,0x56
LEA RCX,[0x103800]
CALL 0x00101080
LAB_00102594:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
SHL RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
SHL RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00101be0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001025cf
JMP 0x0010269b
LAB_001025cf:
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x00101090
MOV qword ptr [RBP + -0x28],0x0
LAB_001025e6:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x00102672
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
LAB_00102608:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0010265f
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
SUB RCX,0x1
AND RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x18],RCX
MOV RDX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00102608
LAB_0010265f:
JMP 0x00102661
LAB_00102661:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001025e6
LAB_00102672:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
IMUL RCX,qword ptr [RBP + -0x10],0x3
SHR RCX,0x2
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
LAB_0010269b:
ADD RSP,0x40
POP RBP
RET
|
void string_table_resize(int8 *param_1)
{
long lVar1;
long lVar2;
void *__s;
ulong uVar3;
long local_38;
ulong local_30;
if (param_1 == (int8 *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("table != NULL",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/string_table.c",0x56,
"void string_table_resize(StringTable *)");
}
lVar1 = param_1[2];
__s = (void *)arena_alloc(*param_1);
if (__s != (void *)0x0) {
memset(__s,0,lVar1 << 4);
for (local_30 = 0; local_30 < (ulong)param_1[2]; local_30 = local_30 + 1) {
local_38 = *(long *)(param_1[1] + local_30 * 8);
while (local_38 != 0) {
lVar2 = *(long *)(local_38 + 0x18);
uVar3 = (ulong)*(uint *)(local_38 + 0x10) & lVar1 * 2 - 1U;
*(int8 *)(local_38 + 0x18) = *(int8 *)((long)__s + uVar3 * 8);
*(long *)((long)__s + uVar3 * 8) = local_38;
local_38 = lVar2;
}
}
param_1[1] = __s;
param_1[2] = lVar1 * 2;
param_1[4] = (ulong)(lVar1 * 6) >> 2;
}
return;
}
|
|
18,355
|
LefDefParser::lefwMacroTimingFallrs(double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwMacroTimingFallrs(double min,
double max)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroTiming)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " FALLRS %.11g %.11g ;\n", min, max);
else
fprintf(lefwFile, " FALLRS %.11g %.11g ;\n", min, max);
lefwLines++;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwMacroTimingFallrs(double, double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
leaq 0x9219a(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x330c9
movl $0x1, 0x14(%rsp)
jmp 0x33166
leaq 0x923d4(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x330e2
movl $0x2, 0x14(%rsp)
jmp 0x33166
leaq 0x92413(%rip), %rax # 0xc54fc
cmpl $0x0, (%rax)
jne 0x330f8
movl $0x2, 0x14(%rsp)
jmp 0x33166
cmpl $0x0, 0x9243d(%rip) # 0xc553c
je 0x33126
leaq 0x92148(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x616bb(%rip), %rsi # 0x947d8
movb $0x2, %al
callq 0x8bf50
jmp 0x33149
leaq 0x92123(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x61696(%rip), %rsi # 0x947d8
movb $0x2, %al
callq 0x2370
leaq 0x9234c(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x92340(%rip), %rax # 0xc549c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
|
_ZN12LefDefParser21lefwMacroTimingFallrsEdd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
movsd [rsp+18h+var_18], xmm1
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_330C9
mov [rsp+18h+var_4], 1
jmp loc_33166
loc_330C9:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_330E2
mov [rsp+18h+var_4], 2
jmp loc_33166
loc_330E2:
lea rax, _ZN12LefDefParser17lefwIsMacroTimingE; LefDefParser::lefwIsMacroTiming
cmp dword ptr [rax], 0
jnz short loc_330F8
mov [rsp+18h+var_4], 2
jmp short loc_33166
loc_330F8:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_33126
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aFallrs11g11g; " FALLRS %.11g %.11g ;\n"
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_33149
loc_33126:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aFallrs11g11g; " FALLRS %.11g %.11g ;\n"
mov al, 2
call _fprintf
loc_33149:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_33166:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwMacroTimingFallrs(
LefDefParser *this,
double a2,
double a3,
long long a4,
int a5,
int a6,
int a7,
int a8)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroTiming )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" FALLRS %.11g %.11g ;\n", a5, a6, a7, a8);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " FALLRS %.11g %.11g ;\n", a2, a3);
++LefDefParser::lefwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwMacroTimingFallrs:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD qword ptr [RSP],XMM1
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x001330c9
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00133166
LAB_001330c9:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x001330e2
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00133166
LAB_001330e2:
LEA RAX,[0x1c54fc]
CMP dword ptr [RAX],0x0
JNZ 0x001330f8
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00133166
LAB_001330f8:
CMP dword ptr [0x001c553c],0x0
JZ 0x00133126
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x1947d8]
MOV AL,0x2
CALL 0x0018bf50
JMP 0x00133149
LAB_00133126:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x1947d8]
MOV AL,0x2
CALL 0x00102370
LAB_00133149:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_00133166:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroTimingFallrs(double, double) */
int4 LefDefParser::lefwMacroTimingFallrs(double param_1,double param_2)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroTiming == 0) {
local_4 = 2;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," FALLRS %.11g %.11g ;\n",param_1,param_2);
}
else {
encPrint(lefwFile," FALLRS %.11g %.11g ;\n",param_1,param_2);
}
lefwLines = lefwLines + 1;
local_4 = 0;
}
return local_4;
}
|
|
18,356
|
ftb_phrase_add_word
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int ftb_phrase_add_word(MYSQL_FTPARSER_PARAM *param,
const char *word, int word_len,
MYSQL_FTPARSER_BOOLEAN_INFO *boolean_info __attribute__((unused)))
{
MY_FTB_PHRASE_PARAM *phrase_param= param->mysql_ftparam;
FT_WORD *w= (FT_WORD *)phrase_param->document->data;
LIST *phrase, *document;
w->pos= (uchar*) word;
w->len= word_len;
phrase_param->document= phrase_param->document->prev;
if (phrase_param->phrase_length > phrase_param->document_length)
{
phrase_param->document_length++;
return 0;
}
/* TODO: rewrite phrase search to avoid
comparing the same word twice. */
for (phrase= phrase_param->phrase, document= phrase_param->document->next;
phrase; phrase= phrase->next, document= document->next)
{
FT_WORD *phrase_word= (FT_WORD *)phrase->data;
FT_WORD *document_word= (FT_WORD *)document->data;
if (my_strnncoll(phrase_param->cs, (uchar*) phrase_word->pos,
phrase_word->len,
(uchar*) document_word->pos, document_word->len))
return 0;
}
phrase_param->match++;
return 0;
}
|
O3
|
c
|
ftb_phrase_add_word:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rsi, (%rax)
movslq %edx, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rbx), %rax
movq (%rax), %r14
movq %r14, 0x8(%rbx)
movl 0x1c(%rbx), %eax
cmpl %eax, 0x18(%rbx)
jbe 0x729ba
incl %eax
movl %eax, 0x1c(%rbx)
jmp 0x729fb
movq (%rbx), %r15
testq %r15, %r15
je 0x729f8
movq 0x8(%r14), %r14
movq 0x10(%r15), %rax
movq 0x10(%r14), %r8
movq 0x10(%rbx), %rdi
movq 0xc0(%rdi), %r10
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movq (%r8), %rcx
movq 0x10(%r8), %r8
xorl %r9d, %r9d
callq *0x8(%r10)
testl %eax, %eax
jne 0x729fb
movq 0x8(%r15), %r15
jmp 0x729bd
incl 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
ftb_phrase_add_word:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, [rdi+18h]
mov rax, [rbx+8]
mov rax, [rax+10h]
mov [rax], rsi
movsxd rcx, edx
mov [rax+10h], rcx
mov rax, [rbx+8]
mov r14, [rax]
mov [rbx+8], r14
mov eax, [rbx+1Ch]
cmp [rbx+18h], eax
jbe short loc_729BA
inc eax
mov [rbx+1Ch], eax
jmp short loc_729FB
loc_729BA:
mov r15, [rbx]
loc_729BD:
test r15, r15
jz short loc_729F8
mov r14, [r14+8]
mov rax, [r15+10h]
mov r8, [r14+10h]
mov rdi, [rbx+10h]
mov r10, [rdi+0C0h]
mov rsi, [rax]
mov rdx, [rax+10h]
mov rcx, [r8]
mov r8, [r8+10h]
xor r9d, r9d
call qword ptr [r10+8]
test eax, eax
jnz short loc_729FB
mov r15, [r15+8]
jmp short loc_729BD
loc_729F8:
inc dword ptr [rbx+20h]
loc_729FB:
xor eax, eax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long ftb_phrase_add_word(long long a1, long long a2, int a3)
{
long long v3; // rax
long long *v4; // rbx
_QWORD *v5; // rax
long long v6; // r14
unsigned int v7; // eax
long long i; // r15
long long v10; // [rsp-8h] [rbp-20h]
v10 = v3;
v4 = *(long long **)(a1 + 24);
v5 = *(_QWORD **)(v4[1] + 16);
*v5 = a2;
v5[2] = a3;
v6 = *(_QWORD *)v4[1];
v4[1] = v6;
v7 = *((_DWORD *)v4 + 7);
if ( *((_DWORD *)v4 + 6) <= v7 )
{
for ( i = *v4; i; i = *(_QWORD *)(i + 8) )
{
v6 = *(_QWORD *)(v6 + 8);
if ( (*(unsigned int ( **)(long long, _QWORD, _QWORD, _QWORD, _QWORD, _QWORD, long long))(*(_QWORD *)(v4[2] + 192) + 8LL))(
v4[2],
**(_QWORD **)(i + 16),
*(_QWORD *)(*(_QWORD *)(i + 16) + 16LL),
**(_QWORD **)(v6 + 16),
*(_QWORD *)(*(_QWORD *)(v6 + 16) + 16LL),
0LL,
v10) )
{
return 0LL;
}
}
++*((_DWORD *)v4 + 8);
}
else
{
*((_DWORD *)v4 + 7) = v7 + 1;
}
return 0LL;
}
|
ftb_phrase_add_word:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RAX],RSI
MOVSXD RCX,EDX
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBX + 0x8]
MOV R14,qword ptr [RAX]
MOV qword ptr [RBX + 0x8],R14
MOV EAX,dword ptr [RBX + 0x1c]
CMP dword ptr [RBX + 0x18],EAX
JBE 0x001729ba
INC EAX
MOV dword ptr [RBX + 0x1c],EAX
JMP 0x001729fb
LAB_001729ba:
MOV R15,qword ptr [RBX]
LAB_001729bd:
TEST R15,R15
JZ 0x001729f8
MOV R14,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [R15 + 0x10]
MOV R8,qword ptr [R14 + 0x10]
MOV RDI,qword ptr [RBX + 0x10]
MOV R10,qword ptr [RDI + 0xc0]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [R8]
MOV R8,qword ptr [R8 + 0x10]
XOR R9D,R9D
CALL qword ptr [R10 + 0x8]
TEST EAX,EAX
JNZ 0x001729fb
MOV R15,qword ptr [R15 + 0x8]
JMP 0x001729bd
LAB_001729f8:
INC dword ptr [RBX + 0x20]
LAB_001729fb:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 ftb_phrase_add_word(long param_1,int8 param_2,int param_3)
{
long *plVar1;
int8 *puVar2;
int iVar3;
long lVar4;
long lVar5;
plVar1 = *(long **)(param_1 + 0x18);
puVar2 = *(int8 **)(plVar1[1] + 0x10);
*puVar2 = param_2;
puVar2[2] = (long)param_3;
lVar4 = *(long *)plVar1[1];
plVar1[1] = lVar4;
if (*(uint *)((long)plVar1 + 0x1c) < *(uint *)(plVar1 + 3)) {
*(uint *)((long)plVar1 + 0x1c) = *(uint *)((long)plVar1 + 0x1c) + 1;
}
else {
for (lVar5 = *plVar1; lVar5 != 0; lVar5 = *(long *)(lVar5 + 8)) {
lVar4 = *(long *)(lVar4 + 8);
iVar3 = (**(code **)(*(long *)(plVar1[2] + 0xc0) + 8))
(plVar1[2],**(int8 **)(lVar5 + 0x10),
(*(int8 **)(lVar5 + 0x10))[2],**(int8 **)(lVar4 + 0x10),
(*(int8 **)(lVar4 + 0x10))[2],0);
if (iVar3 != 0) {
return 0;
}
}
*(int *)(plVar1 + 4) = (int)plVar1[4] + 1;
}
return 0;
}
|
|
18,357
|
plutovg_canvas_fill_text
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-canvas.c
|
float plutovg_canvas_fill_text(plutovg_canvas_t* canvas, const void* text, int length, plutovg_text_encoding_t encoding, float x, float y)
{
plutovg_canvas_new_path(canvas);
float advance_width = plutovg_canvas_add_text(canvas, text, length, encoding, x, y);
plutovg_canvas_fill(canvas);
return advance_width;
}
|
O3
|
c
|
plutovg_canvas_fill_text:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm1, (%rsp)
movss %xmm0, 0x4(%rsp)
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0x2a559
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
callq 0x241b3
movss %xmm0, (%rsp)
movq %r15, %rdi
callq 0x23e0e
movq 0x10(%r15), %rdi
callq 0x2a559
movss (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
plutovg_canvas_fill_text:
push rbp
push r15
push r14
push rbx
push rax
movss [rsp+28h+var_28], xmm1
movss [rsp+28h+var_24], xmm0
mov ebx, ecx
mov ebp, edx
mov r14, rsi
mov r15, rdi
mov rdi, [rdi+10h]
call plutovg_path_reset
mov rdi, r15
mov rsi, r14
mov edx, ebp
mov ecx, ebx
movss xmm0, [rsp+28h+var_24]
movss xmm1, [rsp+28h+var_28]
call plutovg_canvas_add_text
movss [rsp+28h+var_28], xmm0
mov rdi, r15
call plutovg_canvas_fill_preserve
mov rdi, [r15+10h]
call plutovg_path_reset
movss xmm0, [rsp+28h+var_28]
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
float plutovg_canvas_fill_text(long long a1, long long a2, unsigned int a3, unsigned int a4, float a5, float a6)
{
float v9; // [rsp+0h] [rbp-28h]
plutovg_path_reset(*(_QWORD *)(a1 + 16));
LODWORD(v9) = plutovg_canvas_add_text(a1, a2, a3, a4, a5, a6);
plutovg_canvas_fill_preserve(a1);
plutovg_path_reset(*(_QWORD *)(a1 + 16));
return v9;
}
|
plutovg_canvas_fill_text:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOVSS dword ptr [RSP],XMM1
MOVSS dword ptr [RSP + 0x4],XMM0
MOV EBX,ECX
MOV EBP,EDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x10]
CALL 0x0012a559
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
MOV ECX,EBX
MOVSS XMM0,dword ptr [RSP + 0x4]
MOVSS XMM1,dword ptr [RSP]
CALL 0x001241b3
MOVSS dword ptr [RSP],XMM0
MOV RDI,R15
CALL 0x00123e0e
MOV RDI,qword ptr [R15 + 0x10]
CALL 0x0012a559
MOVSS XMM0,dword ptr [RSP]
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4
plutovg_canvas_fill_text
(int4 param_1,int4 param_2,long param_3,int8 param_4,int4 param_5,
int4 param_6)
{
int4 uVar1;
plutovg_path_reset(*(int8 *)(param_3 + 0x10));
uVar1 = plutovg_canvas_add_text(param_1,param_2,param_3,param_4,param_5,param_6);
plutovg_canvas_fill_preserve(param_3);
plutovg_path_reset(*(int8 *)(param_3 + 0x10));
return uVar1;
}
|
|
18,358
|
bitmap_get_next_set
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_get_next_set(const MY_BITMAP *map, uint bitmap_bit)
{
uint word_pos, byte_to_mask, i;
union { my_bitmap_map bitmap ; uchar bitmap_buff[sizeof(my_bitmap_map)]; }
first_word;
uchar *ptr= &first_word.bitmap_buff[0];
my_bitmap_map *data_ptr, *end= map->last_word_ptr;
DBUG_ASSERT(map->bitmap);
/* Look for the next bit */
bitmap_bit++;
if (bitmap_bit >= map->n_bits)
return MY_BIT_NONE;
word_pos= bitmap_bit / 32;
data_ptr= map->bitmap + word_pos;
first_word.bitmap= *data_ptr;
/* Mask out previous bits from first_word */
byte_to_mask= (bitmap_bit % 32) / 8;
for (i= 0; i < byte_to_mask; i++)
ptr[i]= 0;
ptr[byte_to_mask]&= 0xFFU << (bitmap_bit & 7);
if (data_ptr == end)
{
if (first_word.bitmap & ~map->last_word_mask)
return get_first_set(first_word.bitmap, word_pos);
else
return MY_BIT_NONE;
}
if (first_word.bitmap)
return get_first_set(first_word.bitmap, word_pos);
for (data_ptr++, word_pos++; data_ptr < end; data_ptr++, word_pos++)
if (*data_ptr)
return get_first_set(*data_ptr, word_pos);
if (!(*end & ~map->last_word_mask))
return MY_BIT_NONE;
return get_first_set(*end, word_pos);
}
|
O0
|
c
|
bitmap_get_next_set:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xeeb65
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xeeb86
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeecd6
movl -0x14(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
andl $0x1f, %eax
shrl $0x3, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xeebde
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xeebc0
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
movl $0xff, %esi
shll %cl, %esi
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0xeec38
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xeec2c
movl -0x24(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xeeac0
movl %eax, -0x4(%rbp)
jmp 0xeecd6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeecd6
cmpl $0x0, -0x24(%rbp)
je 0xeec51
movl -0x24(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0xeeac0
movl %eax, -0x4(%rbp)
jmp 0xeecd6
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xeeca5
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0xeec8c
movq -0x38(%rbp), %rax
movl (%rax), %edi
movl -0x18(%rbp), %esi
callq 0xeeac0
movl %eax, -0x4(%rbp)
jmp 0xeecd6
jmp 0xeec8e
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeec66
movq -0x40(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xeecc5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeecd6
movq -0x40(%rbp), %rax
movl (%rax), %edi
movl -0x18(%rbp), %esi
callq 0xeeac0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
bitmap_get_next_set:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
lea rax, [rbp+var_24]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_40], rax
jmp short $+2
loc_EEB65:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+1Ch]
jb short loc_EEB86
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_EECD6
loc_EEB86:
mov eax, [rbp+var_14]
shr eax, 5
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov ecx, [rbp+var_18]
shl rcx, 2
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_24], eax
mov eax, [rbp+var_14]
and eax, 1Fh
shr eax, 3
mov [rbp+var_1C], eax
mov [rbp+var_20], 0
loc_EEBC0:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jnb short loc_EEBDE
mov rax, [rbp+var_30]
mov ecx, [rbp+var_20]
mov byte ptr [rax+rcx], 0
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_EEBC0
loc_EEBDE:
mov ecx, [rbp+var_14]
and ecx, 7
mov esi, 0FFh
shl esi, cl
mov rax, [rbp+var_30]
mov ecx, [rbp+var_1C]
movzx edx, byte ptr [rax+rcx]
and edx, esi
mov [rax+rcx], dl
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnz short loc_EEC38
mov eax, [rbp+var_24]
mov rcx, [rbp+var_10]
mov ecx, [rcx+18h]
xor ecx, 0FFFFFFFFh
and eax, ecx
cmp eax, 0
jz short loc_EEC2C
mov edi, [rbp+var_24]
mov esi, [rbp+var_18]
call get_first_set
mov [rbp+var_4], eax
jmp loc_EECD6
loc_EEC2C:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_EECD6
loc_EEC38:
cmp [rbp+var_24], 0
jz short loc_EEC51
mov edi, [rbp+var_24]
mov esi, [rbp+var_18]
call get_first_set
mov [rbp+var_4], eax
jmp loc_EECD6
loc_EEC51:
mov rax, [rbp+var_38]
add rax, 4
mov [rbp+var_38], rax
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
loc_EEC66:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_EECA5
mov rax, [rbp+var_38]
cmp dword ptr [rax], 0
jz short loc_EEC8C
mov rax, [rbp+var_38]
mov edi, [rax]
mov esi, [rbp+var_18]
call get_first_set
mov [rbp+var_4], eax
jmp short loc_EECD6
loc_EEC8C:
jmp short $+2
loc_EEC8E:
mov rax, [rbp+var_38]
add rax, 4
mov [rbp+var_38], rax
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
jmp short loc_EEC66
loc_EECA5:
mov rax, [rbp+var_40]
mov eax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+18h]
xor ecx, 0FFFFFFFFh
and eax, ecx
cmp eax, 0
jnz short loc_EECC5
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_EECD6
loc_EECC5:
mov rax, [rbp+var_40]
mov edi, [rax]
mov esi, [rbp+var_18]
call get_first_set
mov [rbp+var_4], eax
loc_EECD6:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long bitmap_get_next_set(long long a1, unsigned int a2)
{
int *v3; // [rsp+0h] [rbp-40h]
int *v4; // [rsp+8h] [rbp-38h]
int *v5; // [rsp+8h] [rbp-38h]
int v6; // [rsp+1Ch] [rbp-24h]
unsigned int i; // [rsp+20h] [rbp-20h]
unsigned int v8; // [rsp+24h] [rbp-1Ch]
unsigned int v9; // [rsp+28h] [rbp-18h]
unsigned int v10; // [rsp+2Ch] [rbp-14h]
long long v11; // [rsp+30h] [rbp-10h]
v11 = a1;
v10 = a2;
v3 = *(int **)(a1 + 8);
v10 = a2 + 1;
if ( a2 + 1 >= *(_DWORD *)(a1 + 28) )
return (unsigned int)-1;
v9 = v10 >> 5;
v4 = (int *)(4LL * (v10 >> 5) + *(_QWORD *)v11);
v6 = *v4;
v8 = (unsigned __int8)(v10 & 0x1F) >> 3;
for ( i = 0; i < v8; ++i )
*((_BYTE *)&v6 + i) = 0;
*((_BYTE *)&v6 + v8) &= 255 << (v10 & 7);
if ( v4 == v3 )
{
if ( (~*(_DWORD *)(v11 + 24) & v6) == 0 )
return (unsigned int)-1;
return (unsigned int)get_first_set(v6, v9);
}
if ( v6 )
return (unsigned int)get_first_set(v6, v9);
v5 = v4 + 1;
++v9;
while ( v5 < v3 )
{
if ( *v5 )
return (unsigned int)get_first_set(*v5, v9);
++v5;
++v9;
}
if ( (~*(_DWORD *)(v11 + 24) & *v3) != 0 )
return (unsigned int)get_first_set(*v3, v9);
else
return (unsigned int)-1;
}
|
bitmap_get_next_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
LEA RAX,[RBP + -0x24]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001eeb65
LAB_001eeb65:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001eeb86
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001eecd6
LAB_001eeb86:
MOV EAX,dword ptr [RBP + -0x14]
SHR EAX,0x5
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x18]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1f
SHR EAX,0x3
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x20],0x0
LAB_001eebc0:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x001eebde
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001eebc0
LAB_001eebde:
MOV ECX,dword ptr [RBP + -0x14]
AND ECX,0x7
MOV ESI,0xff
SHL ESI,CL
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x1c]
MOVZX EDX,byte ptr [RAX + RCX*0x1]
AND EDX,ESI
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNZ 0x001eec38
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x18]
XOR ECX,0xffffffff
AND EAX,ECX
CMP EAX,0x0
JZ 0x001eec2c
MOV EDI,dword ptr [RBP + -0x24]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x001eeac0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001eecd6
LAB_001eec2c:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001eecd6
LAB_001eec38:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001eec51
MOV EDI,dword ptr [RBP + -0x24]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x001eeac0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001eecd6
LAB_001eec51:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
LAB_001eec66:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001eeca5
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX],0x0
JZ 0x001eec8c
MOV RAX,qword ptr [RBP + -0x38]
MOV EDI,dword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x001eeac0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001eecd6
LAB_001eec8c:
JMP 0x001eec8e
LAB_001eec8e:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x001eec66
LAB_001eeca5:
MOV RAX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x18]
XOR ECX,0xffffffff
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001eecc5
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001eecd6
LAB_001eecc5:
MOV RAX,qword ptr [RBP + -0x40]
MOV EDI,dword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x001eeac0
MOV dword ptr [RBP + -0x4],EAX
LAB_001eecd6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 bitmap_get_next_set(long *param_1,int param_2)
{
uint *puVar1;
int4 uVar2;
uint *local_40;
uint local_2c;
uint local_28;
uint local_24;
uint local_20;
uint local_1c;
long *local_18;
int4 local_c;
puVar1 = (uint *)param_1[1];
local_1c = param_2 + 1;
if (local_1c < *(uint *)((long)param_1 + 0x1c)) {
local_20 = local_1c >> 5;
local_40 = (uint *)(*param_1 + (ulong)local_20 * 4);
local_2c = *local_40;
local_24 = (local_1c & 0x1f) >> 3;
for (local_28 = 0; local_28 < local_24; local_28 = local_28 + 1) {
*(int1 *)((long)&local_2c + (ulong)local_28) = 0;
}
*(byte *)((long)&local_2c + (ulong)local_24) =
*(byte *)((long)&local_2c + (ulong)local_24) & (byte)(0xff << ((byte)local_1c & 7));
local_18 = param_1;
if (local_40 == puVar1) {
if ((local_2c & (*(uint *)(param_1 + 3) ^ 0xffffffff)) == 0) {
local_c = 0xffffffff;
}
else {
local_c = get_first_set(local_2c,local_20);
}
}
else if (local_2c == 0) {
do {
local_20 = local_20 + 1;
local_40 = local_40 + 1;
if (puVar1 <= local_40) {
if ((*puVar1 & (*(uint *)(param_1 + 3) ^ 0xffffffff)) == 0) {
return 0xffffffff;
}
uVar2 = get_first_set(*puVar1,local_20);
return uVar2;
}
} while (*local_40 == 0);
local_c = get_first_set(*local_40,local_20);
}
else {
local_c = get_first_set(local_2c,local_20);
}
}
else {
local_c = 0xffffffff;
}
return local_c;
}
|
|
18,359
|
fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender, char>, std::back_insert_iterator<fmt::v10::basic_memory_buffer<char, 500ul, std::allocator<char>>>, long, std::ratio<1l, 1000000000l>>::on_second(fmt::v10::detail::numeric_system, fmt::v10::detail::pad_type)
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/chrono.h
|
void on_second(numeric_system ns, pad_type pad) {
if (handle_nan_inf()) return;
if (ns == numeric_system::standard) {
if (std::is_floating_point<rep>::value) {
auto buf = memory_buffer();
write_floating_seconds(buf, std::chrono::duration<rep, Period>(val),
precision);
if (negative) *out++ = '-';
if (buf.size() < 2 || buf[1] == '.') {
out = detail::write_padding(out, pad);
}
out = std::copy(buf.begin(), buf.end(), out);
} else {
write(second(), 2, pad);
write_fractional_seconds<char_type>(
out, std::chrono::duration<rep, Period>(val), precision);
}
return;
}
auto time = tm();
time.tm_sec = to_nonnegative_int(second(), 60);
format_tm(time, &tm_writer_type::on_second, ns, pad);
}
|
O0
|
c
|
fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender, char>, std::back_insert_iterator<fmt::v10::basic_memory_buffer<char, 500ul, std::allocator<char>>>, long, std::ratio<1l, 1000000000l>>::on_second(fmt::v10::detail::numeric_system, fmt::v10::detail::pad_type):
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2d7d50
testb $0x1, %al
jne 0x2d7936
jmp 0x2d793b
jmp 0x2d7a06
cmpl $0x0, 0x6c(%rsp)
jne 0x2d7998
movq 0x8(%rsp), %rdi
callq 0x2d82a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x68(%rsp), %ecx
movl $0x2, %edx
callq 0x2d7dd0
movq 0x8(%rsp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
addq $0x18, %rsi
leaq 0x60(%rsp), %rdi
callq 0x190d40
movq 0x8(%rsp), %rax
movq (%rsp), %rdi
movl 0x10(%rax), %edx
movq 0x60(%rsp), %rsi
callq 0x2d82d0
jmp 0x2d7a06
movq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x2d82a0
movq %rax, %rdi
movl $0x3c, %esi
callq 0x2d2aa0
movq 0x8(%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x6c(%rsp), %r8d
movl 0x68(%rsp), %r9d
leaq -0x2d04(%rip), %rax # 0x2d4ce0
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rsi
callq 0x2d8040
addq $0x78, %rsp
retq
nopl (%rax,%rax)
|
_ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE9on_secondENS1_14numeric_systemENS1_8pad_typeE:
sub rsp, 78h
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_C], esi
mov [rsp+78h+var_10], edx
mov rdi, [rsp+78h+var_8]
mov [rsp+78h+var_70], rdi
call _ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE14handle_nan_infEv; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000000l>>::handle_nan_inf(void)
test al, 1
jnz short loc_2D7936
jmp short loc_2D793B
loc_2D7936:
jmp loc_2D7A06
loc_2D793B:
cmp [rsp+78h+var_C], 0
jnz short loc_2D7998
mov rdi, [rsp+78h+var_70]
call _ZNK3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE6secondEv; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000000l>>::second(void)
mov rdi, [rsp+78h+var_70]
mov rsi, rax
mov ecx, [rsp+78h+var_10]
mov edx, 2
call _ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE5writeEliNS1_8pad_typeE; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000000l>>::write(long,int,fmt::v10::detail::pad_type)
mov rsi, [rsp+78h+var_70]
mov rax, rsi
add rax, 8
mov [rsp+78h+var_78], rax
add rsi, 18h
lea rdi, [rsp+78h+var_18]
call __ZNSt6chrono8durationImSt5ratioILl1ELl1000000000EEEC2ImvEERKT_; std::chrono::duration<ulong,std::ratio<1l,1000000000l>>::duration<ulong,void>(ulong const&)
mov rax, [rsp+78h+var_70]
mov rdi, [rsp+78h+var_78]
mov edx, [rax+10h]
mov rsi, [rsp+78h+var_18]
call _ZN3fmt3v106detail24write_fractional_secondsIcSt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEENSt6chrono8durationImSt5ratioILl1ELl1000000000EEEEEEvRT0_T1_i; fmt::v10::detail::write_fractional_seconds<char,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,std::chrono::duration<ulong,std::ratio<1l,1000000000l>>>(std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>> &,std::chrono::duration<ulong,std::ratio<1l,1000000000l>>,int)
jmp short loc_2D7A06
loc_2D7998:
mov rdi, [rsp+78h+var_70]
xorps xmm0, xmm0
movaps [rsp+78h+var_38], xmm0
movaps [rsp+78h+var_48], xmm0
movaps [rsp+78h+var_58], xmm0
mov [rsp+78h+var_28], 0
call _ZNK3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE6secondEv; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000000l>>::second(void)
mov rdi, rax
mov esi, 3Ch ; '<'
call _ZN3fmt3v106detail18to_nonnegative_intIliTnNSt9enable_ifIXsr3std11is_integralIT_EE5valueEiE4typeELi0EEET0_S4_S7_
mov rdi, [rsp+78h+var_70]
mov dword ptr [rsp+78h+var_58], eax
mov r8d, [rsp+78h+var_C]
mov r9d, [rsp+78h+var_10]
lea rax, _ZN3fmt3v106detail9tm_writerISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEEcNSt6chrono8durationIlSt5ratioILl1ELl1EEEEE9on_secondENS1_14numeric_systemENS1_8pad_typeE; fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::on_second(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type)
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 0
mov rdx, [rsp+78h+var_68]
mov rcx, [rsp+78h+var_60]
lea rsi, [rsp+78h+var_58]
call _ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000000EEE9format_tmIMNS1_9tm_writerISA_cNSt6chrono8durationIlSB_ILl1ELl1EEEEEEFvNS1_14numeric_systemENS1_8pad_typeEEJSL_SM_EEEvRK2tmT_DpT0_; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000000l>>::format_tm<void (fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type>(tm const&,void (fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type)
loc_2D7A06:
add rsp, 78h
retn
|
type:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x002d7ea0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x18
CALL 0x002d7ed0
ADD RSP,0x18
RET
|
/* unifex::_task::_promise<aimrt::rpc::Status>::type::type() */
void __thiscall unifex::_task::_promise<aimrt::rpc::Status>::type::type(type *this)
{
_promise_base::_promise_base((_promise_base *)this);
_return_value_or_void<aimrt::rpc::Status>::type::type((type *)(this + 0x18));
return;
}
|
||
18,360
|
fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender, char>, std::back_insert_iterator<fmt::v10::basic_memory_buffer<char, 500ul, std::allocator<char>>>, long, std::ratio<1l, 1000000000l>>::on_second(fmt::v10::detail::numeric_system, fmt::v10::detail::pad_type)
|
aimrt_mujoco_sim/_deps/fmt-src/include/fmt/chrono.h
|
void on_second(numeric_system ns, pad_type pad) {
if (handle_nan_inf()) return;
if (ns == numeric_system::standard) {
if (std::is_floating_point<rep>::value) {
auto buf = memory_buffer();
write_floating_seconds(buf, std::chrono::duration<rep, Period>(val),
precision);
if (negative) *out++ = '-';
if (buf.size() < 2 || buf[1] == '.') {
out = detail::write_padding(out, pad);
}
out = std::copy(buf.begin(), buf.end(), out);
} else {
write(second(), 2, pad);
write_fractional_seconds<char_type>(
out, std::chrono::duration<rep, Period>(val), precision);
}
return;
}
auto time = tm();
time.tm_sec = to_nonnegative_int(second(), 60);
format_tm(time, &tm_writer_type::on_second, ns, pad);
}
|
O3
|
c
|
fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender, char>, std::back_insert_iterator<fmt::v10::basic_memory_buffer<char, 500ul, std::allocator<char>>>, long, std::ratio<1l, 1000000000l>>::on_second(fmt::v10::detail::numeric_system, fmt::v10::detail::pad_type):
pushq %rbx
subq $0x40, %rsp
movl %edx, %r9d
movq %rdi, %rbx
testl %esi, %esi
je 0xf1711
movl %esi, %r8d
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x30(%rsi)
movq 0x20(%rbx), %rcx
movabsq $-0x7777777777777777, %rdx # imm = 0x8888888888888889
movq %rcx, %rax
mulq %rdx
shrq $0x5, %rdx
imull $0x3c, %edx, %eax
subl %eax, %ecx
movl %ecx, (%rsi)
leaq 0x11ff(%rip), %rdx # 0xf2900
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xf1a4a
addq $0x40, %rsp
popq %rbx
retq
movq 0x20(%rbx), %rsi
movabsq $-0x7777777777777777, %rcx # imm = 0x8888888888888889
movq %rsi, %rax
mulq %rcx
shrq $0x5, %rdx
imulq $0x3c, %rdx, %rax
subq %rax, %rsi
movq %rbx, %rdi
movl $0x2, %edx
movl %r9d, %ecx
callq 0xf1862
leaq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
addq $0x40, %rsp
popq %rbx
jmp 0xf2627
nop
|
_ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000EEE9on_secondENS1_14numeric_systemENS1_8pad_typeE:
push rbx
sub rsp, 40h
mov r9d, edx
mov rbx, rdi
test esi, esi
jz short loc_F1711
mov r8d, esi
xorps xmm0, xmm0
mov rsi, rsp
movaps xmmword ptr [rsi+20h], xmm0
movaps xmmword ptr [rsi+10h], xmm0
movaps xmmword ptr [rsi], xmm0
mov qword ptr [rsi+30h], 0
mov rcx, [rbx+20h]
mov rdx, 8888888888888889h
mov rax, rcx
mul rdx
shr rdx, 5
imul eax, edx, 3Ch ; '<'
sub ecx, eax
mov [rsi], ecx
lea rdx, _ZN3fmt3v106detail9tm_writerISt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEEcNSt6chrono8durationIlSt5ratioILl1ELl1EEEEE9on_secondENS1_14numeric_systemENS1_8pad_typeE; fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::on_second(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type)
mov rdi, rbx
xor ecx, ecx
call _ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000EEE9format_tmIMNS1_9tm_writerISA_cNSt6chrono8durationIlSB_ILl1ELl1EEEEEEFvNS1_14numeric_systemENS1_8pad_typeEEJSL_SM_EEEvRK2tmT_DpT0_; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>::format_tm<void (fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type>(tm const&,void (fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type)
add rsp, 40h
pop rbx
retn
loc_F1711:
mov rsi, [rbx+20h]
mov rcx, 8888888888888889h
mov rax, rsi
mul rcx
shr rdx, 5
imul rax, rdx, 3Ch ; '<'
sub rsi, rax
mov rdi, rbx
mov edx, 2
mov ecx, r9d
call _ZN3fmt3v106detail16chrono_formatterINS0_20basic_format_contextINS0_8appenderEcEESt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEElSt5ratioILl1ELl1000000EEE5writeEliNS1_8pad_typeE; fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>::write(long,int,fmt::v10::detail::pad_type)
lea rdi, [rbx+8]
mov rsi, [rbx+18h]
mov edx, [rbx+10h]
add rsp, 40h
pop rbx
jmp _ZN3fmt3v106detail24write_fractional_secondsIcSt20back_insert_iteratorINS0_19basic_memory_bufferIcLm500ESaIcEEEENSt6chrono8durationImSt5ratioILl1ELl1000000EEEEEEvRT0_T1_i; fmt::v10::detail::write_fractional_seconds<char,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,std::chrono::duration<ulong,std::ratio<1l,1000000l>>>(std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>> &,std::chrono::duration<ulong,std::ratio<1l,1000000l>>,int)
|
long long fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>::on_second(
long long a1,
int a2,
unsigned int a3)
{
long long v4; // [rsp+0h] [rbp-48h] BYREF
if ( a2 )
return fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>::format_tm<void (fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type>(
a1,
(unsigned int)&v4,
(unsigned int)&fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::on_second,
0,
a2,
a3,
*(_QWORD *)(a1 + 32) % 0x3CuLL,
0,
0LL,
0LL,
0LL,
0LL,
0LL);
fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>::write(
a1,
*(_QWORD *)(a1 + 32) % 0x3CuLL,
2LL,
a3);
return fmt::v10::detail::write_fractional_seconds<char,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,std::chrono::duration<unsigned long,std::ratio<1l,1000000l>>>(
a1 + 8,
*(_QWORD *)(a1 + 24),
*(unsigned int *)(a1 + 16));
}
|
on_second:
PUSH RBX
SUB RSP,0x40
MOV R9D,EDX
MOV RBX,RDI
TEST ESI,ESI
JZ 0x001f1711
MOV R8D,ESI
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI + 0x20],XMM0
MOVAPS xmmword ptr [RSI + 0x10],XMM0
MOVAPS xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x30],0x0
MOV RCX,qword ptr [RBX + 0x20]
MOV RDX,-0x7777777777777777
MOV RAX,RCX
MUL RDX
SHR RDX,0x5
IMUL EAX,EDX,0x3c
SUB ECX,EAX
MOV dword ptr [RSI],ECX
LEA RDX,[0x1f2900]
MOV RDI,RBX
XOR ECX,ECX
CALL 0x001f1a4a
ADD RSP,0x40
POP RBX
RET
LAB_001f1711:
MOV RSI,qword ptr [RBX + 0x20]
MOV RCX,-0x7777777777777777
MOV RAX,RSI
MUL RCX
SHR RDX,0x5
IMUL RAX,RDX,0x3c
SUB RSI,RAX
MOV RDI,RBX
MOV EDX,0x2
MOV ECX,R9D
CALL 0x001f1862
LEA RDI,[RBX + 0x8]
MOV RSI,qword ptr [RBX + 0x18]
MOV EDX,dword ptr [RBX + 0x10]
ADD RSP,0x40
POP RBX
JMP 0x001f2627
|
/* fmt::v10::detail::chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender, char>,
std::back_insert_iterator<fmt::v10::basic_memory_buffer<char, 500ul, std::allocator<char> > >,
long, std::ratio<1l, 1000000l> >::on_second(fmt::v10::detail::numeric_system,
fmt::v10::detail::pad_type) */
void __thiscall
fmt::v10::detail::
chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>
::on_second(chrono_formatter<fmt::v10::basic_format_context<fmt::v10::appender,char>,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,long,std::ratio<1l,1000000l>>
*this,int param_2,int4 param_3)
{
ulong local_48 [8];
if (param_2 != 0) {
local_48[4] = 0;
local_48[5] = 0;
local_48[2] = 0;
local_48[3] = 0;
local_48[1] = 0;
local_48[6] = 0;
local_48[0] = (ulong)(uint)((int)*(ulong *)(this + 0x20) +
(int)(*(ulong *)(this + 0x20) / 0x3c) * -0x3c);
format_tm<void(fmt::v10::detail::tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>::*)(fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type),fmt::v10::detail::numeric_system,fmt::v10::detail::pad_type>
(this,local_48,
tm_writer<std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,char,std::chrono::duration<long,std::ratio<1l,1l>>>
::on_second,0,param_2);
return;
}
write(this,*(ulong *)(this + 0x20) % 0x3c,2,param_3);
write_fractional_seconds<char,std::back_insert_iterator<fmt::v10::basic_memory_buffer<char,500ul,std::allocator<char>>>,std::chrono::duration<unsigned_long,std::ratio<1l,1000000l>>>
(this + 8,*(int8 *)(this + 0x18),*(int4 *)(this + 0x10));
return;
}
|
|
18,361
|
my_thread_global_reinit
|
eloqsql/mysys/my_thr_init.c
|
void my_thread_global_reinit(void)
{
struct st_my_thread_var *tmp;
DBUG_ASSERT(my_thread_global_init_done);
#ifdef HAVE_PSI_INTERFACE
my_init_mysys_psi_keys();
#endif
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
tmp= my_thread_var;
DBUG_ASSERT(tmp);
my_thread_destory_thr_mutex(tmp);
my_thread_init_thr_mutex(tmp);
}
|
O3
|
c
|
my_thread_global_reinit:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x9f2c7
callq 0xa1278
callq 0xa14b2
callq 0xa13db
callq 0xa163f
leaq 0xb67552(%rip), %rax # 0xc089e4
movl (%rax), %edi
callq 0x29860
movq %rax, %rbx
movq %rax, %rdi
callq 0xa1701
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa176b
|
my_thread_global_reinit:
push rbp
mov rbp, rsp
push rbx
push rax
call my_init_mysys_psi_keys
call my_thread_destroy_common_mutex
call my_thread_init_common_mutex
call my_thread_destroy_internal_mutex
call my_thread_init_internal_mutex
lea rax, THR_KEY_mysys
mov edi, [rax]
call _pthread_getspecific
mov rbx, rax
mov rdi, rax
call my_thread_destory_thr_mutex
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp my_thread_init_thr_mutex
|
long long my_thread_global_reinit(long long a1)
{
long long v1; // rbx
my_init_mysys_psi_keys(a1);
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
v1 = pthread_getspecific(THR_KEY_mysys);
my_thread_destory_thr_mutex(v1);
return my_thread_init_thr_mutex(v1);
}
|
my_thread_global_reinit:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CALL 0x0019f2c7
CALL 0x001a1278
CALL 0x001a14b2
CALL 0x001a13db
CALL 0x001a163f
LEA RAX,[0xd089e4]
MOV EDI,dword ptr [RAX]
CALL 0x00129860
MOV RBX,RAX
MOV RDI,RAX
CALL 0x001a1701
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001a176b
|
void my_thread_global_reinit(void)
{
void *pvVar1;
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
pvVar1 = pthread_getspecific(THR_KEY_mysys);
my_thread_destory_thr_mutex(pvVar1);
my_thread_init_thr_mutex(pvVar1);
return;
}
|
|
18,362
|
my_lock
|
eloqsql/mysys/my_lock.c
|
int my_lock(File fd, int locktype, my_off_t start, my_off_t length,
myf MyFlags)
{
#ifdef HAVE_FCNTL
int value;
ALARM_VARIABLES;
#endif
DBUG_ENTER("my_lock");
DBUG_PRINT("my",("fd: %d Op: %d start: %ld Length: %ld MyFlags: %lu",
fd,locktype,(long) start,(long) length,MyFlags));
if (my_disable_locking && ! (MyFlags & MY_FORCE_LOCK))
DBUG_RETURN(0);
#if defined(_WIN32)
{
int timeout_sec;
if (MyFlags & MY_NO_WAIT)
timeout_sec= 0;
else
timeout_sec= WIN_LOCK_INFINITE;
if (win_lock(fd, locktype, start, length, timeout_sec) == 0)
DBUG_RETURN(0);
}
#else
#if defined(HAVE_FCNTL)
{
struct flock lock;
lock.l_type= (short) locktype;
lock.l_whence= SEEK_SET;
lock.l_start= (off_t) start;
lock.l_len= (off_t) length;
if (MyFlags & (MY_NO_WAIT | MY_SHORT_WAIT))
{
if (fcntl(fd,F_SETLK,&lock) != -1) /* Check if we can lock */
DBUG_RETURN(0); /* Ok, file locked */
if (MyFlags & MY_NO_WAIT)
{
my_errno= (errno == EACCES) ? EAGAIN : errno ? errno : -1;
DBUG_RETURN(-1);
}
DBUG_PRINT("info",("Was locked, trying with alarm"));
ALARM_INIT;
while ((value=fcntl(fd,F_SETLKW,&lock)) && ! ALARM_TEST &&
errno == EINTR)
{ /* Setup again so we don`t miss it */
ALARM_REINIT;
}
ALARM_END;
if (value != -1)
DBUG_RETURN(0);
if (errno == EINTR)
errno=EAGAIN;
}
else if (fcntl(fd,F_SETLKW,&lock) != -1) /* Wait until a lock */
DBUG_RETURN(0);
}
#else
if (MyFlags & MY_SEEK_NOT_DONE)
{
if (my_seek(fd,start,MY_SEEK_SET,MYF(MyFlags & ~MY_SEEK_NOT_DONE))
== MY_FILEPOS_ERROR)
{
/*
If an error has occurred in my_seek then we will already
have an error code in my_errno; Just return error code.
*/
DBUG_RETURN(-1);
}
}
if (lockf(fd,locktype,length) != -1)
DBUG_RETURN(0);
#endif /* HAVE_FCNTL */
#endif /* _WIN32 */
/* We got an error. We don't want EACCES errors */
my_errno=(errno == EACCES) ? EAGAIN : errno ? errno : -1;
if (MyFlags & MY_WME)
{
if (locktype == F_UNLCK)
my_error(EE_CANTUNLOCK,MYF(ME_BELL),my_errno);
else
my_error(EE_CANTLOCK,MYF(ME_BELL),my_errno);
}
DBUG_PRINT("error",("my_errno: %d (%d)",my_errno,errno));
DBUG_RETURN(-1);
}
|
O3
|
c
|
my_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movl %esi, %ebx
movl %edi, %r15d
testb %r14b, %r14b
js 0xa0fc5
leaq 0xb6922f(%rip), %rax # 0xc0a1e8
xorl %r12d, %r12d
cmpb $0x0, (%rax)
jne 0xa115d
movw %bx, -0x58(%rbp)
movw $0x0, -0x56(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
xorl %r12d, %r12d
leaq -0x58(%rbp), %rdx
testl $0x140, %r14d # imm = 0x140
je 0xa10a7
movl %r15d, %edi
movl $0x6, %esi
xorl %eax, %eax
callq 0x29120
cmpl $-0x1, %eax
jne 0xa115d
btl $0x8, %r14d
jb 0xa10da
leaq 0xb691c3(%rip), %rax # 0xc0a1d8
movl $0x0, (%rax)
leaq 0x2e6b16(%rip), %rax # 0x387b38
movl (%rax), %edi
callq 0x29230
movl %eax, -0x2c(%rbp)
leaq 0x839d(%rip), %rsi # 0xa93d0
movl $0xe, %edi
callq 0x292e0
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
leaq -0x58(%rbp), %rdx
movl %r15d, %edi
movl $0x7, %esi
xorl %eax, %eax
callq 0x29120
testl %eax, %eax
je 0xa1125
movl %eax, %r13d
leaq 0xb6916f(%rip), %rax # 0xc0a1d8
cmpl $0x0, (%rax)
je 0xa116f
movl $0xe, %edi
movq -0x38(%rbp), %rsi
callq 0x292e0
movl -0x2c(%rbp), %edi
callq 0x29230
xorl %r12d, %r12d
cmpl $-0x1, %r13d
jne 0xa115d
callq 0x29790
cmpl $0x4, (%rax)
jne 0xa10c4
movl $0xb, (%rax)
jmp 0xa10c4
movl %r15d, %edi
movl $0x7, %esi
xorl %eax, %eax
callq 0x29120
cmpl $-0x1, %eax
jne 0xa115d
callq 0x29790
movl (%rax), %eax
testl %eax, %eax
je 0xa10f3
movl $0xb, %r15d
cmpl $0xd, %eax
je 0xa10f9
movl %eax, %r15d
jmp 0xa10f9
callq 0x29790
movl (%rax), %eax
testl %eax, %eax
je 0xa114b
movl $0xb, %ebx
cmpl $0xd, %eax
je 0xa1150
movl %eax, %ebx
jmp 0xa1150
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
callq 0xa2f62
movl %r15d, (%rax)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testb $0x10, %r14b
je 0xa115d
callq 0xa2f62
movl (%rax), %edx
movl $0x4, %esi
cmpl $0x2, %ebx
jne 0xa113d
movl $0xb, %edi
jmp 0xa1142
movl $0xe, %edi
movq -0x38(%rbp), %rsi
callq 0x292e0
movl -0x2c(%rbp), %edi
callq 0x29230
jmp 0xa115d
movl $0xa, %edi
xorl %eax, %eax
callq 0x9f473
jmp 0xa115d
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
callq 0xa2f62
movl %ebx, (%rax)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29790
movq %rax, %r12
cmpl $0x4, (%r12)
jne 0xa1072
leaq 0x2e69af(%rip), %rax # 0x387b38
movl (%rax), %edi
callq 0x29230
leaq 0xb69041(%rip), %rax # 0xc0a1d8
movl $0x0, (%rax)
xorl %r13d, %r13d
movl %r15d, %edi
movl $0x7, %esi
leaq -0x58(%rbp), %rdx
xorl %eax, %eax
callq 0x29120
testl %eax, %eax
je 0xa1072
leaq 0xb69016(%rip), %rcx # 0xc0a1d8
cmpl $0x0, (%rcx)
movl %eax, %r13d
je 0xa1177
jmp 0xa1072
nop
|
my_lock:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, r8
mov ebx, esi
mov r15d, edi
test r14b, r14b
js short loc_A0FC5
lea rax, my_disable_locking
xor r12d, r12d
cmp byte ptr [rax], 0
jnz loc_A115D
loc_A0FC5:
mov [rbp+var_58], bx
mov [rbp+var_56], 0
mov [rbp+var_50], rdx
mov [rbp+var_48], rcx
xor r12d, r12d
lea rdx, [rbp+var_58]
test r14d, 140h
jz loc_A10A7
mov edi, r15d
mov esi, 6
xor eax, eax
call _fcntl64
cmp eax, 0FFFFFFFFh
jnz loc_A115D
bt r14d, 8
jb loc_A10DA
lea rax, my_have_got_alarm
mov dword ptr [rax], 0
lea rax, my_time_to_wait_for_lock
mov edi, [rax]
call _alarm
mov [rbp+var_2C], eax
lea rsi, my_set_alarm_variable
mov edi, 0Eh
call _signal
mov [rbp+var_38], rax
xor r12d, r12d
lea rdx, [rbp+var_58]
mov edi, r15d
mov esi, 7
xor eax, eax
call _fcntl64
test eax, eax
jz loc_A1125
mov r13d, eax
lea rax, my_have_got_alarm
cmp dword ptr [rax], 0
jz loc_A116F
loc_A1072:
mov edi, 0Eh
mov rsi, [rbp+var_38]
call _signal
mov edi, [rbp+var_2C]
call _alarm
xor r12d, r12d
cmp r13d, 0FFFFFFFFh
jnz loc_A115D
call ___errno_location
cmp dword ptr [rax], 4
jnz short loc_A10C4
mov dword ptr [rax], 0Bh
jmp short loc_A10C4
loc_A10A7:
mov edi, r15d
mov esi, 7
xor eax, eax
call _fcntl64
cmp eax, 0FFFFFFFFh
jnz loc_A115D
call ___errno_location
loc_A10C4:
mov eax, [rax]
test eax, eax
jz short loc_A10F3
mov r15d, 0Bh
cmp eax, 0Dh
jz short loc_A10F9
mov r15d, eax
jmp short loc_A10F9
loc_A10DA:
call ___errno_location
mov eax, [rax]
test eax, eax
jz short loc_A114B
mov ebx, 0Bh
cmp eax, 0Dh
jz short loc_A1150
mov ebx, eax
jmp short loc_A1150
loc_A10F3:
mov r15d, 0FFFFFFFFh
loc_A10F9:
call _my_thread_var
mov [rax], r15d
mov r12d, 0FFFFFFFFh
test r14b, 10h
jz short loc_A115D
call _my_thread_var
mov edx, [rax]
mov esi, 4
cmp ebx, 2
jnz short loc_A113D
mov edi, 0Bh
jmp short loc_A1142
loc_A1125:
mov edi, 0Eh
mov rsi, [rbp+var_38]
call _signal
mov edi, [rbp+var_2C]
call _alarm
jmp short loc_A115D
loc_A113D:
mov edi, 0Ah
loc_A1142:
xor eax, eax
call my_error
jmp short loc_A115D
loc_A114B:
mov ebx, 0FFFFFFFFh
loc_A1150:
call _my_thread_var
mov [rax], ebx
mov r12d, 0FFFFFFFFh
loc_A115D:
mov eax, r12d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A116F:
call ___errno_location
mov r12, rax
loc_A1177:
cmp dword ptr [r12], 4
jnz loc_A1072
lea rax, my_time_to_wait_for_lock
mov edi, [rax]
call _alarm
lea rax, my_have_got_alarm
mov dword ptr [rax], 0
xor r13d, r13d
mov edi, r15d
mov esi, 7
lea rdx, [rbp+var_58]
xor eax, eax
call _fcntl64
test eax, eax
jz loc_A1072
lea rcx, my_have_got_alarm
cmp dword ptr [rcx], 0
mov r13d, eax
jz short loc_A1177
jmp loc_A1072
|
long long my_lock(long long a1, int a2, long long a3, long long a4, __int16 a5)
{
unsigned int v6; // r12d
int v7; // eax
int v8; // r13d
int *v9; // rax
int v10; // eax
int v11; // r15d
int v12; // eax
int v13; // ebx
long long v14; // rdx
unsigned int v15; // edi
_DWORD *v17; // r12
int v18; // eax
_WORD v19[4]; // [rsp+8h] [rbp-58h] BYREF
long long v20; // [rsp+10h] [rbp-50h]
long long v21; // [rsp+18h] [rbp-48h]
long long v22; // [rsp+28h] [rbp-38h]
unsigned int v23; // [rsp+34h] [rbp-2Ch]
if ( (a5 & 0x80u) == 0 )
{
v6 = 0;
if ( my_disable_locking )
return v6;
}
v19[0] = a2;
v19[1] = 0;
v20 = a3;
v21 = a4;
v6 = 0;
if ( (a5 & 0x140) == 0 )
{
a1 = (unsigned int)a1;
if ( (unsigned int)fcntl64((unsigned int)a1, 7LL, v19) != -1 )
return v6;
v9 = (int *)__errno_location((unsigned int)a1);
goto LABEL_13;
}
if ( (unsigned int)fcntl64((unsigned int)a1, 6LL, v19) != -1 )
return v6;
if ( (a5 & 0x100) != 0 )
{
v12 = *(_DWORD *)__errno_location((unsigned int)a1);
if ( v12 )
{
v13 = 11;
if ( v12 != 13 )
v13 = v12;
}
else
{
v13 = -1;
}
*(_DWORD *)my_thread_var((unsigned int)a1) = v13;
return (unsigned int)-1;
}
else
{
my_have_got_alarm = 0;
v23 = alarm(my_time_to_wait_for_lock);
v22 = signal(14LL, my_set_alarm_variable);
v6 = 0;
v7 = fcntl64((unsigned int)a1, 7LL, v19);
if ( !v7 )
{
signal(14LL, v22);
alarm(v23);
return v6;
}
v8 = v7;
if ( !my_have_got_alarm )
{
v17 = (_DWORD *)__errno_location((unsigned int)a1);
do
{
if ( *v17 != 4 )
break;
alarm(my_time_to_wait_for_lock);
my_have_got_alarm = 0;
v8 = 0;
v18 = fcntl64((unsigned int)a1, 7LL, v19);
if ( !v18 )
break;
v8 = v18;
}
while ( !my_have_got_alarm );
}
signal(14LL, v22);
a1 = v23;
alarm(v23);
v6 = 0;
if ( v8 == -1 )
{
v9 = (int *)__errno_location(a1);
if ( *v9 == 4 )
*v9 = 11;
LABEL_13:
v10 = *v9;
if ( v10 )
{
v11 = 11;
if ( v10 != 13 )
v11 = v10;
}
else
{
v11 = -1;
}
*(_DWORD *)my_thread_var(a1) = v11;
v6 = -1;
if ( (a5 & 0x10) != 0 )
{
v14 = *(unsigned int *)my_thread_var(a1);
if ( a2 == 2 )
v15 = 11;
else
v15 = 10;
my_error(v15, 4LL, v14);
}
}
}
return v6;
}
|
my_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,R8
MOV EBX,ESI
MOV R15D,EDI
TEST R14B,R14B
JS 0x001a0fc5
LEA RAX,[0xd0a1e8]
XOR R12D,R12D
CMP byte ptr [RAX],0x0
JNZ 0x001a115d
LAB_001a0fc5:
MOV word ptr [RBP + -0x58],BX
MOV word ptr [RBP + -0x56],0x0
MOV qword ptr [RBP + -0x50],RDX
MOV qword ptr [RBP + -0x48],RCX
XOR R12D,R12D
LEA RDX,[RBP + -0x58]
TEST R14D,0x140
JZ 0x001a10a7
MOV EDI,R15D
MOV ESI,0x6
XOR EAX,EAX
CALL 0x00129120
CMP EAX,-0x1
JNZ 0x001a115d
BT R14D,0x8
JC 0x001a10da
LEA RAX,[0xd0a1d8]
MOV dword ptr [RAX],0x0
LEA RAX,[0x487b38]
MOV EDI,dword ptr [RAX]
CALL 0x00129230
MOV dword ptr [RBP + -0x2c],EAX
LEA RSI,[0x1a93d0]
MOV EDI,0xe
CALL 0x001292e0
MOV qword ptr [RBP + -0x38],RAX
XOR R12D,R12D
LEA RDX,[RBP + -0x58]
MOV EDI,R15D
MOV ESI,0x7
XOR EAX,EAX
CALL 0x00129120
TEST EAX,EAX
JZ 0x001a1125
MOV R13D,EAX
LEA RAX,[0xd0a1d8]
CMP dword ptr [RAX],0x0
JZ 0x001a116f
LAB_001a1072:
MOV EDI,0xe
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001292e0
MOV EDI,dword ptr [RBP + -0x2c]
CALL 0x00129230
XOR R12D,R12D
CMP R13D,-0x1
JNZ 0x001a115d
CALL 0x00129790
CMP dword ptr [RAX],0x4
JNZ 0x001a10c4
MOV dword ptr [RAX],0xb
JMP 0x001a10c4
LAB_001a10a7:
MOV EDI,R15D
MOV ESI,0x7
XOR EAX,EAX
CALL 0x00129120
CMP EAX,-0x1
JNZ 0x001a115d
CALL 0x00129790
LAB_001a10c4:
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x001a10f3
MOV R15D,0xb
CMP EAX,0xd
JZ 0x001a10f9
MOV R15D,EAX
JMP 0x001a10f9
LAB_001a10da:
CALL 0x00129790
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JZ 0x001a114b
MOV EBX,0xb
CMP EAX,0xd
JZ 0x001a1150
MOV EBX,EAX
JMP 0x001a1150
LAB_001a10f3:
MOV R15D,0xffffffff
LAB_001a10f9:
CALL 0x001a2f62
MOV dword ptr [RAX],R15D
MOV R12D,0xffffffff
TEST R14B,0x10
JZ 0x001a115d
CALL 0x001a2f62
MOV EDX,dword ptr [RAX]
MOV ESI,0x4
CMP EBX,0x2
JNZ 0x001a113d
MOV EDI,0xb
JMP 0x001a1142
LAB_001a1125:
MOV EDI,0xe
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001292e0
MOV EDI,dword ptr [RBP + -0x2c]
CALL 0x00129230
JMP 0x001a115d
LAB_001a113d:
MOV EDI,0xa
LAB_001a1142:
XOR EAX,EAX
CALL 0x0019f473
JMP 0x001a115d
LAB_001a114b:
MOV EBX,0xffffffff
LAB_001a1150:
CALL 0x001a2f62
MOV dword ptr [RAX],EBX
MOV R12D,0xffffffff
LAB_001a115d:
MOV EAX,R12D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a116f:
CALL 0x00129790
MOV R12,RAX
LAB_001a1177:
CMP dword ptr [R12],0x4
JNZ 0x001a1072
LEA RAX,[0x487b38]
MOV EDI,dword ptr [RAX]
CALL 0x00129230
LEA RAX,[0xd0a1d8]
MOV dword ptr [RAX],0x0
XOR R13D,R13D
MOV EDI,R15D
MOV ESI,0x7
LEA RDX,[RBP + -0x58]
XOR EAX,EAX
CALL 0x00129120
TEST EAX,EAX
JZ 0x001a1072
LEA RCX,[0xd0a1d8]
CMP dword ptr [RCX],0x0
MOV R13D,EAX
JZ 0x001a1177
JMP 0x001a1072
|
int8
my_lock(int4 param_1,int param_2,int8 param_3,int8 param_4,uint param_5)
{
int iVar1;
int *piVar2;
int4 *puVar3;
int8 uVar4;
int iVar5;
int2 local_60;
int2 local_5e;
int8 local_58;
int8 local_50;
__sighandler_t local_40;
uint local_34;
if ((-1 < (char)param_5) && (my_disable_locking != '\0')) {
return 0;
}
local_60 = (int2)param_2;
local_5e = 0;
local_58 = param_3;
local_50 = param_4;
if ((param_5 & 0x140) == 0) {
iVar1 = fcntl64(param_1,7,&local_60);
if (iVar1 != -1) {
return 0;
}
piVar2 = __errno_location();
}
else {
iVar1 = fcntl64(param_1,6,&local_60);
if (iVar1 != -1) {
return 0;
}
if ((param_5 >> 8 & 1) != 0) {
piVar2 = __errno_location();
iVar1 = *piVar2;
if (iVar1 == 0) {
iVar5 = -1;
}
else {
iVar5 = 0xb;
if (iVar1 != 0xd) {
iVar5 = iVar1;
}
}
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar5;
return 0xffffffff;
}
my_have_got_alarm = 0;
local_34 = alarm(my_time_to_wait_for_lock);
local_40 = signal(0xe,my_set_alarm_variable);
iVar1 = fcntl64(param_1,7,&local_60);
if (iVar1 == 0) {
signal(0xe,local_40);
alarm(local_34);
return 0;
}
iVar5 = iVar1;
if (my_have_got_alarm == 0) {
piVar2 = __errno_location();
while (iVar5 = iVar1, *piVar2 == 4) {
alarm(my_time_to_wait_for_lock);
my_have_got_alarm = 0;
iVar1 = fcntl64(param_1,7,&local_60);
iVar5 = 0;
if ((iVar1 == 0) || (iVar5 = iVar1, my_have_got_alarm != 0)) break;
}
}
signal(0xe,local_40);
alarm(local_34);
if (iVar5 != -1) {
return 0;
}
piVar2 = __errno_location();
if (*piVar2 == 4) {
*piVar2 = 0xb;
}
}
iVar1 = *piVar2;
if (iVar1 == 0) {
iVar5 = -1;
}
else {
iVar5 = 0xb;
if (iVar1 != 0xd) {
iVar5 = iVar1;
}
}
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar5;
if ((param_5 & 0x10) != 0) {
puVar3 = (int4 *)_my_thread_var();
if (param_2 == 2) {
uVar4 = 0xb;
}
else {
uVar4 = 10;
}
my_error(uVar4,4,*puVar3);
}
return 0xffffffff;
}
|
|
18,363
|
gguf_set_val_f64
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void gguf_set_val_f64(struct gguf_context * ctx, const char * key, double val) {
gguf_check_reserved_keys(key, val);
gguf_remove_key(ctx, key);
ctx->kv.emplace_back(key, val);
}
|
O1
|
cpp
|
gguf_set_val_f64:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x17d00
leaq 0x1b5bd(%rip), %rsi # 0x59e92
movq %r14, %rdi
callq 0x163e0
testl %eax, %eax
je 0x3e928
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e8fc
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17080
leaq 0x10(%rsp), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x17660
addq $0x8, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16670
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b4f6(%rip), %rdi # 0x59e25
leaq 0x1bd50(%rip), %rdx # 0x5a686
movl $0x3a8, %esi # imm = 0x3A8
xorl %eax, %eax
callq 0x17c70
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e960
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x17080
movq %rbx, %rdi
callq 0x17e30
|
gguf_set_val_f64:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rsp+48h+var_38], rsi
movsd [rsp+48h+var_40], xmm0
lea r14, [rsp+48h+var_30]
lea rdx, [rsp+48h+var_41]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aGeneralAlignme; "general.alignment"
mov rdi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_3E928
lea rax, [rsp+48h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3E8FC
mov rsi, [rsp+48h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3E8FC:
lea r14, [rsp+48h+var_38]
mov rsi, [r14]
mov rdi, rbx
call _gguf_remove_key
add rbx, 8
lea rdx, [rsp+48h+var_40]
mov rdi, rbx
mov rsi, r14
call __ZNSt6vectorI7gguf_kvSaIS0_EE12emplace_backIJRPKcRdEEERS0_DpOT_; std::vector<gguf_kv>::emplace_back<char const*&,double &>(char const*&,double &)
add rsp, 38h
pop rbx
pop r14
retn
loc_3E928:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGeneralAlignme_0; "general.alignment must be type u32"
mov esi, 3A8h
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rax, [rsp+48h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3E960
mov rsi, [rsp+48h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3E960:
mov rdi, rbx
call __Unwind_Resume
|
long long gguf_set_val_f64(long long a1, long long a2, double a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
char v7; // [rsp+7h] [rbp-41h] BYREF
double v8; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+10h] [rbp-38h] BYREF
void *v10[2]; // [rsp+18h] [rbp-30h] BYREF
long long v11; // [rsp+28h] [rbp-20h] BYREF
v9 = a2;
v8 = a3;
std::string::basic_string<std::allocator<char>>(v10, a2, &v7);
if ( !(unsigned int)std::string::compare(v10, "general.alignment") )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
936,
(unsigned int)"general.alignment must be type u32",
v3,
v4,
v5);
if ( v10[0] != &v11 )
operator delete(v10[0], v11 + 1);
gguf_remove_key(a1, v9);
return std::vector<gguf_kv>::emplace_back<char const*&,double &>(a1 + 8, &v9, &v8);
}
|
gguf_set_val_f64:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV qword ptr [RSP + 0x10],RSI
MOVSD qword ptr [RSP + 0x8],XMM0
LEA R14,[RSP + 0x18]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x00117d00
LEA RSI,[0x159e92]
MOV RDI,R14
CALL 0x001163e0
TEST EAX,EAX
JZ 0x0013e928
LEA RAX,[RSP + 0x28]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013e8fc
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00117080
LAB_0013e8fc:
LEA R14,[RSP + 0x10]
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00117660
ADD RBX,0x8
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00116670
ADD RSP,0x38
POP RBX
POP R14
RET
LAB_0013e928:
LEA RDI,[0x159e25]
LEA RDX,[0x15a686]
MOV ESI,0x3a8
XOR EAX,EAX
CALL 0x00117c70
|
void gguf_set_val_f64(double param_1,long param_2,char *param_3)
{
int iVar1;
allocator local_41;
double local_40;
char *local_38;
long *local_30 [2];
long local_20 [2];
local_40 = param_1;
local_38 = param_3;
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_3,&local_41);
iVar1 = std::__cxx11::string::compare((char *)local_30);
if (iVar1 != 0) {
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
gguf_remove_key(param_2,local_38);
std::vector<gguf_kv,std::allocator<gguf_kv>>::emplace_back<char_const*&,double&>
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_2 + 8),&local_38,&local_40);
return;
}
/* try { // try from 0013e928 to 0013e941 has its CatchHandler @ 0013e942 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",0x3a8,
"general.alignment must be type u32");
}
|
|
18,364
|
gguf_set_val_f64
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void gguf_set_val_f64(struct gguf_context * ctx, const char * key, double val) {
gguf_check_reserved_keys(key, val);
gguf_remove_key(ctx, key);
ctx->kv.emplace_back(key, val);
}
|
O2
|
cpp
|
gguf_set_val_f64:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1e820
leaq 0x1a5cd(%rip), %rsi # 0x5a982
movq %r15, %rdi
callq 0x1efa0
testb %al, %al
jne 0x403f6
leaq 0x20(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1def0
addq $0x8, %rbx
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c8c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a518(%rip), %rdi # 0x5a915
leaq 0x1ad72(%rip), %rdx # 0x5b176
movl $0x3a8, %esi # imm = 0x3A8
xorl %eax, %eax
callq 0x1e770
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1c9a0
movq %rbx, %rdi
callq 0x1e9b0
|
gguf_set_val_f64:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
mov [rsp+58h+var_40], rsi
movsd [rsp+58h+var_48], xmm0
lea r15, [rsp+58h+var_38]
lea rdx, [rsp+58h+var_49]
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aGeneralAlignme; "general.alignment"
mov rdi, r15
call __ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_403F6
lea rdi, [rsp+58h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
mov rsi, r14
call _gguf_remove_key
add rbx, 8
lea rsi, [rsp+58h+var_40]
lea rdx, [rsp+58h+var_48]
mov rdi, rbx
call __ZNSt6vectorI7gguf_kvSaIS0_EE12emplace_backIJRPKcRdEEERS0_DpOT_; std::vector<gguf_kv>::emplace_back<char const*&,double &>(char const*&,double &)
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_403F6:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGeneralAlignme_0; "general.alignment must be type u32"
mov esi, 3A8h
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rdi, [rsp+58h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long gguf_set_val_f64(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rcx
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
long long v15; // rdx
char v17; // [rsp+0h] [rbp-58h]
char v18; // [rsp+Fh] [rbp-49h] BYREF
unsigned long long v19; // [rsp+10h] [rbp-48h] BYREF
long long v20; // [rsp+18h] [rbp-40h] BYREF
_BYTE v21[56]; // [rsp+20h] [rbp-38h] BYREF
v20 = a2;
v19 = a3.m128_u64[0];
std::string::basic_string<std::allocator<char>>(v21, a2, &v18);
if ( (unsigned __int8)std::operator==<char>(v21, "general.alignment") )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
936,
(long long)"general.alignment must be type u32",
v10,
v11,
v12,
a3,
a4,
a5,
a6,
v13,
v14,
a9,
a10,
v17);
std::string::~string(v21);
gguf_remove_key(a1, a2, v15);
return std::vector<gguf_kv>::emplace_back<char const*&,double &>(a1 + 8, &v20, &v19);
}
|
gguf_set_val_f64:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x18],RSI
MOVSD qword ptr [RSP + 0x10],XMM0
LEA R15,[RSP + 0x20]
LEA RDX,[RSP + 0xf]
MOV RDI,R15
CALL 0x0011e820
LEA RSI,[0x15a982]
MOV RDI,R15
CALL 0x0011efa0
TEST AL,AL
JNZ 0x001403f6
LEA RDI,[RSP + 0x20]
CALL 0x0011c9a0
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011def0
ADD RBX,0x8
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0011c8c0
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_001403f6:
LEA RDI,[0x15a915]
LEA RDX,[0x15b176]
MOV ESI,0x3a8
XOR EAX,EAX
CALL 0x0011e770
|
void gguf_set_val_f64(double param_1,long param_2,char *param_3)
{
bool bVar1;
allocator local_49;
double local_48;
char *local_40;
string local_38 [32];
local_48 = param_1;
local_40 = param_3;
std::__cxx11::string::string<std::allocator<char>>(local_38,param_3,&local_49);
bVar1 = std::operator==(local_38,"general.alignment");
if (!bVar1) {
std::__cxx11::string::~string(local_38);
gguf_remove_key(param_2,param_3);
std::vector<gguf_kv,std::allocator<gguf_kv>>::emplace_back<char_const*&,double&>
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_2 + 8),&local_40,&local_48);
return;
}
/* try { // try from 001403f6 to 0014040f has its CatchHandler @ 00140410 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",0x3a8,
"general.alignment must be type u32");
}
|
|
18,365
|
Json_writer::start_sub_element()
|
eloqsql/sql/my_json_writer.cc
|
void Json_writer::start_sub_element()
{
//element_started= true;
if (first_child)
first_child= false;
else
output.append(',');
append_indent();
}
|
O0
|
cpp
|
Json_writer::start_sub_element():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x6(%rax)
je 0xad4614
movq -0x10(%rbp), %rax
movb $0x0, 0x6(%rax)
jmp 0xad4626
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
movl $0x2c, %esi
callq 0xad4ec0
movq -0x10(%rbp), %rdi
callq 0xad4190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN11Json_writer17start_sub_elementEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
test byte ptr [rax+6], 1
jz short loc_AD4614
mov rax, [rbp+var_10]
mov byte ptr [rax+6], 0
jmp short loc_AD4626
loc_AD4614:
mov rdi, [rbp+var_10]
add rdi, 78h ; 'x'; this
mov esi, 2Ch ; ','; char
call _ZN17String_with_limit6appendEc; String_with_limit::append(char)
loc_AD4626:
mov rdi, [rbp+var_10]; this
call _ZN11Json_writer13append_indentEv; Json_writer::append_indent(void)
add rsp, 10h
pop rbp
retn
|
long long Json_writer::start_sub_element(Json_writer *this)
{
if ( (*((_BYTE *)this + 6) & 1) != 0 )
*((_BYTE *)this + 6) = 0;
else
String_with_limit::append((Json_writer *)((char *)this + 120), 44);
return Json_writer::append_indent(this);
}
|
real_field_type:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x38]
ADD RSP,0x10
POP RBP
RET
|
/* Type_handler_hybrid_field_type::real_field_type() const */
void __thiscall
Type_handler_hybrid_field_type::real_field_type(Type_handler_hybrid_field_type *this)
{
(**(code **)(**(long **)this + 0x38))();
return;
}
|
|
18,366
|
translog_page_validator
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_page_validator(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
uint this_page_page_overhead;
uint flags;
uchar *page_pos;
TRANSLOG_FILE *data= (TRANSLOG_FILE *) args->data;
#ifndef DBUG_OFF
pgcache_page_no_t offset= page_no * TRANSLOG_PAGE_SIZE;
#endif
DBUG_ENTER("translog_page_validator");
data->was_recovered= 0;
if (res)
{
DBUG_RETURN(1);
}
if ((pgcache_page_no_t) uint3korr(page) != page_no ||
(uint32) uint3korr(page + 3) != data->number)
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"page address written in the page is incorrect: "
"File %lu instead of %lu or page %lu instead of %lu",
(uint)data->number, (uint)offset,
(ulong) uint3korr(page + 3), (ulong) data->number,
(ulong) uint3korr(page),
(ulong) page_no));
DBUG_RETURN(1);
}
flags= (uint)(page[TRANSLOG_PAGE_FLAGS]);
this_page_page_overhead= page_overhead[flags];
if (flags & ~(TRANSLOG_PAGE_CRC | TRANSLOG_SECTOR_PROTECTION |
TRANSLOG_RECORD_CRC))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"Garbage in the page flags field detected : %x",
(uint) data->number, (uint) offset,
(uint) flags));
DBUG_RETURN(1);
}
page_pos= page + (3 + 3 + 1);
if (flags & TRANSLOG_PAGE_CRC)
{
uint32 crc= translog_crc(page + this_page_page_overhead,
TRANSLOG_PAGE_SIZE -
this_page_page_overhead);
if (crc != uint4korr(page_pos))
{
DBUG_PRINT("error", ("Page " LSN_FMT ": "
"CRC mismatch: calculated: %lx on the page %lx",
(uint) data->number, (uint) offset,
(ulong) crc, (ulong) uint4korr(page_pos)));
DBUG_RETURN(1);
}
page_pos+= CRC_SIZE; /* Skip crc */
}
if (flags & TRANSLOG_SECTOR_PROTECTION &&
translog_check_sector_protection(page, data))
{
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
translog_page_validator:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %r15
movb $0x0, 0x50(%r15)
movb $0x1, %bl
testl %edi, %edi
jne 0x39822
movzwl (%r14), %ecx
movzbl 0x2(%r14), %edx
shll $0x10, %edx
orq %rcx, %rdx
cmpq %rax, %rdx
jne 0x39822
movzwl 0x3(%r14), %eax
movzbl 0x5(%r14), %ecx
shll $0x10, %ecx
orl %eax, %ecx
cmpl (%r15), %ecx
jne 0x39822
movzbl 0x6(%r14), %r12d
cmpl $0x7, %r12d
ja 0x39822
testb $0x1, %r12b
je 0x3980b
leaq 0xbc75f0(%rip), %rax # 0xc00de0
movl (%rax,%r12,4), %esi
movl $0x2000, %edx # imm = 0x2000
subl %esi, %edx
addq %r14, %rsi
xorl %edi, %edi
callq 0xa93a8
cmpl 0x7(%r14), %eax
jne 0x39822
testb $0x2, %r12b
je 0x39820
movq %r14, %rdi
movq %r15, %rsi
callq 0x3982d
testb %al, %al
jne 0x39822
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
translog_page_validator:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, [rsi]
mov rax, [rsi+8]
mov r15, [rsi+10h]
mov byte ptr [r15+50h], 0
mov bl, 1
test edi, edi
jnz short loc_39822
movzx ecx, word ptr [r14]
movzx edx, byte ptr [r14+2]
shl edx, 10h
or rdx, rcx
cmp rdx, rax
jnz short loc_39822
movzx eax, word ptr [r14+3]
movzx ecx, byte ptr [r14+5]
shl ecx, 10h
or ecx, eax
cmp ecx, [r15]
jnz short loc_39822
movzx r12d, byte ptr [r14+6]
cmp r12d, 7
ja short loc_39822
test r12b, 1
jz short loc_3980B
lea rax, page_overhead
mov esi, [rax+r12*4]
mov edx, 2000h
sub edx, esi
add rsi, r14
xor edi, edi
call my_checksum
cmp eax, [r14+7]
jnz short loc_39822
loc_3980B:
test r12b, 2
jz short loc_39820
mov rdi, r14
mov rsi, r15
call translog_check_sector_protection
test al, al
jnz short loc_39822
loc_39820:
xor ebx, ebx
loc_39822:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long translog_page_validator(int a1, unsigned __int16 **a2)
{
unsigned int v2; // ebx
unsigned __int16 *v3; // r14
unsigned __int16 *v4; // rax
unsigned __int16 *v5; // r15
long long v6; // r12
v3 = *a2;
v4 = a2[1];
v5 = a2[2];
*((_BYTE *)v5 + 80) = 0;
LOBYTE(v2) = 1;
if ( !a1
&& (unsigned __int16 *)(*v3 | (unsigned long long)(*((unsigned __int8 *)v3 + 2) << 16)) == v4
&& (*(unsigned __int16 *)((char *)v3 + 3) | (*((unsigned __int8 *)v3 + 5) << 16)) == *(_DWORD *)v5 )
{
v6 = *((unsigned __int8 *)v3 + 6);
if ( (unsigned int)v6 <= 7
&& ((v6 & 1) == 0
|| (unsigned int)my_checksum(
0LL,
(char *)v3 + *((unsigned int *)&page_overhead + v6),
(unsigned int)(0x2000 - *((_DWORD *)&page_overhead + v6))) == *(_DWORD *)((char *)v3 + 7))
&& ((v6 & 2) == 0 || !(unsigned __int8)translog_check_sector_protection(v3, v5)) )
{
return 0;
}
}
return v2;
}
|
translog_page_validator:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI + 0x10]
MOV byte ptr [R15 + 0x50],0x0
MOV BL,0x1
TEST EDI,EDI
JNZ 0x00139822
MOVZX ECX,word ptr [R14]
MOVZX EDX,byte ptr [R14 + 0x2]
SHL EDX,0x10
OR RDX,RCX
CMP RDX,RAX
JNZ 0x00139822
MOVZX EAX,word ptr [R14 + 0x3]
MOVZX ECX,byte ptr [R14 + 0x5]
SHL ECX,0x10
OR ECX,EAX
CMP ECX,dword ptr [R15]
JNZ 0x00139822
MOVZX R12D,byte ptr [R14 + 0x6]
CMP R12D,0x7
JA 0x00139822
TEST R12B,0x1
JZ 0x0013980b
LEA RAX,[0xd00de0]
MOV ESI,dword ptr [RAX + R12*0x4]
MOV EDX,0x2000
SUB EDX,ESI
ADD RSI,R14
XOR EDI,EDI
CALL 0x001a93a8
CMP EAX,dword ptr [R14 + 0x7]
JNZ 0x00139822
LAB_0013980b:
TEST R12B,0x2
JZ 0x00139820
MOV RDI,R14
MOV RSI,R15
CALL 0x0013982d
TEST AL,AL
JNZ 0x00139822
LAB_00139820:
XOR EBX,EBX
LAB_00139822:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong translog_page_validator(int param_1,long *param_2)
{
byte bVar1;
uint3 *puVar2;
ulong uVar3;
uint *puVar4;
char cVar5;
int iVar6;
int8 unaff_RBX;
ulong uVar7;
puVar2 = (uint3 *)*param_2;
uVar3 = param_2[1];
puVar4 = (uint *)param_2[2];
*(int1 *)(puVar4 + 0x14) = 0;
uVar7 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (((param_1 == 0) && (*puVar2 == uVar3)) && ((uint)*(uint3 *)((long)puVar2 + 3) == *puVar4)) {
bVar1 = *(byte *)((long)puVar2 + 6);
if (bVar1 < 8) {
if ((bVar1 & 1) != 0) {
iVar6 = my_checksum(0,(ulong)*(uint *)(page_overhead + (ulong)bVar1 * 4) + (long)puVar2,
0x2000 - *(uint *)(page_overhead + (ulong)bVar1 * 4));
if (iVar6 != *(int *)((long)puVar2 + 7)) goto LAB_00139822;
}
if ((bVar1 & 2) != 0) {
cVar5 = translog_check_sector_protection(puVar2,puVar4);
if (cVar5 != '\0') goto LAB_00139822;
}
uVar7 = 0;
}
}
LAB_00139822:
return uVar7 & 0xffffffff;
}
|
|
18,367
|
google::protobuf::internal::WireFormatLite::WriteSFixed32(int, int, google::protobuf::io::CodedOutputStream*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wire_format_lite.cc
|
void WireFormatLite::WriteSFixed32(int field_number, int32_t value,
io::CodedOutputStream* output) {
WriteTag(field_number, WIRETYPE_FIXED32, output);
WriteSFixed32NoTag(value, output);
}
|
O3
|
cpp
|
google::protobuf::internal::WireFormatLite::WriteSFixed32(int, int, google::protobuf::io::CodedOutputStream*):
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
shll $0x3, %r14d
movq 0x40(%rdx), %rsi
cmpq %rsi, (%rdx)
jbe 0xa9885
movq %rsi, 0x40(%rbx)
movl %r14d, %eax
orb $0x5, %al
movb %al, (%rsi)
cmpl $0x7f, %r14d
ja 0xa982e
incq %rsi
movq %rsi, %rax
jmp 0xa986d
movl %r14d, %eax
orb $-0x7b, %al
movb %al, (%rsi)
movl %r14d, %ecx
shrl $0x7, %ecx
movb %cl, 0x1(%rsi)
leaq 0x2(%rsi), %rax
cmpl $0x4000, %r14d # imm = 0x4000
jb 0xa986d
movb 0x1(%rsi), %sil
movl %ecx, %edx
orb $-0x80, %sil
movb %sil, -0x1(%rax)
shrl $0x7, %edx
movb %dl, (%rax)
incq %rax
movl %edx, %esi
cmpl $0x3fff, %ecx # imm = 0x3FFF
movl %edx, %ecx
ja 0xa9851
movq %rax, 0x40(%rbx)
cmpq %rax, (%rbx)
jbe 0xa9892
movl %ebp, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0xf7ee
movq %rax, %rsi
jmp 0xa9815
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf7ee
jmp 0xa9876
nop
|
_ZN6google8protobuf8internal14WireFormatLite13WriteSFixed32EiiPNS0_2io17CodedOutputStreamE:
push rbp
push r14
push rbx
mov rbx, rdx
mov ebp, esi
mov r14d, edi
shl r14d, 3
mov rsi, [rdx+40h]; unsigned __int8 *
cmp [rdx], rsi
jbe short loc_A9885
loc_A9815:
mov [rbx+40h], rsi
mov eax, r14d
or al, 5
mov [rsi], al
cmp r14d, 7Fh
ja short loc_A982E
inc rsi
mov rax, rsi
jmp short loc_A986D
loc_A982E:
mov eax, r14d
or al, 85h
mov [rsi], al
mov ecx, r14d
shr ecx, 7
mov [rsi+1], cl
lea rax, [rsi+2]
cmp r14d, 4000h
jb short loc_A986D
mov sil, [rsi+1]
mov edx, ecx
loc_A9851:
or sil, 80h
mov [rax-1], sil
shr edx, 7
mov [rax], dl
inc rax
mov esi, edx
cmp ecx, 3FFFh
mov ecx, edx
ja short loc_A9851
loc_A986D:
mov [rbx+40h], rax
cmp [rbx], rax
jbe short loc_A9892
loc_A9876:
mov [rax], ebp
add rax, 4
mov [rbx+40h], rax
pop rbx
pop r14
pop rbp
retn
loc_A9885:
mov rdi, rbx; this
call _ZN6google8protobuf2io19EpsCopyOutputStream19EnsureSpaceFallbackEPh; google::protobuf::io::EpsCopyOutputStream::EnsureSpaceFallback(uchar *)
mov rsi, rax
jmp short loc_A9815
loc_A9892:
mov rdi, rbx; this
mov rsi, rax; unsigned __int8 *
call _ZN6google8protobuf2io19EpsCopyOutputStream19EnsureSpaceFallbackEPh; google::protobuf::io::EpsCopyOutputStream::EnsureSpaceFallback(uchar *)
jmp short loc_A9876
|
unsigned __int8 * google::protobuf::internal::WireFormatLite::WriteSFixed32(
google::protobuf::internal::WireFormatLite *this,
int a2,
google::protobuf::io::EpsCopyOutputStream *a3,
google::protobuf::io::CodedOutputStream *a4)
{
unsigned int v6; // r14d
unsigned __int8 *v7; // rsi
unsigned __int8 *v8; // rax
unsigned int v9; // ecx
unsigned __int8 v10; // si
unsigned int v11; // edx
bool v12; // cc
unsigned __int8 *result; // rax
v6 = 8 * (_DWORD)this;
v7 = (unsigned __int8 *)*((_QWORD *)a3 + 8);
if ( *(_QWORD *)a3 <= (unsigned long long)v7 )
v7 = (unsigned __int8 *)google::protobuf::io::EpsCopyOutputStream::EnsureSpaceFallback(a3, v7);
*((_QWORD *)a3 + 8) = v7;
*v7 = v6 | 5;
if ( v6 > 0x7F )
{
*v7 = v6 | 0x85;
v9 = v6 >> 7;
v7[1] = v6 >> 7;
v8 = v7 + 2;
if ( v6 >= 0x4000 )
{
v10 = v7[1];
v11 = v6 >> 7;
do
{
*(v8 - 1) = v10 | 0x80;
v11 >>= 7;
*v8++ = v11;
v10 = v11;
v12 = v9 <= 0x3FFF;
v9 = v11;
}
while ( !v12 );
}
}
else
{
v8 = v7 + 1;
}
*((_QWORD *)a3 + 8) = v8;
if ( *(_QWORD *)a3 <= (unsigned long long)v8 )
v8 = (unsigned __int8 *)google::protobuf::io::EpsCopyOutputStream::EnsureSpaceFallback(a3, v8);
*(_DWORD *)v8 = a2;
result = v8 + 4;
*((_QWORD *)a3 + 8) = result;
return result;
}
|
WriteSFixed32:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV EBP,ESI
MOV R14D,EDI
SHL R14D,0x3
MOV RSI,qword ptr [RDX + 0x40]
CMP qword ptr [RDX],RSI
JBE 0x001a9885
LAB_001a9815:
MOV qword ptr [RBX + 0x40],RSI
MOV EAX,R14D
OR AL,0x5
MOV byte ptr [RSI],AL
CMP R14D,0x7f
JA 0x001a982e
INC RSI
MOV RAX,RSI
JMP 0x001a986d
LAB_001a982e:
MOV EAX,R14D
OR AL,0x85
MOV byte ptr [RSI],AL
MOV ECX,R14D
SHR ECX,0x7
MOV byte ptr [RSI + 0x1],CL
LEA RAX,[RSI + 0x2]
CMP R14D,0x4000
JC 0x001a986d
MOV SIL,byte ptr [RSI + 0x1]
MOV EDX,ECX
LAB_001a9851:
OR SIL,0x80
MOV byte ptr [RAX + -0x1],SIL
SHR EDX,0x7
MOV byte ptr [RAX],DL
INC RAX
MOV ESI,EDX
CMP ECX,0x3fff
MOV ECX,EDX
JA 0x001a9851
LAB_001a986d:
MOV qword ptr [RBX + 0x40],RAX
CMP qword ptr [RBX],RAX
JBE 0x001a9892
LAB_001a9876:
MOV dword ptr [RAX],EBP
ADD RAX,0x4
MOV qword ptr [RBX + 0x40],RAX
POP RBX
POP R14
POP RBP
RET
LAB_001a9885:
MOV RDI,RBX
CALL 0x0010f7ee
MOV RSI,RAX
JMP 0x001a9815
LAB_001a9892:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0010f7ee
JMP 0x001a9876
|
/* google::protobuf::internal::WireFormatLite::WriteSFixed32(int, int,
google::protobuf::io::CodedOutputStream*) */
void google::protobuf::internal::WireFormatLite::WriteSFixed32
(int param_1,int param_2,CodedOutputStream *param_3)
{
bool bVar1;
byte *pbVar2;
uint uVar3;
byte *pbVar4;
uint uVar5;
uVar5 = param_1 << 3;
pbVar2 = *(byte **)(param_3 + 0x40);
if (*(byte **)param_3 <= pbVar2) {
pbVar2 = (byte *)io::EpsCopyOutputStream::EnsureSpaceFallback
((EpsCopyOutputStream *)param_3,pbVar2);
}
*(byte **)(param_3 + 0x40) = pbVar2;
*pbVar2 = (byte)uVar5 | 5;
if (uVar5 < 0x80) {
pbVar4 = pbVar2 + 1;
}
else {
*pbVar2 = (byte)uVar5 | 0x85;
pbVar2[1] = (byte)(uVar5 >> 7);
pbVar4 = pbVar2 + 2;
if (0x3fff < uVar5) {
uVar3 = (uint)pbVar2[1];
uVar5 = uVar5 >> 7;
do {
pbVar4[-1] = (byte)uVar3 | 0x80;
uVar3 = uVar5 >> 7;
*pbVar4 = (byte)uVar3;
pbVar4 = pbVar4 + 1;
bVar1 = 0x3fff < uVar5;
uVar5 = uVar3;
} while (bVar1);
}
}
*(byte **)(param_3 + 0x40) = pbVar4;
if (*(byte **)param_3 <= pbVar4) {
pbVar4 = (byte *)io::EpsCopyOutputStream::EnsureSpaceFallback
((EpsCopyOutputStream *)param_3,pbVar4);
}
*(int *)pbVar4 = param_2;
*(byte **)(param_3 + 0x40) = pbVar4 + 4;
return;
}
|
|
18,368
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int 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_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x1eb5c0(%rip), %rax # 0x2cdee0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe29ab
leaq 0x1eb57d(%rip), %rax # 0x2cdee0
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xfcc90
movl %eax, -0x24(%rbp)
leaq 0x1eb550(%rip), %rax # 0x2cdee0
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe29c0
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xfcc90
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_file_close_8:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_E29AB
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_E29C0
loc_E29AB:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_E29C0:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_close_8(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 4LL);
if ( v6 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[68])(v6, v11, v10);
v7 = my_close(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[69])(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x3cdee0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001e29ab
LEA RAX,[0x3cdee0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001fcc90
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3cdee0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e29c0
LAB_001e29ab:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001fcc90
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e29c0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
|
|
18,369
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, myf flags)
{
int 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_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O3
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r15d
leaq 0x32916a(%rip), %rax # 0x390ed8
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x67d9b
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa7701
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x2d8b4
jmp 0x67d90
|
inline_mysql_file_close_0:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 48h
mov rbx, rdx
mov r14d, esi
mov r15d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_60]
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_67D9B
mov edi, r14d
mov rsi, rbx
call my_close
loc_67D90:
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_67D9B:
mov rdi, rax
mov esi, r15d
mov edx, r14d
mov rcx, rbx
call inline_mysql_file_close_cold_1_0
jmp short loc_67D90
|
long long inline_mysql_file_close_0(unsigned int a1, long long a2, long long a3)
{
long long v4; // rax
_BYTE v6[96]; // [rsp+0h] [rbp-60h] BYREF
v4 = ((long long ( *)(_BYTE *, long long, long long))PSI_server[43])(v6, a2, 4LL);
if ( v4 )
return inline_mysql_file_close_cold_1_0(v4, a1, a2, a3);
else
return my_close((unsigned int)a2, a3);
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV R14D,ESI
MOV R15D,EDI
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x60]
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00167d9b
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a7701
LAB_00167d90:
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00167d9b:
MOV RDI,RAX
MOV ESI,R15D
MOV EDX,R14D
MOV RCX,RBX
CALL 0x0012d8b4
JMP 0x00167d90
|
void inline_mysql_file_close(int4 param_1,ulong param_2,int8 param_3)
{
long lVar1;
int1 local_68 [72];
lVar1 = (**(code **)(PSI_server + 0x158))(local_68,param_2,4);
if (lVar1 == 0) {
my_close(param_2 & 0xffffffff,param_3);
}
else {
inline_mysql_file_close_cold_1(lVar1,param_1,param_2 & 0xffffffff,param_3);
}
return;
}
|
|
18,370
|
pagecache_unpin
|
eloqsql/storage/maria/ma_pagecache.c
|
void pagecache_unpin(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
LSN lsn)
{
PAGECACHE_BLOCK_LINK *block;
int page_st;
DBUG_ENTER("pagecache_unpin");
DBUG_PRINT("enter", ("fd: %u page: %lu",
(uint) file->file, (ulong) pageno));
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
/*
As soon as we keep lock cache can be used, and we have lock bacause want
aunlock.
*/
DBUG_ASSERT(pagecache->can_be_used);
inc_counter_for_resize_op(pagecache);
/* See NOTE for pagecache_unlock about registering requests */
block= find_block(pagecache, file, pageno, 0, 0, 0, 0, FALSE, &page_st);
DBUG_ASSERT(block != 0);
DBUG_ASSERT(page_st == PAGE_READ);
/* we can't unpin such page without unlock */
DBUG_ASSERT((block->status & PCBLOCK_DIRECT_W) == 0);
if (lsn != LSN_IMPOSSIBLE)
check_and_set_lsn(pagecache, lsn, block);
/*
we can just unpin only with keeping read lock because:
a) we can't pin without any lock
b) we can't unpin keeping write lock
*/
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_LEFT_READLOCKED,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0); /* should not happend */
remove_reader(block);
/*
Link the block into the LRU chain if it's the last submitted request
for the block and block will not be pinned.
See NOTE for pagecache_unlock about registering requests
*/
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_VOID_RETURN;
}
|
O3
|
c
|
pagecache_unpin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x3dcc3
movq %rbx, %rdi
callq 0x2a220
incq 0x68(%r14)
subq $0x8, %rsp
leaq -0x2c(%rbp), %rax
xorl %r10d, %r10d
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r10
callq 0x3d240
addq $0x20, %rsp
movq %rax, %r12
testq %r15, %r15
je 0x3dc35
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d88a
decl 0x64(%r12)
movq 0x20(%r12), %rax
decl 0x68(%rax)
jne 0x3dc63
movq 0x28(%r12), %r15
testq %r15, %r15
je 0x3dc63
movq 0x30(%r15), %rdi
testq %rdi, %rdi
jne 0x3dcee
movq %r15, %rdi
callq 0x2a630
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x3dab7
decq 0x68(%r14)
jne 0x3dca1
movq 0x110(%r14), %rax
testq %rax, %rax
je 0x3dca1
movq 0x88(%rax), %r15
movq 0x38(%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x3dd03
movq %r15, %rdi
callq 0x2a630
movq 0x108(%r14), %rdi
testq %rdi, %rdi
jne 0x3dcdc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a1e0
leaq 0xa3e3f(%rip), %rsi # 0xe1b09
movq %rbx, %rdi
movl $0xcef, %edx # imm = 0xCEF
callq 0x30603
jmp 0x3dbf1
leaq 0x351575(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3dcad
leaq 0x351563(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x3dc5b
leaq 0x35154e(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x3dc99
|
pagecache_unpin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov r14, rdi
lea rbx, [rdi+0C8h]
cmp qword ptr [rdi+108h], 0
jnz loc_3DCC3
mov rdi, rbx
call _pthread_mutex_lock
loc_3DBF1:
inc qword ptr [r14+68h]
sub rsp, 8
lea rax, [rbp+var_2C]
xor r10d, r10d
mov rdi, r14
mov rsi, r13
mov rdx, r12
xor ecx, ecx
xor r8d, r8d
xor r9d, r9d
push rax
push r10
push r10
call find_block
add rsp, 20h
mov r12, rax
test r15, r15
jz short loc_3DC35
mov rdi, r14
mov rsi, r15
mov rdx, r12
call check_and_set_lsn
loc_3DC35:
dec dword ptr [r12+64h]
mov rax, [r12+20h]
dec dword ptr [rax+68h]
jnz short loc_3DC63
mov r15, [r12+28h]
test r15, r15
jz short loc_3DC63
mov rdi, [r15+30h]
test rdi, rdi
jnz loc_3DCEE
loc_3DC5B:
mov rdi, r15
call _pthread_cond_signal
loc_3DC63:
mov rdi, r14
mov rsi, r12
mov edx, 1
call unreg_request
dec qword ptr [r14+68h]
jnz short loc_3DCA1
mov rax, [r14+110h]
test rax, rax
jz short loc_3DCA1
mov r15, [rax+88h]
mov rdi, [r15+38h]
add r15, 8
test rdi, rdi
jnz short loc_3DD03
loc_3DC99:
mov rdi, r15
call _pthread_cond_signal
loc_3DCA1:
mov rdi, [r14+108h]
test rdi, rdi
jnz short loc_3DCDC
loc_3DCAD:
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_3DCC3:
lea rsi, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 0CEFh
call psi_mutex_lock
jmp loc_3DBF1
loc_3DCDC:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_3DCAD
loc_3DCEE:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp loc_3DC5B
loc_3DD03:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_3DC99
|
long long pagecache_unpin(_QWORD *a1, int *a2, long long a3, signed long long a4)
{
long long v4; // rax
_QWORD *v8; // rbx
long long block; // rax
long long v10; // r12
long long v11; // rax
bool v12; // zf
long long v13; // r15
long long v14; // rdi
long long v15; // rax
long long v16; // r15
long long v17; // rdi
long long v18; // r15
long long v19; // rdi
_DWORD v21[11]; // [rsp+0h] [rbp-2Ch] BYREF
v21[0] = HIDWORD(v4);
v8 = a1 + 25;
if ( a1[33] )
psi_mutex_lock(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xCEFu);
else
pthread_mutex_lock(a1 + 25);
++a1[13];
block = find_block((long long)a1, a2, a3, 0, 0, 0, 0, 0, v21);
v10 = block;
if ( a4 )
check_and_set_lsn((long long)a1, a4, block);
--*(_DWORD *)(v10 + 100);
v11 = *(_QWORD *)(v10 + 32);
v12 = (*(_DWORD *)(v11 + 104))-- == 1;
if ( v12 )
{
v13 = *(_QWORD *)(v10 + 40);
if ( v13 )
{
v14 = *(_QWORD *)(v13 + 48);
if ( v14 )
((void ( *)(long long))PSI_server[46])(v14);
pthread_cond_signal(v13);
}
}
unreg_request(a1, v10, 1);
v12 = a1[13]-- == 1LL;
if ( v12 )
{
v15 = a1[34];
if ( v15 )
{
v16 = *(_QWORD *)(v15 + 136);
v17 = *(_QWORD *)(v16 + 56);
v18 = v16 + 8;
if ( v17 )
((void ( *)(long long))PSI_server[46])(v17);
pthread_cond_signal(v18);
}
}
v19 = a1[33];
if ( v19 )
((void ( *)(long long))PSI_server[44])(v19);
return pthread_mutex_unlock(v8);
}
|
pagecache_unpin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV R14,RDI
LEA RBX,[RDI + 0xc8]
CMP qword ptr [RDI + 0x108],0x0
JNZ 0x0013dcc3
MOV RDI,RBX
CALL 0x0012a220
LAB_0013dbf1:
INC qword ptr [R14 + 0x68]
SUB RSP,0x8
LEA RAX,[RBP + -0x2c]
XOR R10D,R10D
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
XOR ECX,ECX
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH R10
PUSH R10
CALL 0x0013d240
ADD RSP,0x20
MOV R12,RAX
TEST R15,R15
JZ 0x0013dc35
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0013d88a
LAB_0013dc35:
DEC dword ptr [R12 + 0x64]
MOV RAX,qword ptr [R12 + 0x20]
DEC dword ptr [RAX + 0x68]
JNZ 0x0013dc63
MOV R15,qword ptr [R12 + 0x28]
TEST R15,R15
JZ 0x0013dc63
MOV RDI,qword ptr [R15 + 0x30]
TEST RDI,RDI
JNZ 0x0013dcee
LAB_0013dc5b:
MOV RDI,R15
CALL 0x0012a630
LAB_0013dc63:
MOV RDI,R14
MOV RSI,R12
MOV EDX,0x1
CALL 0x0013dab7
DEC qword ptr [R14 + 0x68]
JNZ 0x0013dca1
MOV RAX,qword ptr [R14 + 0x110]
TEST RAX,RAX
JZ 0x0013dca1
MOV R15,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [R15 + 0x38]
ADD R15,0x8
TEST RDI,RDI
JNZ 0x0013dd03
LAB_0013dc99:
MOV RDI,R15
CALL 0x0012a630
LAB_0013dca1:
MOV RDI,qword ptr [R14 + 0x108]
TEST RDI,RDI
JNZ 0x0013dcdc
LAB_0013dcad:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012a1e0
LAB_0013dcc3:
LEA RSI,[0x1e1b09]
MOV RDI,RBX
MOV EDX,0xcef
CALL 0x00130603
JMP 0x0013dbf1
LAB_0013dcdc:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013dcad
LAB_0013dcee:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0013dc5b
LAB_0013dd03:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x0013dc99
|
void pagecache_unpin(long param_1,int8 param_2,int8 param_3,long param_4)
{
int *piVar1;
long *plVar2;
pthread_mutex_t *__mutex;
pthread_cond_t *__cond;
long lVar3;
int1 local_34 [4];
__mutex = (pthread_mutex_t *)(param_1 + 200);
if (*(long *)(param_1 + 0x108) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xcef);
}
*(long *)(param_1 + 0x68) = *(long *)(param_1 + 0x68) + 1;
lVar3 = find_block(param_1,param_2,param_3,0,0,0,0,0,local_34);
if (param_4 != 0) {
check_and_set_lsn(param_1,param_4,lVar3);
}
*(int *)(lVar3 + 100) = *(int *)(lVar3 + 100) + -1;
piVar1 = (int *)(*(long *)(lVar3 + 0x20) + 0x68);
*piVar1 = *piVar1 + -1;
if ((*piVar1 == 0) &&
(__cond = *(pthread_cond_t **)(lVar3 + 0x28), __cond != (pthread_cond_t *)0x0)) {
if (__cond[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(__cond);
}
unreg_request(param_1,lVar3,1);
plVar2 = (long *)(param_1 + 0x68);
*plVar2 = *plVar2 + -1;
if ((*plVar2 == 0) && (*(long *)(param_1 + 0x110) != 0)) {
lVar3 = *(long *)(*(long *)(param_1 + 0x110) + 0x88);
if (*(long *)(lVar3 + 0x38) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)(lVar3 + 8));
}
if (*(long *)(param_1 + 0x108) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return;
}
|
|
18,371
|
multadd
|
eloqsql/libmariadb/libmariadb/ma_dtoa.c
|
static Bigint *multadd(Bigint *b, int m, int a, Stack_alloc *alloc)
{
int i, wds;
ULong *x;
ULLong carry, y;
Bigint *b1;
wds= b->wds;
x= b->p.x;
i= 0;
carry= a;
do
{
y= *x * (ULLong)m + carry;
carry= y >> 32;
*x++= (ULong)(y & FFFFFFFF);
}
while (++i < wds);
if (carry)
{
if (wds >= b->maxwds)
{
b1= Balloc(b->k+1, alloc);
Bcopy(b1, b);
Bfree(b, alloc);
b= b1;
}
b->p.x[wds++]= (ULong) carry;
b->wds= wds;
}
return b;
}
|
O0
|
c
|
multadd:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movslq -0xc(%rbp), %rcx
imulq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x30(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl -0x20(%rbp), %eax
jl 0x5bd5a
cmpq $0x0, -0x30(%rbp)
je 0x5be3b
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x5be13
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
addl $0x1, %edi
movq -0x18(%rbp), %rsi
callq 0x5be50
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rdx
shlq $0x2, %rdx
addq $0x8, %rdx
callq 0x370c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b950
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
multadd:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov [rbp+var_18], rcx
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov [rbp+var_20], eax
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_28], rax
mov [rbp+var_1C], 0
movsxd rax, [rbp+var_10]
mov [rbp+var_30], rax
loc_5BD5A:
mov rax, [rbp+var_28]
mov eax, [rax]
movsxd rcx, [rbp+var_C]
imul rax, rcx
add rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
shr rax, 20h
mov [rbp+var_30], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_38]
mov ecx, eax
mov rax, [rbp+var_28]
mov rdx, rax
add rdx, 4
mov [rbp+var_28], rdx
mov [rax], ecx
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
cmp eax, [rbp+var_20]
jl short loc_5BD5A
cmp [rbp+var_30], 0
jz loc_5BE3B
mov eax, [rbp+var_20]
mov rcx, [rbp+var_8]
cmp eax, [rcx+0Ch]
jl short loc_5BE13
mov rax, [rbp+var_8]
mov edi, [rax+8]
add edi, 1
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
add rdi, 10h
mov rsi, [rbp+var_8]
add rsi, 10h
mov rax, [rbp+var_8]
movsxd rdx, dword ptr [rax+14h]
shl rdx, 2
add rdx, 8
call _memcpy
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call Bfree
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_5BE13:
mov rax, [rbp+var_30]
mov edx, eax
mov rax, [rbp+var_8]
mov rax, [rax]
mov ecx, [rbp+var_20]
mov esi, ecx
add esi, 1
mov [rbp+var_20], esi
movsxd rcx, ecx
mov [rax+rcx*4], edx
mov ecx, [rbp+var_20]
mov rax, [rbp+var_8]
mov [rax+14h], ecx
loc_5BE3B:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
unsigned long long multadd(unsigned long long a1, int a2, int a3, unsigned long long *a4)
{
unsigned int *v4; // rax
long long v6; // [rsp+0h] [rbp-40h]
unsigned long long v7; // [rsp+8h] [rbp-38h]
unsigned long long v8; // [rsp+10h] [rbp-30h]
unsigned int *v9; // [rsp+18h] [rbp-28h]
int v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+24h] [rbp-1Ch]
unsigned long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v10 = *(_DWORD *)(a1 + 20);
v9 = *(unsigned int **)a1;
v11 = 0;
v8 = a3;
do
{
v7 = v8 + a2 * (unsigned long long)*v9;
v8 = HIDWORD(v7);
v4 = v9++;
*v4 = v7;
++v11;
}
while ( v11 < v10 );
if ( v8 )
{
if ( v10 >= *(_DWORD *)(a1 + 12) )
{
v6 = Balloc((unsigned int)(*(_DWORD *)(a1 + 8) + 1), a4);
memcpy(v6 + 16, a1 + 16, 4LL * *(int *)(a1 + 20) + 8);
Bfree(a1, a4);
v13 = v6;
}
*(_DWORD *)(*(_QWORD *)v13 + 4LL * v10) = HIDWORD(v7);
*(_DWORD *)(v13 + 20) = v10 + 1;
}
return v13;
}
|
multadd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOVSXD RAX,dword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
LAB_0015bd5a:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0xc]
IMUL RAX,RCX
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x20
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x38]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,dword ptr [RBP + -0x20]
JL 0x0015bd5a
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0015be3b
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0xc]
JL 0x0015be13
MOV RAX,qword ptr [RBP + -0x8]
MOV EDI,dword ptr [RAX + 0x8]
ADD EDI,0x1
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0015be50
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
ADD RDI,0x10
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x10
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RAX + 0x14]
SHL RDX,0x2
ADD RDX,0x8
CALL 0x001370c0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0015b950
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_0015be13:
MOV RAX,qword ptr [RBP + -0x30]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RBP + -0x20],ESI
MOVSXD RCX,ECX
MOV dword ptr [RAX + RCX*0x4],EDX
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x14],ECX
LAB_0015be3b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long * multadd(long *param_1,int param_2,int param_3,int8 param_4)
{
int iVar1;
ulong uVar2;
ulong local_38;
uint *local_30;
int local_24;
long *local_10;
iVar1 = *(int *)((long)param_1 + 0x14);
local_24 = 0;
local_38 = (ulong)param_3;
local_30 = (uint *)*param_1;
do {
uVar2 = (ulong)*local_30 * (long)param_2 + local_38;
local_38 = uVar2 >> 0x20;
*local_30 = (uint)uVar2;
local_24 = local_24 + 1;
local_30 = local_30 + 1;
} while (local_24 < iVar1);
local_10 = param_1;
if (local_38 != 0) {
if (*(int *)((long)param_1 + 0xc) <= iVar1) {
local_10 = (long *)Balloc((int)param_1[1] + 1,param_4);
memcpy(local_10 + 2,param_1 + 2,(long)*(int *)((long)param_1 + 0x14) * 4 + 8);
Bfree(param_1,param_4);
}
*(int *)(*local_10 + (long)iVar1 * 4) = (int)(uVar2 >> 0x20);
*(int *)((long)local_10 + 0x14) = iVar1 + 1;
}
return local_10;
}
|
|
18,372
|
json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool)
|
llama.cpp/common/json-schema-to-grammar.cpp
|
std::string json_schema_to_grammar(const json & schema, bool force_gbnf) {
#ifdef LLAMA_USE_LLGUIDANCE
if (!force_gbnf) {
return "%llguidance {}\nstart: %json " + schema.dump();
}
#else
(void)force_gbnf;
#endif // LLAMA_USE_LLGUIDANCE
return build_grammar([&](const common_grammar_builder & callbacks) {
auto copy = schema;
callbacks.resolve_refs(copy);
callbacks.add_schema("", copy);
});
}
|
O3
|
cpp
|
json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool):
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x25f(%rip), %rcx # 0x30102
movq %rcx, 0x18(%rax)
leaq 0x34e(%rip), %rcx # 0x301fc
movq %rcx, 0x10(%rax)
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
movq %rax, %rsi
callq 0x2ff12
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2fedb
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0x2ff0a
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2ff02
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x17710
movq %rax, %rdi
callq 0x25387
|
_Z22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEb:
push rbx
sub rsp, 30h
mov rbx, rdi
lea rax, [rsp+38h+var_28]
mov qword ptr [rax+8], 0
mov [rax], rsi
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(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&,bool)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rax+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E10_M_managerERSt9_Any_dataRKSN_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(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&,bool)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rax+10h], rcx
lea rdx, [rsp+38h+var_29]
mov byte ptr [rdx], 0
mov rsi, rax
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_2FEDB
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_2FEDB:
mov rax, rbx
add rsp, 30h
pop rbx
retn
jmp short loc_2FF0A
mov rbx, rax
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_2FF02
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_2FF02:
mov rdi, rbx
call __Unwind_Resume
loc_2FF0A:
mov rdi, rax
call __clang_call_terminate
|
long long json_schema_to_grammar(long long a1, long long a2)
{
char v3; // [rsp+Fh] [rbp-29h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-28h] BYREF
long long ( *v5)(); // [rsp+20h] [rbp-18h]
long long ( *v6)(); // [rsp+28h] [rbp-10h]
v4[1] = 0LL;
v4[0] = a2;
v6 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(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&,bool)::$_0>::_M_invoke;
v5 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(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&,bool)::$_0>::_M_manager;
v3 = 0;
build_grammar[abi:cxx11](a1, v4, &v3);
if ( v5 )
((void ( *)(_QWORD *, _QWORD *, long long))v5)(v4, v4, 3LL);
return a1;
}
|
json_schema_to_grammar:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],RSI
LEA RCX,[0x130102]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x1301fc]
MOV qword ptr [RAX + 0x10],RCX
LEA RDX,[RSP + 0xf]
MOV byte ptr [RDX],0x0
LAB_0012feba:
MOV RSI,RAX
CALL 0x0012ff12
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x0012fedb
LAB_0012fecc:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0012fedb:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
RET
|
/* json_schema_to_grammar(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&, bool) */
basic_json * json_schema_to_grammar(basic_json *param_1,bool param_2)
{
int7 in_register_00000031;
int8 local_28;
int8 local_20;
code *local_18;
code *local_10;
local_28 = CONCAT71(in_register_00000031,param_2);
local_20 = 0;
local_10 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(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&,bool)::$_0>
::_M_invoke;
local_18 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(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&,bool)::$_0>
::_M_manager;
/* try { // try from 0012feba to 0012fec1 has its CatchHandler @ 0012fee6 */
build_grammar_abi_cxx11_(param_1,(common_grammar_options *)&local_28);
if (local_18 != (code *)0x0) {
/* try { // try from 0012fecc to 0012feda has its CatchHandler @ 0012fee4 */
(*local_18)(&local_28,&local_28,3);
}
return param_1;
}
|
|
18,373
|
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 0x32d31e(%rip), %rax # 0x38c3c8
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movl %ebx, %esi
movl $0x9, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x5f0d5
movl %ebx, %edi
xorl %esi, %esi
callq 0xa54e0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2d923
movq (%r14), %rax
jmp 0x5f0cc
|
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_5F0D5
mov edi, ebx
xor esi, esi
call my_tell
loc_5F0CC:
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_5F0D5:
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_5F0CC
|
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,[0x48c3c8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x60]
MOV ESI,EBX
MOV EDX,0x9
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0015f0d5
MOV EDI,EBX
XOR ESI,ESI
CALL 0x001a54e0
LAB_0015f0cc:
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0015f0d5:
LEA R14,[RBP + -0x18]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012d923
MOV RAX,qword ptr [R14]
JMP 0x0015f0cc
|
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;
}
|
|
18,374
|
tree_record_pos
|
eloqsql/mysys/tree.c
|
ha_rows tree_record_pos(TREE *tree, const void *key,
enum ha_rkey_function flag, void *custom_arg)
{
int cmp;
TREE_ELEMENT *element= tree->root;
double left= 1;
double right= tree->elements_in_tree;
while (element != &null_element)
{
if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
key)) == 0)
{
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_BEFORE_KEY:
cmp= 1;
break;
case HA_READ_AFTER_KEY:
cmp= -1;
break;
default:
return HA_POS_ERROR;
}
}
if (cmp < 0) /* element < key */
{
element= element->right;
left= (left + right) / 2;
}
else
{
element= element->left;
right= (left + right) / 2;
}
}
switch (flag) {
case HA_READ_KEY_EXACT:
case HA_READ_BEFORE_KEY:
return (ha_rows) right;
case HA_READ_AFTER_KEY:
return (ha_rows) left;
default:
return HA_POS_ERROR;
}
}
|
O3
|
c
|
tree_record_pos:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl 0x20c(%rdi), %eax
cvtsi2sd %rax, %xmm0
movapd %xmm0, -0x50(%rbp)
movq (%rdi), %r13
leaq 0x2e99f8(%rip), %rax # 0x3ae580
cmpq %rax, %r13
je 0xc4c45
movq %rcx, %r14
movq %rdi, %r15
movq %rsi, %r12
movsd 0x4045e(%rip), %xmm0 # 0x105000
movapd %xmm0, -0x40(%rbp)
movl 0x208(%r15), %esi
testq %rsi, %rsi
je 0xc4bb8
addq %r13, %rsi
jmp 0xc4bbc
movq 0x18(%r13), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq *0x228(%r15)
testl %eax, %eax
je 0xc4c05
movapd -0x40(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
mulsd 0x40471(%rip), %xmm0 # 0x105050
testl %eax, %eax
js 0xc4bea
movapd %xmm0, -0x50(%rbp)
jmp 0xc4bef
movapd %xmm0, -0x40(%rbp)
shrl $0x1f, %eax
movq (%r13,%rax,8), %r13
leaq 0x2e9982(%rip), %rax # 0x3ae580
cmpq %rax, %r13
jne 0xc4ba7
jmp 0xc4c1f
movl $0x1, %eax
testl %ebx, %ebx
je 0xc4bcd
cmpl $0x4, %ebx
je 0xc4bcd
cmpl $0x3, %ebx
jne 0xc4c92
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xc4bcd
movapd -0x40(%rbp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x403d8(%rip), %xmm0 # 0x105010
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0xc4c4a
movl $0x1, %eax
cmpl $0x4, %ebx
je 0xc4c5f
cmpl $0x3, %ebx
je 0xc4c83
movq $-0x1, %rax
testl %ebx, %ebx
jne 0xc4c83
movapd -0x50(%rbp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x40398(%rip), %xmm0 # 0x105010
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x1, %rax
jmp 0xc4c83
|
tree_record_pos:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, edx
mov eax, [rdi+20Ch]
cvtsi2sd xmm0, rax
movapd [rbp+var_50], xmm0
mov r13, [rdi]
lea rax, null_element
cmp r13, rax
jz loc_C4C45
mov r14, rcx
mov r15, rdi
mov r12, rsi
movsd xmm0, cs:qword_105000
movapd [rbp+var_40], xmm0
loc_C4BA7:
mov esi, [r15+208h]
test rsi, rsi
jz short loc_C4BB8
add rsi, r13
jmp short loc_C4BBC
loc_C4BB8:
mov rsi, [r13+18h]
loc_C4BBC:
mov rdi, r14
mov rdx, r12
call qword ptr [r15+228h]
test eax, eax
jz short loc_C4C05
loc_C4BCD:
movapd xmm0, [rbp+var_40]
addsd xmm0, qword ptr [rbp+var_50]
mulsd xmm0, cs:qword_105050
test eax, eax
js short loc_C4BEA
movapd [rbp+var_50], xmm0
jmp short loc_C4BEF
loc_C4BEA:
movapd [rbp+var_40], xmm0
loc_C4BEF:
shr eax, 1Fh
mov r13, [r13+rax*8+0]
lea rax, null_element
cmp r13, rax
jnz short loc_C4BA7
jmp short loc_C4C1F
loc_C4C05:
mov eax, 1
test ebx, ebx
jz short loc_C4BCD
cmp ebx, 4
jz short loc_C4BCD
cmp ebx, 3
jnz short loc_C4C92
mov eax, 0FFFFFFFFh
jmp short loc_C4BCD
loc_C4C1F:
movapd xmm0, [rbp+var_40]
cvttsd2si rcx, xmm0
mov rdx, rcx
sar rdx, 3Fh
subsd xmm0, cs:qword_105010
cvttsd2si rax, xmm0
and rax, rdx
or rax, rcx
jmp short loc_C4C4A
loc_C4C45:
mov eax, 1
loc_C4C4A:
cmp ebx, 4
jz short loc_C4C5F
cmp ebx, 3
jz short loc_C4C83
mov rax, 0FFFFFFFFFFFFFFFFh
test ebx, ebx
jnz short loc_C4C83
loc_C4C5F:
movapd xmm0, [rbp+var_50]
cvttsd2si rcx, xmm0
mov rdx, rcx
sar rdx, 3Fh
subsd xmm0, cs:qword_105010
cvttsd2si rax, xmm0
and rax, rdx
or rax, rcx
loc_C4C83:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C4C92:
mov rax, 0FFFFFFFFFFFFFFFFh
jmp short loc_C4C83
|
long long tree_record_pos(long long a1, long long a2, int a3, long long a4)
{
_QWORD *v5; // r13
char *v8; // rsi
int v9; // eax
__int128 v10; // xmm0
long long result; // rax
double v12; // [rsp+0h] [rbp-50h]
__int128 v13; // [rsp+10h] [rbp-40h]
v12 = (double)*(int *)(a1 + 524);
v5 = *(_QWORD **)a1;
if ( *(_UNKNOWN **)a1 != &null_element )
{
v13 = 0x3FF0000000000000uLL;
while ( 1 )
{
if ( *(_DWORD *)(a1 + 520) )
v8 = (char *)v5 + *(unsigned int *)(a1 + 520);
else
v8 = (char *)v5[3];
v9 = (*(long long ( **)(long long, char *, long long))(a1 + 552))(a4, v8, a2);
if ( !v9 )
{
v9 = 1;
if ( a3 )
{
if ( a3 != 4 )
{
if ( a3 != 3 )
return -1LL;
v9 = -1;
}
}
}
*((_QWORD *)&v10 + 1) = *((_QWORD *)&v13 + 1);
if ( v9 < 0 )
{
*(double *)&v10 = (*(double *)&v13 + v12) * 0.5;
v13 = v10;
}
else
{
v12 = (*(double *)&v13 + v12) * 0.5;
}
v5 = (_QWORD *)v5[(unsigned int)v9 >> 31];
if ( v5 == (_QWORD *)&null_element )
{
result = (unsigned int)(int)*(double *)&v13;
goto LABEL_17;
}
}
}
result = 1LL;
LABEL_17:
if ( a3 == 4 )
return (unsigned int)(int)v12;
if ( a3 != 3 )
{
result = -1LL;
if ( !a3 )
return (unsigned int)(int)v12;
}
return result;
}
|
tree_record_pos:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,EDX
MOV EAX,dword ptr [RDI + 0x20c]
CVTSI2SD XMM0,RAX
MOVAPD xmmword ptr [RBP + -0x50],XMM0
MOV R13,qword ptr [RDI]
LEA RAX,[0x4ae580]
CMP R13,RAX
JZ 0x001c4c45
MOV R14,RCX
MOV R15,RDI
MOV R12,RSI
MOVSD XMM0,qword ptr [0x00205000]
MOVAPD xmmword ptr [RBP + -0x40],XMM0
LAB_001c4ba7:
MOV ESI,dword ptr [R15 + 0x208]
TEST RSI,RSI
JZ 0x001c4bb8
ADD RSI,R13
JMP 0x001c4bbc
LAB_001c4bb8:
MOV RSI,qword ptr [R13 + 0x18]
LAB_001c4bbc:
MOV RDI,R14
MOV RDX,R12
CALL qword ptr [R15 + 0x228]
TEST EAX,EAX
JZ 0x001c4c05
LAB_001c4bcd:
MOVAPD XMM0,xmmword ptr [RBP + -0x40]
ADDSD XMM0,qword ptr [RBP + -0x50]
MULSD XMM0,qword ptr [0x00205050]
TEST EAX,EAX
JS 0x001c4bea
MOVAPD xmmword ptr [RBP + -0x50],XMM0
JMP 0x001c4bef
LAB_001c4bea:
MOVAPD xmmword ptr [RBP + -0x40],XMM0
LAB_001c4bef:
SHR EAX,0x1f
MOV R13,qword ptr [R13 + RAX*0x8]
LEA RAX,[0x4ae580]
CMP R13,RAX
JNZ 0x001c4ba7
JMP 0x001c4c1f
LAB_001c4c05:
MOV EAX,0x1
TEST EBX,EBX
JZ 0x001c4bcd
CMP EBX,0x4
JZ 0x001c4bcd
CMP EBX,0x3
JNZ 0x001c4c92
MOV EAX,0xffffffff
JMP 0x001c4bcd
LAB_001c4c1f:
MOVAPD XMM0,xmmword ptr [RBP + -0x40]
CVTTSD2SI RCX,XMM0
MOV RDX,RCX
SAR RDX,0x3f
SUBSD XMM0,qword ptr [0x00205010]
CVTTSD2SI RAX,XMM0
AND RAX,RDX
OR RAX,RCX
JMP 0x001c4c4a
LAB_001c4c45:
MOV EAX,0x1
LAB_001c4c4a:
CMP EBX,0x4
JZ 0x001c4c5f
CMP EBX,0x3
JZ 0x001c4c83
MOV RAX,-0x1
TEST EBX,EBX
JNZ 0x001c4c83
LAB_001c4c5f:
MOVAPD XMM0,xmmword ptr [RBP + -0x50]
CVTTSD2SI RCX,XMM0
MOV RDX,RCX
SAR RDX,0x3f
SUBSD XMM0,qword ptr [0x00205010]
CVTTSD2SI RAX,XMM0
AND RAX,RDX
OR RAX,RCX
LAB_001c4c83:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c4c92:
MOV RAX,-0x1
JMP 0x001c4c83
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong tree_record_pos(long *param_1,int8 param_2,int param_3,int8 param_4)
{
uint uVar1;
ulong uVar2;
int1 *puVar3;
int1 *puVar4;
double dVar5;
double local_58;
double local_48;
local_58 = (double)*(uint *)((long)param_1 + 0x20c);
puVar4 = (int1 *)*param_1;
if (puVar4 == null_element) {
uVar2 = 1;
}
else {
local_48 = DAT_00205000;
do {
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
puVar3 = *(int1 **)(puVar4 + 0x18);
}
else {
puVar3 = puVar4 + *(uint *)(param_1 + 0x41);
}
uVar1 = (*(code *)param_1[0x45])(param_4,puVar3,param_2);
if (((uVar1 == 0) && (uVar1 = 1, param_3 != 0)) && (param_3 != 4)) {
if (param_3 != 3) {
return 0xffffffffffffffff;
}
uVar1 = 0xffffffff;
}
dVar5 = (local_48 + local_58) * DAT_00205050;
if (-1 < (int)uVar1) {
local_58 = dVar5;
dVar5 = local_48;
}
local_48 = dVar5;
puVar4 = *(int1 **)(puVar4 + (ulong)(uVar1 >> 0x1f) * 8);
} while (puVar4 != null_element);
uVar2 = (long)(local_48 - _DAT_00205010) & (long)local_48 >> 0x3f | (long)local_48;
}
if ((param_3 == 4) || ((param_3 != 3 && (uVar2 = 0xffffffffffffffff, param_3 == 0)))) {
uVar2 = (long)(local_58 - _DAT_00205010) & (long)local_58 >> 0x3f | (long)local_58;
}
return uVar2;
}
|
|
18,375
|
js_global_isFinite
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_global_isFinite(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
BOOL res;
double d;
if (unlikely(JS_ToFloat64(ctx, &d, argv[0])))
return JS_EXCEPTION;
res = isfinite(d);
return js_bool(res);
}
|
O2
|
c
|
js_global_isFinite:
pushq %rax
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rsp, %rsi
callq 0x2127f
testl %eax, %eax
jne 0x65eb4
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq (%rsp), %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
xorl %eax, %eax
cmpq %rdx, %rcx
setl %al
pushq $0x1
popq %rdx
popq %rcx
retq
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x65eb2
|
js_global_isFinite:
push rax
mov rdx, [r8]
mov rcx, [r8+8]
mov rsi, rsp
call JS_ToFloat64
test eax, eax
jnz short loc_65EB4
mov rcx, 7FFFFFFFFFFFFFFFh
and rcx, [rsp+8+var_8]
mov rdx, 7FF0000000000000h
xor eax, eax
cmp rcx, rdx
setl al
push 1
pop rdx
loc_65EB2:
pop rcx
retn
loc_65EB4:
push 6
pop rdx
xor eax, eax
jmp short loc_65EB2
|
_BOOL8 js_global_isFinite(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long v5; // rax
long long v7; // [rsp+0h] [rbp-8h] BYREF
v7 = v5;
return !(unsigned int)JS_ToFloat64(a1, (long long)&v7, *(_DWORD **)a5, *(_QWORD *)(a5 + 8))
&& (v7 & 0x7FFFFFFFFFFFFFFFuLL) < 0x7FF0000000000000LL;
}
|
js_global_isFinite:
PUSH RAX
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV RSI,RSP
CALL 0x0012127f
TEST EAX,EAX
JNZ 0x00165eb4
MOV RCX,0x7fffffffffffffff
AND RCX,qword ptr [RSP]
MOV RDX,0x7ff0000000000000
XOR EAX,EAX
CMP RCX,RDX
SETL AL
PUSH 0x1
POP RDX
LAB_00165eb2:
POP RCX
RET
LAB_00165eb4:
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x00165eb2
|
bool js_global_isFinite(int8 param_1)
{
int iVar1;
ulong in_RAX;
int8 *in_R8;
ulong local_8;
local_8 = in_RAX;
iVar1 = JS_ToFloat64(param_1,&local_8,*in_R8,in_R8[1]);
return iVar1 == 0 && (local_8 & 0x7fffffffffffffff) < 0x7ff0000000000000;
}
|
|
18,376
|
js_regexp_Symbol_matchAll
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// [Symbol.matchAll](str)
JSValue R = this_val;
JSValue S, C, flags, matcher, iter;
JSValue args[2];
JSString *strp;
int64_t lastIndex;
JSRegExpStringIteratorData *it;
if (!JS_IsObject(R))
return JS_ThrowTypeErrorNotAnObject(ctx);
C = JS_UNDEFINED;
flags = JS_UNDEFINED;
matcher = JS_UNDEFINED;
iter = JS_UNDEFINED;
S = JS_ToString(ctx, argv[0]);
if (JS_IsException(S))
goto exception;
C = JS_SpeciesConstructor(ctx, R, ctx->regexp_ctor);
if (JS_IsException(C))
goto exception;
flags = JS_ToStringFree(ctx, JS_GetProperty(ctx, R, JS_ATOM_flags));
if (JS_IsException(flags))
goto exception;
args[0] = R;
args[1] = flags;
matcher = JS_CallConstructor(ctx, C, 2, args);
if (JS_IsException(matcher))
goto exception;
if (JS_ToLengthFree(ctx, &lastIndex,
JS_GetProperty(ctx, R, JS_ATOM_lastIndex)))
goto exception;
if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex, js_int64(lastIndex)) < 0)
goto exception;
iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
if (JS_IsException(iter))
goto exception;
it = js_malloc(ctx, sizeof(*it));
if (!it)
goto exception;
it->iterating_regexp = matcher;
it->iterated_string = S;
strp = JS_VALUE_GET_STRING(flags);
it->global = string_indexof_char(strp, 'g', 0) >= 0;
it->unicode = string_indexof_char(strp, 'u', 0) >= 0;
it->done = FALSE;
JS_SetOpaqueInternal(iter, it);
JS_FreeValue(ctx, C);
JS_FreeValue(ctx, flags);
return iter;
exception:
JS_FreeValue(ctx, S);
JS_FreeValue(ctx, C);
JS_FreeValue(ctx, flags);
JS_FreeValue(ctx, matcher);
JS_FreeValue(ctx, iter);
return JS_EXCEPTION;
}
|
O2
|
c
|
js_regexp_Symbol_matchAll:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r12
movq %rdi, %r14
cmpl $-0x1, %r12d
jne 0x40696
movq %rsi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %r14, %rdi
callq 0x1b03c
pushq $0x3
popq %rbp
cmpl $0x6, %edx
jne 0x406a3
xorl %r12d, %r12d
movq $0x0, 0x40(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r15d, %r15d
movq %rbp, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r13d, %r13d
movq %rbp, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq %rbp, %rbx
jmp 0x4080f
movq %r14, %rdi
callq 0x1d5e1
jmp 0x40870
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x78(%r14), %rcx
movq 0x80(%r14), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3bad8
movq %rax, 0x50(%rsp)
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x4070e
xorl %r12d, %r12d
movq $0x0, 0x40(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r15d, %r15d
movq %rbp, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r13d, %r13d
movq %rbp, 0x48(%rsp)
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
jmp 0x4080f
pushq $0x6e
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b043
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e049
movq %rax, %rcx
shrq $0x20, %rcx
movq %rcx, 0x20(%rsp)
cmpl $0x6, %edx
movq %rdx, 0x48(%rsp)
movq %rax, 0x40(%rsp)
jne 0x40775
movq $0x0, 0x10(%rsp)
xorl %r15d, %r15d
movq %rbp, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r13d, %r13d
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
movq 0x20(%rsp), %r12
jmp 0x4080f
leaq 0x60(%rsp), %r8
movq %r15, (%r8)
movq %r12, 0x8(%r8)
movq %rax, 0x10(%r8)
movq %rdx, 0x18(%r8)
pushq $0x2
popq %rcx
movq %r14, %rdi
movq 0x50(%rsp), %rsi
movq %rbx, 0x18(%rsp)
movq %rbx, %rdx
callq 0x283f2
movq %rax, %r13
movq %rdx, %rbx
shrq $0x20, %rax
movq %rax, 0x28(%rsp)
cmpl $0x6, %ebx
movq %rdx, 0x38(%rsp)
movq %r13, 0x30(%rsp)
je 0x407eb
pushq $0x56
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b043
movq %rdx, %rcx
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x3daf8
testl %eax, %eax
je 0x4088f
movq $0x0, 0x10(%rsp)
xorl %r15d, %r15d
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
movq 0x20(%rsp), %r12
movq 0x28(%rsp), %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x1801e
movq %r14, %rdi
movq 0x50(%rsp), %rsi
movq %rbx, %rdx
callq 0x1801e
shlq $0x20, %r12
movl 0x40(%rsp), %esi
orq %r12, %rsi
movq %r14, %rdi
movq 0x48(%rsp), %rdx
callq 0x1801e
shlq $0x20, %r13
movl 0x30(%rsp), %esi
orq %r13, %rsi
movq %r14, %rdi
movq 0x38(%rsp), %rdx
callq 0x1801e
shlq $0x20, %r15
movl 0x10(%rsp), %esi
orq %r15, %rsi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x1801e
pushq $0x6
popq %rbp
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %rbp, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x58(%rsp), %rdi
callq 0x20a0b
movq %rdx, %r9
pushq $0x56
popq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rax, %r8
callq 0x1e446
testl %eax, %eax
js 0x407eb
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x1b297
movq %rax, %rbx
movq %rdx, %rbp
movq %rax, %r12
shrq $0x20, %r12
cmpl $0x6, %ebp
je 0x40985
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x17214
testq %rax, %rax
je 0x40985
movq %rax, %r15
movq 0x30(%rsp), %rax
movq %rax, (%r15)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%r15)
movq (%rsp), %rax
movq %rax, 0x10(%r15)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r15)
pushq $0x67
popq %rsi
movq 0x40(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x414fc
notl %eax
shrl $0x1f, %eax
movl %eax, 0x20(%r15)
pushq $0x75
popq %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x414fc
notl %eax
shrl $0x1f, %eax
movl %eax, 0x24(%r15)
andl $0x0, 0x28(%r15)
movq %r15, 0x30(%rbx)
movq %r14, %rdi
movq 0x50(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x1801e
movq %r14, %rdi
movq %r12, %rsi
movq 0x48(%rsp), %rdx
callq 0x1801e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
movl %ebx, %eax
jmp 0x40877
movq %rbx, 0x10(%rsp)
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
movq %r12, %r15
jmp 0x40805
|
js_regexp_Symbol_matchAll:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r12, rdx
mov r14, rdi
cmp r12d, 0FFFFFFFFh
jnz short loc_40696
mov r15, rsi
mov rsi, [r8]
mov rdx, [r8+8]
mov rdi, r14
call JS_ToString
push 3
pop rbp
cmp edx, 6
jnz short loc_406A3
xor r12d, r12d
mov [rsp+0B8h+var_78], 0
mov [rsp+0B8h+var_A8], 0
xor r15d, r15d
mov [rsp+0B8h+var_80], rbp
mov [rsp+0B8h+var_88], 0
xor r13d, r13d
mov [rsp+0B8h+var_70], rbp
mov [rsp+0B8h+var_68], 0
mov rbx, rbp
jmp loc_4080F
loc_40696:
mov rdi, r14
call JS_ThrowTypeErrorNotAnObject
jmp loc_40870
loc_406A3:
mov [rsp+0B8h+var_B8], rax
mov [rsp+0B8h+var_B0], rdx
mov rcx, [r14+78h]
mov r8, [r14+80h]
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_SpeciesConstructor
mov [rsp+0B8h+var_68], rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_4070E
xor r12d, r12d
mov [rsp+0B8h+var_78], 0
mov [rsp+0B8h+var_A8], 0
xor r15d, r15d
mov [rsp+0B8h+var_80], rbp
mov [rsp+0B8h+var_88], 0
xor r13d, r13d
mov [rsp+0B8h+var_70], rbp
mov rdx, [rsp+0B8h+var_B0]
mov rax, [rsp+0B8h+var_B8]
jmp loc_4080F
loc_4070E:
push 6Eh ; 'n'
pop rcx
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_GetProperty
mov rdi, r14
mov rsi, rax
call JS_ToStringFree
mov rcx, rax
shr rcx, 20h
mov [rsp+0B8h+var_98], rcx
cmp edx, 6
mov [rsp+0B8h+var_70], rdx
mov [rsp+0B8h+var_78], rax
jnz short loc_40775
mov [rsp+0B8h+var_A8], 0
xor r15d, r15d
mov [rsp+0B8h+var_80], rbp
mov [rsp+0B8h+var_88], 0
xor r13d, r13d
mov rdx, [rsp+0B8h+var_B0]
mov rax, [rsp+0B8h+var_B8]
mov r12, [rsp+0B8h+var_98]
jmp loc_4080F
loc_40775:
lea r8, [rsp+0B8h+var_58]
mov [r8], r15
mov [r8+8], r12
mov [r8+10h], rax
mov [r8+18h], rdx
push 2
pop rcx
mov rdi, r14
mov rsi, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_A0], rbx
mov rdx, rbx
call JS_CallConstructor
mov r13, rax
mov rbx, rdx
shr rax, 20h
mov [rsp+0B8h+var_90], rax
cmp ebx, 6
mov [rsp+0B8h+var_80], rdx
mov [rsp+0B8h+var_88], r13
jz short loc_407EB
push 56h ; 'V'
pop rcx
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_GetProperty
mov rcx, rdx
lea rsi, [rsp+0B8h+var_60]
mov rdi, r14
mov rdx, rax
call JS_ToLengthFree
test eax, eax
jz loc_4088F
loc_407EB:
mov [rsp+0B8h+var_A8], 0
xor r15d, r15d
mov rbx, [rsp+0B8h+var_A0]
mov rdx, [rsp+0B8h+var_B0]
mov rax, [rsp+0B8h+var_B8]
loc_40805:
mov r12, [rsp+0B8h+var_98]
mov r13, [rsp+0B8h+var_90]
loc_4080F:
mov rdi, r14
mov rsi, rax
call JS_FreeValue
mov rdi, r14
mov rsi, [rsp+0B8h+var_68]
mov rdx, rbx
call JS_FreeValue
shl r12, 20h
mov esi, dword ptr [rsp+0B8h+var_78]
or rsi, r12
mov rdi, r14
mov rdx, [rsp+0B8h+var_70]
call JS_FreeValue
shl r13, 20h
mov esi, dword ptr [rsp+0B8h+var_88]
or rsi, r13
mov rdi, r14
mov rdx, [rsp+0B8h+var_80]
call JS_FreeValue
shl r15, 20h
mov esi, dword ptr [rsp+0B8h+var_A8]
or rsi, r15
mov rdi, r14
mov rdx, rbp
call JS_FreeValue
loc_40870:
push 6
pop rbp
xor eax, eax
xor ecx, ecx
loc_40877:
or rax, rcx
mov rdx, rbp
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4088F:
mov rdi, [rsp+0B8h+var_60]
call js_int64
mov r9, rdx
push 56h ; 'V'
pop rcx
mov rdi, r14
mov rsi, r13
mov rdx, rbx
mov r8, rax
call JS_SetProperty
test eax, eax
js loc_407EB
push 2Eh ; '.'
pop rsi
mov rdi, r14
call JS_NewObjectClass
mov rbx, rax
mov rbp, rdx
mov r12, rax
shr r12, 20h
cmp ebp, 6
jz loc_40985
push 30h ; '0'
pop rsi
mov rdi, r14
call js_malloc
test rax, rax
jz loc_40985
mov r15, rax
mov rax, [rsp+0B8h+var_88]
mov [r15], rax
mov rax, [rsp+0B8h+var_80]
mov [r15+8], rax
mov rax, [rsp+0B8h+var_B8]
mov [r15+10h], rax
mov rax, [rsp+0B8h+var_B0]
mov [r15+18h], rax
push 67h ; 'g'
pop rsi
mov r12, [rsp+0B8h+var_78]
mov rdi, r12
xor edx, edx
call string_indexof_char
not eax
shr eax, 1Fh
mov [r15+20h], eax
push 75h ; 'u'
pop rsi
mov rdi, r12
xor edx, edx
call string_indexof_char
not eax
shr eax, 1Fh
mov [r15+24h], eax
and dword ptr [r15+28h], 0
mov [rbx+30h], r15
mov rdi, r14
mov rsi, [rsp+0B8h+var_68]
mov rdx, [rsp+0B8h+var_A0]
call JS_FreeValue
mov rdi, r14
mov rsi, r12
mov rdx, [rsp+0B8h+var_70]
call JS_FreeValue
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
mov eax, ebx
jmp loc_40877
loc_40985:
mov [rsp+0B8h+var_A8], rbx
mov rbx, [rsp+0B8h+var_A0]
mov rdx, [rsp+0B8h+var_B0]
mov rax, [rsp+0B8h+var_B8]
mov r15, r12
jmp loc_40805
|
unsigned long long js_regexp_Symbol_matchAll(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // rax
long long v16; // rdx
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
long long v20; // rbp
unsigned long long v21; // r12
unsigned long long v22; // r15
unsigned long long v23; // r13
long long v24; // rbx
long long v25; // rdx
long long Property; // rax
long long v27; // rdx
unsigned long long v28; // rax
long long v29; // rdx
double v30; // xmm4_8
double v31; // xmm5_8
unsigned long long v32; // rax
int v33; // r13d
long long v34; // rdx
long long v35; // rbx
_DWORD *v36; // rax
long long v37; // rdx
long long v38; // rax
unsigned long long v39; // rcx
int v41; // eax
int v42; // edx
unsigned long long v43; // rbx
long long v44; // rdx
unsigned long long v45; // r12
long long v46; // rax
long long v47; // r15
char v48; // [rsp+0h] [rbp-B8h]
long long v49; // [rsp+0h] [rbp-B8h]
long long v50; // [rsp+8h] [rbp-B0h]
unsigned int v51; // [rsp+10h] [rbp-A8h]
long long v52; // [rsp+18h] [rbp-A0h]
unsigned long long v53; // [rsp+20h] [rbp-98h]
unsigned long long v54; // [rsp+28h] [rbp-90h]
unsigned long long v55; // [rsp+30h] [rbp-88h]
long long v56; // [rsp+38h] [rbp-80h]
long long v57; // [rsp+40h] [rbp-78h]
long long v58; // [rsp+48h] [rbp-70h]
_DWORD *v59; // [rsp+50h] [rbp-68h]
long long v60; // [rsp+58h] [rbp-60h] BYREF
_QWORD v61[11]; // [rsp+60h] [rbp-58h] BYREF
if ( (_DWORD)a3 == -1 )
{
v15 = JS_ToString(a1, *a5, a5[1]);
v20 = 3LL;
if ( (_DWORD)v16 == 6 )
{
v21 = 0LL;
LODWORD(v57) = 0;
v51 = 0;
v22 = 0LL;
v56 = 3LL;
LODWORD(v55) = 0;
v23 = 0LL;
v58 = 3LL;
v59 = 0LL;
v24 = 3LL;
}
else
{
v49 = v15;
v50 = v16;
v59 = JS_SpeciesConstructor(
a1,
a2,
a3,
*(_QWORD *)(a1 + 120),
*(_QWORD *)(a1 + 128),
v17,
a7,
a8,
a9,
a10,
v18,
v19,
a13,
a14);
v24 = v25;
if ( (_DWORD)v25 == 6 )
{
v21 = 0LL;
LODWORD(v57) = 0;
v51 = 0;
v22 = 0LL;
v56 = 3LL;
LODWORD(v55) = 0;
v23 = 0LL;
v58 = 3LL;
v16 = v50;
v15 = v49;
}
else
{
Property = JS_GetProperty(a1, a2, a3, 110);
v28 = JS_ToStringFree(a1, Property, v27);
v53 = HIDWORD(v28);
v58 = v29;
v57 = v28;
if ( (_DWORD)v29 == 6 )
{
v51 = 0;
v22 = 0LL;
v56 = 3LL;
LODWORD(v55) = 0;
v23 = 0LL;
v16 = v50;
v15 = v49;
v21 = v53;
}
else
{
v61[0] = a2;
v61[1] = a3;
v61[2] = v28;
v61[3] = v29;
v52 = v24;
v32 = JS_CallConstructor(
a1,
(unsigned long long)v59,
v24,
2u,
(long long)v61,
a7,
a8,
a9,
a10,
v30,
v31,
a13,
a14);
v33 = v32;
v35 = v34;
v54 = HIDWORD(v32);
v56 = v34;
v55 = v32;
if ( (_DWORD)v34 == 6
|| (v36 = (_DWORD *)JS_GetProperty(a1, a2, a3, 86),
(unsigned int)JS_ToLengthFree(a1, (unsigned long long *)&v60, v36, v37))
|| (v41 = js_int64(v60), (int)JS_SetProperty(a1, v33, v35, 86, v41, v42) < 0) )
{
v51 = 0;
v22 = 0LL;
v24 = v52;
v16 = v50;
v15 = v49;
}
else
{
v43 = JS_NewObjectClass(a1, 46);
v20 = v44;
v45 = HIDWORD(v43);
if ( (_DWORD)v44 != 6 )
{
v46 = js_malloc(a1, 48LL);
if ( v46 )
{
v47 = v46;
*(_QWORD *)v46 = v55;
*(_QWORD *)(v46 + 8) = v56;
*(_QWORD *)(v46 + 16) = v49;
*(_QWORD *)(v46 + 24) = v50;
*(_DWORD *)(v46 + 32) = (int)string_indexof_char(v57, 103LL, 0LL) >= 0;
*(_DWORD *)(v47 + 36) = (int)string_indexof_char(v57, 117LL, 0LL) >= 0;
*(_DWORD *)(v47 + 40) = 0;
*(_QWORD *)(v43 + 48) = v47;
JS_FreeValue(a1, (long long)v59, v52);
JS_FreeValue(a1, v57, v58);
v39 = v43 & 0xFFFFFFFF00000000LL;
v38 = (unsigned int)v43;
return v39 | v38;
}
}
v51 = v43;
v24 = v52;
v16 = v50;
v15 = v49;
v22 = v45;
}
v21 = v53;
v23 = v54;
}
}
}
JS_FreeValue(a1, v15, v16);
JS_FreeValue(a1, (long long)v59, v24);
JS_FreeValue(a1, (v21 << 32) | (unsigned int)v57, v58);
JS_FreeValue(a1, (v23 << 32) | (unsigned int)v55, v56);
JS_FreeValue(a1, (v22 << 32) | v51, v20);
}
else
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, (long long)a5, a6, v48);
}
v38 = 0LL;
v39 = 0LL;
return v39 | v38;
}
|
js_regexp_Symbol_matchAll:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R12,RDX
MOV R14,RDI
CMP R12D,-0x1
JNZ 0x00140696
MOV R15,RSI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
MOV RDI,R14
CALL 0x0011b03c
PUSH 0x3
POP RBP
CMP EDX,0x6
JNZ 0x001406a3
XOR R12D,R12D
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x10],0x0
XOR R15D,R15D
MOV qword ptr [RSP + 0x38],RBP
MOV qword ptr [RSP + 0x30],0x0
XOR R13D,R13D
MOV qword ptr [RSP + 0x48],RBP
MOV qword ptr [RSP + 0x50],0x0
MOV RBX,RBP
JMP 0x0014080f
LAB_00140696:
MOV RDI,R14
CALL 0x0011d5e1
JMP 0x00140870
LAB_001406a3:
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RCX,qword ptr [R14 + 0x78]
MOV R8,qword ptr [R14 + 0x80]
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0013bad8
MOV qword ptr [RSP + 0x50],RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x0014070e
XOR R12D,R12D
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x10],0x0
XOR R15D,R15D
MOV qword ptr [RSP + 0x38],RBP
MOV qword ptr [RSP + 0x30],0x0
XOR R13D,R13D
MOV qword ptr [RSP + 0x48],RBP
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
JMP 0x0014080f
LAB_0014070e:
PUSH 0x6e
POP RCX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011b043
MOV RDI,R14
MOV RSI,RAX
CALL 0x0012e049
MOV RCX,RAX
SHR RCX,0x20
MOV qword ptr [RSP + 0x20],RCX
CMP EDX,0x6
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x40],RAX
JNZ 0x00140775
MOV qword ptr [RSP + 0x10],0x0
XOR R15D,R15D
MOV qword ptr [RSP + 0x38],RBP
MOV qword ptr [RSP + 0x30],0x0
XOR R13D,R13D
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
MOV R12,qword ptr [RSP + 0x20]
JMP 0x0014080f
LAB_00140775:
LEA R8,[RSP + 0x60]
MOV qword ptr [R8],R15
MOV qword ptr [R8 + 0x8],R12
MOV qword ptr [R8 + 0x10],RAX
MOV qword ptr [R8 + 0x18],RDX
PUSH 0x2
POP RCX
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x18],RBX
MOV RDX,RBX
CALL 0x001283f2
MOV R13,RAX
MOV RBX,RDX
SHR RAX,0x20
MOV qword ptr [RSP + 0x28],RAX
CMP EBX,0x6
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x30],R13
JZ 0x001407eb
PUSH 0x56
POP RCX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011b043
MOV RCX,RDX
LEA RSI,[RSP + 0x58]
MOV RDI,R14
MOV RDX,RAX
CALL 0x0013daf8
TEST EAX,EAX
JZ 0x0014088f
LAB_001407eb:
MOV qword ptr [RSP + 0x10],0x0
XOR R15D,R15D
MOV RBX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
LAB_00140805:
MOV R12,qword ptr [RSP + 0x20]
MOV R13,qword ptr [RSP + 0x28]
LAB_0014080f:
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011801e
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,RBX
CALL 0x0011801e
SHL R12,0x20
MOV ESI,dword ptr [RSP + 0x40]
OR RSI,R12
MOV RDI,R14
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x0011801e
SHL R13,0x20
MOV ESI,dword ptr [RSP + 0x30]
OR RSI,R13
MOV RDI,R14
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x0011801e
SHL R15,0x20
MOV ESI,dword ptr [RSP + 0x10]
OR RSI,R15
MOV RDI,R14
MOV RDX,RBP
CALL 0x0011801e
LAB_00140870:
PUSH 0x6
POP RBP
XOR EAX,EAX
XOR ECX,ECX
LAB_00140877:
OR RAX,RCX
MOV RDX,RBP
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014088f:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00120a0b
MOV R9,RDX
PUSH 0x56
POP RCX
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBX
MOV R8,RAX
CALL 0x0011e446
TEST EAX,EAX
JS 0x001407eb
PUSH 0x2e
POP RSI
MOV RDI,R14
CALL 0x0011b297
MOV RBX,RAX
MOV RBP,RDX
MOV R12,RAX
SHR R12,0x20
CMP EBP,0x6
JZ 0x00140985
PUSH 0x30
POP RSI
MOV RDI,R14
CALL 0x00117214
TEST RAX,RAX
JZ 0x00140985
MOV R15,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [R15],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [R15 + 0x8],RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [R15 + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R15 + 0x18],RAX
PUSH 0x67
POP RSI
MOV R12,qword ptr [RSP + 0x40]
MOV RDI,R12
XOR EDX,EDX
CALL 0x001414fc
NOT EAX
SHR EAX,0x1f
MOV dword ptr [R15 + 0x20],EAX
PUSH 0x75
POP RSI
MOV RDI,R12
XOR EDX,EDX
CALL 0x001414fc
NOT EAX
SHR EAX,0x1f
MOV dword ptr [R15 + 0x24],EAX
AND dword ptr [R15 + 0x28],0x0
MOV qword ptr [RBX + 0x30],R15
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011801e
MOV RDI,R14
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x0011801e
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
MOV EAX,EBX
JMP 0x00140877
LAB_00140985:
MOV qword ptr [RSP + 0x10],RBX
MOV RBX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP]
MOV R15,R12
JMP 0x00140805
|
int1 [16]
js_regexp_Symbol_matchAll
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 *param_5
)
{
int iVar1;
uint uVar2;
int8 uVar3;
ulong uVar4;
ulong uVar5;
int1 (*pauVar6) [16];
ulong uVar7;
ulong uVar8;
ulong uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
ulong local_a8;
ulong local_88;
int8 local_80;
ulong local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int1 local_48 [16];
if ((int)param_3 == -1) {
auVar10 = JS_ToString(param_1,*param_5,param_5[1]);
if (auVar10._8_4_ == 6) {
uVar7 = 0;
auVar14 = ZEXT816(3) << 0x40;
uVar9 = 0;
auVar13 = ZEXT816(3) << 0x40;
uVar4 = 0;
auVar12 = ZEXT816(3) << 0x40;
auVar11 = ZEXT816(3) << 0x40;
}
else {
auVar11 = JS_SpeciesConstructor
(param_1,param_2,param_3,*(int8 *)(param_1 + 0x78),
*(int8 *)(param_1 + 0x80));
if (auVar11._8_4_ == 6) {
uVar7 = 0;
auVar14 = ZEXT816(3) << 0x40;
uVar9 = 0;
auVar13 = ZEXT816(3) << 0x40;
uVar4 = 0;
auVar12 = ZEXT816(3) << 0x40;
}
else {
uVar3 = JS_GetProperty(param_1,param_2,param_3,0x6e);
auVar12 = JS_ToStringFree(param_1,uVar3);
uVar8 = auVar12._0_8_;
uVar7 = uVar8 >> 0x20;
if (auVar12._8_4_ == 6) {
auVar14 = ZEXT816(3) << 0x40;
uVar9 = 0;
auVar13 = ZEXT816(3) << 0x40;
uVar4 = 0;
}
else {
local_58 = param_2;
local_50 = param_3;
local_48 = auVar12;
auVar13 = JS_CallConstructor(param_1,auVar11._0_8_,auVar11._8_8_,2);
uVar4 = auVar13._0_8_ >> 0x20;
if (auVar13._8_4_ != 6) {
auVar14 = JS_GetProperty(param_1,param_2,param_3,0x56);
iVar1 = JS_ToLengthFree(param_1,&local_60,auVar14._0_8_,auVar14._8_8_);
if (iVar1 == 0) {
auVar14 = js_int64(local_60);
iVar1 = JS_SetProperty(param_1,auVar13._0_8_,auVar13._8_8_,0x56,auVar14._0_8_,
auVar14._8_8_);
if (-1 < iVar1) {
auVar14 = JS_NewObjectClass(param_1,0x2e);
uVar3 = auVar14._8_8_;
uVar5 = auVar14._0_8_;
uVar9 = uVar5 >> 0x20;
if (auVar14._8_4_ != 6) {
pauVar6 = (int1 (*) [16])js_malloc(param_1,0x30);
if (pauVar6 != (int1 (*) [16])0x0) {
*pauVar6 = auVar13;
pauVar6[1] = auVar10;
uVar2 = string_indexof_char(uVar8,0x67,0);
*(uint *)pauVar6[2] = ~uVar2 >> 0x1f;
uVar2 = string_indexof_char(uVar8,0x75,0);
*(uint *)(pauVar6[2] + 4) = ~uVar2 >> 0x1f;
*(int4 *)(pauVar6[2] + 8) = 0;
*(int1 (**) [16])(uVar5 + 0x30) = pauVar6;
JS_FreeValue(param_1,auVar11._0_8_,auVar11._8_8_);
JS_FreeValue(param_1,uVar8,auVar12._8_8_);
uVar8 = uVar5 & 0xffffffff00000000;
uVar5 = uVar5 & 0xffffffff;
goto LAB_00140877;
}
}
goto LAB_0014080f;
}
}
}
auVar14 = ZEXT816(3) << 0x40;
uVar9 = 0;
}
}
}
LAB_0014080f:
local_70 = auVar12._8_8_;
local_78 = auVar12._0_8_;
local_a8 = auVar14._0_8_;
local_80 = auVar13._8_8_;
local_88 = auVar13._0_8_;
local_68 = auVar11._0_8_;
JS_FreeValue(param_1,auVar10._0_8_,auVar10._8_8_);
JS_FreeValue(param_1,local_68,auVar11._8_8_);
JS_FreeValue(param_1,local_78 & 0xffffffff | uVar7 << 0x20,local_70);
JS_FreeValue(param_1,local_88 & 0xffffffff | uVar4 << 0x20,local_80);
JS_FreeValue(param_1,local_a8 & 0xffffffff | uVar9 << 0x20,auVar14._8_8_);
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
}
uVar3 = 6;
uVar5 = 0;
uVar8 = 0;
LAB_00140877:
auVar10._0_8_ = uVar5 | uVar8;
auVar10._8_8_ = uVar3;
return auVar10;
}
|
|
18,377
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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::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>::boolean_t&)
|
monkey531[P]llama/common/json.hpp
|
inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
}
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
}
|
O2
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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::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>::boolean_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x4, (%rdi)
jne 0x639d4
movb 0x8(%r14), %al
movb %al, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x42f88
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x4f309(%rip), %rsi # 0xb2cff
leaq 0x10(%rsp), %rdi
callq 0x63a57
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x62f5e
xorl %ebp, %ebp
leaq 0x96527(%rip), %rsi # 0xf9f48
leaq -0x23f10(%rip), %rdx # 0x3fb18
movq %rbx, %rdi
callq 0x23ef0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241b8
testb %bpl, %bpl
jne 0x63a47
jmp 0x63a4f
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f80
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 4
jnz short loc_639D4
mov al, [r14+8]
mov [rsi], al
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_639D4:
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, aTypeMustBeBool; "type must be boolean, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA30_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(char const(&)[30],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_63A47
jmp short loc_63A4F
mov r14, rax
loc_63A47:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_63A4F:
mov rdi, r14
call __Unwind_Resume
|
unsigned __int8 nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
unsigned __int8 result; // al
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *a1 != 4 )
{
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(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(
v4,
"type must be boolean, but 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,
302,
(long long)v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
result = a1[8];
*a2 = result;
return result;
}
|
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x4
JNZ 0x001639d4
MOV AL,byte ptr [R14 + 0x8]
MOV byte ptr [RSI],AL
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001639d4:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x00142f88
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001639ef:
LEA RSI,[0x1b2cff]
LEA RDI,[RSP + 0x10]
CALL 0x00163a57
MOV BPL,0x1
LAB_00163a03:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00162f5e
XOR EBP,EBP
LEA RSI,[0x1f9f48]
LEA RDX,[0x13fb18]
MOV RDI,RBX
CALL 0x00123ef0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(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>::boolean_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1,boolean_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == '\x04') {
*param_2 = param_1[8];
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)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((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 001639ef to 001639ff has its CatchHandler @ 00163a44 */
concat<std::__cxx11::string,char_const(&)[30],char_const*>
(local_38,"type must be boolean, but is ",&local_40);
/* try { // try from 00163a03 to 00163a2f has its CatchHandler @ 00163a30 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
|
|
18,378
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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::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>::boolean_t&)
|
monkey531[P]llama/common/json.hpp
|
inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
}
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
}
|
O3
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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::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>::boolean_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x4, (%rdi)
jne 0x8711c
movb 0x8(%r14), %al
movb %al, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e894
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x67bdf(%rip), %rsi # 0xeed1f
leaq 0x10(%rsp), %rdi
callq 0x871b2
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x86270
xorl %ebp, %ebp
leaq 0xa1ded(%rip), %rsi # 0x128f58
leaq -0x2c6a8(%rip), %rdx # 0x5aaca
movq %rbx, %rdi
callq 0x1aef0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x87198
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a8c0
testb %bpl, %bpl
jne 0x871a2
jmp 0x871aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a660
movq %r14, %rdi
callq 0x1af80
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 4
jnz short loc_8711C
mov al, [r14+8]
mov [rsi], al
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_8711C:
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, aTypeMustBeBool; "type must be boolean, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA30_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(char const(&)[30],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_87198
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_87198:
test bpl, bpl
jnz short loc_871A2
jmp short loc_871AA
mov r14, rax
loc_871A2:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_871AA:
mov rdi, r14
call __Unwind_Resume
|
unsigned __int8 nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
unsigned __int8 result; // al
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *a1 != 4 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__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(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(
v4,
"type must be boolean, but 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,
302,
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);
}
result = a1[8];
*a2 = result;
return result;
}
|
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x4
JNZ 0x0018711c
MOV AL,byte ptr [R14 + 0x8]
MOV byte ptr [RSI],AL
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0018711c:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015e894
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00187139:
LEA RSI,[0x1eed1f]
LEA RDI,[RSP + 0x10]
CALL 0x001871b2
MOV BPL,0x1
LAB_0018714d:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00186270
XOR EBP,EBP
LEA RSI,[0x228f58]
LEA RDX,[0x15aaca]
MOV RDI,RBX
CALL 0x0011aef0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(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>::boolean_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1,boolean_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x4) {
*param_2 = param_1[8];
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)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((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 00187139 to 00187149 has its CatchHandler @ 0018719f */
concat<std::__cxx11::string,char_const(&)[30],char_const*>
(local_38,"type must be boolean, but is ",&local_40);
/* try { // try from 0018714d to 00187179 has its CatchHandler @ 0018717a */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
|
|
18,379
|
nlohmann::json_abi_v3_11_3::operator<<(std::ostream&, 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&)
|
hkr04[P]cpp-mcp/common/json.hpp
|
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
{
// read width member and use it as indentation parameter if nonzero
const bool pretty_print = o.width() > 0;
const auto indentation = pretty_print ? o.width() : 0;
// reset width to 0 for subsequent calls to this stream
o.width(0);
// do the actual serialization
serializer s(detail::output_adapter<char>(o), o.fill());
s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
return o;
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::operator<<(std::ostream&, 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&):
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, 0x2f0(%rsp)
movq %rsi, 0x2e8(%rsp)
movq 0x2f0(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x47550
cmpq $0x0, %rax
setg %al
andb $0x1, %al
movb %al, 0x2e7(%rsp)
testb $0x1, 0x2e7(%rsp)
je 0x47400
movq 0x2f0(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x47550
movq %rax, 0x18(%rsp)
jmp 0x47409
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x47409
movq 0x18(%rsp), %rax
movq %rax, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x47560
movq 0x2f0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x47590
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x15e90
jmp 0x47459
movq 0x2f0(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x62c0
movb %al, 0xf(%rsp)
jmp 0x47476
movb 0xf(%rsp), %al
movsbl %al, %edx
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %ecx, %ecx
callq 0x15ec0
jmp 0x47490
leaq 0x40(%rsp), %rdi
callq 0x16070
leaq 0x30(%rsp), %rdi
callq 0x16080
movq 0x2e8(%rsp), %rsi
movl 0x2d8(%rsp), %r8d
movzbl 0x2e7(%rsp), %edx
andl $0x1, %edx
leaq 0x50(%rsp), %rdi
xorl %r9d, %r9d
movl %r9d, %ecx
callq 0x16090
jmp 0x474d1
movq 0x2f0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x17070
movq (%rsp), %rax
addq $0x2f8, %rsp # imm = 0x2F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x4751b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x16070
leaq 0x30(%rsp), %rdi
callq 0x16080
jmp 0x4753f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x17070
movq 0x28(%rsp), %rdi
callq 0x6970
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_3lsERSoRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES4_IhSaIhEEvEE:
sub rsp, 2F8h
mov [rsp+2F8h+var_8], rdi
mov [rsp+2F8h+var_10], rsi
mov rdi, [rsp+2F8h+var_8]
mov rax, [rdi]
add rdi, [rax-18h]; this
call _ZNKSt8ios_base5widthEv; std::ios_base::width(void)
cmp rax, 0
setnle al
and al, 1
mov [rsp+2F8h+var_11], al
test [rsp+2F8h+var_11], 1
jz short loc_47400
mov rdi, [rsp+2F8h+var_8]
mov rax, [rdi]
add rdi, [rax-18h]; this
call _ZNKSt8ios_base5widthEv; std::ios_base::width(void)
mov [rsp+2F8h+var_2E0], rax
jmp short loc_47409
loc_47400:
xor eax, eax
mov [rsp+2F8h+var_2E0], rax
jmp short $+2
loc_47409:
mov rax, [rsp+2F8h+var_2E0]
mov [rsp+2F8h+var_20], rax
mov rdi, [rsp+2F8h+var_8]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax; this
xor eax, eax
mov esi, eax; __int64
call _ZNSt8ios_base5widthEl; std::ios_base::width(long)
mov rsi, [rsp+2F8h+var_8]
lea rdi, [rsp+2F8h+var_2C8]
mov [rsp+2F8h+var_2E8], rdi
call _ZN8nlohmann16json_abi_v3_11_36detail14output_adapterIcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2ERSo; nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::output_adapter(std::ostream &)
mov rsi, [rsp+2F8h+var_2E8]
lea rdi, [rsp+2F8h+var_2B8]
call _ZN8nlohmann16json_abi_v3_11_36detail14output_adapterIcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEcvSt10shared_ptrINS1_23output_adapter_protocolIcEEEEv; nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::operator std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>(void)
jmp short $+2
loc_47459:
mov rdi, [rsp+2F8h+var_8]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEE4fillEv; std::ios::fill(void)
mov [rsp+2F8h+var_2E9], al
jmp short $+2
loc_47476:
mov al, [rsp+2F8h+var_2E9]
movsx edx, al
lea rdi, [rsp+2F8h+var_2A8]
lea rsi, [rsp+2F8h+var_2B8]
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt10shared_ptrINS1_23output_adapter_protocolIcEEEcNS1_15error_handler_tE; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>,char,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
jmp short $+2
loc_47490:
lea rdi, [rsp+2F8h+var_2B8]
call _ZNSt10shared_ptrIN8nlohmann16json_abi_v3_11_36detail23output_adapter_protocolIcEEED2Ev; std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>::~shared_ptr()
lea rdi, [rsp+2F8h+var_2C8]
call _ZN8nlohmann16json_abi_v3_11_36detail14output_adapterIcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::~output_adapter()
mov rsi, [rsp+2F8h+var_10]
mov r8d, dword ptr [rsp+2F8h+var_20]
movzx edx, [rsp+2F8h+var_11]
and edx, 1
lea rdi, [rsp+2F8h+var_2A8]
xor r9d, r9d
mov ecx, r9d
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE4dumpERKSF_bbjj; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::dump(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&,bool,bool,uint,uint)
jmp short $+2
loc_474D1:
mov rax, [rsp+2F8h+var_8]
mov [rsp+2F8h+var_2F8], rax
lea rdi, [rsp+2F8h+var_2A8]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEED2Ev; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~serializer()
mov rax, [rsp+2F8h+var_2F8]
add rsp, 2F8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
jmp short loc_4751B
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_38]
call _ZNSt10shared_ptrIN8nlohmann16json_abi_v3_11_36detail23output_adapter_protocolIcEEED2Ev; std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>::~shared_ptr()
loc_4751B:
lea rdi, [rsp+arg_28]
call _ZN8nlohmann16json_abi_v3_11_36detail14output_adapterIcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::~output_adapter()
jmp short loc_4753F
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_48]
call _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEED2Ev; nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~serializer()
loc_4753F:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
|
_QWORD * nlohmann::json_abi_v3_11_3::operator<<(_QWORD *a1, char *a2)
{
long long v2; // rax
_QWORD *v4; // [rsp+0h] [rbp-2F8h]
char v5; // [rsp+Fh] [rbp-2E9h]
long long v6; // [rsp+18h] [rbp-2E0h]
_BYTE v7[16]; // [rsp+30h] [rbp-2C8h] BYREF
_BYTE v8[16]; // [rsp+40h] [rbp-2B8h] BYREF
_BYTE v9[648]; // [rsp+50h] [rbp-2A8h] BYREF
long long v10; // [rsp+2D8h] [rbp-20h]
bool v11; // [rsp+2E7h] [rbp-11h]
char *v12; // [rsp+2E8h] [rbp-10h]
_QWORD *v13; // [rsp+2F0h] [rbp-8h]
v13 = a1;
v12 = a2;
v2 = std::ios_base::width((std::ios_base *)((char *)a1 + *(_QWORD *)(*a1 - 24LL)));
v11 = v2 > 0;
if ( v2 <= 0 )
v6 = 0LL;
else
v6 = std::ios_base::width((std::ios_base *)((char *)v13 + *(_QWORD *)(*v13 - 24LL)));
v10 = v6;
std::ios_base::width((std::ios_base *)((char *)v13 + *(_QWORD *)(*v13 - 24LL)), 0LL);
nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::output_adapter(v7, v13);
nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::operator std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>(
(long long)v8,
(long long)v7);
v5 = std::ios::fill((char *)v13 + *(_QWORD *)(*v13 - 24LL));
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::serializer(
(long long)v9,
(long long)v8,
v5,
0);
std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>::~shared_ptr((long long)v8);
nlohmann::json_abi_v3_11_3::detail::output_adapter<char,std::string>::~output_adapter((long long)v7);
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::dump(
(long long)v9,
v12,
v11,
0,
v10,
0);
v4 = v13;
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~serializer((long long)v9);
return v4;
}
|
operator<<:
SUB RSP,0x2f8
MOV qword ptr [RSP + 0x2f0],RDI
MOV qword ptr [RSP + 0x2e8],RSI
MOV RDI,qword ptr [RSP + 0x2f0]
MOV RAX,qword ptr [RDI]
ADD RDI,qword ptr [RAX + -0x18]
CALL 0x00147550
CMP RAX,0x0
SETG AL
AND AL,0x1
MOV byte ptr [RSP + 0x2e7],AL
TEST byte ptr [RSP + 0x2e7],0x1
JZ 0x00147400
MOV RDI,qword ptr [RSP + 0x2f0]
MOV RAX,qword ptr [RDI]
ADD RDI,qword ptr [RAX + -0x18]
CALL 0x00147550
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00147409
LAB_00147400:
XOR EAX,EAX
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00147409
LAB_00147409:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x2d8],RAX
MOV RDI,qword ptr [RSP + 0x2f0]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00147560
MOV RSI,qword ptr [RSP + 0x2f0]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00147590
MOV RSI,qword ptr [RSP + 0x10]
LAB_0014744d:
LEA RDI,[RSP + 0x40]
CALL 0x00115e90
JMP 0x00147459
LAB_00147459:
MOV RDI,qword ptr [RSP + 0x2f0]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
LAB_0014746b:
CALL 0x001062c0
MOV byte ptr [RSP + 0xf],AL
JMP 0x00147476
LAB_00147476:
MOV AL,byte ptr [RSP + 0xf]
MOVSX EDX,AL
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x40]
XOR ECX,ECX
CALL 0x00115ec0
JMP 0x00147490
LAB_00147490:
LEA RDI,[RSP + 0x40]
CALL 0x00116070
LEA RDI,[RSP + 0x30]
CALL 0x00116080
MOV RSI,qword ptr [RSP + 0x2e8]
MOV R8D,dword ptr [RSP + 0x2d8]
MOVZX EDX,byte ptr [RSP + 0x2e7]
LAB_001474bc:
AND EDX,0x1
LEA RDI,[RSP + 0x50]
XOR R9D,R9D
MOV ECX,R9D
CALL 0x00116090
LAB_001474cf:
JMP 0x001474d1
LAB_001474d1:
MOV RAX,qword ptr [RSP + 0x2f0]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x50]
CALL 0x00117070
MOV RAX,qword ptr [RSP]
ADD RSP,0x2f8
RET
|
/* nlohmann::json_abi_v3_11_3::TEMPNAMEPLACEHOLDERVALUE(std::ostream&,
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&) */
ostream * nlohmann::json_abi_v3_11_3::operator<<(ostream *param_1,basic_json *param_2)
{
ostream *poVar1;
char cVar2;
long lVar3;
int8 local_2e0;
output_adapter<char,std::__cxx11::string> local_2c8 [16];
output_adapter local_2b8 [16];
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
local_2a8 [648];
int8 local_20;
byte local_11;
basic_json *local_10;
ostream *local_8;
local_10 = param_2;
local_8 = param_1;
lVar3 = std::ios_base::width((ios_base *)(param_1 + *(long *)(*(long *)param_1 + -0x18)));
local_11 = 0 < lVar3;
if ((bool)local_11) {
local_2e0 = std::ios_base::width((ios_base *)(local_8 + *(long *)(*(long *)local_8 + -0x18)));
}
else {
local_2e0 = 0;
}
local_20 = local_2e0;
std::ios_base::width((ios_base *)(local_8 + *(long *)(*(long *)local_8 + -0x18)),0);
detail::output_adapter<char,std::__cxx11::string>::output_adapter(local_2c8,local_8);
/* try { // try from 0014744d to 00147456 has its CatchHandler @ 001474f3 */
detail::output_adapter::operator_cast_to_shared_ptr(local_2b8);
/* try { // try from 0014746b to 0014748d has its CatchHandler @ 00147503 */
cVar2 = std::ios::fill();
detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::serializer(local_2a8,local_2b8,(int)cVar2,0);
std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>::~shared_ptr
((shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>> *)
local_2b8);
detail::output_adapter<char,std::__cxx11::string>::~output_adapter(local_2c8);
/* try { // try from 001474bc to 001474ce has its CatchHandler @ 00147527 */
detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::dump(local_2a8,local_10,(bool)(local_11 & 1),false,(uint)local_20,0);
poVar1 = local_8;
detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~serializer(local_2a8);
return poVar1;
}
|
|
18,380
|
blst_sign_pk2_in_g2
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e1.c
|
void blst_sign_pk2_in_g2(unsigned char out[96], POINTonE1_affine *sig,
const POINTonE1 *hash, const pow256 SK)
{
POINTonE1 P[1];
POINTonE1_sign(P, hash, SK);
if (sig != NULL)
vec_copy(sig, P, sizeof(*sig));
if (out != NULL) {
limb_t sgn0_pty = POINTonE1_Serialize_BE(out, P);
out[0] |= (sgn0_pty & 2) << 4; /* pre-decorate */
out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;
}
}
|
O3
|
c
|
blst_sign_pk2_in_g2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5af02
testq %r14, %r14
je 0x5b105
leaq -0xa0(%rbp), %rsi
movl $0xc, %ecx
movq %r14, %rdi
rep movsq (%rsi), %es:(%rdi)
testq %rbx, %rbx
je 0x5b133
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x5b06a
shlb $0x4, %al
andb $0x20, %al
orb %al, (%rbx)
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x70940
shlb $0x6, %al
orb %al, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
blst_sign_pk2_in_g2:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 90h
mov r14, rsi
mov rbx, rdi
lea rdi, [rbp+var_A0]
mov rsi, rdx
mov rdx, rcx
call POINTonE1_sign
test r14, r14
jz short loc_5B105
lea rsi, [rbp+var_A0]
mov ecx, 0Ch
mov rdi, r14
rep movsq
loc_5B105:
test rbx, rbx
jz short loc_5B133
lea rsi, [rbp+var_A0]
mov rdi, rbx
call POINTonE1_Serialize_BE
shl al, 4
and al, 20h
or [rbx], al
lea rdi, [rbp+var_40]
mov esi, 30h ; '0'
call vec_is_zero_16x
shl al, 6
or [rbx], al
loc_5B133:
add rsp, 90h
pop rbx
pop r14
pop rbp
retn
|
char blst_sign_pk2_in_g2(_BYTE *a1, void *a2)
{
char result; // al
_BYTE v3[96]; // [rsp+0h] [rbp-A0h] BYREF
_BYTE v4[64]; // [rsp+60h] [rbp-40h] BYREF
result = POINTonE1_sign((long long)v3);
if ( a2 )
qmemcpy(a2, v3, 0x60uLL);
if ( a1 )
{
*a1 |= (16 * POINTonE1_Serialize_BE(a1, (long long)v3)) & 0x20;
result = (unsigned __int8)vec_is_zero_16x(v4, 48LL) << 6;
*a1 |= result;
}
return result;
}
|
blst_sign_pk2_in_g2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x90
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0xa0]
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0015af02
TEST R14,R14
JZ 0x0015b105
LEA RSI,[RBP + -0xa0]
MOV ECX,0xc
MOV RDI,R14
MOVSQ.REP RDI,RSI
LAB_0015b105:
TEST RBX,RBX
JZ 0x0015b133
LEA RSI,[RBP + -0xa0]
MOV RDI,RBX
CALL 0x0015b06a
SHL AL,0x4
AND AL,0x20
OR byte ptr [RBX],AL
LEA RDI,[RBP + -0x40]
MOV ESI,0x30
CALL 0x00170940
SHL AL,0x6
OR byte ptr [RBX],AL
LAB_0015b133:
ADD RSP,0x90
POP RBX
POP R14
POP RBP
RET
|
void blst_sign_pk2_in_g2(byte *param_1,int8 *param_2,int8 param_3,int8 param_4)
{
byte bVar1;
char cVar2;
long lVar3;
int8 *puVar4;
int8 local_a8 [12];
int1 local_48 [48];
bVar1 = 0;
POINTonE1_sign(local_a8,param_3,param_4);
if (param_2 != (int8 *)0x0) {
puVar4 = local_a8;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = lVar3 + -1) {
*param_2 = *puVar4;
puVar4 = puVar4 + (ulong)bVar1 * -2 + 1;
param_2 = param_2 + (ulong)bVar1 * -2 + 1;
}
}
if (param_1 != (byte *)0x0) {
bVar1 = POINTonE1_Serialize_BE(param_1,local_a8);
*param_1 = *param_1 | (bVar1 & 2) << 4;
cVar2 = vec_is_zero_16x(local_48,0x30);
*param_1 = *param_1 | cVar2 << 6;
}
return;
}
|
|
18,381
|
unifex::_amre::async_manual_reset_event::set()
|
aimrt_mujoco_sim/_deps/libunifex-src/source/async_manual_reset_event.cpp
|
void async_manual_reset_event::set() noexcept {
void* const signalledState = this;
// replace the stack of waiting operations with a sentinel indicating we've
// been signalled
void* top = state_.exchange(signalledState, std::memory_order_acq_rel);
if (top == signalledState) {
// we were already signalled so there are no waiting operations
return;
}
// We are the first thread to set the state to signalled; iteratively pop
// the stack and complete each operation.
auto op = static_cast<_op_base*>(top);
while (op != nullptr) {
std::exchange(op, op->next_)->set_value();
}
}
|
O0
|
cpp
|
unifex::_amre::async_manual_reset_event::set():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movl $0x4, %edx
callq 0x90da0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x151355
jmp 0x151387
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x151387
movq 0x8(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1514f0
movq %rax, (%rsp)
jmp 0x15137c
movq (%rsp), %rdi
callq 0x151520
jmp 0x15135f
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x9cf00
nopw %cs:(%rax,%rax)
|
_ZN6unifex5_amre24async_manual_reset_event3setEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rdi, [rsp+28h+var_8]
mov [rsp+28h+var_10], rdi
mov rsi, [rsp+28h+var_10]
mov edx, 4
call __ZNSt6atomicIPvE8exchangeES0_St12memory_order; std::atomic<void *>::exchange(void *,std::memory_order)
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
cmp rax, [rsp+28h+var_10]
jnz short loc_151355
jmp short loc_151387
loc_151355:
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_20], rax
loc_15135F:
cmp [rsp+28h+var_20], 0
jz short loc_151387
mov rsi, [rsp+28h+var_20]
lea rdi, [rsp+28h+var_20]
call _ZSt8exchangeIPN6unifex5_amre8_op_baseERS3_ET_RS5_OT0_; std::exchange<unifex::_amre::_op_base *,unifex::_amre::_op_base *&>(unifex::_amre::_op_base *&,unifex::_amre::_op_base *&)
mov [rsp+28h+var_28], rax
jmp short $+2
loc_15137C:
mov rdi, [rsp+28h+var_28]; this
call _ZN6unifex5_amre8_op_base9set_valueEv; unifex::_amre::_op_base::set_value(void)
jmp short loc_15135F
loc_151387:
add rsp, 28h
retn
mov rdi, rax
call __clang_call_terminate
|
unifex::_amre::async_manual_reset_event * unifex::_amre::async_manual_reset_event::set(
unifex::_amre::async_manual_reset_event *this)
{
unifex::_amre::async_manual_reset_event *result; // rax
unifex::_amre::_op_base *v2; // [rsp+0h] [rbp-28h]
unifex::_amre::async_manual_reset_event *v3; // [rsp+8h] [rbp-20h] BYREF
unifex::_amre::async_manual_reset_event *v4; // [rsp+10h] [rbp-18h]
unifex::_amre::async_manual_reset_event *v5; // [rsp+18h] [rbp-10h]
unifex::_amre::async_manual_reset_event *v6; // [rsp+20h] [rbp-8h]
v6 = this;
v5 = this;
result = (unifex::_amre::async_manual_reset_event *)std::atomic<void *>::exchange(this, this, 4LL);
v4 = result;
if ( result != this )
{
result = v4;
v3 = v4;
while ( v3 )
{
v2 = (unifex::_amre::_op_base *)std::exchange<unifex::_amre::_op_base *,unifex::_amre::_op_base *&>(&v3, v3);
result = (unifex::_amre::async_manual_reset_event *)unifex::_amre::_op_base::set_value(v2);
}
}
return result;
}
| |||
18,382
|
unifex::_amre::async_manual_reset_event::set()
|
aimrt_mujoco_sim/_deps/libunifex-src/source/async_manual_reset_event.cpp
|
void async_manual_reset_event::set() noexcept {
void* const signalledState = this;
// replace the stack of waiting operations with a sentinel indicating we've
// been signalled
void* top = state_.exchange(signalledState, std::memory_order_acq_rel);
if (top == signalledState) {
// we were already signalled so there are no waiting operations
return;
}
// We are the first thread to set the state to signalled; iteratively pop
// the stack and complete each operation.
auto op = static_cast<_op_base*>(top);
while (op != nullptr) {
std::exchange(op, op->next_)->set_value();
}
}
|
O3
|
cpp
|
unifex::_amre::async_manual_reset_event::set():
movq %rdi, %rax
xchgq %rdi, (%rdi)
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x721e2
pushq %rbx
movq (%rdi), %rbx
callq *0x8(%rdi)
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x721d3
popq %rbx
retq
nop
|
_ZN6unifex5_amre24async_manual_reset_event3setEv:
mov rax, rdi
xchg rdi, [rdi]
cmp rdi, rax
setz al
test rdi, rdi
setz cl
or cl, al
jnz short locret_721E2
push rbx
loc_721D3:
mov rbx, [rdi]
call qword ptr [rdi+8]
mov rdi, rbx
test rbx, rbx
jnz short loc_721D3
pop rbx
locret_721E2:
retn
|
unsigned __int8 unifex::_amre::async_manual_reset_event::set(unifex::_amre::async_manual_reset_event *this)
{
unifex::_amre::async_manual_reset_event *v2; // rdi
unsigned __int8 result; // al
unifex::_amre::async_manual_reset_event *v4; // rbx
v2 = (unifex::_amre::async_manual_reset_event *)_InterlockedExchange64((volatile long long *)this, (long long)this);
result = v2 == this;
if ( !(result | (v2 == 0LL)) )
{
do
{
v4 = *(unifex::_amre::async_manual_reset_event **)v2;
result = (*((long long (**)(void))v2 + 1))();
v2 = v4;
}
while ( v4 );
}
return result;
}
|
set:
MOV RAX,RDI
XCHG qword ptr [RDI],RDI
CMP RDI,RAX
SETZ AL
TEST RDI,RDI
SETZ CL
OR CL,AL
JNZ 0x001721e2
PUSH RBX
LAB_001721d3:
MOV RBX,qword ptr [RDI]
CALL qword ptr [RDI + 0x8]
MOV RDI,RBX
TEST RBX,RBX
JNZ 0x001721d3
POP RBX
LAB_001721e2:
RET
|
/* unifex::_amre::async_manual_reset_event::set() */
void __thiscall unifex::_amre::async_manual_reset_event::set(async_manual_reset_event *this)
{
async_manual_reset_event *paVar1;
async_manual_reset_event *paVar2;
LOCK();
paVar2 = *(async_manual_reset_event **)this;
*(async_manual_reset_event **)this = this;
UNLOCK();
if (paVar2 != (async_manual_reset_event *)0x0 && paVar2 != this) {
do {
paVar1 = *(async_manual_reset_event **)paVar2;
(**(code **)(paVar2 + 8))();
paVar2 = paVar1;
} while (paVar1 != (async_manual_reset_event *)0x0);
}
return;
}
|
|
18,383
|
my_strntol_8bit
|
eloqsql/strings/ctype-simple.c
|
long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O0
|
c
|
my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x6d(%rbp)
jae 0x53ee8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x50(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x53ef1
jmp 0x53f01
jmp 0x53ef3
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x53eb9
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x53f10
jmp 0x54105
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x53f31
movl $0x1, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x53f5b
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x53f52
movl $0x0, -0x3c(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x53f59
movl $0x0, -0x3c(%rbp)
jmp 0x53f5b
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x40(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x44(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb (%rax), %al
movb %al, -0x51(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x54065
movzbl -0x51(%rbp), %eax
cmpl $0x30, %eax
jl 0x53fc0
movzbl -0x51(%rbp), %eax
cmpl $0x39, %eax
jg 0x53fc0
movzbl -0x51(%rbp), %eax
subl $0x30, %eax
movb %al, -0x51(%rbp)
jmp 0x54008
movzbl -0x51(%rbp), %eax
cmpl $0x41, %eax
jl 0x53fe1
movzbl -0x51(%rbp), %eax
cmpl $0x5a, %eax
jg 0x53fe1
movzbl -0x51(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x54006
movzbl -0x51(%rbp), %eax
cmpl $0x61, %eax
jl 0x54002
movzbl -0x51(%rbp), %eax
cmpl $0x7a, %eax
jg 0x54002
movzbl -0x51(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x51(%rbp)
jmp 0x54004
jmp 0x54065
jmp 0x54006
jmp 0x54008
movzbl -0x51(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x54013
jmp 0x54065
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
ja 0x5402c
movl -0x48(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x54035
movzbl -0x51(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x54035
movl $0x1, -0x6c(%rbp)
jmp 0x54049
movl -0x24(%rbp), %eax
imull -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
movzbl -0x51(%rbp), %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x5404b
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb 0x1(%rax), %al
movb %al, -0x51(%rbp)
jmp 0x53f94
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
jne 0x54074
jmp 0x54105
cmpq $0x0, -0x30(%rbp)
je 0x54086
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
je 0x5409e
cmpl $0x80000000, -0x48(%rbp) # imm = 0x80000000
jbe 0x5409c
movl $0x1, -0x6c(%rbp)
jmp 0x540b2
movl -0x48(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x540b0
movl $0x1, -0x6c(%rbp)
jmp 0x540b2
cmpl $0x0, -0x6c(%rbp)
je 0x540de
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x54129
cmpl $0x0, -0x3c(%rbp)
je 0x540f4
movl -0x48(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x78(%rbp)
jmp 0x540fb
movl -0x48(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x54129
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x54121
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
|
my_strntol_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_53EB9:
mov rcx, [rbp+var_50]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_6D], al
jnb short loc_53EE8
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_50]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_6D], al
loc_53EE8:
mov al, [rbp+var_6D]
test al, 1
jnz short loc_53EF1
jmp short loc_53F01
loc_53EF1:
jmp short $+2
loc_53EF3:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_53EB9
loc_53F01:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jnz short loc_53F10
jmp loc_54105
loc_53F10:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_53F31
mov [rbp+var_3C], 1
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_53F5B
loc_53F31:
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_53F52
mov [rbp+var_3C], 0
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp short loc_53F59
loc_53F52:
mov [rbp+var_3C], 0
loc_53F59:
jmp short $+2
loc_53F5B:
mov rax, [rbp+var_50]
mov [rbp+var_60], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_40], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_44], edx
mov [rbp+var_6C], 0
mov [rbp+var_48], 0
mov rax, [rbp+var_50]
mov al, [rax]
mov [rbp+var_51], al
loc_53F94:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_68]
jz loc_54065
movzx eax, [rbp+var_51]
cmp eax, 30h ; '0'
jl short loc_53FC0
movzx eax, [rbp+var_51]
cmp eax, 39h ; '9'
jg short loc_53FC0
movzx eax, [rbp+var_51]
sub eax, 30h ; '0'
mov [rbp+var_51], al
jmp short loc_54008
loc_53FC0:
movzx eax, [rbp+var_51]
cmp eax, 41h ; 'A'
jl short loc_53FE1
movzx eax, [rbp+var_51]
cmp eax, 5Ah ; 'Z'
jg short loc_53FE1
movzx eax, [rbp+var_51]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_54006
loc_53FE1:
movzx eax, [rbp+var_51]
cmp eax, 61h ; 'a'
jl short loc_54002
movzx eax, [rbp+var_51]
cmp eax, 7Ah ; 'z'
jg short loc_54002
movzx eax, [rbp+var_51]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_51], al
jmp short loc_54004
loc_54002:
jmp short loc_54065
loc_54004:
jmp short $+2
loc_54006:
jmp short $+2
loc_54008:
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_24]
jl short loc_54013
jmp short loc_54065
loc_54013:
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
ja short loc_5402C
mov eax, [rbp+var_48]
cmp eax, [rbp+var_40]
jnz short loc_54035
movzx eax, [rbp+var_51]
cmp eax, [rbp+var_44]
jbe short loc_54035
loc_5402C:
mov [rbp+var_6C], 1
jmp short loc_54049
loc_54035:
mov eax, [rbp+var_24]
imul eax, [rbp+var_48]
mov [rbp+var_48], eax
movzx eax, [rbp+var_51]
add eax, [rbp+var_48]
mov [rbp+var_48], eax
loc_54049:
jmp short $+2
loc_5404B:
mov rax, [rbp+var_50]
mov rcx, rax
add rcx, 1
mov [rbp+var_50], rcx
mov al, [rax+1]
mov [rbp+var_51], al
jmp loc_53F94
loc_54065:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_60]
jnz short loc_54074
jmp loc_54105
loc_54074:
cmp [rbp+var_30], 0
jz short loc_54086
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_54086:
cmp [rbp+var_3C], 0
jz short loc_5409E
cmp [rbp+var_48], 80000000h
jbe short loc_5409C
mov [rbp+var_6C], 1
loc_5409C:
jmp short loc_540B2
loc_5409E:
mov eax, [rbp+var_48]
cmp rax, 7FFFFFFFh
jle short loc_540B0
mov [rbp+var_6C], 1
loc_540B0:
jmp short $+2
loc_540B2:
cmp [rbp+var_6C], 0
jz short loc_540DE
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_54129
loc_540DE:
cmp [rbp+var_3C], 0
jz short loc_540F4
mov eax, [rbp+var_48]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_78], rax
jmp short loc_540FB
loc_540F4:
mov eax, [rbp+var_48]
mov [rbp+var_78], rax
loc_540FB:
mov rax, [rbp+var_78]
mov [rbp+var_8], rax
jmp short loc_54129
loc_54105:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_54121
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_54121:
mov [rbp+var_8], 0
loc_54129:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long my_strntol_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
_BYTE *v6; // rax
long long v7; // rax
bool v10; // [rsp+Bh] [rbp-6Dh]
int v11; // [rsp+Ch] [rbp-6Ch]
_BYTE *v12; // [rsp+10h] [rbp-68h]
_BYTE *v13; // [rsp+18h] [rbp-60h]
unsigned __int8 v14; // [rsp+27h] [rbp-51h]
unsigned __int8 v15; // [rsp+27h] [rbp-51h]
_BYTE *v16; // [rsp+28h] [rbp-50h]
unsigned int v17; // [rsp+30h] [rbp-48h]
unsigned long long v18; // [rsp+34h] [rbp-44h]
int v19; // [rsp+3Ch] [rbp-3Ch]
*a6 = 0;
v16 = a2;
v12 = &a2[a3];
while ( 1 )
{
v10 = 0;
if ( v16 < v12 )
v10 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v16 + 1LL) & 8) != 0;
if ( !v10 )
break;
++v16;
}
if ( v16 == v12 )
goto LABEL_45;
if ( *v16 == 45 )
{
v19 = 1;
++v16;
}
else
{
v19 = 0;
if ( *v16 == 43 )
++v16;
}
v13 = v16;
v11 = 0;
v17 = 0;
v14 = *v16;
while ( v16 != v12 )
{
if ( v14 < 0x30u || v14 > 0x39u )
{
if ( v14 < 0x41u || v14 > 0x5Au )
{
if ( v14 < 0x61u || v14 > 0x7Au )
break;
v15 = v14 - 97 + 10;
}
else
{
v15 = v14 - 65 + 10;
}
}
else
{
v15 = v14 - 48;
}
if ( v15 >= a4 )
break;
LODWORD(v18) = 0xFFFFFFFF % a4;
HIDWORD(v18) = 0xFFFFFFFF / a4;
if ( __PAIR64__(v17, v15) <= v18 )
v17 = v17 * a4 + v15;
else
v11 = 1;
v6 = v16++;
v14 = v6[1];
}
if ( v16 == v13 )
{
LABEL_45:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v16;
if ( v19 )
{
if ( v17 > 0x80000000 )
v11 = 1;
}
else if ( v17 > 0x7FFFFFFFuLL )
{
v11 = 1;
}
if ( v11 )
{
*a6 = 34;
v7 = 0x7FFFFFFFLL;
if ( v19 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v19 )
{
return -(long long)v17;
}
else
{
return v17;
}
}
}
|
my_strntol_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
LAB_00153eb9:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x6d],AL
JNC 0x00153ee8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x6d],AL
LAB_00153ee8:
MOV AL,byte ptr [RBP + -0x6d]
TEST AL,0x1
JNZ 0x00153ef1
JMP 0x00153f01
LAB_00153ef1:
JMP 0x00153ef3
LAB_00153ef3:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00153eb9
LAB_00153f01:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x00153f10
JMP 0x00154105
LAB_00153f10:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00153f31
MOV dword ptr [RBP + -0x3c],0x1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00153f5b
LAB_00153f31:
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x00153f52
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00153f59
LAB_00153f52:
MOV dword ptr [RBP + -0x3c],0x0
LAB_00153f59:
JMP 0x00153f5b
LAB_00153f5b:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x6c],0x0
MOV dword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x51],AL
LAB_00153f94:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x68]
JZ 0x00154065
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x30
JL 0x00153fc0
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x39
JG 0x00153fc0
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x30
MOV byte ptr [RBP + -0x51],AL
JMP 0x00154008
LAB_00153fc0:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x41
JL 0x00153fe1
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x5a
JG 0x00153fe1
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x41
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00154006
LAB_00153fe1:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x61
JL 0x00154002
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,0x7a
JG 0x00154002
MOVZX EAX,byte ptr [RBP + -0x51]
SUB EAX,0x61
ADD EAX,0xa
MOV byte ptr [RBP + -0x51],AL
JMP 0x00154004
LAB_00154002:
JMP 0x00154065
LAB_00154004:
JMP 0x00154006
LAB_00154006:
JMP 0x00154008
LAB_00154008:
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00154013
JMP 0x00154065
LAB_00154013:
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JA 0x0015402c
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x40]
JNZ 0x00154035
MOVZX EAX,byte ptr [RBP + -0x51]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x00154035
LAB_0015402c:
MOV dword ptr [RBP + -0x6c],0x1
JMP 0x00154049
LAB_00154035:
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
MOVZX EAX,byte ptr [RBP + -0x51]
ADD EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
LAB_00154049:
JMP 0x0015404b
LAB_0015404b:
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x50],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x51],AL
JMP 0x00153f94
LAB_00154065:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x60]
JNZ 0x00154074
JMP 0x00154105
LAB_00154074:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00154086
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00154086:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0015409e
CMP dword ptr [RBP + -0x48],0x80000000
JBE 0x0015409c
MOV dword ptr [RBP + -0x6c],0x1
LAB_0015409c:
JMP 0x001540b2
LAB_0015409e:
MOV EAX,dword ptr [RBP + -0x48]
CMP RAX,0x7fffffff
JLE 0x001540b0
MOV dword ptr [RBP + -0x6c],0x1
LAB_001540b0:
JMP 0x001540b2
LAB_001540b2:
CMP dword ptr [RBP + -0x6c],0x0
JZ 0x001540de
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,0x7fffffff
MOV RCX,-0x80000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00154129
LAB_001540de:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x001540f4
MOV EAX,dword ptr [RBP + -0x48]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x78],RAX
JMP 0x001540fb
LAB_001540f4:
MOV EAX,dword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x78],RAX
LAB_001540fb:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00154129
LAB_00154105:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00154121
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00154121:
MOV qword ptr [RBP + -0x8],0x0
LAB_00154129:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,int8 *param_5,
int4 *param_6)
{
bool bVar1;
byte *pbVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
ulong local_80;
byte local_59;
byte *local_58;
uint local_50;
*param_6 = 0;
pbVar4 = param_2 + param_3;
local_58 = param_2;
while( true ) {
bVar5 = false;
if (local_58 < pbVar4) {
bVar5 = (*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_58) & 8) != 0;
}
if (!bVar5) break;
local_58 = local_58 + 1;
}
if (local_58 != pbVar4) {
if (*local_58 == 0x2d) {
bVar5 = true;
local_58 = local_58 + 1;
}
else {
if (*local_58 == 0x2b) {
local_58 = local_58 + 1;
}
bVar5 = false;
}
pbVar2 = local_58;
uVar3 = (uint)(0xffffffff / (ulong)param_4);
bVar1 = false;
local_50 = 0;
local_59 = *local_58;
for (; local_58 != pbVar4; local_58 = local_58 + 1) {
if ((local_59 < 0x30) || (0x39 < local_59)) {
if ((local_59 < 0x41) || (0x5a < local_59)) {
if ((local_59 < 0x61) || (0x7a < local_59)) break;
local_59 = local_59 + 0xa9;
}
else {
local_59 = local_59 - 0x37;
}
}
else {
local_59 = local_59 - 0x30;
}
if ((int)param_4 <= (int)(uint)local_59) break;
if ((uVar3 < local_50) ||
((local_50 == uVar3 && ((uint)(0xffffffff % (ulong)param_4) < (uint)local_59)))) {
bVar1 = true;
}
else {
local_50 = (uint)local_59 + param_4 * local_50;
}
local_59 = local_58[1];
}
if (local_58 != pbVar2) {
if (param_5 != (int8 *)0x0) {
*param_5 = local_58;
}
if (bVar5) {
if (0x80000000 < local_50) {
bVar1 = true;
}
}
else if (0x7fffffff < local_50) {
bVar1 = true;
}
if (bVar1) {
*param_6 = 0x22;
if (!bVar5) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar5) {
local_80 = -(ulong)local_50;
}
else {
local_80 = (ulong)local_50;
}
return local_80;
}
}
*param_6 = 0x21;
if (param_5 != (int8 *)0x0) {
*param_5 = param_2;
}
return 0;
}
|
|
18,384
|
my_strntol_8bit
|
eloqsql/strings/ctype-simple.c
|
long my_strntol_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register uint32 cutoff;
register uint cutlim;
register uint32 i;
register const char *s;
register uchar c;
const char *save, *e;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for ( ; s<e && my_isspace(cs, *s) ; s++);
if (s == e)
{
goto noconv;
}
/* Check for a sign. */
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = ((uint32)~0L) / (uint32) base;
cutlim = (uint) (((uint32)~0L) % (uint32) base);
overflow = 0;
i = 0;
for (c = *s; s != e; c = *++s)
{
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (uint32) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (negative)
{
if (i > (uint32) INT_MIN32)
overflow = 1;
}
else if (i > INT_MAX32)
overflow = 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) i) : (long) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O3
|
c
|
my_strntol_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x3f18b
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x3f18b
incq %r10
cmpq %r11, %r10
jb 0x3f178
cmpq %r11, %r10
je 0x3f290
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl %ecx
xorl %ebx, %ebx
cmpq %r11, %r10
je 0x3f23c
movq %rdi, -0x30(%rbp)
xorl %r12d, %r12d
movq %r10, %r14
xorl %r13d, %r13d
movl %r13d, %ebx
movl %r12d, %r15d
movb (%r14), %r12b
leal -0x30(%r12), %edi
cmpb $0xa, %dil
jb 0x3f1fa
leal -0x41(%r12), %edi
cmpb $0x19, %dil
ja 0x3f1e8
addb $-0x37, %r12b
jmp 0x3f1f7
leal -0x61(%r12), %edi
cmpb $0x19, %dil
ja 0x3f236
addb $-0x57, %r12b
movl %r12d, %edi
movzbl %dil, %edi
cmpl %ecx, %edi
jge 0x3f236
movl $0x1, %r12d
cmpl %eax, %ebx
jbe 0x3f211
movl %ebx, %r13d
jmp 0x3f225
jne 0x3f21a
movl %eax, %r13d
cmpl %edi, %edx
jb 0x3f225
imull %ecx, %ebx
addl %edi, %ebx
movl %ebx, %r13d
movl %r15d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x3f1c3
movl %r13d, %ebx
movq %r11, %r14
movl %r12d, %r15d
movq -0x30(%rbp), %rdi
jmp 0x3f242
movq %r11, %r14
xorl %r15d, %r15d
cmpq %r10, %r14
je 0x3f290
testq %r8, %r8
je 0x3f24f
movq %r14, (%r8)
cmpl $0x80000001, %ebx # imm = 0x80000001
movl $0x1, %eax
movl %r15d, %ecx
cmovael %eax, %ecx
testl %ebx, %ebx
cmovsl %eax, %r15d
cmpb $0x2d, %dil
cmovel %ecx, %r15d
testl %r15d, %r15d
je 0x3f2ac
cmpb $0x2d, %dil
movl $0x22, (%r9)
movq $-0x80000000, %rcx # imm = 0x80000000
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmoveq %rcx, %rax
jmp 0x3f2a1
movl $0x21, (%r9)
testq %r8, %r8
je 0x3f29f
movq %rsi, (%r8)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %ecx
movq %rcx, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %rcx, %rax
jmp 0x3f2a1
|
my_strntol_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_3F18B
mov rax, [rdi+40h]
mov r10, rsi
loc_3F178:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_3F18B
inc r10
cmp r10, r11
jb short loc_3F178
loc_3F18B:
cmp r10, r11
jz loc_3F290
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
mov eax, 0FFFFFFFFh
xor edx, edx
div ecx
xor ebx, ebx
cmp r10, r11
jz loc_3F23C
mov [rbp+var_30], rdi
xor r12d, r12d
mov r14, r10
xor r13d, r13d
loc_3F1C3:
mov ebx, r13d
mov r15d, r12d
mov r12b, [r14]
lea edi, [r12-30h]
cmp dil, 0Ah
jb short loc_3F1FA
lea edi, [r12-41h]
cmp dil, 19h
ja short loc_3F1E8
add r12b, 0C9h
jmp short loc_3F1F7
loc_3F1E8:
lea edi, [r12-61h]
cmp dil, 19h
ja short loc_3F236
add r12b, 0A9h
loc_3F1F7:
mov edi, r12d
loc_3F1FA:
movzx edi, dil
cmp edi, ecx
jge short loc_3F236
mov r12d, 1
cmp ebx, eax
jbe short loc_3F211
mov r13d, ebx
jmp short loc_3F225
loc_3F211:
jnz short loc_3F21A
mov r13d, eax
cmp edx, edi
jb short loc_3F225
loc_3F21A:
imul ebx, ecx
add ebx, edi
mov r13d, ebx
mov r12d, r15d
loc_3F225:
inc r14
cmp r14, r11
jnz short loc_3F1C3
mov ebx, r13d
mov r14, r11
mov r15d, r12d
loc_3F236:
mov rdi, [rbp+var_30]
jmp short loc_3F242
loc_3F23C:
mov r14, r11
xor r15d, r15d
loc_3F242:
cmp r14, r10
jz short loc_3F290
test r8, r8
jz short loc_3F24F
mov [r8], r14
loc_3F24F:
cmp ebx, 80000001h
mov eax, 1
mov ecx, r15d
cmovnb ecx, eax
test ebx, ebx
cmovs r15d, eax
cmp dil, 2Dh ; '-'
cmovz r15d, ecx
test r15d, r15d
jz short loc_3F2AC
cmp dil, 2Dh ; '-'
mov dword ptr [r9], 22h ; '"'
mov rcx, 0FFFFFFFF80000000h
mov eax, 7FFFFFFFh
cmovz rax, rcx
jmp short loc_3F2A1
loc_3F290:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_3F29F
mov [r8], rsi
loc_3F29F:
xor eax, eax
loc_3F2A1:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F2AC:
mov ecx, ebx
mov rax, rcx
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, rcx
jmp short loc_3F2A1
|
long long my_strntol_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned int v10; // eax
unsigned int v11; // ebx
int v12; // r12d
unsigned __int8 *v13; // r14
unsigned int v14; // r13d
int v15; // r15d
unsigned __int8 v16; // r12
unsigned __int8 v17; // di
unsigned __int8 v18; // r12
int v19; // ecx
long long result; // rax
unsigned __int8 v21; // [rsp+0h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_36;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFF / a4;
v11 = 0;
if ( v9 == v6 )
{
v13 = &a2[a3];
v15 = 0;
}
else
{
v21 = v8;
v12 = 0;
v13 = v9;
v14 = 0;
while ( 1 )
{
v11 = v14;
v15 = v12;
v16 = *v13;
v17 = *v13 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= (int)a4 )
break;
v12 = 1;
if ( v14 <= v10 )
{
if ( v14 != v10 || (v14 = 0xFFFFFFFF / a4, 0xFFFFFFFF % a4 >= v17) )
{
v14 = v17 + a4 * v11;
v12 = v15;
}
}
if ( ++v13 == v6 )
{
v11 = v14;
v13 = &a2[a3];
v15 = v12;
break;
}
}
v8 = v21;
}
if ( v13 == v9 )
{
LABEL_36:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v13;
v19 = v15;
if ( v11 >= 0x80000001 )
v19 = 1;
if ( (v11 & 0x80000000) != 0 )
v15 = 1;
if ( v8 == 45 )
v15 = v19;
if ( v15 )
{
*a6 = 34;
result = 0x7FFFFFFFLL;
if ( v8 == 45 )
return 0xFFFFFFFF80000000LL;
}
else
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
}
return result;
}
|
my_strntol_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x0013f18b
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_0013f178:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x0013f18b
INC R10
CMP R10,R11
JC 0x0013f178
LAB_0013f18b:
CMP R10,R11
JZ 0x0013f290
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOV EAX,0xffffffff
XOR EDX,EDX
DIV ECX
XOR EBX,EBX
CMP R10,R11
JZ 0x0013f23c
MOV qword ptr [RBP + -0x30],RDI
XOR R12D,R12D
MOV R14,R10
XOR R13D,R13D
LAB_0013f1c3:
MOV EBX,R13D
MOV R15D,R12D
MOV R12B,byte ptr [R14]
LEA EDI,[R12 + -0x30]
CMP DIL,0xa
JC 0x0013f1fa
LEA EDI,[R12 + -0x41]
CMP DIL,0x19
JA 0x0013f1e8
ADD R12B,0xc9
JMP 0x0013f1f7
LAB_0013f1e8:
LEA EDI,[R12 + -0x61]
CMP DIL,0x19
JA 0x0013f236
ADD R12B,0xa9
LAB_0013f1f7:
MOV EDI,R12D
LAB_0013f1fa:
MOVZX EDI,DIL
CMP EDI,ECX
JGE 0x0013f236
MOV R12D,0x1
CMP EBX,EAX
JBE 0x0013f211
MOV R13D,EBX
JMP 0x0013f225
LAB_0013f211:
JNZ 0x0013f21a
MOV R13D,EAX
CMP EDX,EDI
JC 0x0013f225
LAB_0013f21a:
IMUL EBX,ECX
ADD EBX,EDI
MOV R13D,EBX
MOV R12D,R15D
LAB_0013f225:
INC R14
CMP R14,R11
JNZ 0x0013f1c3
MOV EBX,R13D
MOV R14,R11
MOV R15D,R12D
LAB_0013f236:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0013f242
LAB_0013f23c:
MOV R14,R11
XOR R15D,R15D
LAB_0013f242:
CMP R14,R10
JZ 0x0013f290
TEST R8,R8
JZ 0x0013f24f
MOV qword ptr [R8],R14
LAB_0013f24f:
CMP EBX,0x80000001
MOV EAX,0x1
MOV ECX,R15D
CMOVNC ECX,EAX
TEST EBX,EBX
CMOVS R15D,EAX
CMP DIL,0x2d
CMOVZ R15D,ECX
TEST R15D,R15D
JZ 0x0013f2ac
CMP DIL,0x2d
MOV dword ptr [R9],0x22
MOV RCX,-0x80000000
MOV EAX,0x7fffffff
CMOVZ RAX,RCX
JMP 0x0013f2a1
LAB_0013f290:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x0013f29f
MOV qword ptr [R8],RSI
LAB_0013f29f:
XOR EAX,EAX
LAB_0013f2a1:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f2ac:
MOV ECX,EBX
MOV RAX,RCX
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,RCX
JMP 0x0013f2a1
|
ulong my_strntol_8bit(long param_1,byte *param_2,long param_3,uint param_4,ulong *param_5,
int4 *param_6)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
bool bVar4;
bool bVar5;
uint uVar6;
uint uVar7;
byte *pbVar8;
byte bVar9;
uint uVar10;
byte *pbVar11;
byte *pbVar12;
*param_6 = 0;
pbVar1 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar1);
}
if (pbVar8 != pbVar1) {
bVar2 = *pbVar8;
pbVar8 = pbVar8 + ((bVar2 - 0x2b & 0xfd) == 0);
uVar10 = 0;
if (pbVar8 == pbVar1) {
bVar4 = false;
pbVar12 = pbVar1;
}
else {
bVar4 = false;
uVar10 = 0;
pbVar11 = pbVar8;
do {
bVar3 = *pbVar11;
bVar9 = bVar3 - 0x30;
pbVar12 = pbVar11;
if (9 < bVar9) {
if ((byte)(bVar3 + 0xbf) < 0x1a) {
bVar9 = bVar3 - 0x37;
}
else {
if (0x19 < (byte)(bVar3 + 0x9f)) break;
bVar9 = bVar3 + 0xa9;
}
}
if ((int)param_4 <= (int)(uint)bVar9) break;
uVar7 = (uint)(0xffffffff / (ulong)param_4);
uVar6 = uVar10;
bVar5 = true;
if ((uVar10 <= uVar7) &&
((uVar10 != uVar7 || (uVar6 = uVar7, (uint)bVar9 <= (uint)(0xffffffff % (ulong)param_4)))
)) {
uVar6 = uVar10 * param_4 + (uint)bVar9;
bVar5 = bVar4;
}
bVar4 = bVar5;
uVar10 = uVar6;
pbVar11 = pbVar11 + 1;
pbVar12 = pbVar1;
} while (pbVar11 != pbVar1);
}
if (pbVar12 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar12;
}
bVar5 = bVar4;
if (0x80000000 < uVar10) {
bVar5 = true;
}
if ((int)uVar10 < 0) {
bVar4 = true;
}
if (bVar2 == 0x2d) {
bVar4 = bVar5;
}
if (bVar4) {
*param_6 = 0x22;
if (bVar2 != 0x2d) {
return 0x7fffffff;
}
return 0xffffffff80000000;
}
if (bVar2 == 0x2d) {
return -(ulong)uVar10;
}
return (ulong)uVar10;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
|
|
18,385
|
my_setwd
|
eloqsql/mysys/my_getwd.c
|
int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
}
|
O0
|
c
|
my_setwd:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x35d82
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x35dac
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x35db7
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x35db7
leaq 0xb9d34(%rip), %rax # 0xefae7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29510
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x35e10
callq 0x29040
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0x38d10
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x35e0e
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x29040
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x11, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x315c0
jmp 0x35e85
movq -0x28(%rbp), %rdi
callq 0x35ea0
cmpl $0x0, %eax
je 0x35e79
movq -0x28(%rbp), %rsi
leaq 0x3c8fa7(%rip), %rdi # 0x3fedd0
movl $0x1ff, %edx # imm = 0x1FF
callq 0x86440
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x35e77
movq -0x30(%rbp), %rax
leaq 0x3c8f81(%rip), %rcx # 0x3fedd0
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x3c8f6d(%rip), %rax # 0x3fedd0
movb $0x2f, (%rax,%rcx)
movq -0x20(%rbp), %rcx
leaq 0x3c8f5e(%rip), %rax # 0x3fedd0
movb $0x0, 0x1(%rax,%rcx)
jmp 0x35e83
leaq 0x3c8f50(%rip), %rax # 0x3fedd0
movb $0x0, (%rax)
jmp 0x35e85
jmp 0x35e87
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_setwd:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_35D82:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz short loc_35DAC
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_35DB7
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax+1]
cmp eax, 0
jnz short loc_35DB7
loc_35DAC:
lea rax, word_EFAE7
mov [rbp+var_8], rax
loc_35DB7:
mov rdi, [rbp+var_8]
call _chdir
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_35E10
call ___errno_location
mov eax, [rax]
mov [rbp+var_34], eax
call _my_thread_var
mov ecx, [rbp+var_34]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_35E0E
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 11h
mov esi, 4
mov al, 0
call my_error
loc_35E0E:
jmp short loc_35E85
loc_35E10:
mov rdi, [rbp+var_28]
call test_if_hard_path
cmp eax, 0
jz short loc_35E79
mov rsi, [rbp+var_28]
lea rdi, curr_dir
mov edx, 1FFh
call strmake
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_35E77
mov rax, [rbp+var_30]
lea rcx, curr_dir
sub rax, rcx
mov eax, eax
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx], 2Fh ; '/'
mov rcx, [rbp+var_20]
lea rax, curr_dir
mov byte ptr [rax+rcx+1], 0
loc_35E77:
jmp short loc_35E83
loc_35E79:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_35E83:
jmp short $+2
loc_35E85:
jmp short $+2
loc_35E87:
mov eax, [rbp+var_14]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long my_setwd(__int16 *a1, char a2, double a3)
{
unsigned int *v3; // rax
int v5; // [rsp+1Ch] [rbp-34h]
long long v6; // [rsp+20h] [rbp-30h]
unsigned int v7; // [rsp+3Ch] [rbp-14h]
__int16 *v8; // [rsp+48h] [rbp-8h]
v8 = a1;
if ( !*(_BYTE *)a1 || *(_BYTE *)a1 == 47 && !*((_BYTE *)a1 + 1) )
v8 = &word_EFAE7;
v7 = chdir(v8);
if ( v7 )
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a3) = v5;
if ( (a2 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x11u, 4LL, a1, *v3);
}
}
else if ( (unsigned int)test_if_hard_path(a1) )
{
v6 = strmake(curr_dir, a1, 511LL);
if ( *(_BYTE *)(v6 - 1) != 47 )
{
curr_dir[(unsigned int)(v6 - (_QWORD)curr_dir)] = 47;
curr_dir[(unsigned int)(v6 - (_QWORD)curr_dir) + 1] = 0;
}
}
else
{
curr_dir[0] = 0;
}
return v7;
}
|
my_setwd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00135d82
LAB_00135d82:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x00135dac
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x00135db7
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x0
JNZ 0x00135db7
LAB_00135dac:
LEA RAX,[0x1efae7]
MOV qword ptr [RBP + -0x8],RAX
LAB_00135db7:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00129510
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x00135e10
CALL 0x00129040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
CALL 0x00138d10
MOV ECX,dword ptr [RBP + -0x34]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x00135e0e
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00129040
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x11
MOV ESI,0x4
MOV AL,0x0
CALL 0x001315c0
LAB_00135e0e:
JMP 0x00135e85
LAB_00135e10:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00135ea0
CMP EAX,0x0
JZ 0x00135e79
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[0x4fedd0]
MOV EDX,0x1ff
CALL 0x00186440
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x00135e77
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x4fedd0]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4fedd0]
MOV byte ptr [RAX + RCX*0x1],0x2f
MOV RCX,qword ptr [RBP + -0x20]
LEA RAX,[0x4fedd0]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_00135e77:
JMP 0x00135e83
LAB_00135e79:
LEA RAX,[0x4fedd0]
MOV byte ptr [RAX],0x0
LAB_00135e83:
JMP 0x00135e85
LAB_00135e85:
JMP 0x00135e87
LAB_00135e87:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
uint uVar3;
int *piVar4;
long lVar5;
char *local_10;
if ((*param_1 == '\0') || ((local_10 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
local_10 = "/";
}
iVar1 = chdir(local_10);
if (iVar1 == 0) {
iVar2 = test_if_hard_path(param_1);
if (iVar2 == 0) {
curr_dir = 0;
}
else {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) != '/') {
uVar3 = (int)lVar5 - 0x4fedd0;
(&curr_dir)[uVar3] = 0x2f;
(&DAT_004fedd1)[uVar3] = 0;
}
}
}
else {
piVar4 = __errno_location();
iVar2 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar2;
if ((param_2 & 0x10) != 0) {
piVar4 = __errno_location();
my_error(0x11,4,param_1,*piVar4);
}
}
return iVar1;
}
|
|
18,386
|
CLI::App::_trigger_pre_parse(unsigned long)
|
MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/impl/App_inl.hpp
|
CLI11_INLINE void App::_trigger_pre_parse(std::size_t remaining_args) {
if(!pre_parse_called_) {
pre_parse_called_ = true;
if(pre_parse_callback_) {
pre_parse_callback_(remaining_args);
}
} else if(immediate_callback_) {
if(!name_.empty()) {
auto pcnt = parsed_;
auto extras = std::move(missing_);
clear();
parsed_ = pcnt;
pre_parse_called_ = true;
missing_ = std::move(extras);
}
}
}
|
O1
|
cpp
|
CLI::App::_trigger_pre_parse(unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x4e(%rdi)
je 0x1eac1
cmpb $0x1, 0x4f(%rbx)
jne 0x1eade
cmpq $0x0, 0x10(%rbx)
je 0x1eade
movl 0x2a4(%rbx), %ebp
movq 0x178(%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x180(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x188(%rbx), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x178(%rbx)
movq $0x0, 0x188(%rbx)
movq %rbx, %rdi
callq 0x1e1bc
movl %ebp, 0x2a4(%rbx)
movb $0x1, 0x4e(%rbx)
leaq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x178(%rbx), %rax
movups 0x180(%rbx), %xmm0
leaq 0x8(%rsp), %r14
movq (%r14), %rcx
movq %rcx, 0x178(%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x180(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x188(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r14)
movq %rdx, 0x8(%r14)
movq %rsi, 0x10(%r14)
callq 0x19366
movq %r14, %rdi
callq 0x19366
jmp 0x1eade
movb $0x1, 0x4e(%rbx)
cmpq $0x0, 0x60(%rbx)
je 0x1eade
leaq 0x50(%rbx), %rdi
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq *0x68(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x19366
movq %rbx, %rdi
callq 0x7780
|
_ZN3CLI3App18_trigger_pre_parseEm:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
cmp byte ptr [rdi+4Eh], 0
jz loc_1EAC1
cmp byte ptr [rbx+4Fh], 1
jnz loc_1EADE
cmp qword ptr [rbx+10h], 0
jz loc_1EADE
mov ebp, [rbx+2A4h]
mov rax, [rbx+178h]
mov [rsp+58h+var_50], rax
mov rax, [rbx+180h]
mov [rsp+58h+var_48], rax
mov rax, [rbx+188h]
mov [rsp+58h+var_40], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+178h], xmm0
mov qword ptr [rbx+188h], 0
mov rdi, rbx; this
call _ZN3CLI3App5clearEv; CLI::App::clear(void)
mov [rbx+2A4h], ebp
mov byte ptr [rbx+4Eh], 1
lea rdi, [rsp+58h+var_38]
xorps xmm0, xmm0
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+178h]
movups xmm0, xmmword ptr [rbx+180h]
lea r14, [rsp+58h+var_50]
mov rcx, [r14]
mov [rbx+178h], rcx
mov rcx, [r14+8]
mov [rbx+180h], rcx
mov rcx, [r14+10h]
mov [rbx+188h], rcx
mov rcx, [rdi]
mov rdx, [rdi+8]
mov rsi, [rdi+10h]
mov [rdi], rax
movups xmmword ptr [rdi+8], xmm0
mov [r14], rcx
mov [r14+8], rdx
mov [r14+10h], rsi
call _ZNSt6vectorISt4pairIN3CLI6detail10ClassifierENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESaISA_EED2Ev; std::vector<std::pair<CLI::detail::Classifier,std::string>>::~vector()
mov rdi, r14
call _ZNSt6vectorISt4pairIN3CLI6detail10ClassifierENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESaISA_EED2Ev; std::vector<std::pair<CLI::detail::Classifier,std::string>>::~vector()
jmp short loc_1EADE
loc_1EAC1:
mov byte ptr [rbx+4Eh], 1
cmp qword ptr [rbx+60h], 0
jz short loc_1EADE
lea rdi, [rbx+50h]
lea rax, [rsp+58h+var_38]
mov [rax], rsi
mov rsi, rax
call qword ptr [rbx+68h]
loc_1EADE:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt6vectorISt4pairIN3CLI6detail10ClassifierENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESaISA_EED2Ev; std::vector<std::pair<CLI::detail::Classifier,std::string>>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void CLI::App::_trigger_pre_parse(CLI::App *this, long long a2)
{
int v2; // ebp
long long v3; // rax
__int128 v4; // xmm0
long long v5; // rcx
long long v6; // rdx
long long v7; // rsi
long long v8; // [rsp+8h] [rbp-50h] BYREF
long long v9; // [rsp+10h] [rbp-48h]
long long v10; // [rsp+18h] [rbp-40h]
_QWORD v11[7]; // [rsp+20h] [rbp-38h] BYREF
if ( *((_BYTE *)this + 78) )
{
if ( *((_BYTE *)this + 79) == 1 )
{
if ( *((_QWORD *)this + 2) )
{
v2 = *((_DWORD *)this + 169);
v8 = *((_QWORD *)this + 47);
v9 = *((_QWORD *)this + 48);
v10 = *((_QWORD *)this + 49);
*(_OWORD *)((char *)this + 376) = 0LL;
*((_QWORD *)this + 49) = 0LL;
CLI::App::clear(this);
*((_DWORD *)this + 169) = v2;
*((_BYTE *)this + 78) = 1;
memset(v11, 0, 24);
v3 = *((_QWORD *)this + 47);
v4 = *((_OWORD *)this + 24);
*((_QWORD *)this + 47) = v8;
*((_QWORD *)this + 48) = v9;
*((_QWORD *)this + 49) = v10;
v5 = v11[0];
v6 = v11[1];
v7 = v11[2];
v11[0] = v3;
*(_OWORD *)&v11[1] = v4;
v8 = v5;
v9 = v6;
v10 = v7;
std::vector<std::pair<CLI::detail::Classifier,std::string>>::~vector(v11);
std::vector<std::pair<CLI::detail::Classifier,std::string>>::~vector(&v8);
}
}
}
else
{
*((_BYTE *)this + 78) = 1;
if ( *((_QWORD *)this + 12) )
{
v11[0] = a2;
(*((void ( **)(char *, _QWORD *))this + 13))((char *)this + 80, v11);
}
}
}
|
_trigger_pre_parse:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CMP byte ptr [RDI + 0x4e],0x0
JZ 0x0011eac1
CMP byte ptr [RBX + 0x4f],0x1
JNZ 0x0011eade
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0011eade
MOV EBP,dword ptr [RBX + 0x2a4]
MOV RAX,qword ptr [RBX + 0x178]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RBX + 0x180]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RBX + 0x188]
MOV qword ptr [RSP + 0x18],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x178],XMM0
MOV qword ptr [RBX + 0x188],0x0
LAB_0011ea3d:
MOV RDI,RBX
CALL 0x0011e1bc
LAB_0011ea45:
MOV dword ptr [RBX + 0x2a4],EBP
MOV byte ptr [RBX + 0x4e],0x1
LEA RDI,[RSP + 0x20]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RBX + 0x178]
MOVUPS XMM0,xmmword ptr [RBX + 0x180]
LEA R14,[RSP + 0x8]
MOV RCX,qword ptr [R14]
MOV qword ptr [RBX + 0x178],RCX
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x180],RCX
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x188],RCX
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI + 0x10]
MOV qword ptr [RDI],RAX
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV qword ptr [R14],RCX
MOV qword ptr [R14 + 0x8],RDX
MOV qword ptr [R14 + 0x10],RSI
CALL 0x00119366
MOV RDI,R14
CALL 0x00119366
JMP 0x0011eade
LAB_0011eac1:
MOV byte ptr [RBX + 0x4e],0x1
CMP qword ptr [RBX + 0x60],0x0
JZ 0x0011eade
LEA RDI,[RBX + 0x50]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RAX],RSI
MOV RSI,RAX
CALL qword ptr [RBX + 0x68]
LAB_0011eade:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* CLI::App::_trigger_pre_parse(unsigned long) */
void __thiscall CLI::App::_trigger_pre_parse(App *this,ulong param_1)
{
int4 uVar1;
int8 local_50;
int8 local_48;
int8 local_40;
ulong local_38;
int8 uStack_30;
int8 local_28;
if (this[0x4e] == (App)0x0) {
this[0x4e] = (App)0x1;
if (*(long *)(this + 0x60) != 0) {
local_38 = param_1;
(**(code **)(this + 0x68))(this + 0x50,&local_38);
}
}
else if ((this[0x4f] == (App)0x1) && (*(long *)(this + 0x10) != 0)) {
uVar1 = *(int4 *)(this + 0x2a4);
local_50 = *(int8 *)(this + 0x178);
local_48 = *(int8 *)(this + 0x180);
local_40 = *(int8 *)(this + 0x188);
*(int8 *)(this + 0x178) = 0;
*(int8 *)(this + 0x180) = 0;
*(int8 *)(this + 0x188) = 0;
/* try { // try from 0011ea3d to 0011ea44 has its CatchHandler @ 0011eae7 */
clear(this);
*(int4 *)(this + 0x2a4) = uVar1;
this[0x4e] = (App)0x1;
local_38 = *(ulong *)(this + 0x178);
uStack_30 = *(int8 *)(this + 0x180);
local_28 = *(int8 *)(this + 0x188);
*(int8 *)(this + 0x178) = local_50;
*(int8 *)(this + 0x180) = local_48;
*(int8 *)(this + 0x188) = local_40;
local_50 = 0;
local_48 = 0;
local_40 = 0;
std::
vector<std::pair<CLI::detail::Classifier,std::__cxx11::string>,std::allocator<std::pair<CLI::detail::Classifier,std::__cxx11::string>>>
::~vector((vector<std::pair<CLI::detail::Classifier,std::__cxx11::string>,std::allocator<std::pair<CLI::detail::Classifier,std::__cxx11::string>>>
*)&local_38);
std::
vector<std::pair<CLI::detail::Classifier,std::__cxx11::string>,std::allocator<std::pair<CLI::detail::Classifier,std::__cxx11::string>>>
::~vector((vector<std::pair<CLI::detail::Classifier,std::__cxx11::string>,std::allocator<std::pair<CLI::detail::Classifier,std::__cxx11::string>>>
*)&local_50);
}
return;
}
|
|
18,387
|
glfwSetWindowOpacity
|
untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c
|
GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(opacity == opacity);
assert(opacity >= 0.f);
assert(opacity <= 1.f);
_GLFW_REQUIRE_INIT();
if (opacity != opacity || opacity < 0.f || opacity > 1.f)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid window opacity %f", opacity);
return;
}
_glfwPlatformSetWindowOpacity(window, opacity);
}
|
O2
|
c
|
glfwSetWindowOpacity:
pushq %rax
testq %rdi, %rdi
je 0x19c94
ucomiss %xmm0, %xmm0
jp 0x19cb3
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x19cd2
movss 0x3bfa3(%rip), %xmm1 # 0x55bec
ucomiss %xmm0, %xmm1
jb 0x19cf1
leaq 0x819ef(%rip), %rax # 0x9b648
cmpl $0x0, (%rax)
je 0x19c7f
ucomiss 0x3bf87(%rip), %xmm0 # 0x55bec
jbe 0x19c8e
cvtss2sd %xmm0, %xmm0
leaq 0x59b24(%rip), %rsi # 0x73796
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
popq %rcx
jmp 0x1547b
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1547b
popq %rax
jmp 0x1f56e
leaq 0x3c97b(%rip), %rdi # 0x56616
leaq 0x595b0(%rip), %rsi # 0x73252
leaq 0x59a8d(%rip), %rcx # 0x73736
movl $0x2bf, %edx # imm = 0x2BF
callq 0xb510
leaq 0x59aab(%rip), %rdi # 0x73765
leaq 0x59591(%rip), %rsi # 0x73252
leaq 0x59a6e(%rip), %rcx # 0x73736
movl $0x2c0, %edx # imm = 0x2C0
callq 0xb510
leaq 0x59a9f(%rip), %rdi # 0x73778
leaq 0x59572(%rip), %rsi # 0x73252
leaq 0x59a4f(%rip), %rcx # 0x73736
movl $0x2c1, %edx # imm = 0x2C1
callq 0xb510
leaq 0x59a8f(%rip), %rdi # 0x73787
leaq 0x59553(%rip), %rsi # 0x73252
leaq 0x59a30(%rip), %rcx # 0x73736
movl $0x2c2, %edx # imm = 0x2C2
callq 0xb510
|
glfwSetWindowOpacity:
push rax
test rdi, rdi
jz short loc_19C94
ucomiss xmm0, xmm0
jp short loc_19CB3
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jb loc_19CD2
movss xmm1, cs:dword_55BEC
ucomiss xmm1, xmm0
jb loc_19CF1
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_19C7F
ucomiss xmm0, cs:dword_55BEC
jbe short loc_19C8E
cvtss2sd xmm0, xmm0
lea rsi, aInvalidWindowO; "Invalid window opacity %f"
mov edi, 10004h
mov al, 1
pop rcx
jmp _glfwInputError
loc_19C7F:
mov edi, 10001h
xor esi, esi
xor eax, eax
pop rcx
jmp _glfwInputError
loc_19C8E:
pop rax
jmp _glfwPlatformSetWindowOpacity
loc_19C94:
lea rdi, aWindowNull; "window != NULL"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwsetwin_6; "void glfwSetWindowOpacity(GLFWwindow *,"...
mov edx, 2BFh
call ___assert_fail
loc_19CB3:
lea rdi, aOpacityOpacity; "opacity == opacity"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwsetwin_6; "void glfwSetWindowOpacity(GLFWwindow *,"...
mov edx, 2C0h
call ___assert_fail
loc_19CD2:
lea rdi, aOpacity0F; "opacity >= 0.f"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwsetwin_6; "void glfwSetWindowOpacity(GLFWwindow *,"...
mov edx, 2C1h
call ___assert_fail
loc_19CF1:
lea rdi, aOpacity1F; "opacity <= 1.f"
lea rsi, aWorkspaceLlm4b_15; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwsetwin_6; "void glfwSetWindowOpacity(GLFWwindow *,"...
mov edx, 2C2h
call ___assert_fail
|
long long ( * glfwSetWindowOpacity(long long a1, float a2))(_QWORD, _QWORD)
{
if ( !a1 )
__assert_fail(
"window != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c",
703LL,
"void glfwSetWindowOpacity(GLFWwindow *, float)");
if ( a2 < 0.0 )
__assert_fail(
"opacity >= 0.f",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c",
705LL,
"void glfwSetWindowOpacity(GLFWwindow *, float)");
if ( a2 > 1.0 )
__assert_fail(
"opacity <= 1.f",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c",
706LL,
"void glfwSetWindowOpacity(GLFWwindow *, float)");
if ( !glfw[0] )
return glfwInputError(0x10001u, 0LL);
if ( a2 <= 1.0 )
return (long long ( *)(_QWORD, _QWORD))glfwPlatformSetWindowOpacity();
return glfwInputError(0x10004u, (long long)"Invalid window opacity %f", a2);
}
|
glfwSetWindowOpacity:
PUSH RAX
TEST RDI,RDI
JZ 0x00119c94
UCOMISS XMM0,XMM0
JP 0x00119cb3
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JC 0x00119cd2
MOVSS XMM1,dword ptr [0x00155bec]
UCOMISS XMM1,XMM0
JC 0x00119cf1
LEA RAX,[0x19b648]
CMP dword ptr [RAX],0x0
JZ 0x00119c7f
UCOMISS XMM0,dword ptr [0x00155bec]
JBE 0x00119c8e
CVTSS2SD XMM0,XMM0
LEA RSI,[0x173796]
MOV EDI,0x10004
MOV AL,0x1
POP RCX
JMP 0x0011547b
LAB_00119c7f:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
POP RCX
JMP 0x0011547b
LAB_00119c8e:
POP RAX
JMP 0x0011f56e
LAB_00119c94:
LEA RDI,[0x156616]
LEA RSI,[0x173252]
LEA RCX,[0x173736]
MOV EDX,0x2bf
CALL 0x0010b510
LAB_00119cb3:
LEA RDI,[0x173765]
LEA RSI,[0x173252]
LEA RCX,[0x173736]
MOV EDX,0x2c0
CALL 0x0010b510
LAB_00119cd2:
LEA RDI,[0x173778]
LEA RSI,[0x173252]
LEA RCX,[0x173736]
MOV EDX,0x2c1
CALL 0x0010b510
LAB_00119cf1:
LEA RDI,[0x173787]
LEA RSI,[0x173252]
LEA RCX,[0x173736]
MOV EDX,0x2c2
CALL 0x0010b510
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void glfwSetWindowOpacity(float param_1,long param_2,int8 param_3,int8 param_4)
{
int8 in_RAX;
if (param_2 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("window != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x2bf,"void glfwSetWindowOpacity(GLFWwindow *, float)");
}
if (NAN(param_1)) {
/* WARNING: Subroutine does not return */
__assert_fail("opacity == opacity",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x2c0,"void glfwSetWindowOpacity(GLFWwindow *, float)");
}
if (param_1 < 0.0) {
/* WARNING: Subroutine does not return */
__assert_fail("opacity >= 0.f",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x2c1,"void glfwSetWindowOpacity(GLFWwindow *, float)");
}
if (param_1 <= _DAT_00155bec) {
if (_glfw == 0) {
_glfwInputError(0x10001,0,param_4,in_RAX);
return;
}
if (_DAT_00155bec < param_1) {
_glfwInputError((double)param_1,0x10004,"Invalid window opacity %f",param_4,in_RAX);
return;
}
_glfwPlatformSetWindowOpacity();
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("opacity <= 1.f",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O2/_deps/glfw-src/src/window.c"
,0x2c2,"void glfwSetWindowOpacity(GLFWwindow *, float)");
}
|
|
18,388
|
LefDefParser::defwComponentMaskShift(int)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwComponentMaskShift(int shiftLayerMasks)
{
defwFunc = DEFW_COMPONENT; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defVersionNum < 5.8) {
return DEFW_WRONG_VERSION;
}
if (defwState != DEFW_COMPONENT)
return DEFW_BAD_ORDER;
fprintf(defwFile, "\n + MASKSHIFT %d ", shiftLayerMasks);
defwLines++;
return DEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::defwComponentMaskShift(int):
pushq %rax
movl %edi, (%rsp)
leaq 0x1616d(%rip), %rax # 0x2b168
movl $0x22, (%rax)
leaq 0x16150(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x15018
movl $0x1, 0x4(%rsp)
jmp 0x15082
movsd 0xe308(%rip), %xmm0 # 0x23328
ucomisd 0x16088(%rip), %xmm0 # 0x2b0b0
jbe 0x15034
movl $0x5, 0x4(%rsp)
jmp 0x15082
leaq 0x16129(%rip), %rax # 0x2b164
cmpl $0x22, (%rax)
je 0x1504a
movl $0x2, 0x4(%rsp)
jmp 0x15082
leaq 0x16107(%rip), %rax # 0x2b158
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0xf4f2(%rip), %rsi # 0x24550
movb $0x0, %al
callq 0x10f0
leaq 0x160f4(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x160e8(%rip), %rax # 0x2b160
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax,%rax)
|
_ZN12LefDefParser22defwComponentMaskShiftEi:
push rax
mov [rsp+8+var_8], edi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 22h ; '"'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_15018
mov [rsp+8+var_4], 1
jmp short loc_15082
loc_15018:
movsd xmm0, cs:qword_23328
ucomisd xmm0, cs:_ZN12LefDefParserL13defVersionNumE; LefDefParser::defVersionNum
jbe short loc_15034
mov [rsp+8+var_4], 5
jmp short loc_15082
loc_15034:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 22h ; '"'
jz short loc_1504A
mov [rsp+8+var_4], 2
jmp short loc_15082
loc_1504A:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
mov edx, [rsp+8+var_8]
lea rsi, aMaskshiftD; "\n + MASKSHIFT %d "
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_15082:
mov eax, [rsp+8+var_4]
pop rcx
retn
|
long long LefDefParser::defwComponentMaskShift(LefDefParser *this)
{
LefDefParser::defwFunc = 34;
if ( LefDefParser::defwFile )
{
if ( *(double *)&LefDefParser::defVersionNum >= 5.8 )
{
if ( LefDefParser::defwState == 34 )
{
fprintf(LefDefParser::defwFile, "\n + MASKSHIFT %d ", (_DWORD)this);
++LefDefParser::defwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 5;
}
}
else
{
return 1;
}
}
|
defwComponentMaskShift:
PUSH RAX
MOV dword ptr [RSP],EDI
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x22
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x00115018
MOV dword ptr [RSP + 0x4],0x1
JMP 0x00115082
LAB_00115018:
MOVSD XMM0,qword ptr [0x00123328]
UCOMISD XMM0,qword ptr [0x0012b0b0]
JBE 0x00115034
MOV dword ptr [RSP + 0x4],0x5
JMP 0x00115082
LAB_00115034:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x22
JZ 0x0011504a
MOV dword ptr [RSP + 0x4],0x2
JMP 0x00115082
LAB_0011504a:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [RSP]
LEA RSI,[0x124550]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_00115082:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwComponentMaskShift(int) */
int4 LefDefParser::defwComponentMaskShift(int param_1)
{
int4 local_4;
defwFunc = 0x22;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if (DAT_00123328 <= defVersionNum) {
if (defwState == 0x22) {
fprintf(defwFile,"\n + MASKSHIFT %d ",param_1);
defwLines = defwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
}
else {
local_4 = 5;
}
return local_4;
}
|
|
18,389
|
rtree_delete_req
|
eloqsql/storage/myisam/rt_index.c
|
static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
uint key_length, my_off_t page, uint *page_size,
stPageList *ReinsertList, int level)
{
uchar *k;
uchar *last;
ulong i;
uint nod_flag;
uchar *page_buf;
int res;
DBUG_ENTER("rtree_delete_req");
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
{
my_errno = HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u",
(ulong) page, level, nod_flag));
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (i = 0; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag), ++i)
{
if (nod_flag)
{
/* not leaf */
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_WITHIN))
{
switch ((res = rtree_delete_req(info, keyinfo, key, key_length,
_mi_kpos(nod_flag, k), page_size, ReinsertList, level + 1)))
{
case 0: /* deleted */
{
/* test page filling */
if (*page_size + key_length >= rt_PAGE_MIN_SIZE(keyinfo->block_length))
{
/* OK */
/* Calculate a new key value (MBR) for the shrinked block. */
if (rtree_set_key_mbr(info, keyinfo, k, key_length,
_mi_kpos(nod_flag, k)))
goto err1;
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
}
else
{
/*
Too small: delete key & add it descendant to reinsert list.
Store position and level of the block so that it can be
accessed later for inserting the remaining keys.
*/
DBUG_PRINT("rtree", ("too small. move block to reinsert list"));
if (rtree_fill_reinsert_list(ReinsertList, _mi_kpos(nod_flag, k),
level + 1))
goto err1;
/*
Delete the key that references the block. This makes the
block disappear from the index. Hence we need to insert
its remaining keys later. Note: if the block is a branch
block, we do not only remove this block, but the whole
subtree. So we need to re-insert its keys on the same
level later to reintegrate the subtrees.
*/
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size = mi_getint(page_buf);
}
goto ok;
}
case 1: /* not found - continue searching */
{
break;
}
case 2: /* vacuous case: last key in the leaf */
{
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
if (_mi_write_keypage(info, keyinfo, page,
DFLT_INIT_HITS, page_buf))
goto err1;
*page_size = mi_getint(page_buf);
res = 0;
goto ok;
}
default: /* error */
case -1:
{
goto err1;
}
}
}
}
else
{
/* leaf */
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_EQUAL | MBR_DATA))
{
rtree_delete_key(info, page_buf, k, key_length, nod_flag);
*page_size = mi_getint(page_buf);
if (*page_size == 2)
{
/* last key in the leaf */
res = 2;
if (_mi_dispose(info, keyinfo, page, DFLT_INIT_HITS))
goto err1;
}
else
{
res = 0;
if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf))
goto err1;
}
goto ok;
}
}
}
res = 1;
ok:
my_afree((uchar*)page_buf);
DBUG_RETURN(res);
err1:
my_afree((uchar*)page_buf);
DBUG_RETURN(-1); /* purecov: inspected */
}
|
O3
|
c
|
rtree_delete_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x60(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movzwl 0xe(%rsi), %eax
movq %rsp, %r12
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r12
movq %r12, %rsp
xorl %ebx, %ebx
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %r8, -0x50(%rbp)
movq %r8, %rdx
movl $0x3, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x86f80
testq %rax, %rax
je 0x8deb4
movzbl (%r12), %r15d
testb %r15b, %r15b
jns 0x8dbcf
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %ebx
movl %ebx, %r13d
leaq (%r12,%r13), %rbx
addq $0x2, %rbx
movzbl 0x1(%r12), %eax
andl $0x7f, %r15d
shll $0x8, %r15d
orq %rax, %r15
addq %r12, %r15
movl $0x1, %eax
cmpq %r15, %rbx
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %ecx
jae 0x8deb9
movq %r12, -0x58(%rbp)
movl 0x18(%rbp), %edx
incl %edx
movq %rdx, -0x68(%rbp)
movl %ecx, %r12d
movq 0x28(%rsi), %rdi
movq %r14, %rsi
movq %rbx, %rdx
testq %r13, %r13
je 0x8dc6d
movl $0x800, %r8d # imm = 0x800
callq 0x8e73c
movq %r13, %rcx
testl %eax, %eax
jne 0x8dc8d
movl %r13d, %edi
movq %rbx, %rsi
callq 0x878fa
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
movl -0x34(%rbp), %ecx
movq %rax, %r8
movq -0x60(%rbp), %r9
pushq -0x68(%rbp)
pushq 0x10(%rbp)
callq 0x8db53
addq $0x10, %rsp
movq %r13, %rcx
cmpl $0x1, %eax
je 0x8dc8d
jmp 0x8dcad
movl $0x6000, %r8d # imm = 0x6000
callq 0x8e73c
testl %eax, %eax
je 0x8dd50
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %ecx
addq %r12, %rbx
addq %rcx, %rbx
cmpq %r15, %rbx
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %ecx
jb 0x8dc13
movl $0x1, %eax
jmp 0x8deb9
cmpl $0x2, %eax
je 0x8ddae
testl %eax, %eax
jne 0x8deb4
movq -0x60(%rbp), %rax
movl (%rax), %r15d
addl -0x34(%rbp), %r15d
movq -0x40(%rbp), %r14
movzwl 0xe(%r14), %eax
imull $0xaaab, %eax, %r12d # imm = 0xAAAB
shrl $0x11, %r12d
movl %r13d, %edi
movq %rbx, %rsi
callq 0x878fa
movq %rax, %r8
cmpl %r12d, %r15d
jae 0x8de1e
movq 0x10(%rbp), %r14
movq (%r14), %rdx
cmpq 0x8(%r14), %rdx
jne 0x8de57
movq %r8, -0x70(%rbp)
addq $0xa, %rdx
movq %rdx, 0x8(%r14)
leaq 0xb74a8c(%rip), %rax # 0xc027a4
movl (%rax), %edi
movq 0x10(%r14), %rsi
shlq $0x4, %rdx
movl $0x40, %ecx
callq 0xa2d94
movq %rax, 0x10(%r14)
testq %rax, %rax
movq -0x58(%rbp), %r15
je 0x8deb4
movq (%r14), %rdx
movq -0x50(%rbp), %r12
movl -0x34(%rbp), %ecx
movq -0x70(%rbp), %r8
jmp 0x8de66
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x58(%rbp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
xorl %r8d, %r8d
callq 0x8e647
movzbl 0x1(%r14), %eax
movl (%r14), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
movq %r15, %rdi
cmpl $0x2, %ecx
jne 0x8ddf7
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
callq 0x870ff
testl %eax, %eax
jne 0x8deb4
movl $0x2, %eax
jmp 0x8deb9
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq -0x58(%rbp), %r14
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
movl %r13d, %r8d
callq 0x8e647
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x8702c
testl %eax, %eax
jne 0x8deb4
movzbl 0x1(%r14), %eax
movl (%r14), %ecx
jmp 0x8dedf
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
movq %r14, %r8
callq 0x8702c
testl %eax, %eax
movl $0x0, %eax
jne 0x8deb4
jmp 0x8deb9
movq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl -0x34(%rbp), %ecx
callq 0x8e6d4
testl %eax, %eax
movq -0x58(%rbp), %r8
jne 0x8deb4
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl $0x3, %ecx
callq 0x8702c
testl %eax, %eax
jne 0x8deb4
jmp 0x8deed
movq 0x10(%r14), %rax
movq -0x58(%rbp), %r15
movq -0x50(%rbp), %r12
movl -0x34(%rbp), %ecx
shlq $0x4, %rdx
movq %r8, 0x8(%rax,%rdx)
movq (%r14), %rax
movq 0x10(%r14), %rdx
shlq $0x4, %rax
movq -0x68(%rbp), %rsi
movl %esi, (%rdx,%rax)
incq (%r14)
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %r13d, %r8d
callq 0x8e647
movq %r14, %rdi
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movl $0x3, %ecx
movq %r15, %r8
callq 0x8702c
testl %eax, %eax
je 0x8ded7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x8def1
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x1(%r15), %eax
movl (%r15), %ecx
andl $0x7f, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
jmp 0x8deb9
callq 0x29220
|
rtree_delete_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_60], r9
mov [rbp+var_34], ecx
mov r14, rdx
mov rax, fs:28h
mov [rbp+var_30], rax
movzx eax, word ptr [rsi+0Eh]
mov r12, rsp
add eax, 0Fh
and eax, 0FFFFFFF0h
sub r12, rax
mov rsp, r12
xor ebx, ebx
mov [rbp+var_48], rdi
mov [rbp+var_40], rsi
mov [rbp+var_50], r8
mov rdx, r8
mov ecx, 3
mov r8, r12
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_8DEB4
movzx r15d, byte ptr [r12]
test r15b, r15b
jns short loc_8DBCF
mov rax, [rbp+var_48]
mov rax, [rax]
mov ebx, [rax+17Ch]
loc_8DBCF:
mov r13d, ebx
lea rbx, [r12+r13]
add rbx, 2
movzx eax, byte ptr [r12+1]
and r15d, 7Fh
shl r15d, 8
or r15, rax
add r15, r12
mov eax, 1
cmp rbx, r15
mov rsi, [rbp+var_40]
mov ecx, [rbp+var_34]
jnb loc_8DEB9
mov [rbp+var_58], r12
mov edx, [rbp+arg_8]
inc edx
mov [rbp+var_68], rdx
mov r12d, ecx
loc_8DC13:
mov rdi, [rsi+28h]
mov rsi, r14
mov rdx, rbx
test r13, r13
jz short loc_8DC6D
mov r8d, 800h
call rtree_key_cmp
mov rcx, r13
test eax, eax
jnz short loc_8DC8D
mov edi, r13d
mov rsi, rbx
call _mi_kpos
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov rdx, r14
mov ecx, [rbp+var_34]
mov r8, rax
mov r9, [rbp+var_60]
push [rbp+var_68]
push [rbp+arg_0]
call rtree_delete_req
add rsp, 10h
mov rcx, r13
cmp eax, 1
jz short loc_8DC8D
jmp short loc_8DCAD
loc_8DC6D:
mov r8d, 6000h
call rtree_key_cmp
test eax, eax
jz loc_8DD50
mov rax, [rbp+var_48]
mov rax, [rax]
mov ecx, [rax+178h]
loc_8DC8D:
add rbx, r12
add rbx, rcx
cmp rbx, r15
mov rsi, [rbp+var_40]
mov ecx, [rbp+var_34]
jb loc_8DC13
mov eax, 1
jmp loc_8DEB9
loc_8DCAD:
cmp eax, 2
jz loc_8DDAE
test eax, eax
jnz loc_8DEB4
mov rax, [rbp+var_60]
mov r15d, [rax]
add r15d, [rbp+var_34]
mov r14, [rbp+var_40]
movzx eax, word ptr [r14+0Eh]
imul r12d, eax, 0AAABh
shr r12d, 11h
mov edi, r13d
mov rsi, rbx
call _mi_kpos
mov r8, rax
cmp r15d, r12d
jnb loc_8DE1E
mov r14, [rbp+arg_0]
mov rdx, [r14]
cmp rdx, [r14+8]
jnz loc_8DE57
mov [rbp+var_70], r8
add rdx, 0Ah
mov [r14+8], rdx
lea rax, mi_key_memory_stPageList_pages
mov edi, [rax]
mov rsi, [r14+10h]
shl rdx, 4
mov ecx, 40h ; '@'
call my_realloc
mov [r14+10h], rax
test rax, rax
mov r15, [rbp+var_58]
jz loc_8DEB4
mov rdx, [r14]
mov r12, [rbp+var_50]
mov ecx, [rbp+var_34]
mov r8, [rbp+var_70]
jmp loc_8DE66
loc_8DD50:
mov r15, [rbp+var_48]
mov rdi, r15
mov r14, [rbp+var_58]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
xor r8d, r8d
call rtree_delete_key
movzx eax, byte ptr [r14+1]
mov ecx, [r14]
and ecx, 7Fh
shl ecx, 8
or ecx, eax
mov rax, [rbp+var_60]
mov [rax], ecx
mov rdi, r15
cmp ecx, 2
jnz short loc_8DDF7
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
call _mi_dispose
test eax, eax
jnz loc_8DEB4
mov eax, 2
jmp loc_8DEB9
loc_8DDAE:
mov r15, [rbp+var_48]
mov rdi, r15
mov r14, [rbp+var_58]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
mov r8d, r13d
call rtree_delete_key
mov rdi, r15
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
jnz loc_8DEB4
movzx eax, byte ptr [r14+1]
mov ecx, [r14]
jmp loc_8DEDF
loc_8DDF7:
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
mov r8, r14
call _mi_write_keypage
test eax, eax
mov eax, 0
jnz loc_8DEB4
jmp loc_8DEB9
loc_8DE1E:
mov rdi, [rbp+var_48]
mov rsi, r14
mov rdx, rbx
mov ecx, [rbp+var_34]
call rtree_set_key_mbr
test eax, eax
mov r8, [rbp+var_58]
jnz short loc_8DEB4
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_50]
mov ecx, 3
call _mi_write_keypage
test eax, eax
jnz short loc_8DEB4
jmp loc_8DEED
loc_8DE57:
mov rax, [r14+10h]
mov r15, [rbp+var_58]
mov r12, [rbp+var_50]
mov ecx, [rbp+var_34]
loc_8DE66:
shl rdx, 4
mov [rax+rdx+8], r8
mov rax, [r14]
mov rdx, [r14+10h]
shl rax, 4
mov rsi, [rbp+var_68]
mov [rdx+rax], esi
inc qword ptr [r14]
mov r14, [rbp+var_48]
mov rdi, r14
mov rsi, r15
mov rdx, rbx
mov r8d, r13d
call rtree_delete_key
mov rdi, r14
mov rsi, [rbp+var_40]
mov rdx, r12
mov ecx, 3
mov r8, r15
call _mi_write_keypage
test eax, eax
jz short loc_8DED7
loc_8DEB4:
mov eax, 0FFFFFFFFh
loc_8DEB9:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_8DEF1
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8DED7:
movzx eax, byte ptr [r15+1]
mov ecx, [r15]
loc_8DEDF:
and ecx, 7Fh
shl ecx, 8
or ecx, eax
mov rax, [rbp+var_60]
mov [rax], ecx
loc_8DEED:
xor eax, eax
jmp short loc_8DEB9
loc_8DEF1:
call ___stack_chk_fail
|
long long rtree_delete_req(
long long *a1,
long long a2,
long long a3,
unsigned int a4,
long long a5,
int *a6,
long long *a7,
int a8)
{
char *v9; // r12
unsigned int v10; // ebx
long long v11; // r13
unsigned long long v12; // rbx
char *v13; // r15
long long result; // rax
long long v15; // rsi
long long v16; // rcx
long long v17; // r12
long long v18; // rdi
int v19; // eax
long long v20; // rcx
int v21; // eax
int v22; // eax
unsigned int v23; // r15d
long long v24; // r14
unsigned int v25; // r12d
unsigned long long v26; // rax
unsigned long long v27; // r8
long long v28; // rdx
long long v29; // rdx
long long v30; // rax
_BYTE *v31; // r15
unsigned long long v32; // r12
long long v33; // rcx
long long *v34; // r15
_BYTE *v35; // r14
int v36; // ecx
long long *v37; // r15
_BYTE *v38; // r14
int v39; // eax
int v40; // ecx
bool v41; // zf
long long *v42; // r14
unsigned long long v43; // [rsp+0h] [rbp-70h] BYREF
long long v44; // [rsp+8h] [rbp-68h]
int *v45; // [rsp+10h] [rbp-60h]
_BYTE *v46; // [rsp+18h] [rbp-58h]
unsigned long long v47; // [rsp+20h] [rbp-50h]
long long *v48; // [rsp+28h] [rbp-48h]
long long v49; // [rsp+30h] [rbp-40h]
unsigned int v50; // [rsp+3Ch] [rbp-34h]
unsigned long long v51; // [rsp+40h] [rbp-30h]
v45 = a6;
v50 = a4;
v51 = __readfsqword(0x28u);
v9 = (char *)&v43 - ((*(unsigned __int16 *)(a2 + 14) + 15) & 0xFFFFFFF0);
v10 = 0;
v48 = a1;
v49 = a2;
v47 = a5;
if ( !mi_fetch_keypage(a1, a2, a5) )
return 0xFFFFFFFFLL;
if ( *v9 < 0 )
v10 = *(_DWORD *)(*v48 + 380);
v11 = v10;
v12 = (unsigned long long)&v9[v10 + 2];
v13 = &v9[(unsigned __int8)v9[1] | (unsigned long long)((unsigned __int8)(*v9 & 0x7F) << 8)];
result = 1LL;
v15 = v49;
v16 = v50;
if ( v12 < (unsigned long long)v13 )
{
v46 = v9;
v44 = (unsigned int)(a8 + 1);
v17 = v50;
while ( 1 )
{
v18 = *(_QWORD *)(v15 + 40);
if ( v11 )
{
v19 = rtree_key_cmp(v18, a3, v12, v16, 2048LL);
v20 = v11;
if ( !v19 )
{
v21 = mi_kpos(v11, v12);
v22 = rtree_delete_req((_DWORD)v48, v49, a3, v50, v21, (_DWORD)v45, (long long)a7, v44);
v20 = v11;
if ( v22 != 1 )
{
if ( v22 != 2 )
{
if ( v22 )
return 0xFFFFFFFFLL;
v23 = v50 + *v45;
v24 = v49;
v25 = *(unsigned __int16 *)(v49 + 14) / 3u;
v26 = mi_kpos(v11, v12);
v27 = v26;
if ( v23 >= v25 )
{
if ( (unsigned int)rtree_set_key_mbr(v48, v24, v12, v50, v26)
|| (unsigned int)mi_write_keypage(v48, v49, v47, 3u, v46) )
{
return 0xFFFFFFFFLL;
}
}
else
{
v28 = *a7;
if ( *a7 == a7[1] )
{
v43 = v26;
v29 = v28 + 10;
a7[1] = v29;
v30 = my_realloc(mi_key_memory_stPageList_pages, a7[2], 16 * v29, 64LL);
a7[2] = v30;
v31 = v46;
if ( !v30 )
return 0xFFFFFFFFLL;
v28 = *a7;
v32 = v47;
v33 = v50;
v27 = v43;
}
else
{
v30 = a7[2];
v31 = v46;
v32 = v47;
v33 = v50;
}
*(_QWORD *)(v30 + 16 * v28 + 8) = v27;
*(_DWORD *)(a7[2] + 16 * (*a7)++) = v44;
v42 = v48;
rtree_delete_key(v48, v31, v12, v33, (unsigned int)v11);
if ( (unsigned int)mi_write_keypage(v42, v49, v32, 3u, v31) )
return 0xFFFFFFFFLL;
v39 = (unsigned __int8)v31[1];
v40 = *(_DWORD *)v31;
LABEL_35:
*v45 = v39 | ((v40 & 0x7F) << 8);
}
return 0LL;
}
v37 = v48;
v38 = v46;
rtree_delete_key(v48, v46, v12, v50, (unsigned int)v11);
if ( (unsigned int)mi_write_keypage(v37, v49, v47, 3u, v38) )
return 0xFFFFFFFFLL;
v39 = (unsigned __int8)v38[1];
v40 = *(_DWORD *)v38;
goto LABEL_35;
}
}
}
else
{
if ( !(unsigned int)rtree_key_cmp(v18, a3, v12, v16, 24576LL) )
{
v34 = v48;
v35 = v46;
rtree_delete_key(v48, v46, v12, v50, 0LL);
v36 = (unsigned __int8)v35[1] | ((*(_DWORD *)v35 & 0x7F) << 8);
*v45 = v36;
if ( v36 == 2 )
{
if ( (unsigned int)mi_dispose(v34, v49, v47, 3u) )
return 0xFFFFFFFFLL;
return 2LL;
}
else
{
v41 = (unsigned int)mi_write_keypage(v34, v49, v47, 3u, v35) == 0;
result = 0LL;
if ( !v41 )
return 0xFFFFFFFFLL;
}
return result;
}
v20 = *(unsigned int *)(*v48 + 376);
}
v12 += v20 + v17;
v15 = v49;
v16 = v50;
if ( v12 >= (unsigned long long)v13 )
return 1LL;
}
}
return result;
}
|
rtree_delete_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x60],R9
MOV dword ptr [RBP + -0x34],ECX
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOVZX EAX,word ptr [RSI + 0xe]
MOV R12,RSP
ADD EAX,0xf
AND EAX,0xfffffff0
SUB R12,RAX
MOV RSP,R12
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x50],R8
MOV RDX,R8
MOV ECX,0x3
MOV R8,R12
XOR R9D,R9D
CALL 0x00186f80
TEST RAX,RAX
JZ 0x0018deb4
MOVZX R15D,byte ptr [R12]
TEST R15B,R15B
JNS 0x0018dbcf
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV EBX,dword ptr [RAX + 0x17c]
LAB_0018dbcf:
MOV R13D,EBX
LEA RBX,[R12 + R13*0x1]
ADD RBX,0x2
MOVZX EAX,byte ptr [R12 + 0x1]
AND R15D,0x7f
SHL R15D,0x8
OR R15,RAX
ADD R15,R12
MOV EAX,0x1
CMP RBX,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x34]
JNC 0x0018deb9
MOV qword ptr [RBP + -0x58],R12
MOV EDX,dword ptr [RBP + 0x18]
INC EDX
MOV qword ptr [RBP + -0x68],RDX
MOV R12D,ECX
LAB_0018dc13:
MOV RDI,qword ptr [RSI + 0x28]
MOV RSI,R14
MOV RDX,RBX
TEST R13,R13
JZ 0x0018dc6d
MOV R8D,0x800
CALL 0x0018e73c
MOV RCX,R13
TEST EAX,EAX
JNZ 0x0018dc8d
MOV EDI,R13D
MOV RSI,RBX
CALL 0x001878fa
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R14
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,RAX
MOV R9,qword ptr [RBP + -0x60]
PUSH qword ptr [RBP + -0x68]
PUSH qword ptr [RBP + 0x10]
CALL 0x0018db53
ADD RSP,0x10
MOV RCX,R13
CMP EAX,0x1
JZ 0x0018dc8d
JMP 0x0018dcad
LAB_0018dc6d:
MOV R8D,0x6000
CALL 0x0018e73c
TEST EAX,EAX
JZ 0x0018dd50
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x178]
LAB_0018dc8d:
ADD RBX,R12
ADD RBX,RCX
CMP RBX,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x34]
JC 0x0018dc13
MOV EAX,0x1
JMP 0x0018deb9
LAB_0018dcad:
CMP EAX,0x2
JZ 0x0018ddae
TEST EAX,EAX
JNZ 0x0018deb4
MOV RAX,qword ptr [RBP + -0x60]
MOV R15D,dword ptr [RAX]
ADD R15D,dword ptr [RBP + -0x34]
MOV R14,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [R14 + 0xe]
IMUL R12D,EAX,0xaaab
SHR R12D,0x11
MOV EDI,R13D
MOV RSI,RBX
CALL 0x001878fa
MOV R8,RAX
CMP R15D,R12D
JNC 0x0018de1e
MOV R14,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [R14]
CMP RDX,qword ptr [R14 + 0x8]
JNZ 0x0018de57
MOV qword ptr [RBP + -0x70],R8
ADD RDX,0xa
MOV qword ptr [R14 + 0x8],RDX
LEA RAX,[0xd027a4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [R14 + 0x10]
SHL RDX,0x4
MOV ECX,0x40
CALL 0x001a2d94
MOV qword ptr [R14 + 0x10],RAX
TEST RAX,RAX
MOV R15,qword ptr [RBP + -0x58]
JZ 0x0018deb4
MOV RDX,qword ptr [R14]
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
MOV R8,qword ptr [RBP + -0x70]
JMP 0x0018de66
LAB_0018dd50:
MOV R15,qword ptr [RBP + -0x48]
MOV RDI,R15
MOV R14,qword ptr [RBP + -0x58]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
XOR R8D,R8D
CALL 0x0018e647
MOVZX EAX,byte ptr [R14 + 0x1]
MOV ECX,dword ptr [R14]
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
MOV RDI,R15
CMP ECX,0x2
JNZ 0x0018ddf7
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
CALL 0x001870ff
TEST EAX,EAX
JNZ 0x0018deb4
MOV EAX,0x2
JMP 0x0018deb9
LAB_0018ddae:
MOV R15,qword ptr [RBP + -0x48]
MOV RDI,R15
MOV R14,qword ptr [RBP + -0x58]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
MOV R8D,R13D
CALL 0x0018e647
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
MOV R8,R14
CALL 0x0018702c
TEST EAX,EAX
JNZ 0x0018deb4
MOVZX EAX,byte ptr [R14 + 0x1]
MOV ECX,dword ptr [R14]
JMP 0x0018dedf
LAB_0018ddf7:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
MOV R8,R14
CALL 0x0018702c
TEST EAX,EAX
MOV EAX,0x0
JNZ 0x0018deb4
JMP 0x0018deb9
LAB_0018de1e:
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,dword ptr [RBP + -0x34]
CALL 0x0018e6d4
TEST EAX,EAX
MOV R8,qword ptr [RBP + -0x58]
JNZ 0x0018deb4
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x3
CALL 0x0018702c
TEST EAX,EAX
JNZ 0x0018deb4
JMP 0x0018deed
LAB_0018de57:
MOV RAX,qword ptr [R14 + 0x10]
MOV R15,qword ptr [RBP + -0x58]
MOV R12,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x34]
LAB_0018de66:
SHL RDX,0x4
MOV qword ptr [RAX + RDX*0x1 + 0x8],R8
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x10]
SHL RAX,0x4
MOV RSI,qword ptr [RBP + -0x68]
MOV dword ptr [RDX + RAX*0x1],ESI
INC qword ptr [R14]
MOV R14,qword ptr [RBP + -0x48]
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
MOV R8D,R13D
CALL 0x0018e647
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,R12
MOV ECX,0x3
MOV R8,R15
CALL 0x0018702c
TEST EAX,EAX
JZ 0x0018ded7
LAB_0018deb4:
MOV EAX,0xffffffff
LAB_0018deb9:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0018def1
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018ded7:
MOVZX EAX,byte ptr [R15 + 0x1]
MOV ECX,dword ptr [R15]
LAB_0018dedf:
AND ECX,0x7f
SHL ECX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV dword ptr [RAX],ECX
LAB_0018deed:
XOR EAX,EAX
JMP 0x0018deb9
LAB_0018def1:
CALL 0x00129220
|
int8
rtree_delete_req(long *param_1,long param_2,int8 param_3,uint param_4,int8 param_5,
uint *param_6,long *param_7,int param_8)
{
byte bVar1;
ushort uVar2;
long lVar3;
int8 uVar4;
long *plVar5;
uint uVar6;
int iVar7;
long lVar8;
int8 uVar9;
long lVar10;
uint uVar11;
ulong uVar12;
byte *pbVar13;
uint *puVar14;
ulong uVar15;
ulong uVar16;
uint uVar17;
byte *pbVar18;
long in_FS_OFFSET;
ulong auStack_90 [3];
int8 local_78;
ulong local_70;
uint *local_68;
uint *local_60;
int8 local_58;
long *local_50;
long local_48;
uint local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar3 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0xf & 0xfffffff0);
puVar14 = (uint *)((long)&local_78 + lVar3);
uVar11 = 0;
local_68 = param_6;
local_58 = param_5;
local_50 = param_1;
local_48 = param_2;
local_3c = param_4;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dbaf;
lVar8 = _mi_fetch_keypage(param_1,param_2,param_5,3,puVar14,0);
if (lVar8 == 0) {
LAB_0018deb4:
uVar9 = 0xffffffff;
}
else {
if ((char)(byte)*puVar14 < '\0') {
uVar11 = *(uint *)(*local_50 + 0x17c);
}
uVar16 = (ulong)uVar11;
pbVar13 = (byte *)((long)puVar14 + uVar16 + 2);
pbVar18 = (byte *)(((ulong)(((byte)*puVar14 & 0x7f) << 8) |
(ulong)*(byte *)((long)&local_78 + lVar3 + 1)) + (long)puVar14);
uVar9 = 1;
if (pbVar13 < pbVar18) {
local_70 = (ulong)(param_8 + 1);
uVar15 = (ulong)local_3c;
local_60 = puVar14;
do {
uVar6 = local_3c;
uVar9 = *(int8 *)(local_48 + 0x28);
if (uVar16 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dc78;
iVar7 = rtree_key_cmp(uVar9,param_3,pbVar13,uVar6,0x6000);
uVar6 = local_3c;
plVar5 = local_50;
puVar14 = local_60;
if (iVar7 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dd6c;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,0);
lVar8 = local_48;
uVar9 = local_58;
uVar11 = (*puVar14 & 0x7f) << 8 | (uint)*(byte *)((long)puVar14 + 1);
*local_68 = uVar11;
if (uVar11 != 2) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18de0c;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
uVar9 = 0;
if (iVar7 == 0) goto LAB_0018deb9;
goto LAB_0018deb4;
}
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dd9c;
iVar7 = _mi_dispose(plVar5,lVar8,uVar9,3);
if (iVar7 != 0) goto LAB_0018deb4;
uVar9 = 2;
goto LAB_0018deb9;
}
uVar12 = (ulong)*(uint *)(*local_50 + 0x178);
}
else {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dc2d;
iVar7 = rtree_key_cmp(uVar9,param_3,pbVar13,uVar6,0x800);
uVar12 = uVar16;
if (iVar7 == 0) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dc3f;
uVar9 = _mi_kpos(uVar16,pbVar13);
uVar6 = local_3c;
lVar8 = local_48;
plVar5 = local_50;
puVar14 = local_68;
*(ulong *)((long)auStack_90 + lVar3 + 0x10) = local_70;
*(long **)((long)auStack_90 + lVar3 + 8) = param_7;
*(int8 *)((long)auStack_90 + lVar3) = 0x18dc5f;
iVar7 = rtree_delete_req(plVar5,lVar8,param_3,uVar6,uVar9,puVar14);
uVar6 = local_3c;
lVar8 = local_48;
plVar5 = local_50;
puVar14 = local_60;
if (iVar7 != 1) {
if (iVar7 == 2) {
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18ddca;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,uVar11);
lVar8 = local_48;
uVar9 = local_58;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dde2;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
if (iVar7 != 0) goto LAB_0018deb4;
bVar1 = *(byte *)((long)puVar14 + 1);
uVar11 = *puVar14;
LAB_0018dedf:
*local_68 = (uVar11 & 0x7f) << 8 | (uint)bVar1;
}
else {
if (iVar7 != 0) goto LAB_0018deb4;
uVar17 = *local_68 + local_3c;
uVar2 = *(ushort *)(local_48 + 0xe);
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dce8;
uVar9 = _mi_kpos(uVar16,pbVar13);
uVar6 = local_3c;
plVar5 = local_50;
if (uVar17 < uVar2 / 3) {
lVar8 = *param_7;
if (lVar8 == param_7[1]) {
param_7[1] = lVar8 + 10;
lVar10 = param_7[2];
local_78 = uVar9;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18dd2c;
lVar10 = my_realloc(mi_key_memory_stPageList_pages,lVar10,(lVar8 + 10) * 0x10,
0x40);
param_7[2] = lVar10;
if (lVar10 == 0) goto LAB_0018deb4;
lVar8 = *param_7;
uVar9 = local_78;
}
else {
lVar10 = param_7[2];
}
uVar6 = local_3c;
plVar5 = local_50;
uVar4 = local_58;
puVar14 = local_60;
*(int8 *)(lVar10 + 8 + lVar8 * 0x10) = uVar9;
*(int *)(param_7[2] + *param_7 * 0x10) = (int)local_70;
*param_7 = *param_7 + 1;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18de99;
rtree_delete_key(plVar5,puVar14,pbVar13,uVar6,uVar11);
lVar8 = local_48;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18deb0;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar4,3,puVar14);
if (iVar7 == 0) {
bVar1 = *(byte *)((long)puVar14 + 1);
uVar11 = *puVar14;
goto LAB_0018dedf;
}
goto LAB_0018deb4;
}
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18de30;
iVar7 = rtree_set_key_mbr(plVar5,lVar8,pbVar13,uVar6);
lVar8 = local_48;
plVar5 = local_50;
uVar9 = local_58;
puVar14 = local_60;
if (iVar7 != 0) goto LAB_0018deb4;
*(int8 *)((long)auStack_90 + lVar3 + 0x10) = 0x18de4e;
iVar7 = _mi_write_keypage(plVar5,lVar8,uVar9,3,puVar14);
if (iVar7 != 0) goto LAB_0018deb4;
}
uVar9 = 0;
goto LAB_0018deb9;
}
}
}
pbVar13 = pbVar13 + uVar12 + uVar15;
} while (pbVar13 < pbVar18);
uVar9 = 1;
}
}
LAB_0018deb9:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)auStack_90 + lVar3 + 0x10) = rtree_estimate;
__stack_chk_fail();
}
return uVar9;
}
|
|
18,390
|
SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<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-schema-to-grammar.cpp
|
std::string _generate_union_rule(const std::string & name, const std::vector<json> & alt_schemas) {
std::vector<std::string> rules;
for (size_t i = 0; i < alt_schemas.size(); i++) {
rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i)));
}
return string_join(rules, " | ");
}
|
O0
|
cpp
|
SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<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&):
subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x100(%rsp), %rdi
callq 0x62080
movq $0x0, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x118(%rsp), %rdi
callq 0xaede0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1ac962
movq 0x118(%rsp), %rdi
movq 0xf8(%rsp), %rsi
callq 0x1b1080
movq %rax, 0x10(%rsp)
movq 0x120(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5a4f0
movq 0x18(%rsp), %rsi
movb %al, %cl
leaq 0x68ac8(%rip), %rax # 0x2152b7
leaq 0x5f7e1(%rip), %rdx # 0x20bfd7
testb %cl, %cl
cmovneq %rax, %rdx
leaq 0x98(%rsp), %rdi
callq 0x894d0
jmp 0x1ac80b
movq 0xf8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xae4e0
jmp 0x1ac81f
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x8b940
jmp 0x1ac83b
movq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rcx
callq 0x1a8ed0
jmp 0x1ac85c
leaq 0x100(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xf7510
jmp 0x1ac873
leaq 0xd8(%rsp), %rdi
callq 0x5b558
leaq 0xb8(%rsp), %rdi
callq 0x5b558
leaq 0x68(%rsp), %rdi
callq 0x5b558
leaq 0x98(%rsp), %rdi
callq 0x5b558
movq 0xf8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rsp)
jmp 0x1ac78a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1aca0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1ac950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1ac946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1ac939
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x5b558
leaq 0xb8(%rsp), %rdi
callq 0x5b558
leaq 0x68(%rsp), %rdi
callq 0x5b558
leaq 0x98(%rsp), %rdi
callq 0x5b558
jmp 0x1aca0e
leaq 0x47(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5b0d0
movq 0x8(%rsp), %rdx
leaq 0x68af1(%rip), %rsi # 0x21546e
leaq 0x48(%rsp), %rdi
callq 0x61fc0
jmp 0x1ac989
movq 0x28(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xec580
jmp 0x1ac9a2
leaq 0x48(%rsp), %rdi
callq 0x5b558
leaq 0x47(%rsp), %rdi
callq 0x5b530
leaq 0x100(%rsp), %rdi
callq 0x620d0
movq 0x30(%rsp), %rax
addq $0x138, %rsp # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1aca04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b558
leaq 0x47(%rsp), %rdi
callq 0x5b530
leaq 0x100(%rsp), %rdi
callq 0x620d0
movq 0x90(%rsp), %rdi
callq 0x5abc0
nopl (%rax,%rax)
|
_ZN15SchemaConverter20_generate_union_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapES8_S5_blmdSaNSA_14adl_serializerES8_IhSaIhEEvEESaISG_EE:
sub rsp, 138h
mov [rsp+138h+var_110], rdi
mov rax, rdi
mov [rsp+138h+var_108], rax
mov [rsp+138h+var_8], rdi
mov [rsp+138h+var_10], rsi
mov [rsp+138h+var_18], rdx
mov [rsp+138h+var_20], rcx
mov rax, [rsp+138h+var_10]
mov [rsp+138h+var_100], rax
lea rdi, [rsp+138h+var_38]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov [rsp+138h+var_40], 0
loc_1AC78A:
mov rax, [rsp+138h+var_40]
mov [rsp+138h+var_118], rax
mov rdi, [rsp+138h+var_20]
call _ZNKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4sizeEv; 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>>::size(void)
mov rcx, rax
mov rax, [rsp+138h+var_118]
cmp rax, rcx
jnb loc_1AC962
mov rdi, [rsp+138h+var_20]
mov rsi, [rsp+138h+var_40]
call _ZNKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEixEm; 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>>::operator[](ulong)
mov qword ptr [rsp+138h+var_128], rax; int
mov rdi, [rsp+138h+var_18]
mov [rsp+138h+var_120], rdi; __int64
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
mov rsi, [rsp+138h+var_120]; int
mov cl, al; int
lea rax, aAlternative; "alternative-"
lea rdx, asc_20BFD6+1; "-"
test cl, cl
cmovnz rdx, rax; int
lea rdi, [rsp+138h+var_A0]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
jmp short $+2
loc_1AC80B:
mov rsi, [rsp+138h+var_40]; unsigned __int64
lea rdi, [rsp+138h+var_D0]; this
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_1AC81F:
lea rdi, [rsp+138h+var_80]
lea rsi, [rsp+138h+var_A0]
lea rdx, [rsp+138h+var_D0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
jmp short $+2
loc_1AC83B:
mov rdx, qword ptr [rsp+138h+var_128]
mov rsi, [rsp+138h+var_100]
lea rdi, [rsp+138h+var_60]
lea rcx, [rsp+138h+var_80]
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(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&,std::string const&)
jmp short $+2
loc_1AC85C:
lea rdi, [rsp+138h+var_38]
lea rsi, [rsp+138h+var_60]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
jmp short $+2
loc_1AC873:
lea rdi, [rsp+138h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+138h+var_40]
add rax, 1
mov [rsp+138h+var_40], rax
jmp loc_1AC78A
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
jmp loc_1ACA0E
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
jmp short loc_1AC950
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
jmp short loc_1AC946
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
jmp short loc_1AC939
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
lea rdi, [rsp+arg_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1AC939:
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1AC946:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1AC950:
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1ACA0E
loc_1AC962:
lea rdi, [rsp+138h+var_F1]
mov [rsp+138h+var_130], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+138h+var_130]
lea rsi, asc_21546D+1; " | "
lea rdi, [rsp+138h+var_F0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_1AC989:
mov rdi, [rsp+138h+var_110]
lea rsi, [rsp+138h+var_38]
lea rdx, [rsp+138h+var_F0]
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
jmp short $+2
loc_1AC9A2:
lea rdi, [rsp+138h+var_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+138h+var_F1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+138h+var_38]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+138h+var_108]
add rsp, 138h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
jmp short loc_1ACA04
mov rcx, rax
mov eax, edx
mov [rsp+arg_88], rcx
mov [rsp+arg_84], eax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1ACA04:
lea rdi, [rsp+arg_3F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_1ACA0E:
lea rdi, [rsp+arg_F8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_88]
call __Unwind_Resume
|
long long SchemaConverter::_generate_union_rule(long long a1, _BYTE *a2, long long a3, _QWORD *a4)
{
char v4; // al
char *v5; // rdx
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
long long v11; // [rsp+10h] [rbp-128h]
long long v12; // [rsp+18h] [rbp-120h]
unsigned long long v13; // [rsp+20h] [rbp-118h]
long long v14; // [rsp+38h] [rbp-100h]
char v15; // [rsp+47h] [rbp-F1h] BYREF
_BYTE v16[32]; // [rsp+48h] [rbp-F0h] BYREF
_BYTE v17[48]; // [rsp+68h] [rbp-D0h] BYREF
int v18[8]; // [rsp+98h] [rbp-A0h] BYREF
_BYTE v19[32]; // [rsp+B8h] [rbp-80h] BYREF
_BYTE v20[32]; // [rsp+D8h] [rbp-60h] BYREF
unsigned long long i; // [rsp+F8h] [rbp-40h]
long long v22[3]; // [rsp+100h] [rbp-38h] BYREF
_QWORD *v23; // [rsp+118h] [rbp-20h]
long long v24; // [rsp+120h] [rbp-18h]
_BYTE *v25; // [rsp+128h] [rbp-10h]
long long v26; // [rsp+130h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v14 = (long long)a2;
std::vector<std::string>::vector((long long)v22);
for ( i = 0LL; ; ++i )
{
v13 = i;
if ( v13 >= 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>>::size(v23) )
break;
v11 = 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>>::operator[](
v23,
i);
v12 = v24;
v4 = std::string::empty(v24);
v5 = "-";
if ( v4 )
v5 = "alternative-";
std::operator+<char>((long long)v18, v12, (long long)v5);
std::to_string((std::__cxx11 *)v17, i);
std::operator+<char>((long long)v19, (long long)v18, (long long)v17);
SchemaConverter::visit((long long)v20, v14, v11, (long long)v19);
a2 = v20;
std::vector<std::string>::push_back((long long)v22, (long long)v20, v6, v7, v8, v9);
std::string::~string(v20);
std::string::~string(v19);
std::string::~string(v17);
std::string::~string(v18);
}
std::allocator<char>::allocator(&v15, a2);
std::string::basic_string<std::allocator<char>>((long long)v16, (long long)" | ", (long long)&v15);
string_join(a1, v22, (long long)v16);
std::string::~string(v16);
std::allocator<char>::~allocator(&v15);
std::vector<std::string>::~vector(v22);
return a1;
}
| |||
18,391
|
SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<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-schema-to-grammar.cpp
|
std::string _generate_union_rule(const std::string & name, const std::vector<json> & alt_schemas) {
std::vector<std::string> rules;
for (size_t i = 0; i < alt_schemas.size(); i++) {
rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i)));
}
return string_join(rules, " | ");
}
|
O3
|
cpp
|
SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movq (%rcx), %r12
movq %rcx, 0xa0(%rsp)
cmpq %r12, 0x8(%rcx)
je 0xc310c
leaq 0x70(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x40(%rsp), %r14
movq %rbp, %rbx
movq 0xb0(%rsp), %rcx
movq 0x8(%rcx), %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rcx), %rsi
leaq (%rsi,%rbp), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x213b2
testq %rbp, %rbp
leaq 0x30921(%rip), %rsi # 0xf3837
leaq 0x309c3(%rip), %rax # 0xf38e0
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x1b0f0
movl $0x1, %esi
cmpq $0xa, %r13
movq %rbx, %rbp
jb 0xc2f86
movl $0x4, %esi
movq %r13, %rcx
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
cmpq $0x63, %rcx
jbe 0xc2f7f
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0xc2f84
cmpq $0x2710, %rcx # imm = 0x2710
jb 0xc2f86
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0xc2f49
addl $-0x3, %esi
jmp 0xc2f86
addl $-0x2, %esi
jmp 0xc2f86
decl %esi
movl %esi, %esi
movq %rbp, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
xorl %edx, %edx
callq 0x1aa30
movq 0x60(%rsp), %rdi
movl 0x68(%rsp), %esi
movq %r13, %rdx
callq 0x21652
movq (%rsp), %rcx
movl $0xf, %edi
leaq 0x10(%rsp), %rax
cmpq %rax, %rcx
je 0xc2fc2
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r8
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0xc2fee
movl $0xf, %edi
cmpq %rbp, %rsi
je 0xc2fe9
movq 0x70(%rsp), %rdi
cmpq %rdi, %rax
jbe 0xc2ff8
movq %rsp, %rdi
callq 0x1a260
jmp 0xc3006
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a9e0
leaq 0x30(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0xc302b
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xc3031
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq %r13, %rax
shlq $0x4, %rax
addq %rax, %r12
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %r14, %rdi
movq 0xa8(%rsp), %rsi
movq %r12, %rdx
leaq 0x20(%rsp), %rcx
callq 0xc00d2
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
leaq 0x30(%rsp), %r12
callq 0x55076
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xc30a1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc30b8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0x60(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc30cf
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc30ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
incq %r13
movq 0xa0(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
sarq $0x4, %rax
cmpq %rax, %r13
jb 0xc2ee2
leaq 0x50(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x3097b(%rip), %rsi # 0xf3a97
leaq 0x30977(%rip), %rdx # 0xf3a9a
leaq 0x40(%rsp), %rdi
callq 0x214e2
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x719b1
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc3161
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x80(%rsp), %rdi
callq 0x20f1c
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc3220
movq 0x50(%rsp), %rsi
jmp 0xc3218
jmp 0xc319d
movq %rax, %r14
jmp 0xc3220
jmp 0xc31a4
movq %rax, %r14
jmp 0xc3205
movq %rax, %r14
jmp 0xc31ee
movq %rax, %r14
jmp 0xc31d2
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0xc31d2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xc31ee
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc3205
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc3220
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x80(%rsp), %rdi
callq 0x20f1c
movq %r14, %rdi
callq 0x1afa0
nop
|
_ZN15SchemaConverter20_generate_union_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapES8_S5_blmdSaNSA_14adl_serializerES8_IhSaIhEEvEESaISG_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_38], rdx
mov [rsp+0E8h+var_40], rsi
mov [rsp+0E8h+var_50], rdi
xorps xmm0, xmm0
movaps [rsp+0E8h+var_68], xmm0
mov [rsp+0E8h+var_58], 0
mov r12, [rcx]
mov [rsp+0E8h+var_48], rcx
cmp [rcx+8], r12
jz loc_C310C
lea rbp, [rsp+0E8h+var_78]
xor r13d, r13d
lea r14, [rsp+0E8h+var_A8]
loc_C2EE2:
mov rbx, rbp
mov rcx, [rsp+0E8h+var_38]
mov rbp, [rcx+8]
lea rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_E8], rax
mov rsi, [rcx]
lea rdx, [rsi+rbp]
mov r15, rsp
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
test rbp, rbp
lea rsi, aTuple+5; "-"
lea rax, aAlternative; "alternative-"
cmovz rsi, rax
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov esi, 1
cmp r13, 0Ah
mov rbp, rbx
jb short loc_C2F86
mov esi, 4
mov rcx, r13
mov rdi, 346DC5D63886594Bh
loc_C2F49:
cmp rcx, 63h ; 'c'
jbe short loc_C2F7F
cmp rcx, 3E7h
jbe short loc_C2F84
cmp rcx, 2710h
jb short loc_C2F86
mov rax, rcx
mul rdi
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_C2F49
add esi, 0FFFFFFFDh
jmp short loc_C2F86
loc_C2F7F:
add esi, 0FFFFFFFEh
jmp short loc_C2F86
loc_C2F84:
dec esi
loc_C2F86:
mov esi, esi
mov [rsp+0E8h+var_88], rbp
lea rdi, [rsp+0E8h+var_88]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [rsp+0E8h+var_88]
mov esi, dword ptr [rsp+0E8h+var_80]
mov rdx, r13
call _ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov rcx, [rsp+0E8h+var_E8]
mov edi, 0Fh
lea rax, [rsp+0E8h+var_D8]
cmp rcx, rax
jz short loc_C2FC2
mov rdi, [rsp+0E8h+var_D8]
loc_C2FC2:
mov r8, [rsp+0E8h+var_E0]
mov rsi, [rsp+0E8h+var_88]
mov rdx, [rsp+0E8h+var_80]
lea rax, [rdx+r8]
cmp rax, rdi
jbe short loc_C2FEE
mov edi, 0Fh
cmp rsi, rbp
jz short loc_C2FE9
mov rdi, [rsp+0E8h+var_78]
loc_C2FE9:
cmp rax, rdi
jbe short loc_C2FF8
loc_C2FEE:
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_C3006
loc_C2FF8:
lea rdi, [rsp+0E8h+var_88]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_C3006:
lea rsi, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_C8], rsi
mov rdx, [rax]
lea rcx, [rax+10h]
cmp rdx, rcx
jz short loc_C302B
mov [rsp+0E8h+var_C8], rdx
mov rdx, [rcx]
mov [rsp+0E8h+var_B8], rdx
jmp short loc_C3031
loc_C302B:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_C3031:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0E8h+var_C0], rsi
mov [rax], rcx
mov rax, r13
shl rax, 4
add r12, rax
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
mov rdi, r14
mov rsi, [rsp+0E8h+var_40]
mov rdx, r12
lea rcx, [rsp+0E8h+var_C8]
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(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&,std::string const&)
lea rdi, [rsp+0E8h+var_68]
mov rsi, r14
lea r12, [rsp+0E8h+var_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+0E8h+var_A8]; void *
lea rax, [rsp+0E8h+var_98]
cmp rdi, rax
jz short loc_C30A1
mov rsi, [rsp+0E8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C30A1:
mov rdi, [rsp+0E8h+var_C8]; void *
cmp rdi, r12
jz short loc_C30B8
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C30B8:
mov rdi, [rsp+0E8h+var_88]; void *
cmp rdi, rbp
jz short loc_C30CF
mov rsi, [rsp+0E8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C30CF:
mov rdi, [rsp+0E8h+var_E8]; void *
lea rax, [rsp+0E8h+var_D8]
cmp rdi, rax
jz short loc_C30EA
mov rsi, [rsp+0E8h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C30EA:
inc r13
mov rax, [rsp+0E8h+var_48]
mov r12, [rax]
mov rax, [rax+8]
sub rax, r12
sar rax, 4
cmp r13, rax
jb loc_C2EE2
loc_C310C:
lea rbx, [rsp+0E8h+var_98]
mov [rbx-10h], rbx
lea rsi, asc_F3A96+1; " | "
lea rdx, asc_F3A96+4; ""
lea rdi, [rsp+0E8h+var_A8]
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, [rsp+0E8h+var_68]
lea rdx, [rsp+0E8h+var_A8]
mov r14, [rsp+0E8h+var_50]
mov rdi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
mov rdi, [rsp+0E8h+var_A8]; void *
cmp rdi, rbx
jz short loc_C3161
mov rsi, [rsp+0E8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C3161:
lea rdi, [rsp+0E8h+var_68]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, r14
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_38]
cmp rdi, rbx
jz loc_C3220
mov rsi, [rsp+arg_48]
jmp short loc_C3218
jmp short $+2
loc_C319D:
mov r14, rax
jmp short loc_C3220
jmp short $+2
loc_C31A4:
mov r14, rax
jmp short loc_C3205
mov r14, rax
jmp short loc_C31EE
mov r14, rax
jmp short loc_C31D2
mov r14, rax
mov rdi, [rsp+arg_38]; void *
lea rax, [rsp+arg_48]
cmp rdi, rax
jz short loc_C31D2
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C31D2:
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_C31EE
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C31EE:
mov rdi, [rsp+arg_58]; void *
cmp rdi, rbx
jz short loc_C3205
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C3205:
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_C3220
mov rsi, [rsp+arg_8]
loc_C3218:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C3220:
lea rdi, [rsp+arg_78]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
|
long long SchemaConverter::_generate_union_rule(long long a1, long long a2, long long a3, long long *a4)
{
__m128d v4; // xmm0
long long v5; // r12
unsigned long long *v6; // rbp
unsigned long long v7; // r13
unsigned long long *v8; // rbx
long long v9; // rbp
char *v10; // rsi
unsigned int v11; // esi
unsigned long long v12; // rcx
bool v13; // cc
unsigned long long v14; // rdi
unsigned long long v15; // rdi
void **v16; // rax
__m128d *v17; // rcx
long long v18; // r14
void *v20; // [rsp+0h] [rbp-E8h] BYREF
long long v21; // [rsp+8h] [rbp-E0h]
_QWORD v22[2]; // [rsp+10h] [rbp-D8h] BYREF
void *v23[2]; // [rsp+20h] [rbp-C8h] BYREF
__m128d v24; // [rsp+30h] [rbp-B8h] BYREF
void *v25[2]; // [rsp+40h] [rbp-A8h] BYREF
_QWORD v26[2]; // [rsp+50h] [rbp-98h] BYREF
void *v27; // [rsp+60h] [rbp-88h] BYREF
long long v28; // [rsp+68h] [rbp-80h]
unsigned long long v29; // [rsp+70h] [rbp-78h] BYREF
__int128 v30; // [rsp+80h] [rbp-68h] BYREF
long long v31; // [rsp+90h] [rbp-58h]
long long v32; // [rsp+98h] [rbp-50h]
long long *v33; // [rsp+A0h] [rbp-48h]
long long v34; // [rsp+A8h] [rbp-40h]
long long v35; // [rsp+B0h] [rbp-38h]
v35 = a3;
v34 = a2;
v32 = a1;
v4 = 0LL;
v30 = 0LL;
v31 = 0LL;
v5 = *a4;
v33 = a4;
if ( a4[1] != v5 )
{
v6 = &v29;
v7 = 0LL;
do
{
v8 = v6;
v9 = *(_QWORD *)(v35 + 8);
v20 = v22;
std::string::_M_construct<char *>((long long)&v20, *(_BYTE **)v35, *(_QWORD *)v35 + v9);
v10 = "-";
if ( !v9 )
v10 = "alternative-";
std::string::append(&v20, v10);
v11 = 1;
v6 = v8;
if ( v7 >= 0xA )
{
v11 = 4;
v12 = v7;
while ( 1 )
{
if ( v12 <= 0x63 )
{
v11 -= 2;
goto LABEL_14;
}
if ( v12 <= 0x3E7 )
break;
if ( v12 < 0x2710 )
goto LABEL_14;
v11 += 4;
v13 = v12 <= 0x1869F;
v12 /= 0x2710uLL;
if ( v13 )
{
v11 -= 3;
goto LABEL_14;
}
}
--v11;
}
LABEL_14:
v27 = v8;
std::string::_M_construct(&v27, v11, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>((char *)v27, v28, v7);
v14 = 15LL;
if ( v20 != v22 )
v14 = v22[0];
if ( v28 + v21 <= v14 )
goto LABEL_20;
v15 = 15LL;
if ( v27 != v8 )
v15 = v29;
if ( v28 + v21 <= v15 )
v16 = (void **)std::string::replace(&v27, 0LL, 0LL, v20, v21);
else
LABEL_20:
v16 = (void **)std::string::_M_append(&v20, v27, v28);
v23[0] = &v24;
v17 = (__m128d *)(v16 + 2);
if ( *v16 == v16 + 2 )
{
v4 = *v17;
v24 = *v17;
}
else
{
v23[0] = *v16;
v24.m128d_f64[0] = v17->m128d_f64[0];
}
v23[1] = v16[1];
*v16 = v17;
v16[1] = 0LL;
LOBYTE(v17->m128d_f64[0]) = 0;
SchemaConverter::visit(v25, v34, 16 * v7 + v5, (long long)v23, v4);
std::vector<std::string>::emplace_back<std::string>((long long)&v30, (long long)v25);
if ( v25[0] != v26 )
operator delete(v25[0], v26[0] + 1LL);
if ( v23[0] != &v24 )
operator delete(v23[0], *(_QWORD *)&v24.m128d_f64[0] + 1LL);
if ( v27 != v8 )
operator delete(v27, v29 + 1);
if ( v20 != v22 )
operator delete(v20, v22[0] + 1LL);
++v7;
v5 = *v33;
}
while ( v7 < (v33[1] - *v33) >> 4 );
}
v25[0] = v26;
std::string::_M_construct<char const*>((long long)v25, " | ", (long long)"");
v18 = v32;
string_join(v32, (long long *)&v30, v25);
if ( v25[0] != v26 )
operator delete(v25[0], v26[0] + 1LL);
std::vector<std::string>::~vector((long long)&v30);
return v18;
}
|
_generate_union_rule:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0x98],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x90],0x0
MOV R12,qword ptr [RCX]
MOV qword ptr [RSP + 0xa0],RCX
CMP qword ptr [RCX + 0x8],R12
JZ 0x001c310c
LEA RBP,[RSP + 0x70]
XOR R13D,R13D
LEA R14,[RSP + 0x40]
LAB_001c2ee2:
MOV RBX,RBP
MOV RCX,qword ptr [RSP + 0xb0]
MOV RBP,qword ptr [RCX + 0x8]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RCX]
LEA RDX,[RSI + RBP*0x1]
LAB_001c2f01:
MOV R15,RSP
MOV RDI,R15
CALL 0x001213b2
TEST RBP,RBP
LEA RSI,[0x1f3837]
LEA RAX,[0x1f38e0]
CMOVZ RSI,RAX
LAB_001c2f21:
MOV RDI,R15
CALL 0x0011b0f0
MOV ESI,0x1
CMP R13,0xa
MOV RBP,RBX
JC 0x001c2f86
MOV ESI,0x4
MOV RCX,R13
MOV RDI,0x346dc5d63886594b
LAB_001c2f49:
CMP RCX,0x63
JBE 0x001c2f7f
CMP RCX,0x3e7
JBE 0x001c2f84
CMP RCX,0x2710
JC 0x001c2f86
MOV RAX,RCX
MUL RDI
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x001c2f49
ADD ESI,-0x3
JMP 0x001c2f86
LAB_001c2f7f:
ADD ESI,-0x2
JMP 0x001c2f86
LAB_001c2f84:
DEC ESI
LAB_001c2f86:
MOV ESI,ESI
MOV qword ptr [RSP + 0x60],RBP
LAB_001c2f8d:
LEA RDI,[RSP + 0x60]
XOR EDX,EDX
CALL 0x0011aa30
MOV RDI,qword ptr [RSP + 0x60]
MOV ESI,dword ptr [RSP + 0x68]
MOV RDX,R13
CALL 0x00121652
MOV RCX,qword ptr [RSP]
MOV EDI,0xf
LEA RAX,[RSP + 0x10]
CMP RCX,RAX
JZ 0x001c2fc2
MOV RDI,qword ptr [RSP + 0x10]
LAB_001c2fc2:
MOV R8,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
LEA RAX,[RDX + R8*0x1]
CMP RAX,RDI
JBE 0x001c2fee
MOV EDI,0xf
CMP RSI,RBP
JZ 0x001c2fe9
MOV RDI,qword ptr [RSP + 0x70]
LAB_001c2fe9:
CMP RAX,RDI
JBE 0x001c2ff8
LAB_001c2fee:
MOV RDI,RSP
CALL 0x0011a260
JMP 0x001c3006
LAB_001c2ff8:
LEA RDI,[RSP + 0x60]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011a9e0
LAB_001c3006:
LEA RSI,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RSI
MOV RDX,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RDX,RCX
JZ 0x001c302b
MOV qword ptr [RSP + 0x20],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001c3031
LAB_001c302b:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_001c3031:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RAX],RCX
MOV RAX,R13
SHL RAX,0x4
ADD R12,RAX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_001c3058:
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,R12
LEA RCX,[RSP + 0x20]
CALL 0x001c00d2
LAB_001c3070:
LEA RDI,[RSP + 0x80]
MOV RSI,R14
LEA R12,[RSP + 0x30]
CALL 0x00155076
MOV RDI,qword ptr [RSP + 0x40]
LEA RAX,[RSP + 0x50]
CMP RDI,RAX
JZ 0x001c30a1
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x0011a8e0
LAB_001c30a1:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R12
JZ 0x001c30b8
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a8e0
LAB_001c30b8:
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,RBP
JZ 0x001c30cf
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011a8e0
LAB_001c30cf:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001c30ea
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a8e0
LAB_001c30ea:
INC R13
MOV RAX,qword ptr [RSP + 0xa0]
MOV R12,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,R12
SAR RAX,0x4
CMP R13,RAX
JC 0x001c2ee2
LAB_001c310c:
LEA RBX,[RSP + 0x50]
MOV qword ptr [RBX + -0x10],RBX
LAB_001c3115:
LEA RSI,[0x1f3a97]
LEA RDX,[0x1f3a9a]
LEA RDI,[RSP + 0x40]
CALL 0x001214e2
LAB_001c312d:
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x40]
MOV R14,qword ptr [RSP + 0x98]
MOV RDI,R14
CALL 0x001719b1
LAB_001c314a:
MOV RDI,qword ptr [RSP + 0x40]
CMP RDI,RBX
JZ 0x001c3161
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x0011a8e0
LAB_001c3161:
LEA RDI,[RSP + 0x80]
CALL 0x00120f1c
MOV RAX,R14
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_generate_union_rule(std::__cxx11::string const&,
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> > > const&) */
vector * SchemaConverter::_generate_union_rule(string *param_1,vector *param_2)
{
long *plVar1;
ulong uVar2;
bool bVar3;
string *psVar4;
char cVar5;
int8 *puVar6;
long *in_RCX;
ulong uVar7;
long *in_RDX;
char cVar8;
ulong uVar9;
ulong *local_e8;
long local_e0;
ulong local_d8 [2];
long *local_c8;
int8 local_c0;
long local_b8;
int8 uStack_b0;
long *local_a8 [2];
long local_98 [2];
ulong *local_88;
uint local_80;
int4 uStack_7c;
ulong local_78 [2];
int8 local_68;
int8 uStack_60;
int8 local_58;
string *local_50;
long *local_48;
vector *local_40;
long *local_38;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
local_50 = param_1;
local_40 = param_2;
if (in_RCX[1] != *in_RCX) {
uVar9 = 0;
local_48 = in_RCX;
local_38 = in_RDX;
do {
local_e8 = local_d8;
/* try { // try from 001c2f01 to 001c2f0b has its CatchHandler @ 001c319d */
std::__cxx11::string::_M_construct<char*>(&local_e8,*local_38,*local_38 + local_38[1]);
/* try { // try from 001c2f21 to 001c2f28 has its CatchHandler @ 001c31a2 */
std::__cxx11::string::append((char *)&local_e8);
cVar8 = '\x01';
if (9 < uVar9) {
uVar7 = uVar9;
cVar5 = '\x04';
do {
cVar8 = cVar5;
if (uVar7 < 100) {
cVar8 = cVar8 + -2;
goto LAB_001c2f86;
}
if (uVar7 < 1000) {
cVar8 = cVar8 + -1;
goto LAB_001c2f86;
}
if (uVar7 < 10000) goto LAB_001c2f86;
bVar3 = 99999 < uVar7;
uVar7 = uVar7 / 10000;
cVar5 = cVar8 + '\x04';
} while (bVar3);
cVar8 = cVar8 + '\x01';
}
LAB_001c2f86:
/* try { // try from 001c2f8d to 001c2f98 has its CatchHandler @ 001c31a4 */
local_88 = local_78;
std::__cxx11::string::_M_construct((ulong)&local_88,cVar8);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_88,local_80,uVar9);
uVar7 = 0xf;
if (local_e8 != local_d8) {
uVar7 = local_d8[0];
}
uVar2 = CONCAT44(uStack_7c,local_80) + local_e0;
if (uVar7 < uVar2) {
uVar7 = 0xf;
if (local_88 != local_78) {
uVar7 = local_78[0];
}
if (uVar7 < uVar2) goto LAB_001c2fee;
puVar6 = (int8 *)
std::__cxx11::string::replace((ulong)&local_88,0,(char *)0x0,(ulong)local_e8);
}
else {
LAB_001c2fee:
/* try { // try from 001c2fee to 001c3005 has its CatchHandler @ 001c31a9 */
puVar6 = (int8 *)std::__cxx11::string::_M_append((char *)&local_e8,(ulong)local_88);
}
local_c8 = &local_b8;
plVar1 = puVar6 + 2;
if ((long *)*puVar6 == plVar1) {
local_b8 = *plVar1;
uStack_b0 = puVar6[3];
}
else {
local_b8 = *plVar1;
local_c8 = (long *)*puVar6;
}
local_c0 = puVar6[1];
*puVar6 = plVar1;
puVar6[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 001c3058 to 001c306f has its CatchHandler @ 001c31ae */
visit((basic_json *)local_a8,(string *)local_40);
/* try { // try from 001c3070 to 001c3084 has its CatchHandler @ 001c31b3 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68,
(string *)local_a8);
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (local_c8 != &local_b8) {
operator_delete(local_c8,local_b8 + 1);
}
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_e8 != local_d8) {
operator_delete(local_e8,local_d8[0] + 1);
}
uVar9 = uVar9 + 1;
} while (uVar9 < (ulong)(local_48[1] - *local_48 >> 4));
}
/* try { // try from 001c3115 to 001c312c has its CatchHandler @ 001c319b */
local_a8[0] = local_98;
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001f3a97,&DAT_001f3a9a);
psVar4 = local_50;
/* try { // try from 001c312d to 001c3149 has its CatchHandler @ 001c3183 */
string_join((vector *)local_50,(string *)&local_68);
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
return (vector *)psVar4;
}
|
|
18,392
|
minja::TemplateNode::render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
void render(std::ostringstream & out, const std::shared_ptr<Context> & context) const {
try {
do_render(out, context);
} catch (const LoopControlException & e) {
// TODO: make stack creation lazy. Only needed if it was thrown outside of a loop.
std::ostringstream err;
err << e.what();
if (location_.source) err << error_location_suffix(*location_.source, location_.pos);
throw LoopControlException(err.str(), e.control_type);
} catch (const std::exception & e) {
std::ostringstream err;
err << e.what();
if (location_.source) err << error_location_suffix(*location_.source, location_.pos);
throw std::runtime_error(err.str());
}
}
|
O3
|
cpp
|
minja::TemplateNode::render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %r14
movq (%rdi), %rax
callq *(%rax)
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x2, %edx
jne 0x7d8e9
movq %rbx, %rdi
callq 0x192b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x198d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x19680
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x7d96e
movl $0x18, %edi
callq 0x19370
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x19a80
movl 0x10(%rbx), %ebx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x19840
leaq 0x6d8c7(%rip), %rax # 0xeb188
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
xorl %ebp, %ebp
leaq 0x6d89b(%rip), %rsi # 0xeb170
movq 0x6e6ac(%rip), %rdx # 0xebf88
movq %r14, %rdi
callq 0x19b70
jmp 0x7d96e
cmpl $0x1, %edx
jne 0x7db0b
movq %rbx, %rdi
callq 0x192b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x198d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x19680
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x7d9b4
movl $0x10, %edi
callq 0x19370
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x19a80
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x19ac0
xorl %ebp, %ebp
movq 0x6e689(%rip), %rsi # 0xebfe8
movq 0x6e602(%rip), %rdx # 0xebf68
movq %r14, %rdi
callq 0x19b70
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c4a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x19780
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d88b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7d88b
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c4a0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x19780
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d92a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7d92a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7dab6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7dab6
jmp 0x7dab3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7dae3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
jmp 0x7dae3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7da6b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
testb %bpl, %bpl
jne 0x7da75
jmp 0x7dab6
movq %rax, %rbx
movq %r14, %rdi
callq 0x19510
jmp 0x7dab6
jmp 0x7dae0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7da9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196b0
testb %bpl, %bpl
jne 0x7daa9
jmp 0x7dae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x19510
jmp 0x7dae3
movq %rax, %rbx
movq 0x6e4c3(%rip), %rsi # 0xebf80
leaq 0x28(%rsp), %rdi
callq 0x193c0
leaq 0x98(%rsp), %rdi
callq 0x19200
jmp 0x7dad9
movq %rax, %rbx
callq 0x19af0
jmp 0x7db0b
movq %rax, %rbx
movq 0x6e496(%rip), %rsi # 0xebf80
leaq 0x28(%rsp), %rdi
callq 0x193c0
leaq 0x98(%rsp), %rdi
callq 0x19200
jmp 0x7db06
movq %rax, %rbx
callq 0x19af0
movq %rbx, %rdi
callq 0x19be0
movq %rax, %rdi
callq 0x27a01
nop
|
_ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rdi
mov rax, [rdi]
call qword ptr [rax]
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 2
jnz loc_7D8E9
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]; int
test rsi, rsi
jnz loc_7D96E
loc_7D88B:
mov edi, 18h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov ebx, [rbx+10h]
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
xor ebp, ebp
lea rsi, _ZTIN5minja20LoopControlExceptionE; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD2Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
|
long long minja::TemplateNode::render(long long ( ***a1)(_QWORD))
{
return (**a1)(a1);
}
|
render:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RDI
MOV RAX,qword ptr [RDI]
LAB_0017d839:
CALL qword ptr [RAX]
LAB_0017d83b:
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::TemplateNode::render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void minja::TemplateNode::render(ostringstream *param_1,shared_ptr *param_2)
{
/* try { // try from 0017d839 to 0017d83a has its CatchHandler @ 0017d847 */
(*(code *)**(int8 **)param_1)();
return;
}
|
|
18,393
|
my_strnncollsp_latin1_de
|
eloqsql/strings/ctype-latin1.c
|
static int my_strnncollsp_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *a_end= a + a_length, *b_end= b + b_length;
uchar a_char, a_extend= 0, b_char, b_extend= 0;
while ((a < a_end || a_extend) && (b < b_end || b_extend))
{
if (a_extend)
{
a_char=a_extend;
a_extend= 0;
}
else
{
a_extend= combo2map[*a];
a_char= combo1map[*a++];
}
if (b_extend)
{
b_char= b_extend;
b_extend= 0;
}
else
{
b_extend= combo2map[*b];
b_char= combo1map[*b++];
}
if (a_char != b_char)
return (int) a_char - (int) b_char;
}
/* Check if double character last */
if (a_extend)
return 1;
if (b_extend)
return -1;
if (a < a_end)
return my_strnncollsp_padspace_bin(a, a_end - a);
if (b < b_end)
return -my_strnncollsp_padspace_bin(b, b_end - b);
return 0;
}
|
O3
|
c
|
my_strnncollsp_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
addq %rsi, %rdx
addq %rcx, %r8
xorl %edi, %edi
leaq 0x16d429(%rip), %rax # 0x1a7d30
leaq 0x16d322(%rip), %r9 # 0x1a7c30
xorl %r10d, %r10d
cmpq %rdx, %rsi
jb 0x3a91b
testb %dil, %dil
je 0x3a96b
cmpq %r8, %rcx
jb 0x3a925
testb %r10b, %r10b
je 0x3a977
testb %dil, %dil
je 0x3a931
movl %edi, %r11d
xorl %edi, %edi
jmp 0x3a940
movzbl (%rsi), %r11d
movb (%r11,%rax), %dil
incq %rsi
movb (%r11,%r9), %r11b
testb %r10b, %r10b
je 0x3a94d
movl %r10d, %ebx
xorl %r10d, %r10d
jmp 0x3a95b
movzbl (%rcx), %ebx
movb (%rbx,%rax), %r10b
incq %rcx
movb (%rbx,%r9), %bl
cmpb %bl, %r11b
je 0x3a911
movzbl %bl, %ecx
movzbl %r11b, %eax
subl %ecx, %eax
jmp 0x3a9b1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %r10b, %r10b
jne 0x3a9b1
jmp 0x3a99a
movl $0x1, %eax
testb %dil, %dil
jne 0x3a9b1
cmpq %rdx, %rsi
jae 0x3a99a
subq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x33f89
xorl %eax, %eax
cmpq %r8, %rcx
jae 0x3a9b1
subq %rcx, %r8
movq %rcx, %rdi
movq %r8, %rsi
callq 0x33f89
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
my_strnncollsp_latin1_de:
push rbp
mov rbp, rsp
push rbx
push rax
add rdx, rsi
add r8, rcx
xor edi, edi
lea rax, combo2map
lea r9, combo1map
xor r10d, r10d
loc_3A911:
cmp rsi, rdx
jb short loc_3A91B
test dil, dil
jz short loc_3A96B
loc_3A91B:
cmp rcx, r8
jb short loc_3A925
test r10b, r10b
jz short loc_3A977
loc_3A925:
test dil, dil
jz short loc_3A931
mov r11d, edi
xor edi, edi
jmp short loc_3A940
loc_3A931:
movzx r11d, byte ptr [rsi]
mov dil, [r11+rax]
inc rsi
mov r11b, [r11+r9]
loc_3A940:
test r10b, r10b
jz short loc_3A94D
mov ebx, r10d
xor r10d, r10d
jmp short loc_3A95B
loc_3A94D:
movzx ebx, byte ptr [rcx]
mov r10b, [rbx+rax]
inc rcx
mov bl, [rbx+r9]
loc_3A95B:
cmp r11b, bl
jz short loc_3A911
movzx ecx, bl
movzx eax, r11b
sub eax, ecx
jmp short loc_3A9B1
loc_3A96B:
mov eax, 0FFFFFFFFh
test r10b, r10b
jnz short loc_3A9B1
jmp short loc_3A99A
loc_3A977:
mov eax, 1
test dil, dil
jnz short loc_3A9B1
cmp rsi, rdx
jnb short loc_3A99A
sub rdx, rsi
mov rdi, rsi
mov rsi, rdx
add rsp, 8
pop rbx
pop rbp
jmp my_strnncollsp_padspace_bin
loc_3A99A:
xor eax, eax
cmp rcx, r8
jnb short loc_3A9B1
sub r8, rcx
mov rdi, rcx
mov rsi, r8
call my_strnncollsp_padspace_bin
neg eax
loc_3A9B1:
add rsp, 8
pop rbx
pop rbp
retn
|
long long my_strnncollsp_latin1_de(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5)
{
unsigned __int8 *v5; // rdx
unsigned __int8 *v6; // r8
unsigned __int8 v7; // di
unsigned __int8 v8; // r10
unsigned __int8 v9; // r11
long long v10; // r11
unsigned __int8 v11; // bl
long long v12; // rbx
long long result; // rax
v5 = &a2[a3];
v6 = &a4[a5];
v7 = 0;
v8 = 0;
while ( 1 )
{
if ( a2 >= v5 && !v7 )
{
result = 0xFFFFFFFFLL;
if ( v8 )
return result;
goto LABEL_19;
}
if ( a4 >= v6 && !v8 )
break;
if ( v7 )
{
v9 = v7;
v7 = 0;
}
else
{
v10 = *a2;
v7 = combo2map[v10];
++a2;
v9 = combo1map[v10];
}
if ( v8 )
{
v11 = v8;
v8 = 0;
}
else
{
v12 = *a4;
v8 = combo2map[v12];
++a4;
v11 = combo1map[v12];
}
if ( v9 != v11 )
return v9 - (unsigned int)v11;
}
result = 1LL;
if ( v7 )
return result;
if ( a2 < v5 )
return my_strnncollsp_padspace_bin((long long)a2, v5 - a2);
LABEL_19:
result = 0LL;
if ( a4 < v6 )
return (unsigned int)-my_strnncollsp_padspace_bin((long long)a4, v6 - a4);
return result;
}
|
my_strnncollsp_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
ADD RDX,RSI
ADD R8,RCX
XOR EDI,EDI
LEA RAX,[0x2a7d30]
LEA R9,[0x2a7c30]
XOR R10D,R10D
LAB_0013a911:
CMP RSI,RDX
JC 0x0013a91b
TEST DIL,DIL
JZ 0x0013a96b
LAB_0013a91b:
CMP RCX,R8
JC 0x0013a925
TEST R10B,R10B
JZ 0x0013a977
LAB_0013a925:
TEST DIL,DIL
JZ 0x0013a931
MOV R11D,EDI
XOR EDI,EDI
JMP 0x0013a940
LAB_0013a931:
MOVZX R11D,byte ptr [RSI]
MOV DIL,byte ptr [R11 + RAX*0x1]
INC RSI
MOV R11B,byte ptr [R11 + R9*0x1]
LAB_0013a940:
TEST R10B,R10B
JZ 0x0013a94d
MOV EBX,R10D
XOR R10D,R10D
JMP 0x0013a95b
LAB_0013a94d:
MOVZX EBX,byte ptr [RCX]
MOV R10B,byte ptr [RBX + RAX*0x1]
INC RCX
MOV BL,byte ptr [RBX + R9*0x1]
LAB_0013a95b:
CMP R11B,BL
JZ 0x0013a911
MOVZX ECX,BL
MOVZX EAX,R11B
SUB EAX,ECX
JMP 0x0013a9b1
LAB_0013a96b:
MOV EAX,0xffffffff
TEST R10B,R10B
JNZ 0x0013a9b1
JMP 0x0013a99a
LAB_0013a977:
MOV EAX,0x1
TEST DIL,DIL
JNZ 0x0013a9b1
CMP RSI,RDX
JNC 0x0013a99a
SUB RDX,RSI
MOV RDI,RSI
MOV RSI,RDX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00133f89
LAB_0013a99a:
XOR EAX,EAX
CMP RCX,R8
JNC 0x0013a9b1
SUB R8,RCX
MOV RDI,RCX
MOV RSI,R8
CALL 0x00133f89
NEG EAX
LAB_0013a9b1:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
ulong my_strnncollsp_latin1_de
(int8 param_1,byte *param_2,long param_3,byte *param_4,long param_5)
{
int iVar1;
ulong uVar2;
byte *pbVar3;
byte bVar4;
byte bVar5;
byte *pbVar6;
byte bVar7;
byte bVar8;
pbVar3 = param_2 + param_3;
pbVar6 = param_4 + param_5;
bVar5 = 0;
bVar7 = 0;
do {
if ((pbVar3 <= param_2) && (bVar5 == 0)) {
if (bVar7 != 0) {
return 0xffffffff;
}
LAB_0013a99a:
if (pbVar6 <= param_4) {
return 0;
}
iVar1 = my_strnncollsp_padspace_bin(param_4,(long)pbVar6 - (long)param_4);
return (ulong)(uint)-iVar1;
}
if ((pbVar6 <= param_4) && (bVar7 == 0)) {
if (bVar5 != 0) {
return 1;
}
if (param_2 < pbVar3) {
uVar2 = my_strnncollsp_padspace_bin(param_2,(long)pbVar3 - (long)param_2);
return uVar2;
}
goto LAB_0013a99a;
}
if (bVar5 == 0) {
bVar8 = *param_2;
bVar5 = combo2map[bVar8];
param_2 = param_2 + 1;
bVar8 = combo1map[bVar8];
}
else {
bVar8 = bVar5;
bVar5 = 0;
}
if (bVar7 == 0) {
bVar4 = *param_4;
bVar7 = combo2map[bVar4];
param_4 = param_4 + 1;
bVar4 = combo1map[bVar4];
}
else {
bVar4 = bVar7;
bVar7 = 0;
}
if (bVar8 != bVar4) {
return (ulong)((uint)bVar8 - (uint)bVar4);
}
} while( true );
}
|
|
18,394
|
backup_block_ddl(THD*)
|
eloqsql/sql/backup.cc
|
static bool backup_block_ddl(THD *thd)
{
PSI_stage_info org_stage;
uint sleep_time;
DBUG_ENTER("backup_block_ddl");
kill_delayed_threads();
mysql_ha_cleanup_no_free(thd);
thd->backup_stage(&org_stage);
THD_STAGE_INFO(thd, stage_waiting_for_flush);
/* Wait until all non trans statements has ended */
if (thd->mdl_context.upgrade_shared_lock(backup_flush_ticket,
MDL_BACKUP_WAIT_FLUSH,
thd->variables.lock_wait_timeout))
goto err;
/*
Remove not used tables from the table share. Flush all changes to
non transaction tables and mark those that are not in use in write
operations as closed. From backup purposes it's not critical if
flush_tables() returns an error. It's ok to continue with next
backup stage even if we got an error.
*/
(void) flush_tables(thd, FLUSH_NON_TRANS_TABLES);
thd->clear_error();
#ifdef WITH_WSREP
/*
We desync the node for BACKUP STAGE because applier threads
bypass backup MDL locks (see MDL_lock::can_grant_lock)
*/
if (WSREP_NNULL(thd))
{
Wsrep_server_state &server_state= Wsrep_server_state::instance();
if (server_state.desync_and_pause().is_undefined()) {
DBUG_RETURN(1);
}
thd->wsrep_desynced_backup_stage= true;
}
#endif /* WITH_WSREP */
/*
block new DDL's, in addition to all previous blocks
We didn't do this lock above, as we wanted DDL's to be executed while
we wait for non transactional tables (which may take a while).
We do this lock in a loop as we can get a deadlock if there are multi-object
ddl statements like
RENAME TABLE t1 TO t2, t3 TO t3
and the MDL happens in the middle of it.
*/
THD_STAGE_INFO(thd, stage_waiting_for_ddl);
sleep_time= 100; // Start with 0.1 seconds
for (uint i= 0 ; i <= MAX_RETRY_COUNT ; i++)
{
if (!thd->mdl_context.upgrade_shared_lock(backup_flush_ticket,
MDL_BACKUP_WAIT_DDL,
thd->variables.lock_wait_timeout))
break;
if (thd->get_stmt_da()->sql_errno() != ER_LOCK_DEADLOCK || thd->killed ||
i == MAX_RETRY_COUNT)
{
/*
Could be a timeout. Downgrade lock to what is was before this function
was called so that this function can be called again
*/
backup_flush_ticket->downgrade_lock(MDL_BACKUP_FLUSH);
goto err;
}
thd->clear_error(); // Forget the DEADLOCK error
my_sleep(sleep_time);
sleep_time*= 5; // Wait a bit longer next time
}
/* There can't be anything more that needs to be logged to ddl log */
THD_STAGE_INFO(thd, org_stage);
stop_ddl_logging();
DBUG_RETURN(0);
err:
THD_STAGE_INFO(thd, org_stage);
DBUG_RETURN(1);
}
|
O0
|
cpp
|
backup_block_ddl(THD*):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
callq 0x8b47b0
movq -0x10(%rbp), %rdi
callq 0x8aec30
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x890510
movq -0x10(%rbp), %rdi
leaq 0xf8aebe(%rip), %rsi # 0x1acad30
leaq 0x8453cc(%rip), %rdx # 0x1385245
leaq 0x878943(%rip), %rcx # 0x13b87c3
movl $0x113, %r8d # imm = 0x113
callq 0x7dbdb0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x150, %rdi # imm = 0x150
movq 0x11bc5a8(%rip), %rsi # 0x1cfc448
movq 0x968(%rax), %xmm0
movaps 0x904801(%rip), %xmm1 # 0x14446b0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x904805(%rip), %xmm1 # 0x14446c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl $0x2, %edx
callq 0xa65080
testb $0x1, %al
jne 0xb3feda
jmp 0xb3fedf
jmp 0xb4006d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x85f240
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x811a50
leaq 0x1a0e025(%rip), %rax # 0x254df24
testb $0x1, (%rax)
je 0xb3ff4c
movq -0x10(%rbp), %rax
cmpb $0x0, 0xbd0(%rax)
je 0xb3ff4c
callq 0x7dc760
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x135d6a0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb40ec0
testb $0x1, %al
jne 0xb3ff36
jmp 0xb3ff41
jmp 0xb3ff38
movb $0x1, -0x1(%rbp)
jmp 0xb40092
movq -0x10(%rbp), %rax
movb $0x1, 0x3e74(%rax)
movq -0x10(%rbp), %rdi
leaq 0xf8adf1(%rip), %rsi # 0x1acad48
leaq 0x8452e7(%rip), %rdx # 0x1385245
leaq 0x87885e(%rip), %rcx # 0x13b87c3
movl $0x13d, %r8d # imm = 0x13D
callq 0x7dbdb0
movl $0x64, -0x2c(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
ja 0xb40041
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x150, %rdi # imm = 0x150
movq 0x11bc4ab(%rip), %rsi # 0x1cfc448
movq 0x968(%rax), %xmm0
movaps 0x904704(%rip), %xmm1 # 0x14446b0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x904708(%rip), %xmm1 # 0x14446c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl $0x3, %edx
callq 0xa65080
testb $0x1, %al
jne 0xb3ffd7
jmp 0xb40041
movq -0x10(%rbp), %rdi
callq 0x7ddd20
movq %rax, %rdi
callq 0x7ec100
cmpl $0x4bd, %eax # imm = 0x4BD
jne 0xb40004
movq -0x10(%rbp), %rax
movl 0x3ebc(%rax), %eax
cmpl $0x0, %eax
jne 0xb40004
cmpl $0x5, -0x44(%rbp)
jne 0xb40017
movq 0x11bc43d(%rip), %rdi # 0x1cfc448
movl $0x1, %esi
callq 0xa65a40
jmp 0xb4006d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x811a50
movl -0x2c(%rbp), %eax
movl %eax, %edi
callq 0x12c8d70
imull $0x5, -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xb3ff7e
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq 0x8451f5(%rip), %rdx # 0x1385245
leaq 0x87876c(%rip), %rcx # 0x13b87c3
movl $0x155, %r8d # imm = 0x155
callq 0x7dbdb0
callq 0xb40260
movb $0x0, -0x1(%rbp)
jmp 0xb40092
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq 0x8451c9(%rip), %rdx # 0x1385245
leaq 0x878740(%rip), %rcx # 0x13b87c3
movl $0x159, %r8d # imm = 0x159
callq 0x7dbdb0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZL16backup_block_ddlP3THD:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
call _Z20kill_delayed_threadsv; kill_delayed_threads(void)
mov rdi, [rbp+var_10]; THD *
call _Z24mysql_ha_cleanup_no_freeP3THD; mysql_ha_cleanup_no_free(THD *)
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_28]
call _ZN3THD12backup_stageEP17PSI_stage_info_v1; THD::backup_stage(PSI_stage_info_v1 *)
mov rdi, [rbp+var_10]
lea rsi, stage_waiting_for_flush
lea rdx, aUnknown; "<unknown>"
lea rcx, aWorkspaceLlm4b_88; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 113h
call _ZN3THD11enter_stageEPK17PSI_stage_info_v1PKcS4_j; THD::enter_stage(PSI_stage_info_v1 const*,char const*,char const*,uint)
mov rax, [rbp+var_10]
mov rdi, rax
add rdi, 150h
mov rsi, cs:_ZL19backup_flush_ticket; backup_flush_ticket
movq xmm0, qword ptr [rax+968h]
movaps xmm1, cs:xmmword_14446B0
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_14446C0
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
mov edx, 2
call _ZN11MDL_context19upgrade_shared_lockEP10MDL_ticket13enum_mdl_typed; MDL_context::upgrade_shared_lock(MDL_ticket *,enum_mdl_type,double)
test al, 1
jnz short loc_B3FEDA
jmp short loc_B3FEDF
loc_B3FEDA:
jmp loc_B4006D
loc_B3FEDF:
mov rdi, [rbp+var_10]
mov esi, 1
call _Z12flush_tablesP3THD17flush_tables_type; flush_tables(THD *,flush_tables_type)
mov rdi, [rbp+var_10]; this
xor esi, esi; bool
call _ZN3THD11clear_errorEb; THD::clear_error(bool)
lea rax, WSREP_PROVIDER_EXISTS_
test byte ptr [rax], 1
jz short loc_B3FF4C
mov rax, [rbp+var_10]
cmp byte ptr [rax+0BD0h], 0
jz short loc_B3FF4C
call _ZN18Wsrep_server_state8instanceEv; Wsrep_server_state::instance(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]; this
call _ZN5wsrep12server_state16desync_and_pauseEv; wsrep::server_state::desync_and_pause(void)
mov [rbp+var_40], rax
lea rdi, [rbp+var_40]; this
call _ZNK5wsrep5seqno12is_undefinedEv; wsrep::seqno::is_undefined(void)
test al, 1
jnz short loc_B3FF36
jmp short loc_B3FF41
loc_B3FF36:
jmp short $+2
loc_B3FF38:
mov [rbp+var_1], 1
jmp loc_B40092
loc_B3FF41:
mov rax, [rbp+var_10]
mov byte ptr [rax+3E74h], 1
loc_B3FF4C:
mov rdi, [rbp+var_10]
lea rsi, stage_waiting_for_ddl
lea rdx, aUnknown; "<unknown>"
lea rcx, aWorkspaceLlm4b_88; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 13Dh
call _ZN3THD11enter_stageEPK17PSI_stage_info_v1PKcS4_j; THD::enter_stage(PSI_stage_info_v1 const*,char const*,char const*,uint)
mov [rbp+var_2C], 64h ; 'd'
mov [rbp+var_44], 0
loc_B3FF7E:
cmp [rbp+var_44], 5
ja loc_B40041
mov rax, [rbp+var_10]
mov rdi, rax
add rdi, 150h
mov rsi, cs:_ZL19backup_flush_ticket; backup_flush_ticket
movq xmm0, qword ptr [rax+968h]
movaps xmm1, cs:xmmword_14446B0
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_14446C0
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
mov edx, 3
call _ZN11MDL_context19upgrade_shared_lockEP10MDL_ticket13enum_mdl_typed; MDL_context::upgrade_shared_lock(MDL_ticket *,enum_mdl_type,double)
test al, 1
jnz short loc_B3FFD7
jmp short loc_B40041
loc_B3FFD7:
mov rdi, [rbp+var_10]; this
call _ZN3THD11get_stmt_daEv; THD::get_stmt_da(void)
mov rdi, rax; this
call _ZNK16Diagnostics_area9sql_errnoEv; Diagnostics_area::sql_errno(void)
cmp eax, 4BDh
jnz short loc_B40004
mov rax, [rbp+var_10]
mov eax, [rax+3EBCh]
cmp eax, 0
jnz short loc_B40004
cmp [rbp+var_44], 5
jnz short loc_B40017
loc_B40004:
mov rdi, cs:_ZL19backup_flush_ticket; backup_flush_ticket
mov esi, 1
call _ZN10MDL_ticket14downgrade_lockE13enum_mdl_type; MDL_ticket::downgrade_lock(enum_mdl_type)
jmp short loc_B4006D
loc_B40017:
mov rdi, [rbp+var_10]; this
xor esi, esi; bool
call _ZN3THD11clear_errorEb; THD::clear_error(bool)
mov eax, [rbp+var_2C]
mov edi, eax
call my_sleep
imul eax, [rbp+var_2C], 5
mov [rbp+var_2C], eax
mov eax, [rbp+var_44]
add eax, 1
mov [rbp+var_44], eax
jmp loc_B3FF7E
loc_B40041:
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_28]
lea rdx, aUnknown; "<unknown>"
lea rcx, aWorkspaceLlm4b_88; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 155h
call _ZN3THD11enter_stageEPK17PSI_stage_info_v1PKcS4_j; THD::enter_stage(PSI_stage_info_v1 const*,char const*,char const*,uint)
call _ZL16stop_ddl_loggingv; stop_ddl_logging(void)
mov [rbp+var_1], 0
jmp short loc_B40092
loc_B4006D:
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_28]
lea rdx, aUnknown; "<unknown>"
lea rcx, aWorkspaceLlm4b_88; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 159h
call _ZN3THD11enter_stageEPK17PSI_stage_info_v1PKcS4_j; THD::enter_stage(PSI_stage_info_v1 const*,char const*,char const*,uint)
mov [rbp+var_1], 1
loc_B40092:
mov al, [rbp+var_1]
and al, 1
add rsp, 50h
pop rbp
retn
|
char backup_block_ddl(THD *a1)
{
__m128d v1; // xmm1
Wsrep_server_state *v2; // rdi
__m128d v3; // xmm1
Diagnostics_area *stmt_da; // rax
unsigned int i; // [rsp+Ch] [rbp-44h]
long long v7; // [rsp+10h] [rbp-40h] BYREF
wsrep::server_state *v8; // [rsp+18h] [rbp-38h]
unsigned int v9; // [rsp+24h] [rbp-2Ch]
_BYTE v10[24]; // [rsp+28h] [rbp-28h] BYREF
Wsrep_server_state *v11; // [rsp+40h] [rbp-10h]
v11 = a1;
kill_delayed_threads();
mysql_ha_cleanup_no_free(a1);
THD::backup_stage((long long)a1, (long long)v10);
THD::enter_stage(
(long long)v11,
(long long)&stage_waiting_for_flush,
"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/sql/backup.cc",
0x113u);
v1 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)((char *)v11 + 2408)), (__m128i)xmmword_14446B0),
(__m128d)xmmword_14446C0);
if ( (MDL_context::upgrade_shared_lock(
(Wsrep_server_state *)((char *)v11 + 336),
(MDL_ticket *)backup_flush_ticket,
2,
_mm_unpackhi_pd(v1, v1).m128d_f64[0] + v1.m128d_f64[0]) & 1) != 0 )
{
LABEL_16:
THD::enter_stage(
(long long)v11,
(long long)v10,
"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/sql/backup.cc",
0x159u);
return 1;
}
flush_tables(v11, 1);
v2 = v11;
THD::clear_error(v11, 0);
if ( (WSREP_PROVIDER_EXISTS_ & 1) != 0 && *((_BYTE *)v11 + 3024) )
{
v8 = (wsrep::server_state *)Wsrep_server_state::instance(v2);
v7 = wsrep::server_state::desync_and_pause(v8);
if ( (wsrep::seqno::is_undefined((wsrep::seqno *)&v7) & 1) != 0 )
return 1;
*((_BYTE *)v11 + 15988) = 1;
}
THD::enter_stage(
(long long)v11,
(long long)&stage_waiting_for_ddl,
"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/sql/backup.cc",
0x13Du);
v9 = 100;
for ( i = 0; i <= 5; ++i )
{
v3 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)((char *)v11 + 2408)), (__m128i)xmmword_14446B0),
(__m128d)xmmword_14446C0);
if ( (MDL_context::upgrade_shared_lock(
(Wsrep_server_state *)((char *)v11 + 336),
(MDL_ticket *)backup_flush_ticket,
3,
_mm_unpackhi_pd(v3, v3).m128d_f64[0] + v3.m128d_f64[0]) & 1) == 0 )
break;
stmt_da = (Diagnostics_area *)THD::get_stmt_da(v11);
if ( (unsigned int)Diagnostics_area::sql_errno(stmt_da) != 1213 || *((_DWORD *)v11 + 4015) || i == 5 )
{
MDL_ticket::downgrade_lock(backup_flush_ticket, 1);
goto LABEL_16;
}
THD::clear_error(v11, 0);
my_sleep(v9);
v9 *= 5;
}
THD::enter_stage(
(long long)v11,
(long long)v10,
"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/sql/backup.cc",
0x155u);
stop_ddl_logging();
return 0;
}
|
field_type_handler:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RDI,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,dword ptr [RBP + -0x14]
MOV ESI,EAX
CALL 0x00b3e560
MOV RDI,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x18],EAX
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00b40dc0
MOV word ptr [RBP + -0x1a],AX
JMP 0x00b3fe76
LAB_00b3fe76:
JMP 0x00b3fe78
LAB_00b3fe78:
JMP 0x00b3fe7a
LAB_00b3fe7a:
CMP dword ptr [RBP + -0x18],0xfc
JNZ 0x00b3feef
MOVZX EAX,byte ptr [RBP + -0x1a]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x30],RCX
SUB EAX,0x3
JA 0x00b3fee5
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x1549478]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
LEA RAX,[0x1dfb740]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
caseD_2:
LEA RAX,[0x1dfb788]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
caseD_3:
LEA RAX,[0x1dfb758]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
caseD_4:
LEA RAX,[0x1dfb770]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
default:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00b3ff5e
LAB_00b3feef:
CMP dword ptr [RBP + -0x18],0xfe
JNZ 0x00b3ff3f
MOVZX EAX,word ptr [RBP + -0x1a]
SAR EAX,0x8
MOV byte ptr [RBP + -0x1b],AL
MOVZX EAX,byte ptr [RBP + -0x1b]
CMP EAX,0xf8
JNZ 0x00b3ff1a
LEA RAX,[0x1dfb6b0]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
LAB_00b3ff1a:
MOVZX EAX,byte ptr [RBP + -0x1b]
CMP EAX,0xf7
JNZ 0x00b3ff32
LEA RAX,[0x1dfb698]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
LAB_00b3ff32:
LEA RAX,[0x1dfb6c8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
LAB_00b3ff3f:
CMP dword ptr [RBP + -0x18],0xa
JNZ 0x00b3ff52
LEA RAX,[0x1dfb668]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00b3ff5e
LAB_00b3ff52:
MOV EDI,dword ptr [RBP + -0x18]
CALL 0x00bec1d0
MOV qword ptr [RBP + -0x8],RAX
LAB_00b3ff5e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* table_def::field_type_handler(unsigned int) const */
int8 * __thiscall table_def::field_type_handler(table_def *this,uint param_1)
{
char cVar1;
int2 uVar2;
int iVar3;
int1 local_22;
int8 *local_10;
iVar3 = binlog_type(this,(ulong)param_1);
uVar2 = field_metadata(this,param_1);
if (iVar3 == 0xfc) {
local_22 = (int1)uVar2;
switch(local_22) {
case 1:
local_10 = (int8 *)type_handler_tiny_blob;
break;
case 2:
local_10 = (int8 *)type_handler_blob;
break;
case 3:
local_10 = (int8 *)type_handler_medium_blob;
break;
case 4:
local_10 = (int8 *)type_handler_long_blob;
break;
default:
local_10 = (int8 *)0x0;
}
}
else if (iVar3 == 0xfe) {
cVar1 = (char)((ushort)uVar2 >> 8);
if (cVar1 == -8) {
local_10 = (int8 *)type_handler_set;
}
else if (cVar1 == -9) {
local_10 = (int8 *)type_handler_enum;
}
else {
local_10 = &type_handler_string;
}
}
else if (iVar3 == 10) {
local_10 = (int8 *)type_handler_newdate;
}
else {
local_10 = (int8 *)Type_handler::get_handler_by_real_type(iVar3);
}
return local_10;
}
|
|
18,395
|
bool (anonymous namespace)::IsDifferent<double [3]>(double const (&) [3], double const (&) [3])
|
aimrt_mujoco_sim/_deps/mujoco-src/simulate/simulate.cc
|
inline bool IsDifferent(const T& a, const T& b) {
if constexpr (std::is_array_v<T>) {
static_assert(std::rank_v<T> == 1);
for (int i = 0; i < std::extent_v<T>; ++i) {
if (a[i] != b[i]) {
return true;
}
}
return false;
} else {
return a != b;
}
}
|
O0
|
cpp
|
bool (anonymous namespace)::IsDifferent<double [3]>(double const (&) [3], double const (&) [3]):
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movslq -0x1c(%rsp), %rax
cmpq $0x20, %rax
jae 0x397a63
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x397a54
movb $0x1, -0x1(%rsp)
jmp 0x397a68
jmp 0x397a56
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x397a22
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
|
_ZN12_GLOBAL__N_111IsDifferentIA32_hEEbRKT_S4_:
mov [rsp+var_10], rdi
mov [rsp+var_18], rsi
mov [rsp+var_1C], 0
loc_397A22:
movsxd rax, [rsp+var_1C]
cmp rax, 20h ; ' '
jnb short loc_397A63
mov rax, [rsp+var_10]
movsxd rcx, [rsp+var_1C]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rsp+var_18]
movsxd rdx, [rsp+var_1C]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_397A54
mov [rsp+var_1], 1
jmp short loc_397A68
loc_397A54:
jmp short $+2
loc_397A56:
mov eax, [rsp+var_1C]
add eax, 1
mov [rsp+var_1C], eax
jmp short loc_397A22
loc_397A63:
mov [rsp+var_1], 0
loc_397A68:
mov al, [rsp+var_1]
and al, 1
retn
|
char `anonymous namespace'::IsDifferent<unsigned char [32]>(long long a1, long long a2)
{
int i; // [rsp+0h] [rbp-1Ch]
for ( i = 0; (unsigned long long)i < 0x20; ++i )
{
if ( *(unsigned __int8 *)(a1 + i) != *(unsigned __int8 *)(a2 + i) )
return 1;
}
return 0;
}
|
NewFromPrototype:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00397a30
ADD RSP,0x18
RET
|
/* google::protobuf::internal::GenericTypeHandler<google::protobuf::SourceCodeInfo_Location>::NewFromPrototype(google::protobuf::SourceCodeInfo_Location
const*, google::protobuf::Arena*) */
void google::protobuf::internal::GenericTypeHandler<google::protobuf::SourceCodeInfo_Location>::
NewFromPrototype(SourceCodeInfo_Location *param_1,Arena *param_2)
{
New(param_2);
return;
}
|
|
18,396
|
mysql_set_character_set
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname)
{
const MARIADB_CHARSET_INFO *cs;
if (!csname)
goto error;
if ((cs= mysql_find_charset_name(csname)))
{
char buff[64];
snprintf(buff, 63, "SET NAMES %s", cs->csname);
if (!mysql_real_query(mysql, buff, (unsigned long)strlen(buff)))
{
mysql->charset= cs;
return(0);
}
return(mysql->net.last_errno);
}
error:
my_set_error(mysql, CR_CANT_READ_CHARSET, SQLSTATE_UNKNOWN,
0, csname, "compiled_in");
return(mysql->net.last_errno);
}
|
O0
|
c
|
mysql_set_character_set:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x1fc8c
jmp 0x1fd15
movq -0x68(%rbp), %rdi
callq 0x462d0
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x1fd13
leaq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x3f, %esi
leaq 0x2e558(%rip), %rdx # 0x4e20f
movb $0x0, %al
callq 0x136d0
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x131a0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
callq 0x1f380
cmpl $0x0, %eax
jne 0x1fd04
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x2f0(%rax)
movl $0x0, -0x54(%rbp)
jmp 0x1fd4b
movq -0x60(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x54(%rbp)
jmp 0x1fd4b
jmp 0x1fd15
movq -0x60(%rbp), %rdi
leaq 0x422b0(%rip), %rax # 0x61fd0
movq (%rax), %rdx
movq -0x68(%rbp), %r8
movl $0x7e3, %esi # imm = 0x7E3
xorl %eax, %eax
movl %eax, %ecx
leaq 0x2e40c(%rip), %r9 # 0x4e143
movb $0x0, %al
callq 0x18360
movq -0x60(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x84(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x1fd75
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
callq 0x134b0
nopw (%rax,%rax)
|
mysql_set_character_set:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
cmp [rbp+var_68], 0
jnz short loc_1FC8C
jmp loc_1FD15
loc_1FC8C:
mov rdi, [rbp+var_68]
call mysql_find_charset_name
mov [rbp+var_70], rax
cmp rax, 0
jz short loc_1FD13
lea rdi, [rbp+var_50]
mov rax, [rbp+var_70]
mov rcx, [rax+8]
mov esi, 3Fh ; '?'
lea rdx, aSetNamesS; "SET NAMES %s"
mov al, 0
call _snprintf
mov rax, [rbp+var_60]
mov [rbp+var_80], rax
lea rax, [rbp+var_50]
mov [rbp+var_78], rax
lea rdi, [rbp+var_50]
call _strlen
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_78]
mov rdx, rax
call mysql_real_query
cmp eax, 0
jnz short loc_1FD04
mov rcx, [rbp+var_70]
mov rax, [rbp+var_60]
mov [rax+2F0h], rcx
mov [rbp+var_54], 0
jmp short loc_1FD4B
loc_1FD04:
mov rax, [rbp+var_60]
mov eax, [rax+90h]
mov [rbp+var_54], eax
jmp short loc_1FD4B
loc_1FD13:
jmp short $+2
loc_1FD15:
mov rdi, [rbp+var_60]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov r8, [rbp+var_68]
mov esi, 7E3h
xor eax, eax
mov ecx, eax
lea r9, aCompiledIn; "compiled_in"
mov al, 0
call my_set_error
mov rax, [rbp+var_60]
mov eax, [rax+90h]
mov [rbp+var_54], eax
loc_1FD4B:
mov eax, [rbp+var_54]
mov [rbp+var_84], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_1FD75
mov eax, [rbp+var_84]
add rsp, 90h
pop rbp
retn
loc_1FD75:
call ___stack_chk_fail
|
long long mysql_set_character_set(long long a1, long long a2)
{
long long v2; // rax
long long charset_name; // [rsp+20h] [rbp-70h]
_BYTE v6[72]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+88h] [rbp-8h]
v7 = __readfsqword(0x28u);
if ( a2 && (charset_name = mysql_find_charset_name(a2)) != 0 )
{
snprintf(v6, 63LL, "SET NAMES %s", *(const char **)(charset_name + 8));
v2 = strlen(v6);
if ( (unsigned int)mysql_real_query(a1, (long long)v6, v2) )
{
return *(unsigned int *)(a1 + 144);
}
else
{
*(_QWORD *)(a1 + 752) = charset_name;
return 0;
}
}
else
{
my_set_error(a1, 0x7E3u, (long long)SQLSTATE_UNKNOWN, 0LL, a2, "compiled_in");
return *(unsigned int *)(a1 + 144);
}
}
|
mysql_set_character_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
CMP qword ptr [RBP + -0x68],0x0
JNZ 0x0011fc8c
JMP 0x0011fd15
LAB_0011fc8c:
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x001462d0
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,0x0
JZ 0x0011fd13
LEA RDI,[RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RAX + 0x8]
MOV ESI,0x3f
LEA RDX,[0x14e20f]
MOV AL,0x0
CALL 0x001136d0
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x80],RAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x50]
CALL 0x001131a0
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,RAX
CALL 0x0011f380
CMP EAX,0x0
JNZ 0x0011fd04
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x2f0],RCX
MOV dword ptr [RBP + -0x54],0x0
JMP 0x0011fd4b
LAB_0011fd04:
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0011fd4b
LAB_0011fd13:
JMP 0x0011fd15
LAB_0011fd15:
MOV RDI,qword ptr [RBP + -0x60]
LEA RAX,[0x161fd0]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RBP + -0x68]
MOV ESI,0x7e3
XOR EAX,EAX
MOV ECX,EAX
LEA R9,[0x14e143]
MOV AL,0x0
CALL 0x00118360
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x54],EAX
LAB_0011fd4b:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x84],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0011fd75
MOV EAX,dword ptr [RBP + -0x84]
ADD RSP,0x90
POP RBP
RET
LAB_0011fd75:
CALL 0x001134b0
|
int4 mysql_set_character_set(long param_1,long param_2)
{
int iVar1;
long lVar2;
size_t sVar3;
long in_FS_OFFSET;
int4 local_5c;
char local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((param_2 == 0) || (lVar2 = mysql_find_charset_name(param_2), lVar2 == 0)) {
my_set_error(param_1,0x7e3,SQLSTATE_UNKNOWN,0,param_2,"compiled_in");
local_5c = *(int4 *)(param_1 + 0x90);
}
else {
snprintf(local_58,0x3f,"SET NAMES %s",*(int8 *)(lVar2 + 8));
sVar3 = strlen(local_58);
iVar1 = mysql_real_query(param_1,local_58,sVar3);
if (iVar1 == 0) {
*(long *)(param_1 + 0x2f0) = lVar2;
local_5c = 0;
}
else {
local_5c = *(int4 *)(param_1 + 0x90);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_5c;
}
|
|
18,397
|
nglog::LogMessage::Flush()
|
ng-log[P]ng-log/src/logging.cc
|
void LogMessage::Flush() {
if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) {
return;
}
data_->num_chars_to_log_ = data_->stream_.pcount();
data_->num_chars_to_syslog_ =
data_->num_chars_to_log_ - data_->num_prefix_chars_;
// Do we need to add a \n to the end of this message?
bool append_newline =
(data_->message_text_[data_->num_chars_to_log_ - 1] != '\n');
char original_final_char = '\0';
// If we do need to add a \n, we'll do it by violating the memory of the
// ostrstream buffer. This is quick, and we'll make sure to undo our
// modification before anything else is done with the ostrstream. It
// would be preferable not to do things this way, but it seems to be
// the best way to deal with this.
if (append_newline) {
original_final_char = data_->message_text_[data_->num_chars_to_log_];
data_->message_text_[data_->num_chars_to_log_++] = '\n';
}
data_->message_text_[data_->num_chars_to_log_] = '\0';
// Prevent any subtle race conditions by wrapping a mutex lock around
// the actual logging action per se.
{
std::lock_guard<std::mutex> l{log_mutex};
(this->*(data_->send_method_))();
++num_messages_[static_cast<int>(data_->severity_)];
}
LogDestination::WaitForSinks(data_);
if (append_newline) {
// Fix the ostrstream back how it was before we screwed with it.
// It's 99.44% certain that we don't need to worry about doing this.
data_->message_text_[data_->num_chars_to_log_ - 1] = original_final_char;
}
// If errno was already set before we enter the logging call, we'll
// set it back to that value when we return from the logging call.
// It happens often that we log an error message after a syscall
// failure, which can potentially set the errno to some other
// values. We would like to preserve the original errno.
if (data_->preserved_errno_ != 0) {
errno = data_->preserved_errno_;
}
// Note that this message is now safely logged. If we're asked to flush
// again, as a result of destruction, say, we'll do nothing on future calls.
data_->has_been_flushed_ = true;
}
|
O1
|
cpp
|
nglog::LogMessage::Flush():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
cmpb $0x0, 0x76e0(%rax)
jne 0xbc5c
movl 0x7698(%rax), %ecx
leaq 0x26fba(%rip), %rdx # 0x32aa0
cmpl (%rdx), %ecx
jl 0xbc5c
movq %rdi, %rbx
movq 0x7568(%rax), %rcx
subq 0x7560(%rax), %rcx
movq %rcx, 0x76c0(%rax)
movq %rcx, %rdx
subq 0x76b8(%rax), %rdx
movq %rdx, 0x76c8(%rax)
movb 0x3(%rcx,%rax), %r14b
cmpb $0xa, %r14b
jne 0xbb26
xorl %ebp, %ebp
jmp 0xbb3b
movb 0x4(%rax,%rcx), %bpl
leaq 0x1(%rcx), %rdx
movq %rdx, 0x76c0(%rax)
movb $0xa, 0x4(%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb $0x0, 0x4(%rax,%rcx)
leaq 0x361e6(%rip), %rdi # 0x41d38
callq 0x77f0
testl %eax, %eax
jne 0xbc65
movq 0x8(%rbx), %rcx
movq 0x76a0(%rcx), %rax
movq 0x76a8(%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0xbb80
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
movq 0x8(%rbx), %rax
movslq 0x7698(%rax), %rax
leaq 0x2701c(%rip), %rcx # 0x32bb0
incq (%rcx,%rax,8)
leaq 0x36199(%rip), %rdi # 0x41d38
callq 0x73f0
movq 0x8(%rbx), %r15
leaq 0x27089(%rip), %rdi # 0x32c38
callq 0x12a9a
movq 0x27075(%rip), %rax # 0x32c30
testq %rax, %rax
je 0xbbe7
movq 0x8(%rax), %r12
subq (%rax), %r12
sarq $0x3, %r12
subq $0x1, %r12
jb 0xbbe7
movq 0x27058(%rip), %rax # 0x32c30
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xbbcb
movq 0x76a0(%r15), %rax
cmpq 0x253f3(%rip), %rax # 0x30fe8
setne %cl
cmpq 0x25399(%rip), %rax # 0x30f98
setne %al
testb %al, %cl
jne 0xbc22
cmpq $0x0, 0x76a8(%r15)
jne 0xbc22
movq 0x76b0(%r15), %rdi
testq %rdi, %rdi
je 0xbc22
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x2700f(%rip), %rdi # 0x32c38
callq 0x76f0
cmpb $0xa, %r14b
je 0xbc44
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb %bpl, 0x3(%rcx,%rax)
movq 0x8(%rbx), %rbx
movl (%rbx), %ebp
testl %ebp, %ebp
je 0xbc55
callq 0x7050
movl %ebp, (%rax)
movb $0x1, 0x76e0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7350
jmp 0xbc7f
movq %rax, %rbx
leaq 0x360c0(%rip), %rdi # 0x41d38
callq 0x73f0
jmp 0xbc8e
movq %rax, %rbx
leaq 0x26faf(%rip), %rdi # 0x32c38
callq 0x76f0
movq %rbx, %rdi
callq 0x7950
|
_ZN5nglog10LogMessage5FlushEv:
push rbp
push r15
push r14
push r12
push rbx
mov rax, [rdi+8]
cmp byte ptr [rax+76E0h], 0
jnz loc_BC5C
mov ecx, [rax+7698h]
lea rdx, _ZN3fLI17FLAGS_minloglevelE; fLI::FLAGS_minloglevel
cmp ecx, [rdx]
jl loc_BC5C
mov rbx, rdi
mov rcx, [rax+7568h]
sub rcx, [rax+7560h]
mov [rax+76C0h], rcx
mov rdx, rcx
sub rdx, [rax+76B8h]
mov [rax+76C8h], rdx
mov r14b, [rcx+rax+3]
cmp r14b, 0Ah
jnz short loc_BB26
xor ebp, ebp
jmp short loc_BB3B
loc_BB26:
mov bpl, [rax+rcx+4]
lea rdx, [rcx+1]
mov [rax+76C0h], rdx
mov byte ptr [rax+rcx+4], 0Ah
loc_BB3B:
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov byte ptr [rax+rcx+4], 0
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_BC65
mov rcx, [rbx+8]
mov rax, [rcx+76A0h]
mov rdi, [rcx+76A8h]
add rdi, rbx
test al, 1
jz short loc_BB80
mov rcx, [rdi]
mov rax, [rcx+rax-1]
loc_BB80:
call rax
mov rax, [rbx+8]
movsxd rax, dword ptr [rax+7698h]
lea rcx, _ZN5nglog10LogMessage13num_messages_E; nglog::LogMessage::num_messages_
inc qword ptr [rcx+rax*8]
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov r15, [rbx+8]
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; this
call _ZNSt22__shared_mutex_pthread11lock_sharedEv; std::__shared_mutex_pthread::lock_shared(void)
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
test rax, rax
jz short loc_BBE7
mov r12, [rax+8]
sub r12, [rax]
sar r12, 3
loc_BBCB:
sub r12, 1
jb short loc_BBE7
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rax, [rax]
mov rdi, [rax+r12*8]
mov rax, [rdi]
call qword ptr [rax+18h]
jmp short loc_BBCB
loc_BBE7:
mov rax, [r15+76A0h]
cmp rax, cs:_ZN5nglog10LogMessage10SendToSinkEv_ptr
setnz cl
cmp rax, cs:_ZN5nglog10LogMessage16SendToSinkAndLogEv_ptr
setnz al
test cl, al
jnz short loc_BC22
cmp qword ptr [r15+76A8h], 0
jnz short loc_BC22
mov rdi, [r15+76B0h]
test rdi, rdi
jz short loc_BC22
mov rax, [rdi]
call qword ptr [rax+18h]
loc_BC22:
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
cmp r14b, 0Ah
jz short loc_BC44
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov [rcx+rax+3], bpl
loc_BC44:
mov rbx, [rbx+8]
mov ebp, [rbx]
test ebp, ebp
jz short loc_BC55
call ___errno_location
mov [rax], ebp
loc_BC55:
mov byte ptr [rbx+76E0h], 1
loc_BC5C:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BC65:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_BC7F
mov rbx, rax
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
jmp short loc_BC8E
loc_BC7F:
mov rbx, rax
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
loc_BC8E:
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogMessage::Flush(nglog::LogMessage *this)
{
long long result; // rax
long long v3; // rcx
char v4; // r14
char v5; // bp
int v6; // eax
long long v7; // rcx
void ( *v8)(_QWORD); // rax
_QWORD *v9; // rdi
long long v10; // rax
_QWORD *v11; // r15
long long i; // r12
long long v14; // rdi
int *v15; // rbx
int v16; // ebp
result = *((_QWORD *)this + 1);
if ( !*(_BYTE *)(result + 30432) && *(_DWORD *)(result + 30360) >= fLI::FLAGS_minloglevel )
{
v3 = *(_QWORD *)(result + 30056) - *(_QWORD *)(result + 30048);
*(_QWORD *)(result + 30400) = v3;
*(_QWORD *)(result + 30408) = v3 - *(_QWORD *)(result + 30392);
v4 = *(_BYTE *)(v3 + result + 3);
if ( v4 == 10 )
{
v5 = 0;
}
else
{
v5 = *(_BYTE *)(result + v3 + 4);
*(_QWORD *)(result + 30400) = v3 + 1;
*(_BYTE *)(result + v3 + 4) = 10;
}
*(_BYTE *)(*((_QWORD *)this + 1) + *(_QWORD *)(*((_QWORD *)this + 1) + 30400LL) + 4LL) = 0;
v6 = pthread_mutex_lock(&nglog::log_mutex);
if ( v6 )
std::__throw_system_error(v6);
v7 = *((_QWORD *)this + 1);
v8 = *(void ( **)(_QWORD))(v7 + 30368);
v9 = (_QWORD *)((char *)this + *(_QWORD *)(v7 + 30376));
if ( ((unsigned __int8)v8 & 1) != 0 )
v8 = *(void ( **)(_QWORD))((char *)v8 + *v9 - 1);
v8(v9);
v10 = *(int *)(*((_QWORD *)this + 1) + 30360LL);
++nglog::LogMessage::num_messages_[v10];
pthread_mutex_unlock(&nglog::log_mutex);
v11 = (_QWORD *)*((_QWORD *)this + 1);
std::__shared_mutex_pthread::lock_shared((std::__shared_mutex_pthread *)&nglog::LogDestination::sink_mutex_);
if ( nglog::LogDestination::sinks_ )
{
for ( i = (long long)(*(_QWORD *)(nglog::LogDestination::sinks_ + 8) - *(_QWORD *)nglog::LogDestination::sinks_) >> 3;
i-- != 0;
(*(void ( **)(_QWORD))(**(_QWORD **)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i) + 24LL))(*(_QWORD *)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i)) )
{
;
}
}
if ( (v11[3796] == (_QWORD)nglog::LogMessage::SendToSinkAndLog || v11[3796] == (_QWORD)nglog::LogMessage::SendToSink)
&& !v11[3797] )
{
v14 = v11[3798];
if ( v14 )
(*(void ( **)(long long))(*(_QWORD *)v14 + 24LL))(v14);
}
result = pthread_rwlock_unlock(&nglog::LogDestination::sink_mutex_);
if ( v4 != 10 )
{
result = *((_QWORD *)this + 1);
*(_BYTE *)(*(_QWORD *)(result + 30400) + result + 3) = v5;
}
v15 = (int *)*((_QWORD *)this + 1);
v16 = *v15;
if ( *v15 )
{
result = __errno_location();
*(_DWORD *)result = v16;
}
*((_BYTE *)v15 + 30432) = 1;
}
return result;
}
|
Flush:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
CMP byte ptr [RAX + 0x76e0],0x0
JNZ 0x0010bc5c
MOV ECX,dword ptr [RAX + 0x7698]
LEA RDX,[0x132aa0]
CMP ECX,dword ptr [RDX]
JL 0x0010bc5c
MOV RBX,RDI
MOV RCX,qword ptr [RAX + 0x7568]
SUB RCX,qword ptr [RAX + 0x7560]
MOV qword ptr [RAX + 0x76c0],RCX
MOV RDX,RCX
SUB RDX,qword ptr [RAX + 0x76b8]
MOV qword ptr [RAX + 0x76c8],RDX
MOV R14B,byte ptr [RCX + RAX*0x1 + 0x3]
CMP R14B,0xa
JNZ 0x0010bb26
XOR EBP,EBP
JMP 0x0010bb3b
LAB_0010bb26:
MOV BPL,byte ptr [RAX + RCX*0x1 + 0x4]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x76c0],RDX
MOV byte ptr [RAX + RCX*0x1 + 0x4],0xa
LAB_0010bb3b:
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RAX + RCX*0x1 + 0x4],0x0
LEA RDI,[0x141d38]
CALL 0x001077f0
TEST EAX,EAX
JNZ 0x0010bc65
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + 0x76a0]
MOV RDI,qword ptr [RCX + 0x76a8]
ADD RDI,RBX
TEST AL,0x1
JZ 0x0010bb80
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RCX + RAX*0x1 + -0x1]
LAB_0010bb80:
CALL RAX
LAB_0010bb82:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RAX,dword ptr [RAX + 0x7698]
LEA RCX,[0x132bb0]
INC qword ptr [RCX + RAX*0x8]
LEA RDI,[0x141d38]
CALL 0x001073f0
MOV R15,qword ptr [RBX + 0x8]
LEA RDI,[0x132c38]
CALL 0x00112a9a
MOV RAX,qword ptr [0x00132c30]
TEST RAX,RAX
JZ 0x0010bbe7
MOV R12,qword ptr [RAX + 0x8]
SUB R12,qword ptr [RAX]
SAR R12,0x3
LAB_0010bbcb:
SUB R12,0x1
JC 0x0010bbe7
MOV RAX,qword ptr [0x00132c30]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + R12*0x8]
MOV RAX,qword ptr [RDI]
LAB_0010bbe2:
CALL qword ptr [RAX + 0x18]
JMP 0x0010bbcb
LAB_0010bbe7:
MOV RAX,qword ptr [R15 + 0x76a0]
CMP RAX,qword ptr [0x00130fe8]
SETNZ CL
CMP RAX,qword ptr [0x00130f98]
SETNZ AL
TEST CL,AL
JNZ 0x0010bc22
CMP qword ptr [R15 + 0x76a8],0x0
JNZ 0x0010bc22
MOV RDI,qword ptr [R15 + 0x76b0]
TEST RDI,RDI
JZ 0x0010bc22
MOV RAX,qword ptr [RDI]
LAB_0010bc1f:
CALL qword ptr [RAX + 0x18]
LAB_0010bc22:
LEA RDI,[0x132c38]
CALL 0x001076f0
CMP R14B,0xa
JZ 0x0010bc44
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RCX + RAX*0x1 + 0x3],BPL
LAB_0010bc44:
MOV RBX,qword ptr [RBX + 0x8]
MOV EBP,dword ptr [RBX]
TEST EBP,EBP
JZ 0x0010bc55
CALL 0x00107050
MOV dword ptr [RAX],EBP
LAB_0010bc55:
MOV byte ptr [RBX + 0x76e0],0x1
LAB_0010bc5c:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010bc65:
MOV EDI,EAX
CALL 0x00107350
|
/* nglog::LogMessage::Flush() */
void __thiscall nglog::LogMessage::Flush(LogMessage *this)
{
char cVar1;
long lVar2;
int *piVar3;
int iVar4;
code *pcVar5;
int *piVar6;
long lVar7;
int1 uVar8;
bool bVar9;
lVar2 = *(long *)(this + 8);
if ((*(char *)(lVar2 + 0x76e0) == '\0') && (fLI::FLAGS_minloglevel <= *(int *)(lVar2 + 0x7698))) {
lVar7 = *(long *)(lVar2 + 0x7568) - *(long *)(lVar2 + 0x7560);
*(long *)(lVar2 + 0x76c0) = lVar7;
*(long *)(lVar2 + 0x76c8) = lVar7 - *(long *)(lVar2 + 0x76b8);
cVar1 = *(char *)(lVar7 + 3 + lVar2);
if (cVar1 == '\n') {
uVar8 = 0;
}
else {
uVar8 = *(int1 *)(lVar2 + 4 + lVar7);
*(long *)(lVar2 + 0x76c0) = lVar7 + 1;
*(int1 *)(lVar2 + 4 + lVar7) = 10;
}
*(int1 *)(*(long *)(this + 8) + 4 + *(long *)(*(long *)(this + 8) + 0x76c0)) = 0;
iVar4 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar4 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar4);
}
pcVar5 = *(code **)(*(long *)(this + 8) + 0x76a0);
if (((ulong)pcVar5 & 1) != 0) {
pcVar5 = *(code **)(pcVar5 + *(long *)(this + *(long *)(*(long *)(this + 8) + 0x76a8)) + -1);
}
/* try { // try from 0010bb80 to 0010bb81 has its CatchHandler @ 0010bc6e */
(*pcVar5)();
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) =
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) + 1;
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
lVar2 = *(long *)(this + 8);
std::__shared_mutex_pthread::lock_shared((__shared_mutex_pthread *)LogDestination::sink_mutex_);
if (LogDestination::sinks_ != (long *)0x0) {
lVar7 = LogDestination::sinks_[1] - *LogDestination::sinks_ >> 3;
while (bVar9 = lVar7 != 0, lVar7 = lVar7 + -1, bVar9) {
/* try { // try from 0010bbe2 to 0010bbe4 has its CatchHandler @ 0010bc7f */
(**(code **)(**(long **)(*LogDestination::sinks_ + lVar7 * 8) + 0x18))();
}
}
if (((*(int **)(lVar2 + 0x76a0) == PTR_SendToSink_00130fe8 ||
*(int **)(lVar2 + 0x76a0) == PTR_SendToSinkAndLog_00130f98) &&
(*(long *)(lVar2 + 0x76a8) == 0)) && (*(long **)(lVar2 + 0x76b0) != (long *)0x0)) {
/* try { // try from 0010bc1f to 0010bc21 has its CatchHandler @ 0010bc6c */
(**(code **)(**(long **)(lVar2 + 0x76b0) + 0x18))();
}
pthread_rwlock_unlock((pthread_rwlock_t *)LogDestination::sink_mutex_);
if (cVar1 != '\n') {
*(int1 *)(*(long *)(*(long *)(this + 8) + 0x76c0) + 3 + *(long *)(this + 8)) = uVar8;
}
piVar3 = *(int **)(this + 8);
iVar4 = *piVar3;
if (iVar4 != 0) {
piVar6 = __errno_location();
*piVar6 = iVar4;
}
*(int1 *)(piVar3 + 0x1db8) = 1;
}
return;
}
|
|
18,398
|
nglog::LogMessage::Flush()
|
ng-log[P]ng-log/src/logging.cc
|
void LogMessage::Flush() {
if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) {
return;
}
data_->num_chars_to_log_ = data_->stream_.pcount();
data_->num_chars_to_syslog_ =
data_->num_chars_to_log_ - data_->num_prefix_chars_;
// Do we need to add a \n to the end of this message?
bool append_newline =
(data_->message_text_[data_->num_chars_to_log_ - 1] != '\n');
char original_final_char = '\0';
// If we do need to add a \n, we'll do it by violating the memory of the
// ostrstream buffer. This is quick, and we'll make sure to undo our
// modification before anything else is done with the ostrstream. It
// would be preferable not to do things this way, but it seems to be
// the best way to deal with this.
if (append_newline) {
original_final_char = data_->message_text_[data_->num_chars_to_log_];
data_->message_text_[data_->num_chars_to_log_++] = '\n';
}
data_->message_text_[data_->num_chars_to_log_] = '\0';
// Prevent any subtle race conditions by wrapping a mutex lock around
// the actual logging action per se.
{
std::lock_guard<std::mutex> l{log_mutex};
(this->*(data_->send_method_))();
++num_messages_[static_cast<int>(data_->severity_)];
}
LogDestination::WaitForSinks(data_);
if (append_newline) {
// Fix the ostrstream back how it was before we screwed with it.
// It's 99.44% certain that we don't need to worry about doing this.
data_->message_text_[data_->num_chars_to_log_ - 1] = original_final_char;
}
// If errno was already set before we enter the logging call, we'll
// set it back to that value when we return from the logging call.
// It happens often that we log an error message after a syscall
// failure, which can potentially set the errno to some other
// values. We would like to preserve the original errno.
if (data_->preserved_errno_ != 0) {
errno = data_->preserved_errno_;
}
// Note that this message is now safely logged. If we're asked to flush
// again, as a result of destruction, say, we'll do nothing on future calls.
data_->has_been_flushed_ = true;
}
|
O3
|
cpp
|
nglog::LogMessage::Flush():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
cmpb $0x0, 0x76e0(%rax)
jne 0xbb02
movl 0x7698(%rax), %ecx
leaq 0x27114(%rip), %rdx # 0x32aa0
cmpl (%rdx), %ecx
jl 0xbb02
movq %rdi, %rbx
movq 0x7568(%rax), %rcx
subq 0x7560(%rax), %rcx
movq %rcx, 0x76c0(%rax)
movq %rcx, %rdx
subq 0x76b8(%rax), %rdx
movq %rdx, 0x76c8(%rax)
movb 0x3(%rcx,%rax), %r14b
cmpb $0xa, %r14b
jne 0xb9cc
xorl %ebp, %ebp
jmp 0xb9ec
movb 0x4(%rax,%rcx), %bpl
leaq 0x1(%rcx), %rdx
movq %rdx, 0x76c0(%rax)
movb $0xa, 0x4(%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb $0x0, 0x4(%rax,%rcx)
leaq 0x36340(%rip), %rdi # 0x41d38
callq 0x77f0
testl %eax, %eax
jne 0xbb0b
movq 0x8(%rbx), %rcx
movq 0x76a0(%rcx), %rax
movq 0x76a8(%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0xba26
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
movq 0x8(%rbx), %rax
movslq 0x7698(%rax), %rax
leaq 0x27176(%rip), %rcx # 0x32bb0
incq (%rcx,%rax,8)
leaq 0x362f3(%rip), %rdi # 0x41d38
callq 0x73f0
movq 0x8(%rbx), %r15
leaq 0x271e3(%rip), %rdi # 0x32c38
callq 0x1283c
movq 0x271cf(%rip), %rax # 0x32c30
testq %rax, %rax
je 0xba8d
movq 0x8(%rax), %r12
subq (%rax), %r12
sarq $0x3, %r12
subq $0x1, %r12
jb 0xba8d
movq 0x271b2(%rip), %rax # 0x32c30
movq (%rax), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xba71
movq 0x76a0(%r15), %rax
cmpq 0x2554d(%rip), %rax # 0x30fe8
setne %cl
cmpq 0x254f3(%rip), %rax # 0x30f98
setne %al
testb %al, %cl
jne 0xbac8
cmpq $0x0, 0x76a8(%r15)
jne 0xbac8
movq 0x76b0(%r15), %rdi
testq %rdi, %rdi
je 0xbac8
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x27169(%rip), %rdi # 0x32c38
callq 0x76f0
cmpb $0xa, %r14b
je 0xbaea
movq 0x8(%rbx), %rax
movq 0x76c0(%rax), %rcx
movb %bpl, 0x3(%rcx,%rax)
movq 0x8(%rbx), %rbx
movl (%rbx), %ebp
testl %ebp, %ebp
je 0xbafb
callq 0x7050
movl %ebp, (%rax)
movb $0x1, 0x76e0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7350
jmp 0xbb25
movq %rax, %rbx
leaq 0x3621a(%rip), %rdi # 0x41d38
callq 0x73f0
jmp 0xbb34
movq %rax, %rbx
leaq 0x27109(%rip), %rdi # 0x32c38
callq 0x76f0
movq %rbx, %rdi
callq 0x7950
|
_ZN5nglog10LogMessage5FlushEv:
push rbp
push r15
push r14
push r12
push rbx
mov rax, [rdi+8]
cmp byte ptr [rax+76E0h], 0
jnz loc_BB02
mov ecx, [rax+7698h]
lea rdx, _ZN3fLI17FLAGS_minloglevelE; fLI::FLAGS_minloglevel
cmp ecx, [rdx]
jl loc_BB02
mov rbx, rdi
mov rcx, [rax+7568h]
sub rcx, [rax+7560h]
mov [rax+76C0h], rcx
mov rdx, rcx
sub rdx, [rax+76B8h]
mov [rax+76C8h], rdx
mov r14b, [rcx+rax+3]
cmp r14b, 0Ah
jnz short loc_B9CC
xor ebp, ebp
jmp short loc_B9EC
loc_B9CC:
mov bpl, [rax+rcx+4]
lea rdx, [rcx+1]
mov [rax+76C0h], rdx
mov byte ptr [rax+rcx+4], 0Ah
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
loc_B9EC:
mov byte ptr [rax+rcx+4], 0
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_BB0B
mov rcx, [rbx+8]
mov rax, [rcx+76A0h]
mov rdi, [rcx+76A8h]
add rdi, rbx
test al, 1
jz short loc_BA26
mov rcx, [rdi]
mov rax, [rcx+rax-1]
loc_BA26:
call rax
mov rax, [rbx+8]
movsxd rax, dword ptr [rax+7698h]
lea rcx, _ZN5nglog10LogMessage13num_messages_E; nglog::LogMessage::num_messages_
inc qword ptr [rcx+rax*8]
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov r15, [rbx+8]
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; this
call _ZNSt22__shared_mutex_pthread11lock_sharedEv; std::__shared_mutex_pthread::lock_shared(void)
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
test rax, rax
jz short loc_BA8D
mov r12, [rax+8]
sub r12, [rax]
sar r12, 3
loc_BA71:
sub r12, 1
jb short loc_BA8D
mov rax, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rax, [rax]
mov rdi, [rax+r12*8]
mov rax, [rdi]
call qword ptr [rax+18h]
jmp short loc_BA71
loc_BA8D:
mov rax, [r15+76A0h]
cmp rax, cs:_ZN5nglog10LogMessage10SendToSinkEv_ptr
setnz cl
cmp rax, cs:_ZN5nglog10LogMessage16SendToSinkAndLogEv_ptr
setnz al
test cl, al
jnz short loc_BAC8
cmp qword ptr [r15+76A8h], 0
jnz short loc_BAC8
mov rdi, [r15+76B0h]
test rdi, rdi
jz short loc_BAC8
mov rax, [rdi]
call qword ptr [rax+18h]
loc_BAC8:
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
cmp r14b, 0Ah
jz short loc_BAEA
mov rax, [rbx+8]
mov rcx, [rax+76C0h]
mov [rcx+rax+3], bpl
loc_BAEA:
mov rbx, [rbx+8]
mov ebp, [rbx]
test ebp, ebp
jz short loc_BAFB
call ___errno_location
mov [rax], ebp
loc_BAFB:
mov byte ptr [rbx+76E0h], 1
loc_BB02:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_BB0B:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short loc_BB25
mov rbx, rax
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
jmp short loc_BB34
loc_BB25:
mov rbx, rax
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
loc_BB34:
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::LogMessage::Flush(nglog::LogMessage *this)
{
long long result; // rax
long long v3; // rcx
char v4; // r14
char v5; // bp
int v6; // eax
long long v7; // rcx
void ( *v8)(_QWORD); // rax
_QWORD *v9; // rdi
long long v10; // rax
_QWORD *v11; // r15
long long i; // r12
long long v14; // rdi
int *v15; // rbx
int v16; // ebp
result = *((_QWORD *)this + 1);
if ( !*(_BYTE *)(result + 30432) && *(_DWORD *)(result + 30360) >= fLI::FLAGS_minloglevel )
{
v3 = *(_QWORD *)(result + 30056) - *(_QWORD *)(result + 30048);
*(_QWORD *)(result + 30400) = v3;
*(_QWORD *)(result + 30408) = v3 - *(_QWORD *)(result + 30392);
v4 = *(_BYTE *)(v3 + result + 3);
if ( v4 == 10 )
{
v5 = 0;
}
else
{
v5 = *(_BYTE *)(result + v3 + 4);
*(_QWORD *)(result + 30400) = v3 + 1;
*(_BYTE *)(result + v3 + 4) = 10;
result = *((_QWORD *)this + 1);
v3 = *(_QWORD *)(result + 30400);
}
*(_BYTE *)(result + v3 + 4) = 0;
v6 = pthread_mutex_lock(&nglog::log_mutex);
if ( v6 )
std::__throw_system_error(v6);
v7 = *((_QWORD *)this + 1);
v8 = *(void ( **)(_QWORD))(v7 + 30368);
v9 = (_QWORD *)((char *)this + *(_QWORD *)(v7 + 30376));
if ( ((unsigned __int8)v8 & 1) != 0 )
v8 = *(void ( **)(_QWORD))((char *)v8 + *v9 - 1);
v8(v9);
v10 = *(int *)(*((_QWORD *)this + 1) + 30360LL);
++nglog::LogMessage::num_messages_[v10];
pthread_mutex_unlock(&nglog::log_mutex);
v11 = (_QWORD *)*((_QWORD *)this + 1);
std::__shared_mutex_pthread::lock_shared((std::__shared_mutex_pthread *)&nglog::LogDestination::sink_mutex_);
if ( nglog::LogDestination::sinks_ )
{
for ( i = (long long)(*(_QWORD *)(nglog::LogDestination::sinks_ + 8) - *(_QWORD *)nglog::LogDestination::sinks_) >> 3;
i-- != 0;
(*(void ( **)(_QWORD))(**(_QWORD **)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i) + 24LL))(*(_QWORD *)(*(_QWORD *)nglog::LogDestination::sinks_ + 8 * i)) )
{
;
}
}
if ( (v11[3796] == (_QWORD)nglog::LogMessage::SendToSinkAndLog || v11[3796] == (_QWORD)nglog::LogMessage::SendToSink)
&& !v11[3797] )
{
v14 = v11[3798];
if ( v14 )
(*(void ( **)(long long))(*(_QWORD *)v14 + 24LL))(v14);
}
result = pthread_rwlock_unlock(&nglog::LogDestination::sink_mutex_);
if ( v4 != 10 )
{
result = *((_QWORD *)this + 1);
*(_BYTE *)(*(_QWORD *)(result + 30400) + result + 3) = v5;
}
v15 = (int *)*((_QWORD *)this + 1);
v16 = *v15;
if ( *v15 )
{
result = __errno_location();
*(_DWORD *)result = v16;
}
*((_BYTE *)v15 + 30432) = 1;
}
return result;
}
|
Flush:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
CMP byte ptr [RAX + 0x76e0],0x0
JNZ 0x0010bb02
MOV ECX,dword ptr [RAX + 0x7698]
LEA RDX,[0x132aa0]
CMP ECX,dword ptr [RDX]
JL 0x0010bb02
MOV RBX,RDI
MOV RCX,qword ptr [RAX + 0x7568]
SUB RCX,qword ptr [RAX + 0x7560]
MOV qword ptr [RAX + 0x76c0],RCX
MOV RDX,RCX
SUB RDX,qword ptr [RAX + 0x76b8]
MOV qword ptr [RAX + 0x76c8],RDX
MOV R14B,byte ptr [RCX + RAX*0x1 + 0x3]
CMP R14B,0xa
JNZ 0x0010b9cc
XOR EBP,EBP
JMP 0x0010b9ec
LAB_0010b9cc:
MOV BPL,byte ptr [RAX + RCX*0x1 + 0x4]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RAX + 0x76c0],RDX
MOV byte ptr [RAX + RCX*0x1 + 0x4],0xa
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
LAB_0010b9ec:
MOV byte ptr [RAX + RCX*0x1 + 0x4],0x0
LEA RDI,[0x141d38]
CALL 0x001077f0
TEST EAX,EAX
JNZ 0x0010bb0b
MOV RCX,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RCX + 0x76a0]
MOV RDI,qword ptr [RCX + 0x76a8]
ADD RDI,RBX
TEST AL,0x1
JZ 0x0010ba26
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RCX + RAX*0x1 + -0x1]
LAB_0010ba26:
CALL RAX
LAB_0010ba28:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RAX,dword ptr [RAX + 0x7698]
LEA RCX,[0x132bb0]
INC qword ptr [RCX + RAX*0x8]
LEA RDI,[0x141d38]
CALL 0x001073f0
MOV R15,qword ptr [RBX + 0x8]
LEA RDI,[0x132c38]
CALL 0x0011283c
MOV RAX,qword ptr [0x00132c30]
TEST RAX,RAX
JZ 0x0010ba8d
MOV R12,qword ptr [RAX + 0x8]
SUB R12,qword ptr [RAX]
SAR R12,0x3
LAB_0010ba71:
SUB R12,0x1
JC 0x0010ba8d
MOV RAX,qword ptr [0x00132c30]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + R12*0x8]
MOV RAX,qword ptr [RDI]
LAB_0010ba88:
CALL qword ptr [RAX + 0x18]
JMP 0x0010ba71
LAB_0010ba8d:
MOV RAX,qword ptr [R15 + 0x76a0]
CMP RAX,qword ptr [0x00130fe8]
SETNZ CL
CMP RAX,qword ptr [0x00130f98]
SETNZ AL
TEST CL,AL
JNZ 0x0010bac8
CMP qword ptr [R15 + 0x76a8],0x0
JNZ 0x0010bac8
MOV RDI,qword ptr [R15 + 0x76b0]
TEST RDI,RDI
JZ 0x0010bac8
MOV RAX,qword ptr [RDI]
LAB_0010bac5:
CALL qword ptr [RAX + 0x18]
LAB_0010bac8:
LEA RDI,[0x132c38]
CALL 0x001076f0
CMP R14B,0xa
JZ 0x0010baea
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RAX + 0x76c0]
MOV byte ptr [RCX + RAX*0x1 + 0x3],BPL
LAB_0010baea:
MOV RBX,qword ptr [RBX + 0x8]
MOV EBP,dword ptr [RBX]
TEST EBP,EBP
JZ 0x0010bafb
CALL 0x00107050
MOV dword ptr [RAX],EBP
LAB_0010bafb:
MOV byte ptr [RBX + 0x76e0],0x1
LAB_0010bb02:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010bb0b:
MOV EDI,EAX
CALL 0x00107350
|
/* nglog::LogMessage::Flush() */
void __thiscall nglog::LogMessage::Flush(LogMessage *this)
{
char cVar1;
int *piVar2;
int iVar3;
long lVar4;
code *pcVar5;
int *piVar6;
long lVar7;
int1 uVar8;
bool bVar9;
lVar4 = *(long *)(this + 8);
if ((*(char *)(lVar4 + 0x76e0) == '\0') && (fLI::FLAGS_minloglevel <= *(int *)(lVar4 + 0x7698))) {
lVar7 = *(long *)(lVar4 + 0x7568) - *(long *)(lVar4 + 0x7560);
*(long *)(lVar4 + 0x76c0) = lVar7;
*(long *)(lVar4 + 0x76c8) = lVar7 - *(long *)(lVar4 + 0x76b8);
cVar1 = *(char *)(lVar7 + 3 + lVar4);
if (cVar1 == '\n') {
uVar8 = 0;
}
else {
uVar8 = *(int1 *)(lVar4 + 4 + lVar7);
*(long *)(lVar4 + 0x76c0) = lVar7 + 1;
*(int1 *)(lVar4 + 4 + lVar7) = 10;
lVar4 = *(long *)(this + 8);
lVar7 = *(long *)(lVar4 + 0x76c0);
}
*(int1 *)(lVar4 + 4 + lVar7) = 0;
iVar3 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar3 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar3);
}
pcVar5 = *(code **)(*(long *)(this + 8) + 0x76a0);
if (((ulong)pcVar5 & 1) != 0) {
pcVar5 = *(code **)(pcVar5 + *(long *)(this + *(long *)(*(long *)(this + 8) + 0x76a8)) + -1);
}
/* try { // try from 0010ba26 to 0010ba27 has its CatchHandler @ 0010bb14 */
(*pcVar5)();
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) =
*(long *)(num_messages_ + (long)*(int *)(*(long *)(this + 8) + 0x7698) * 8) + 1;
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
lVar4 = *(long *)(this + 8);
std::__shared_mutex_pthread::lock_shared((__shared_mutex_pthread *)LogDestination::sink_mutex_);
if (LogDestination::sinks_ != (long *)0x0) {
lVar7 = LogDestination::sinks_[1] - *LogDestination::sinks_ >> 3;
while (bVar9 = lVar7 != 0, lVar7 = lVar7 + -1, bVar9) {
/* try { // try from 0010ba88 to 0010ba8a has its CatchHandler @ 0010bb25 */
(**(code **)(**(long **)(*LogDestination::sinks_ + lVar7 * 8) + 0x18))();
}
}
if (((*(int **)(lVar4 + 0x76a0) == PTR_SendToSink_00130fe8 ||
*(int **)(lVar4 + 0x76a0) == PTR_SendToSinkAndLog_00130f98) &&
(*(long *)(lVar4 + 0x76a8) == 0)) && (*(long **)(lVar4 + 0x76b0) != (long *)0x0)) {
/* try { // try from 0010bac5 to 0010bac7 has its CatchHandler @ 0010bb12 */
(**(code **)(**(long **)(lVar4 + 0x76b0) + 0x18))();
}
pthread_rwlock_unlock((pthread_rwlock_t *)LogDestination::sink_mutex_);
if (cVar1 != '\n') {
*(int1 *)(*(long *)(*(long *)(this + 8) + 0x76c0) + 3 + *(long *)(this + 8)) = uVar8;
}
piVar2 = *(int **)(this + 8);
iVar3 = *piVar2;
if (iVar3 != 0) {
piVar6 = __errno_location();
*piVar6 = iVar3;
}
*(int1 *)(piVar2 + 0x1db8) = 1;
}
return;
}
|
|
18,399
|
main
|
eloqsql/storage/maria/aria_dump_log.c
|
int main(int argc, char **argv)
{
char **default_argv;
uchar buffer[TRANSLOG_PAGE_SIZE];
MY_INIT(argv[0]);
load_defaults_or_exit("my", load_default_groups, &argc, &argv);
default_argv= argv;
get_options(&argc, &argv);
if (opt_unit)
translog_example_table_init();
else
translog_table_init();
translog_fill_overhead_table();
maria_data_root= ".";
if ((handler= my_open(opt_file, O_RDONLY, MYF(MY_WME))) < 0)
{
fprintf(stderr, "Can't open file: '%s' errno: %d\n",
opt_file, my_errno);
goto err;
}
if (my_seek(handler, opt_offset, SEEK_SET, MYF(MY_WME)) !=
opt_offset)
{
fprintf(stderr, "Can't set position %lld file: '%s' errno: %d\n",
opt_offset, opt_file, my_errno);
goto err;
}
for (;
opt_pages;
opt_offset+= TRANSLOG_PAGE_SIZE, opt_pages--)
{
if (my_pread(handler, buffer, TRANSLOG_PAGE_SIZE, opt_offset,
MYF(MY_NABP)))
{
if (my_errno == HA_ERR_FILE_TOO_SHORT)
goto end;
fprintf(stderr, "Can't read page at position %lld file: '%s' "
"errno: %d\n", opt_offset, opt_file, my_errno);
goto err;
}
printf("Page by offset %llu (0x%llx)\n", opt_offset, opt_offset);
dump_page(buffer, handler);
}
end:
my_close(handler, MYF(0));
free_defaults(default_argv);
exit(0);
return 0; /* No compiler warning */
err:
my_close(handler, MYF(0));
fprintf(stderr, "%s: FAILED\n", my_progname_short);
free_defaults(default_argv);
exit(1);
}
|
O0
|
c
|
main:
pushq %rbp
movq %rsp, %rbp
subq $0x2070, %rsp # imm = 0x2070
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0xc5f019(%rip), %rax # 0xc89b40
movq %rcx, (%rax)
callq 0xf88d0
leaq 0x12c4e2(%rip), %rdi # 0x157018
leaq 0x2994d3(%rip), %rsi # 0x2c4010
leaq -0x8(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0xdda50
movl %eax, %ecx
movl %ecx, -0x2024(%rbp)
testl %eax, %eax
je 0x2ab65
jmp 0x2ab58
movl -0x2024(%rbp), %eax
subl $0x4, %eax
je 0x2ab67
jmp 0x2ab75
jmp 0x2ab86
xorl %edi, %edi
callq 0xf8b10
xorl %edi, %edi
callq 0x2a500
xorl %edi, %edi
callq 0xf8b10
movl $0x1, %edi
callq 0x2a500
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2ae20
cmpb $0x0, 0x4538b6(%rip) # 0x47e458
je 0x2abad
movb $0x0, %al
callq 0x2b430
jmp 0x2abb4
movb $0x0, %al
callq 0x2b540
movb $0x0, %al
callq 0x2c6a0
leaq 0x453d8e(%rip), %rax # 0x47e950
leaq 0x12fa5f(%rip), %rcx # 0x15a628
movq %rcx, (%rax)
movq 0x45388d(%rip), %rdi # 0x47e460
xorl %esi, %esi
movl $0x10, %edx
callq 0xfa360
movl %eax, 0x29943b(%rip) # 0x2c4020
cmpl $0x0, %eax
jge 0x2ac31
movq 0x2993ef(%rip), %rax # 0x2c3fe0
movq (%rax), %rax
movq %rax, -0x2038(%rbp)
movq 0x45385e(%rip), %rax # 0x47e460
movq %rax, -0x2030(%rbp)
callq 0xfc1b0
movq -0x2038(%rbp), %rdi
movq -0x2030(%rbp), %rdx
movl (%rax), %ecx
leaq 0x12c3f6(%rip), %rsi # 0x15701b
movb $0x0, %al
callq 0x2a180
jmp 0x2add0
movl 0x2993e9(%rip), %edi # 0x2c4020
movq 0x45382a(%rip), %rsi # 0x47e468
xorl %edx, %edx
movl $0x10, %ecx
callq 0xfad90
cmpq 0x453817(%rip), %rax # 0x47e468
je 0x2acb0
movq 0x299386(%rip), %rax # 0x2c3fe0
movq (%rax), %rax
movq %rax, -0x2050(%rbp)
movq 0x4537fd(%rip), %rax # 0x47e468
movq %rax, -0x2048(%rbp)
movq 0x4537e7(%rip), %rax # 0x47e460
movq %rax, -0x2040(%rbp)
callq 0xfc1b0
movq -0x2050(%rbp), %rdi
movq -0x2048(%rbp), %rdx
movq -0x2040(%rbp), %rcx
movl (%rax), %r8d
leaq 0x12c399(%rip), %rsi # 0x15703d
movb $0x0, %al
callq 0x2a180
jmp 0x2add0
jmp 0x2acb2
cmpq $0x0, 0x4537b6(%rip) # 0x47e470
je 0x2adaf
movl 0x29935a(%rip), %edi # 0x2c4020
leaq -0x2020(%rbp), %rsi
movq 0x453794(%rip), %rcx # 0x47e468
movl $0x2000, %edx # imm = 0x2000
movl $0x4, %r8d
callq 0xfa750
cmpq $0x0, %rax
je 0x2ad56
callq 0xfc1b0
cmpl $0xaf, (%rax)
jne 0x2acfc
jmp 0x2adb1
movq 0x2992dd(%rip), %rax # 0x2c3fe0
movq (%rax), %rax
movq %rax, -0x2068(%rbp)
movq 0x453754(%rip), %rax # 0x47e468
movq %rax, -0x2060(%rbp)
movq 0x45373e(%rip), %rax # 0x47e460
movq %rax, -0x2058(%rbp)
callq 0xfc1b0
movq -0x2068(%rbp), %rdi
movq -0x2060(%rbp), %rdx
movq -0x2058(%rbp), %rcx
movl (%rax), %r8d
leaq 0x12c320(%rip), %rsi # 0x15706d
movb $0x0, %al
callq 0x2a180
jmp 0x2add0
movq 0x45370b(%rip), %rsi # 0x47e468
movq 0x453704(%rip), %rdx # 0x47e468
leaq 0x12c33b(%rip), %rdi # 0x1570a6
movb $0x0, %al
callq 0x2a060
leaq -0x2020(%rbp), %rdi
movl 0x2992a1(%rip), %esi # 0x2c4020
callq 0x34570
movq 0x4536dd(%rip), %rax # 0x47e468
addq $0x2000, %rax # imm = 0x2000
movq %rax, 0x4536d0(%rip) # 0x47e468
movq 0x4536d1(%rip), %rax # 0x47e470
addq $-0x1, %rax
movq %rax, 0x4536c6(%rip) # 0x47e470
jmp 0x2acb2
jmp 0x2adb1
movl 0x299269(%rip), %edi # 0x2c4020
xorl %eax, %eax
movl %eax, %esi
callq 0xfa5f0
movq -0x18(%rbp), %rdi
callq 0xde2a0
xorl %edi, %edi
callq 0x2a500
movl 0x29924a(%rip), %edi # 0x2c4020
xorl %eax, %eax
movl %eax, %esi
callq 0xfa5f0
movq 0x2991fa(%rip), %rax # 0x2c3fe0
movq (%rax), %rdi
leaq 0xc5ed58(%rip), %rax # 0xc89b48
movq (%rax), %rdx
leaq 0x12c2ca(%rip), %rsi # 0x1570c4
movb $0x0, %al
callq 0x2a180
movq -0x18(%rbp), %rdi
callq 0xde2a0
movl $0x1, %edi
callq 0x2a500
nopw %cs:(%rax,%rax)
|
main:
push rbp
mov rbp, rsp
sub rsp, 2070h
mov [rbp+var_4], 0
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rcx, [rax]
lea rax, my_progname
mov [rax], rcx
call my_init
lea rdi, unk_157018
lea rsi, load_default_groups
lea rdx, [rbp+var_8]
lea rcx, [rbp+var_10]
call load_defaults
mov ecx, eax
mov [rbp+var_2024], ecx
test eax, eax
jz short loc_2AB65
jmp short $+2
loc_2AB58:
mov eax, [rbp+var_2024]
sub eax, 4
jz short loc_2AB67
jmp short loc_2AB75
loc_2AB65:
jmp short loc_2AB86
loc_2AB67:
xor edi, edi
call my_end
xor edi, edi
call _exit
loc_2AB75:
xor edi, edi
call my_end
mov edi, 1
call _exit
loc_2AB86:
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
lea rdi, [rbp+var_8]
lea rsi, [rbp+var_10]
call get_options
cmp cs:opt_unit, 0
jz short loc_2ABAD
mov al, 0
call translog_example_table_init
jmp short loc_2ABB4
loc_2ABAD:
mov al, 0
call translog_table_init
loc_2ABB4:
mov al, 0
call translog_fill_overhead_table
lea rax, maria_data_root
lea rcx, asc_15A627+1; "."
mov [rax], rcx
mov rdi, cs:opt_file
xor esi, esi
mov edx, 10h
call my_open
mov cs:handler, eax
cmp eax, 0
jge short loc_2AC31
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_2038], rax
mov rax, cs:opt_file
mov [rbp+var_2030], rax
call _my_thread_var
mov rdi, [rbp+var_2038]
mov rdx, [rbp+var_2030]
mov ecx, [rax]
lea rsi, aCanTOpenFileSE; "Can't open file: '%s' errno: %d\n"
mov al, 0
call _fprintf
jmp loc_2ADD0
loc_2AC31:
mov edi, cs:handler
mov rsi, cs:opt_offset
xor edx, edx
mov ecx, 10h
call my_seek
cmp rax, cs:opt_offset
jz short loc_2ACB0
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_2050], rax
mov rax, cs:opt_offset
mov [rbp+var_2048], rax
mov rax, cs:opt_file
mov [rbp+var_2040], rax
call _my_thread_var
mov rdi, [rbp+var_2050]
mov rdx, [rbp+var_2048]
mov rcx, [rbp+var_2040]
mov r8d, [rax]
lea rsi, aCanTSetPositio; "Can't set position %lld file: '%s' er"...
mov al, 0
call _fprintf
jmp loc_2ADD0
loc_2ACB0:
jmp short $+2
loc_2ACB2:
cmp cs:opt_pages, 0
jz loc_2ADAF
mov edi, cs:handler
lea rsi, [rbp+var_2020]
mov rcx, cs:opt_offset
mov edx, 2000h
mov r8d, 4
call my_pread
cmp rax, 0
jz short loc_2AD56
call _my_thread_var
cmp dword ptr [rax], 0AFh
jnz short loc_2ACFC
jmp loc_2ADB1
loc_2ACFC:
mov rax, cs:stderr_ptr
mov rax, [rax]
mov [rbp+var_2068], rax
mov rax, cs:opt_offset
mov [rbp+var_2060], rax
mov rax, cs:opt_file
mov [rbp+var_2058], rax
call _my_thread_var
mov rdi, [rbp+var_2068]
mov rdx, [rbp+var_2060]
mov rcx, [rbp+var_2058]
mov r8d, [rax]
lea rsi, aCanTReadPageAt; "Can't read page at position %lld file:"...
mov al, 0
call _fprintf
jmp short loc_2ADD0
loc_2AD56:
mov rsi, cs:opt_offset
mov rdx, cs:opt_offset
lea rdi, aPageByOffsetLl; "Page by offset %llu (0x%llx)\n"
mov al, 0
call _printf
lea rdi, [rbp+var_2020]
mov esi, cs:handler
call dump_page
mov rax, cs:opt_offset
add rax, 2000h
mov cs:opt_offset, rax
mov rax, cs:opt_pages
add rax, 0FFFFFFFFFFFFFFFFh
mov cs:opt_pages, rax
jmp loc_2ACB2
loc_2ADAF:
jmp short $+2
loc_2ADB1:
mov edi, cs:handler
xor eax, eax
mov esi, eax
call my_close
mov rdi, [rbp+var_18]
call free_defaults
xor edi, edi
call _exit
loc_2ADD0:
mov edi, cs:handler
xor eax, eax
mov esi, eax
call my_close
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rax, my_progname_short
mov rdx, [rax]
lea rsi, aSFailed; "%s: FAILED\n"
mov al, 0
call _fprintf
mov rdi, [rbp+var_18]
call free_defaults
mov edi, 1
call _exit
|
int __noreturn main(int argc, const char **argv, const char **envp)
{
_DWORD *v3; // rax
_DWORD *v4; // rax
_DWORD *v5; // rax
long long v6; // [rsp+8h] [rbp-2068h]
long long v7; // [rsp+10h] [rbp-2060h]
const char *v8; // [rsp+18h] [rbp-2058h]
long long v9; // [rsp+20h] [rbp-2050h]
long long v10; // [rsp+28h] [rbp-2048h]
const char *v11; // [rsp+30h] [rbp-2040h]
long long v12; // [rsp+38h] [rbp-2038h]
const char *v13; // [rsp+40h] [rbp-2030h]
int v14; // [rsp+4Ch] [rbp-2024h]
_BYTE v15[8200]; // [rsp+50h] [rbp-2020h] BYREF
const char **v16; // [rsp+2058h] [rbp-18h]
const char **v17; // [rsp+2060h] [rbp-10h] BYREF
_DWORD v18[2]; // [rsp+2068h] [rbp-8h] BYREF
v18[1] = 0;
v18[0] = argc;
v17 = argv;
my_progname = *argv;
my_init(argc, argv, envp);
v14 = load_defaults(&unk_157018, &load_default_groups, v18, &v17);
if ( v14 )
{
if ( v14 != 4 )
{
my_end(0LL);
exit(1LL);
}
my_end(0LL);
exit(0LL);
}
v16 = v17;
get_options(v18, &v17);
if ( opt_unit )
translog_example_table_init();
else
translog_table_init();
translog_fill_overhead_table();
maria_data_root = ".";
handler = my_open(opt_file, 0LL, 16LL);
if ( handler >= 0 )
{
if ( my_seek((unsigned int)handler, opt_offset, 0LL, 16LL) == opt_offset )
{
while ( 1 )
{
if ( !opt_pages )
goto LABEL_18;
if ( my_pread((unsigned int)handler, v15, 0x2000LL, opt_offset, 4LL) )
break;
printf("Page by offset %llu (0x%llx)\n", opt_offset, opt_offset);
dump_page(v15, (unsigned int)handler);
opt_offset += 0x2000LL;
--opt_pages;
}
if ( *(_DWORD *)my_thread_var() == 175 )
{
LABEL_18:
my_close((unsigned int)handler, 0LL);
free_defaults(v16);
exit(0LL);
}
v6 = stderr;
v7 = opt_offset;
v8 = (const char *)opt_file;
v5 = (_DWORD *)my_thread_var();
fprintf(v6, "Can't read page at position %lld file: '%s' errno: %d\n", v7, v8, *v5);
}
else
{
v9 = stderr;
v10 = opt_offset;
v11 = (const char *)opt_file;
v4 = (_DWORD *)my_thread_var();
fprintf(v9, "Can't set position %lld file: '%s' errno: %d\n", v10, v11, *v4);
}
}
else
{
v12 = stderr;
v13 = (const char *)opt_file;
v3 = (_DWORD *)my_thread_var();
fprintf(v12, "Can't open file: '%s' errno: %d\n", v13, *v3);
}
my_close((unsigned int)handler, 0LL);
fprintf(stderr, "%s: FAILED\n", my_progname_short);
free_defaults(v16);
exit(1LL);
}
|
main:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2070
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
LEA RAX,[0xd89b40]
MOV qword ptr [RAX],RCX
CALL 0x001f88d0
LEA RDI,[0x257018]
LEA RSI,[0x3c4010]
LEA RDX,[RBP + -0x8]
LEA RCX,[RBP + -0x10]
CALL 0x001dda50
MOV ECX,EAX
MOV dword ptr [RBP + -0x2024],ECX
TEST EAX,EAX
JZ 0x0012ab65
JMP 0x0012ab58
LAB_0012ab58:
MOV EAX,dword ptr [RBP + -0x2024]
SUB EAX,0x4
JZ 0x0012ab67
JMP 0x0012ab75
LAB_0012ab65:
JMP 0x0012ab86
LAB_0012ab67:
XOR EDI,EDI
CALL 0x001f8b10
XOR EDI,EDI
CALL 0x0012a500
LAB_0012ab75:
XOR EDI,EDI
CALL 0x001f8b10
MOV EDI,0x1
CALL 0x0012a500
LAB_0012ab86:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0x8]
LEA RSI,[RBP + -0x10]
CALL 0x0012ae20
CMP byte ptr [0x0057e458],0x0
JZ 0x0012abad
MOV AL,0x0
CALL 0x0012b430
JMP 0x0012abb4
LAB_0012abad:
MOV AL,0x0
CALL 0x0012b540
LAB_0012abb4:
MOV AL,0x0
CALL 0x0012c6a0
LEA RAX,[0x57e950]
LEA RCX,[0x25a628]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [0x0057e460]
XOR ESI,ESI
MOV EDX,0x10
CALL 0x001fa360
MOV dword ptr [0x003c4020],EAX
CMP EAX,0x0
JGE 0x0012ac31
MOV RAX,qword ptr [0x003c3fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2038],RAX
MOV RAX,qword ptr [0x0057e460]
MOV qword ptr [RBP + -0x2030],RAX
CALL 0x001fc1b0
MOV RDI,qword ptr [RBP + -0x2038]
MOV RDX,qword ptr [RBP + -0x2030]
MOV ECX,dword ptr [RAX]
LEA RSI,[0x25701b]
MOV AL,0x0
CALL 0x0012a180
JMP 0x0012add0
LAB_0012ac31:
MOV EDI,dword ptr [0x003c4020]
MOV RSI,qword ptr [0x0057e468]
XOR EDX,EDX
MOV ECX,0x10
CALL 0x001fad90
CMP RAX,qword ptr [0x0057e468]
JZ 0x0012acb0
MOV RAX,qword ptr [0x003c3fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2050],RAX
MOV RAX,qword ptr [0x0057e468]
MOV qword ptr [RBP + -0x2048],RAX
MOV RAX,qword ptr [0x0057e460]
MOV qword ptr [RBP + -0x2040],RAX
CALL 0x001fc1b0
MOV RDI,qword ptr [RBP + -0x2050]
MOV RDX,qword ptr [RBP + -0x2048]
MOV RCX,qword ptr [RBP + -0x2040]
MOV R8D,dword ptr [RAX]
LEA RSI,[0x25703d]
MOV AL,0x0
CALL 0x0012a180
JMP 0x0012add0
LAB_0012acb0:
JMP 0x0012acb2
LAB_0012acb2:
CMP qword ptr [0x0057e470],0x0
JZ 0x0012adaf
MOV EDI,dword ptr [0x003c4020]
LEA RSI,[RBP + -0x2020]
MOV RCX,qword ptr [0x0057e468]
MOV EDX,0x2000
MOV R8D,0x4
CALL 0x001fa750
CMP RAX,0x0
JZ 0x0012ad56
CALL 0x001fc1b0
CMP dword ptr [RAX],0xaf
JNZ 0x0012acfc
JMP 0x0012adb1
LAB_0012acfc:
MOV RAX,qword ptr [0x003c3fe0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2068],RAX
MOV RAX,qword ptr [0x0057e468]
MOV qword ptr [RBP + -0x2060],RAX
MOV RAX,qword ptr [0x0057e460]
MOV qword ptr [RBP + -0x2058],RAX
CALL 0x001fc1b0
MOV RDI,qword ptr [RBP + -0x2068]
MOV RDX,qword ptr [RBP + -0x2060]
MOV RCX,qword ptr [RBP + -0x2058]
MOV R8D,dword ptr [RAX]
LEA RSI,[0x25706d]
MOV AL,0x0
CALL 0x0012a180
JMP 0x0012add0
LAB_0012ad56:
MOV RSI,qword ptr [0x0057e468]
MOV RDX,qword ptr [0x0057e468]
LEA RDI,[0x2570a6]
MOV AL,0x0
CALL 0x0012a060
LEA RDI,[RBP + -0x2020]
MOV ESI,dword ptr [0x003c4020]
CALL 0x00134570
MOV RAX,qword ptr [0x0057e468]
ADD RAX,0x2000
MOV qword ptr [0x0057e468],RAX
MOV RAX,qword ptr [0x0057e470]
ADD RAX,-0x1
MOV qword ptr [0x0057e470],RAX
JMP 0x0012acb2
LAB_0012adaf:
JMP 0x0012adb1
LAB_0012adb1:
MOV EDI,dword ptr [0x003c4020]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001fa5f0
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001de2a0
XOR EDI,EDI
CALL 0x0012a500
LAB_0012add0:
MOV EDI,dword ptr [0x003c4020]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001fa5f0
MOV RAX,qword ptr [0x003c3fe0]
MOV RDI,qword ptr [RAX]
LEA RAX,[0xd89b48]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x2570c4]
MOV AL,0x0
CALL 0x0012a180
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001de2a0
MOV EDI,0x1
CALL 0x0012a500
|
void main(int4 param_1,int8 *param_2)
{
FILE *pFVar1;
int8 uVar2;
int iVar3;
uint *puVar4;
long lVar5;
long lVar6;
int *piVar7;
int1 local_2028 [8200];
int8 *local_20;
int8 *local_18;
int4 local_10;
int4 local_c;
local_c = 0;
my_progname = *param_2;
local_18 = param_2;
local_10 = param_1;
my_init();
iVar3 = load_defaults(&DAT_00257018,load_default_groups,&local_10,&local_18);
if (iVar3 != 0) {
if (iVar3 == 4) {
my_end();
/* WARNING: Subroutine does not return */
exit(0);
}
my_end(0);
/* WARNING: Subroutine does not return */
exit(1);
}
local_20 = local_18;
get_options(&local_10,&local_18);
if (opt_unit == '\0') {
translog_table_init();
}
else {
translog_example_table_init();
}
translog_fill_overhead_table();
maria_data_root = &DAT_0025a628;
handler = my_open(opt_file,0,0x10);
uVar2 = opt_file;
if (handler < 0) {
pFVar1 = *(FILE **)PTR_stderr_003c3fe0;
puVar4 = (uint *)_my_thread_var();
fprintf(pFVar1,"Can\'t open file: \'%s\' errno: %d\n",uVar2,(ulong)*puVar4);
}
else {
lVar5 = my_seek(handler,opt_offset,0,0x10);
lVar6 = opt_offset;
uVar2 = opt_file;
if (lVar5 == opt_offset) {
do {
if (opt_pages == 0) {
LAB_0012adb1:
my_close(handler,0);
free_defaults();
/* WARNING: Subroutine does not return */
exit(0);
}
lVar6 = my_pread(handler,local_2028,0x2000,opt_offset,4);
if (lVar6 != 0) {
piVar7 = (int *)_my_thread_var();
lVar6 = opt_offset;
uVar2 = opt_file;
if (*piVar7 != 0xaf) {
pFVar1 = *(FILE **)PTR_stderr_003c3fe0;
puVar4 = (uint *)_my_thread_var();
fprintf(pFVar1,"Can\'t read page at position %lld file: \'%s\' errno: %d\n",lVar6,
uVar2,(ulong)*puVar4);
goto LAB_0012add0;
}
goto LAB_0012adb1;
}
printf("Page by offset %llu (0x%llx)\n",opt_offset,opt_offset);
dump_page(local_2028,handler);
opt_offset = opt_offset + 0x2000;
opt_pages = opt_pages + -1;
} while( true );
}
pFVar1 = *(FILE **)PTR_stderr_003c3fe0;
puVar4 = (uint *)_my_thread_var();
fprintf(pFVar1,"Can\'t set position %lld file: \'%s\' errno: %d\n",lVar6,uVar2,(ulong)*puVar4)
;
}
LAB_0012add0:
my_close(handler,0);
fprintf(*(FILE **)PTR_stderr_003c3fe0,"%s: FAILED\n",my_progname_short);
free_defaults(local_20);
/* WARNING: Subroutine does not return */
exit(1);
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.