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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
31,200 | ma_apply_redo_free_head_or_tail | eloqsql/storage/maria/ma_blockrec.c | uint _ma_apply_redo_free_head_or_tail(MARIA_HA *info, LSN lsn,
const uchar *header)
{
MARIA_SHARE *share= info->s;
uchar *buff;
pgcache_page_no_t page;
MARIA_PINNED_PAGE page_link;
my_bool res;
DBUG_ENTER("_ma_apply_redo_free_head_or_tail");
share->state.changed|= (STATE_CHANGED | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
page= page_korr(header);
if (!(buff= pagecache_read(share->pagecache,
&info->dfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE, &page_link.link)))
{
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
goto err;
}
if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 1, page);
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
}
else
{
buff[PAGE_TYPE_OFFSET]= UNALLOCATED_PAGE;
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
uint number_of_records= (uint) buff[DIR_COUNT_OFFSET];
uchar *dir= dir_entry_pos(buff, share->block_size,
number_of_records-1);
buff[DIR_FREE_OFFSET]= END_OF_DIR_FREE_LIST;
bzero(dir, number_of_records * DIR_ENTRY_SIZE);
}
#endif
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
/** @todo leave bitmap lock to the bitmap code... */
mysql_mutex_lock(&share->bitmap.bitmap_lock);
res= _ma_bitmap_reset_full_page_bits(info, &share->bitmap, page, 1);
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
if (res)
goto err;
DBUG_RETURN(0);
err:
_ma_mark_file_crashed(share);
DBUG_ASSERT(!maria_assert_if_crashed_table);
DBUG_RETURN(1);
} | O0 | c | ma_apply_redo_free_head_or_tail:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x181, %ecx # imm = 0x181
movl %ecx, 0x170(%rax)
movq -0x20(%rbp), %rdi
callq 0x58b40
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3b470
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x599f2
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x50(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3b210
jmp 0x59b3b
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x30(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
cmpq -0x18(%rbp), %rax
jl 0x59aa7
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x20, %rsi
movq -0x30(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rsi
movq -0x38(%rbp), %rcx
movl $0x1, %edx
callq 0x322d0
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x50(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3b210
jmp 0x59ace
movq -0x30(%rbp), %rax
movb $0x0, 0x7(%rax)
movl $0x6, -0x48(%rbp)
movb $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xda300
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xfe652(%rip), %rsi # 0x158139
movl $0x1a93, %edx # imm = 0x1A93
callq 0x59860
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
movq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x621c0
movb %al, -0x51(%rbp)
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x598d0
cmpb $0x0, -0x51(%rbp)
je 0x59b30
jmp 0x59b3b
jmp 0x59b32
movl $0x0, -0x4(%rbp)
jmp 0x59b4f
movq -0x28(%rbp), %rdi
callq 0x47700
jmp 0x59b46
jmp 0x59b48
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_apply_redo_free_head_or_tail:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov ecx, [rax+170h]
or ecx, 181h
mov [rax+170h], ecx
mov rdi, [rbp+var_20]
call uint5korr_0
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov rdx, [rbp+var_38]
lea rax, [rbp+var_50]
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
mov [rsp+70h+var_70], 4
mov [rsp+70h+var_68], rax
call pagecache_read
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_599F2
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_50]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+70h+var_70], 0
mov dword ptr [rsp+70h+var_68], 0
call pagecache_unlock_by_link
jmp loc_59B3B
loc_599F2:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_30]
mov ecx, [rcx+3]
or rax, rcx
cmp rax, [rbp+var_18]
jl short loc_59AA7
mov rdi, [rbp+var_10]
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov esi, eax
shl rsi, 20h
mov rax, [rbp+var_30]
mov eax, [rax+3]
or rsi, rax
mov rcx, [rbp+var_38]
mov edx, 1
call check_skipped_lsn
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_50]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+70h+var_70], 0
mov dword ptr [rsp+70h+var_68], 0
call pagecache_unlock_by_link
jmp short loc_59ACE
loc_59AA7:
mov rax, [rbp+var_30]
mov byte ptr [rax+7], 0
mov [rbp+var_48], 6
mov [rbp+var_40], 1
mov rdi, [rbp+var_10]
add rdi, 2E8h
lea rsi, [rbp+var_50]
call insert_dynamic
loc_59ACE:
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1A93h
call inline_mysql_mutex_lock_7
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
add rsi, 0A10h
mov rdx, [rbp+var_38]
mov ecx, 1
call _ma_bitmap_reset_full_page_bits
mov [rbp+var_51], al
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_7
cmp [rbp+var_51], 0
jz short loc_59B30
jmp short loc_59B3B
loc_59B30:
jmp short $+2
loc_59B32:
mov [rbp+var_4], 0
jmp short loc_59B4F
loc_59B3B:
mov rdi, [rbp+var_28]
call _ma_mark_file_crashed
jmp short $+2
loc_59B46:
jmp short $+2
loc_59B48:
mov [rbp+var_4], 1
loc_59B4F:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long ma_apply_redo_free_head_or_tail(long long *a1, signed long long a2, unsigned int *a3)
{
char v4; // [rsp+1Fh] [rbp-51h]
long long v5; // [rsp+20h] [rbp-50h] BYREF
int v6; // [rsp+28h] [rbp-48h]
char v7; // [rsp+30h] [rbp-40h]
unsigned long long v8; // [rsp+38h] [rbp-38h]
unsigned __int16 *v9; // [rsp+40h] [rbp-30h]
long long v10; // [rsp+48h] [rbp-28h]
unsigned int *v11; // [rsp+50h] [rbp-20h]
signed long long v12; // [rsp+58h] [rbp-18h]
long long *v13; // [rsp+60h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = *a1;
*(_DWORD *)(v10 + 368) |= 0x181u;
v8 = uint5korr_0(v11);
v9 = (unsigned __int16 *)pagecache_read(
*(_QWORD **)(v10 + 1536),
(long long)(v13 + 142),
v8,
0,
0LL,
1,
4u,
(char *)&v5);
if ( !v9 )
{
pagecache_unlock_by_link(*(_QWORD **)(v10 + 1536), v5, 6, 3, 0LL, 0LL, 0, 0);
LABEL_8:
ma_mark_file_crashed(v10);
return 1;
}
if ( (long long)(*(unsigned int *)((char *)v9 + 3) | ((unsigned long long)((*((unsigned __int8 *)v9 + 2) << 16) | (unsigned int)*v9) << 32)) < v12 )
{
*((_BYTE *)v9 + 7) = 0;
v6 = 6;
v7 = 1;
insert_dynamic(v13 + 93, &v5);
}
else
{
check_skipped_lsn(
(long long)v13,
*(unsigned int *)((char *)v9 + 3) | ((unsigned long long)((*((unsigned __int8 *)v9 + 2) << 16) | (unsigned int)*v9) << 32),
1,
v8);
pagecache_unlock_by_link(*(_QWORD **)(v10 + 1536), v5, 6, 3, 0LL, 0LL, 0, 0);
}
inline_mysql_mutex_lock_7(
v10 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1A93u);
v4 = ma_bitmap_reset_full_page_bits(v13, v10 + 2576, v8, 1LL);
inline_mysql_mutex_unlock_7(v10 + 2712);
if ( v4 )
goto LABEL_8;
return 0;
}
| _ma_apply_redo_free_head_or_tail:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
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]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x181
MOV dword ptr [RAX + 0x170],ECX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00158b40
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV RDX,qword ptr [RBP + -0x38]
LEA RAX,[RBP + -0x50]
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0013b470
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,0x0
JNZ 0x001599f2
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0013b210
JMP 0x00159b3b
LAB_001599f2:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JL 0x00159aa7
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x20
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x3]
OR RSI,RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV EDX,0x1
CALL 0x001322d0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0013b210
JMP 0x00159ace
LAB_00159aa7:
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x7],0x0
MOV dword ptr [RBP + -0x48],0x6
MOV byte ptr [RBP + -0x40],0x1
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x50]
CALL 0x001da300
LAB_00159ace:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x258139]
MOV EDX,0x1a93
CALL 0x00159860
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0xa10
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,0x1
CALL 0x001621c0
MOV byte ptr [RBP + -0x51],AL
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x001598d0
CMP byte ptr [RBP + -0x51],0x0
JZ 0x00159b30
JMP 0x00159b3b
LAB_00159b30:
JMP 0x00159b32
LAB_00159b32:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00159b4f
LAB_00159b3b:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00147700
JMP 0x00159b46
LAB_00159b46:
JMP 0x00159b48
LAB_00159b48:
MOV dword ptr [RBP + -0x4],0x1
LAB_00159b4f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 _ma_apply_redo_free_head_or_tail(long *param_1,long param_2,int8 param_3)
{
char cVar1;
int8 *puVar2;
int8 local_58;
int4 local_50;
int1 local_48;
int8 local_40;
int3 *local_38;
long local_30;
int8 local_28;
long local_20;
long *local_18;
local_30 = *param_1;
*(uint *)(local_30 + 0x170) = *(uint *)(local_30 + 0x170) | 0x181;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_40 = uint5korr(param_3);
puVar2 = &local_58;
local_38 = (int3 *)
pagecache_read(*(int8 *)(local_30 + 0x600),local_18 + 0x8e,local_40,0,0,1,4,
puVar2);
if (local_38 == (int3 *)0x0) {
pagecache_unlock_by_link
(*(int8 *)(local_30 + 0x600),local_58,6,3,0,0,0,
(ulong)puVar2 & 0xffffffff00000000);
}
else {
if ((long)(ulong)CONCAT34(*local_38,*(int4 *)((long)local_38 + 3)) < local_20) {
*(int1 *)((long)local_38 + 7) = 0;
local_50 = 6;
local_48 = 1;
insert_dynamic(local_18 + 0x5d,&local_58);
}
else {
check_skipped_lsn(local_18,(ulong)CONCAT34(*local_38,*(int4 *)((long)local_38 + 3)),1,
local_40);
pagecache_unlock_by_link
(*(int8 *)(local_30 + 0x600),local_58,6,3,0,0,0,
(ulong)puVar2 & 0xffffffff00000000);
}
inline_mysql_mutex_lock
(local_30 + 0xa98,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",0x1a93);
cVar1 = _ma_bitmap_reset_full_page_bits(local_18,local_30 + 0xa10,local_40,1);
inline_mysql_mutex_unlock(local_30 + 0xa98);
if (cVar1 == '\0') {
return 0;
}
}
_ma_mark_file_crashed(local_30);
return 1;
}
| |
31,201 | my_charlen_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_charlen_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_charlen_utf8mb4:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x530aa
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0x53016
movl $0x1, %eax
testb %cl, %cl
jns 0x530aa
cmpb $-0x3e, %cl
jb 0x530a8
cmpb $-0x21, %cl
ja 0x5306f
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0x530aa
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0x530aa
cmpb $-0xc, %cl
ja 0x530a8
leaq 0x4(%rsi), %rdi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %rdi
ja 0x530aa
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0x530a8
cmpb $-0x41, 0x2(%rsi)
jg 0x530a8
cmpb $-0x41, 0x3(%rsi)
jg 0x530a8
cmpb $-0x10, %cl
sete %sil
cmpb $-0x70, %dl
setb %dil
movl $0x0, %eax
testb %dil, %sil
jne 0x530aa
cmpb $-0xc, %cl
setne %al
cmpb $-0x70, %dl
setb %cl
orb %al, %cl
movzbl %cl, %eax
shll $0x2, %eax
jmp 0x530aa
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0x530aa
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0x530a8
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0x530aa
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0x530aa
xorl %eax, %eax
popq %rbp
retq
| my_charlen_utf8mb4:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb loc_530AA
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_53016
mov eax, 1
test cl, cl
jns loc_530AA
cmp cl, 0C2h
jb loc_530A8
cmp cl, 0DFh
ja short loc_5306F
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja loc_530AA
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp loc_530AA
loc_53016:
cmp cl, 0F4h
ja loc_530A8
lea rdi, [rsi+4]
mov eax, 0FFFFFF98h
cmp rdi, rdx
ja short loc_530AA
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_530A8
cmp byte ptr [rsi+2], 0BFh
jg short loc_530A8
cmp byte ptr [rsi+3], 0BFh
jg short loc_530A8
cmp cl, 0F0h
setz sil
cmp dl, 90h
setb dil
mov eax, 0
test sil, dil
jnz short loc_530AA
cmp cl, 0F4h
setnz al
cmp dl, 90h
setb cl
or cl, al
movzx eax, cl
shl eax, 2
jmp short loc_530AA
loc_5306F:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_530AA
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_530A8
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_530AA
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_530AA
loc_530A8:
xor eax, eax
loc_530AA:
pop rbp
retn
| long long my_charlen_utf8mb4(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
char v6; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (unsigned __int8)*a2 <= 0xEFu )
{
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 >= 0xC2u )
{
if ( (unsigned __int8)v4 <= 0xDFu )
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
return result;
}
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v6 = a2[1];
if ( v6 <= -65 )
{
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v6 >= 0xA0u);
}
return result;
}
}
return 0LL;
}
if ( (unsigned __int8)v4 > 0xF4u )
return 0LL;
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v5 = a2[1];
if ( v5 > -65 || a2[2] > -65 || a2[3] > -65 )
return 0LL;
result = 0LL;
if ( (unsigned __int8)v5 >= 0x90u || v4 != -16 )
return 4 * (unsigned int)(v4 != -12 || (unsigned __int8)v5 < 0x90u);
return result;
}
| my_charlen_utf8mb4:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001530aa
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x00153016
MOV EAX,0x1
TEST CL,CL
JNS 0x001530aa
CMP CL,0xc2
JC 0x001530a8
CMP CL,0xdf
JA 0x0015306f
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x001530aa
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x001530aa
LAB_00153016:
CMP CL,0xf4
JA 0x001530a8
LEA RDI,[RSI + 0x4]
MOV EAX,0xffffff98
CMP RDI,RDX
JA 0x001530aa
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001530a8
CMP byte ptr [RSI + 0x2],0xbf
JG 0x001530a8
CMP byte ptr [RSI + 0x3],0xbf
JG 0x001530a8
CMP CL,0xf0
SETZ SIL
CMP DL,0x90
SETC DIL
MOV EAX,0x0
TEST SIL,DIL
JNZ 0x001530aa
CMP CL,0xf4
SETNZ AL
CMP DL,0x90
SETC CL
OR CL,AL
MOVZX EAX,CL
SHL EAX,0x2
JMP 0x001530aa
LAB_0015306f:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x001530aa
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001530a8
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x001530aa
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x001530aa
LAB_001530a8:
XOR EAX,EAX
LAB_001530aa:
POP RBP
RET
|
ulong my_charlen_utf8mb4(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
return (ulong)((uint)((char)param_2[1] < -0x40) * 2);
}
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (ulong)((uint)(0x9f < param_2[1]) * 3);
}
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar2 = param_2[1];
if ((((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) {
if (bVar1 == 0xf0 && bVar2 < 0x90) {
return 0;
}
return (ulong)(bVar2 < 0x90 || bVar1 != 0xf4) << 2;
}
}
return 0;
}
| |
31,202 | init_sync_class(unsigned int, unsigned int, unsigned int) | eloqsql/storage/perfschema/pfs_instr_class.cc | int init_sync_class(uint mutex_class_sizing,
uint rwlock_class_sizing,
uint cond_class_sizing)
{
mutex_class_dirty_count= mutex_class_allocated_count= 0;
rwlock_class_dirty_count= rwlock_class_allocated_count= 0;
cond_class_dirty_count= cond_class_allocated_count= 0;
mutex_class_max= mutex_class_sizing;
rwlock_class_max= rwlock_class_sizing;
cond_class_max= cond_class_sizing;
mutex_class_lost= rwlock_class_lost= cond_class_lost= 0;
mutex_class_array= NULL;
rwlock_class_array= NULL;
cond_class_array= NULL;
if (mutex_class_max > 0)
{
mutex_class_array= PFS_MALLOC_ARRAY(& builtin_memory_mutex_class,
mutex_class_max,
sizeof(PFS_mutex_class), PFS_mutex_class,
MYF(MY_ZEROFILL));
if (unlikely(mutex_class_array == NULL))
return 1;
}
if (rwlock_class_max > 0)
{
rwlock_class_array= PFS_MALLOC_ARRAY(& builtin_memory_rwlock_class,
rwlock_class_max,
sizeof(PFS_rwlock_class), PFS_rwlock_class,
MYF(MY_ZEROFILL));
if (unlikely(rwlock_class_array == NULL))
return 1;
}
if (cond_class_max > 0)
{
cond_class_array= PFS_MALLOC_ARRAY(& builtin_memory_cond_class,
cond_class_max,
sizeof(PFS_cond_class), PFS_cond_class,
MYF(MY_ZEROFILL));
if (unlikely(cond_class_array == NULL))
return 1;
}
return 0;
} | O3 | cpp | init_sync_class(unsigned int, unsigned int, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
andl $0x0, 0x3a6271(%rip) # 0x3cd928
andl $0x0, 0x3a626e(%rip) # 0x3cd92c
andl $0x0, 0x3a626b(%rip) # 0x3cd930
andl $0x0, 0x3a6268(%rip) # 0x3cd934
andl $0x0, 0x3a6265(%rip) # 0x3cd938
andl $0x0, 0x3a6262(%rip) # 0x3cd93c
andq $0x0, 0x3a59c6(%rip) # 0x3cd0a8
andq $0x0, 0x3a59ae(%rip) # 0x3cd098
movl %edi, %eax
andq $0x0, 0x3a5994(%rip) # 0x3cd088
movq %rax, 0x3a5985(%rip) # 0x3cd080
andq $0x0, 0x3a5a15(%rip) # 0x3cd118
movl %esi, %esi
andq $0x0, 0x3a5a13(%rip) # 0x3cd120
movq %rsi, 0x3a597c(%rip) # 0x3cd090
andq $0x0, 0x3a5a0c(%rip) # 0x3cd128
movl %edx, %ecx
movq %rcx, 0x3a597b(%rip) # 0x3cd0a0
pushq $0x1
popq %rbx
testl %edi, %edi
je 0x27756
leaq 0x3a368d(%rip), %rdi # 0x3cadc0
pushq $0x20
popq %rcx
movl $0x100, %edx # imm = 0x100
movq %rax, %rsi
callq 0x2cd6c
movq %rax, 0x3a59ce(%rip) # 0x3cd118
testq %rax, %rax
je 0x277a9
movq 0x3a593a(%rip), %rsi # 0x3cd090
testq %rsi, %rsi
je 0x2777b
leaq 0x3a379e(%rip), %rdi # 0x3caf00
pushq $0x20
popq %rcx
movl $0x100, %edx # imm = 0x100
callq 0x2cd6c
movq %rax, 0x3a59aa(%rip) # 0x3cd120
testq %rax, %rax
je 0x277a9
movq 0x3a591e(%rip), %rsi # 0x3cd0a0
testq %rsi, %rsi
je 0x277a7
leaq 0x3a38b2(%rip), %rdi # 0x3cb040
pushq $0x20
popq %rcx
movl $0x100, %edx # imm = 0x100
callq 0x2cd6c
movq %rax, 0x3a5986(%rip) # 0x3cd128
testq %rax, %rax
je 0x277a9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _Z15init_sync_classjjj:
push rbp
mov rbp, rsp
push rbx
push rax
and cs:_ZL27mutex_class_allocated_count, 0; mutex_class_allocated_count
and cs:_ZL23mutex_class_dirty_count, 0; mutex_class_dirty_count
and cs:_ZL28rwlock_class_allocated_count, 0; rwlock_class_allocated_count
and cs:_ZL24rwlock_class_dirty_count, 0; rwlock_class_dirty_count
and cs:_ZL26cond_class_allocated_count, 0; cond_class_allocated_count
and cs:_ZL22cond_class_dirty_count, 0; cond_class_dirty_count
and cs:cond_class_lost, 0
and cs:rwlock_class_lost, 0
mov eax, edi
and cs:mutex_class_lost, 0
mov cs:mutex_class_max, rax
and cs:mutex_class_array, 0
mov esi, esi
and cs:rwlock_class_array, 0
mov cs:rwlock_class_max, rsi
and cs:cond_class_array, 0
mov ecx, edx
mov cs:cond_class_max, rcx
push 1
pop rbx
test edi, edi
jz short loc_27756
lea rdi, builtin_memory_mutex_class
push 20h ; ' '
pop rcx
mov edx, 100h
mov rsi, rax
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:mutex_class_array, rax
test rax, rax
jz short loc_277A9
mov rsi, cs:rwlock_class_max
loc_27756:
test rsi, rsi
jz short loc_2777B
lea rdi, builtin_memory_rwlock_class
push 20h ; ' '
pop rcx
mov edx, 100h
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:rwlock_class_array, rax
test rax, rax
jz short loc_277A9
loc_2777B:
mov rsi, cs:cond_class_max
test rsi, rsi
jz short loc_277A7
lea rdi, builtin_memory_cond_class
push 20h ; ' '
pop rcx
mov edx, 100h
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:cond_class_array, rax
test rax, rax
jz short loc_277A9
loc_277A7:
xor ebx, ebx
loc_277A9:
mov eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
| long long init_sync_class(unsigned int a1, long long a2, unsigned int a3)
{
unsigned int v3; // ebx
mutex_class_allocated_count = 0;
mutex_class_dirty_count = 0;
rwlock_class_allocated_count = 0;
rwlock_class_dirty_count = 0;
cond_class_allocated_count = 0;
cond_class_dirty_count = 0;
cond_class_lost = 0LL;
rwlock_class_lost = 0LL;
mutex_class_lost = 0LL;
mutex_class_max = a1;
mutex_class_array = 0LL;
a2 = (unsigned int)a2;
rwlock_class_array = 0LL;
rwlock_class_max = (unsigned int)a2;
cond_class_array = 0LL;
cond_class_max = a3;
v3 = 1;
if ( a1 )
{
mutex_class_array = pfs_malloc_array(&builtin_memory_mutex_class, a1, 256LL, 32LL);
if ( !mutex_class_array )
return v3;
a2 = rwlock_class_max;
}
if ( !a2 || (rwlock_class_array = pfs_malloc_array(&builtin_memory_rwlock_class, a2, 256LL, 32LL)) != 0 )
{
if ( !cond_class_max )
return 0;
cond_class_array = pfs_malloc_array(&builtin_memory_cond_class, cond_class_max, 256LL, 32LL);
if ( cond_class_array )
return 0;
}
return v3;
}
| init_sync_class:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
AND dword ptr [0x004cd928],0x0
AND dword ptr [0x004cd92c],0x0
AND dword ptr [0x004cd930],0x0
AND dword ptr [0x004cd934],0x0
AND dword ptr [0x004cd938],0x0
AND dword ptr [0x004cd93c],0x0
AND qword ptr [0x004cd0a8],0x0
AND qword ptr [0x004cd098],0x0
MOV EAX,EDI
AND qword ptr [0x004cd088],0x0
MOV qword ptr [0x004cd080],RAX
AND qword ptr [0x004cd118],0x0
MOV ESI,ESI
AND qword ptr [0x004cd120],0x0
MOV qword ptr [0x004cd090],RSI
AND qword ptr [0x004cd128],0x0
MOV ECX,EDX
MOV qword ptr [0x004cd0a0],RCX
PUSH 0x1
POP RBX
TEST EDI,EDI
JZ 0x00127756
LEA RDI,[0x4cadc0]
PUSH 0x20
POP RCX
MOV EDX,0x100
MOV RSI,RAX
CALL 0x0012cd6c
MOV qword ptr [0x004cd118],RAX
TEST RAX,RAX
JZ 0x001277a9
MOV RSI,qword ptr [0x004cd090]
LAB_00127756:
TEST RSI,RSI
JZ 0x0012777b
LEA RDI,[0x4caf00]
PUSH 0x20
POP RCX
MOV EDX,0x100
CALL 0x0012cd6c
MOV qword ptr [0x004cd120],RAX
TEST RAX,RAX
JZ 0x001277a9
LAB_0012777b:
MOV RSI,qword ptr [0x004cd0a0]
TEST RSI,RSI
JZ 0x001277a7
LEA RDI,[0x4cb040]
PUSH 0x20
POP RCX
MOV EDX,0x100
CALL 0x0012cd6c
MOV qword ptr [0x004cd128],RAX
TEST RAX,RAX
JZ 0x001277a9
LAB_001277a7:
XOR EBX,EBX
LAB_001277a9:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* init_sync_class(unsigned int, unsigned int, unsigned int) */
int8 init_sync_class(uint param_1,uint param_2,uint param_3)
{
int8 uVar1;
mutex_class_allocated_count = 0;
mutex_class_dirty_count = 0;
rwlock_class_allocated_count = 0;
rwlock_class_dirty_count = 0;
cond_class_allocated_count = 0;
cond_class_dirty_count = 0;
cond_class_lost = 0;
rwlock_class_lost = 0;
mutex_class_max = (ulong)param_1;
mutex_class_lost = 0;
mutex_class_array = 0;
rwlock_class_max = (ulong)param_2;
rwlock_class_array = 0;
cond_class_array = 0;
cond_class_max = (ulong)param_3;
uVar1 = 1;
if ((((param_1 == 0) ||
(mutex_class_array =
pfs_malloc_array((PFS_builtin_memory_class *)builtin_memory_mutex_class,mutex_class_max
,0x100,0x20), mutex_class_array != 0)) &&
((rwlock_class_max == 0 ||
(rwlock_class_array =
pfs_malloc_array((PFS_builtin_memory_class *)builtin_memory_rwlock_class,
rwlock_class_max,0x100,0x20), rwlock_class_array != 0)))) &&
((cond_class_max == 0 ||
(cond_class_array =
pfs_malloc_array((PFS_builtin_memory_class *)builtin_memory_cond_class,cond_class_max,
0x100,0x20), cond_class_array != 0)))) {
uVar1 = 0;
}
return uVar1;
}
| |
31,203 | mariadb_read_options | eloqsql/libmariadb/libmariadb/ma_default.c | my_bool _mariadb_read_options(MYSQL *mysql,
const char *config_dir,
const char *config_file,
const char *group,
unsigned int recursion)
{
int i= 0,
exts,
errors= 0;
char filename[FN_REFLEN + 1];
unsigned int recursion_stop= 64;
#ifndef _WIN32
char *env;
#endif
if (recursion >= recursion_stop)
return 1;
if (config_file && config_file[0])
return _mariadb_read_options_from_file(mysql, config_file, group, recursion);
if (config_dir && config_dir[0])
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%cmy.%s", config_dir, FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
return errors;
}
for (i=0; i < MAX_CONFIG_DIRS && configuration_dirs[i]; i++)
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%cmy.%s", configuration_dirs[i], FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
}
#ifndef _WIN32
/* special case: .my.cnf in Home directory */
if ((env= getenv("HOME")))
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%c.my.%s", env, FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
}
#endif
return errors;
} | O3 | c | mariadb_read_options:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, -0x258(%rbp)
movq %rdi, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movb $0x1, %r12b
movl %r8d, -0x244(%rbp)
cmpl $0x3f, %r8d
jbe 0x34b38
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x34d1b
movl %r12d, %eax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r9
testq %rdx, %rdx
je 0x34b85
cmpb $0x0, (%rdx)
je 0x34b85
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x34d1b
movq -0x250(%rbp), %rdi
movq %rdx, %rsi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34d20
testq %r9, %r9
je 0x34c03
cmpb $0x0, (%r9)
je 0x34c03
leaq 0x6090(%rip), %r10 # 0x3ac27
leaq 0x6044(%rip), %r8 # 0x3abe2
xorl %r12d, %r12d
leaq -0x240(%rbp), %r14
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
xorl %eax, %eax
pushq %r10
pushq $0x2f
callq 0x132d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x13770
testl %eax, %eax
jne 0x34b10
leaq -0x240(%rbp), %rsi
movq -0x250(%rbp), %rdi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x34d20
jmp 0x34d13
xorl %r12d, %r12d
leaq 0x19f43(%rip), %r15 # 0x4eb50
leaq 0x5fce(%rip), %r13 # 0x3abe2
leaq -0x240(%rbp), %r14
xorl %ebx, %ebx
movq (%r15), %rax
movq (%rax,%rbx,8), %r9
testq %r9, %r9
je 0x34c8d
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
movq %r13, %r8
xorl %eax, %eax
leaq 0x5fe0(%rip), %r10 # 0x3ac27
pushq %r10
pushq $0x2f
callq 0x132d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x13770
testl %eax, %eax
jne 0x34c84
movq -0x250(%rbp), %rdi
movq %r14, %rsi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x34d20
addb %al, %r12b
incq %rbx
cmpq $0x6, %rbx
jne 0x34c1d
leaq 0x5f3e(%rip), %rdi # 0x3abd2
callq 0x135a0
testq %rax, %rax
je 0x34b10
leaq 0x5f43(%rip), %r8 # 0x3abec
leaq -0x240(%rbp), %r14
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
movq %rax, %r9
xorl %eax, %eax
leaq 0x5f59(%rip), %r10 # 0x3ac27
pushq %r10
pushq $0x2f
callq 0x132d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x13770
testl %eax, %eax
jne 0x34b10
leaq -0x240(%rbp), %rsi
movq -0x250(%rbp), %rdi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x34d20
addb %r12b, %al
movl %eax, %r12d
jmp 0x34b10
callq 0x13510
| _mariadb_read_options:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 238h
mov [rbp+var_258], rcx
mov [rbp+var_250], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r12b, 1
mov [rbp+var_244], r8d
cmp r8d, 3Fh ; '?'
jbe short loc_34B38
loc_34B10:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_34D1B
mov eax, r12d
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34B38:
mov r9, rsi
test rdx, rdx
jz short loc_34B85
cmp byte ptr [rdx], 0
jz short loc_34B85
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_34D1B
mov rdi, [rbp+var_250]
mov rsi, rdx
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _mariadb_read_options_from_file
loc_34B85:
test r9, r9
jz short loc_34C03
cmp byte ptr [r9], 0
jz short loc_34C03
lea r10, aCnf; "cnf"
lea r8, aSCmyS; "%s%cmy.%s"
xor r12d, r12d
lea r14, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
xor eax, eax
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz loc_34B10
lea rsi, [rbp+var_240]
mov rdi, [rbp+var_250]
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
jmp loc_34D13
loc_34C03:
xor r12d, r12d
lea r15, configuration_dirs
lea r13, aSCmyS; "%s%cmy.%s"
lea r14, [rbp+var_240]
xor ebx, ebx
loc_34C1D:
mov rax, [r15]
mov r9, [rax+rbx*8]
test r9, r9
jz short loc_34C8D
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
mov r8, r13
xor eax, eax
lea r10, aCnf; "cnf"
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz short loc_34C84
mov rdi, [rbp+var_250]
mov rsi, r14
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
add r12b, al
loc_34C84:
inc rbx
cmp rbx, 6
jnz short loc_34C1D
loc_34C8D:
lea rdi, aMariadbHome+8; "HOME"
call _getenv
test rax, rax
jz loc_34B10
lea r8, aSCMyS; "%s%c.my.%s"
lea r14, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
mov r9, rax
xor eax, eax
lea r10, aCnf; "cnf"
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz loc_34B10
lea rsi, [rbp+var_240]
mov rdi, [rbp+var_250]
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
add al, r12b
loc_34D13:
mov r12d, eax
jmp loc_34B10
loc_34D1B:
call ___stack_chk_fail
| long long mariadb_read_options(long long a1, const char *a2, _BYTE *a3, long long a4, unsigned int a5)
{
unsigned int v5; // r12d
double v7; // xmm0_8
unsigned int options_from_file; // eax
long long i; // rbx
const char *v10; // r9
double v11; // xmm0_8
const char *v12; // rax
double v13; // xmm0_8
_BYTE v16[528]; // [rsp+20h] [rbp-240h] BYREF
unsigned long long v17; // [rsp+230h] [rbp-30h]
v17 = __readfsqword(0x28u);
LOBYTE(v5) = 1;
if ( a5 > 0x3F )
return v5;
if ( !a3 || !*a3 )
{
if ( a2 && *a2 )
{
v5 = 0;
v7 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%cmy.%s", a2, 47LL, "cnf");
if ( (unsigned int)access(v16, 4LL, v7) )
return v5;
return (unsigned int)mariadb_read_options_from_file(a1, v16, a4, a5);
}
else
{
v5 = 0;
for ( i = 0LL; i != 6; ++i )
{
v10 = *(const char **)(configuration_dirs + 8 * i);
if ( !v10 )
break;
v11 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%cmy.%s", v10, 47LL, "cnf");
if ( !(unsigned int)access(v16, 4LL, v11) )
LOBYTE(v5) = mariadb_read_options_from_file(a1, v16, a4, a5) + v5;
}
v12 = (const char *)getenv("HOME");
if ( !v12 )
return v5;
v13 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%c.my.%s", v12, 47LL, "cnf");
if ( (unsigned int)access(v16, 4LL, v13) )
return v5;
options_from_file = mariadb_read_options_from_file(a1, v16, a4, a5);
LOBYTE(options_from_file) = v5 + options_from_file;
}
return options_from_file;
}
return mariadb_read_options_from_file(a1, a3, a4, a5);
}
| _mariadb_read_options:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x258],RCX
MOV qword ptr [RBP + -0x250],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R12B,0x1
MOV dword ptr [RBP + -0x244],R8D
CMP R8D,0x3f
JBE 0x00134b38
LAB_00134b10:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00134d1b
MOV EAX,R12D
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134b38:
MOV R9,RSI
TEST RDX,RDX
JZ 0x00134b85
CMP byte ptr [RDX],0x0
JZ 0x00134b85
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00134d1b
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,RDX
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00134d20
LAB_00134b85:
TEST R9,R9
JZ 0x00134c03
CMP byte ptr [R9],0x0
JZ 0x00134c03
LEA R10,[0x13ac27]
LEA R8,[0x13abe2]
XOR R12D,R12D
LEA R14,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
XOR EAX,EAX
PUSH R10
PUSH 0x2f
CALL 0x001132d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00113770
TEST EAX,EAX
JNZ 0x00134b10
LEA RSI,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x250]
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00134d20
JMP 0x00134d13
LAB_00134c03:
XOR R12D,R12D
LEA R15,[0x14eb50]
LEA R13,[0x13abe2]
LEA R14,[RBP + -0x240]
XOR EBX,EBX
LAB_00134c1d:
MOV RAX,qword ptr [R15]
MOV R9,qword ptr [RAX + RBX*0x8]
TEST R9,R9
JZ 0x00134c8d
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
MOV R8,R13
XOR EAX,EAX
LEA R10,[0x13ac27]
PUSH R10
PUSH 0x2f
CALL 0x001132d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00113770
TEST EAX,EAX
JNZ 0x00134c84
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00134d20
ADD R12B,AL
LAB_00134c84:
INC RBX
CMP RBX,0x6
JNZ 0x00134c1d
LAB_00134c8d:
LEA RDI,[0x13abd2]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x00134b10
LEA R8,[0x13abec]
LEA R14,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
MOV R9,RAX
XOR EAX,EAX
LEA R10,[0x13ac27]
PUSH R10
PUSH 0x2f
CALL 0x001132d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00113770
TEST EAX,EAX
JNZ 0x00134b10
LEA RSI,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x250]
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00134d20
ADD AL,R12B
LAB_00134d13:
MOV R12D,EAX
JMP 0x00134b10
LAB_00134d1b:
CALL 0x00113510
|
ulong _mariadb_read_options
(int8 param_1,char *param_2,char *param_3,int8 param_4,uint param_5)
{
long lVar1;
char cVar2;
int iVar3;
uint uVar4;
ulong uVar5;
char *pcVar6;
int8 uVar7;
long lVar8;
int8 unaff_R12;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = CONCAT71((int7)((ulong)unaff_R12 >> 8),1);
if (param_5 < 0x40) {
if ((param_3 != (char *)0x0) && (*param_3 != '\0')) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar5 = _mariadb_read_options_from_file(param_1,param_3,param_4,param_5);
return uVar5;
}
goto LAB_00134d1b;
}
if ((param_2 == (char *)0x0) || (*param_2 == '\0')) {
uVar5 = 0;
lVar8 = 0;
do {
lVar1 = *(long *)(configuration_dirs + lVar8 * 8);
if (lVar1 == 0) break;
__snprintf_chk(local_248,0x200,1,0x201,"%s%cmy.%s",lVar1,0x2f,&DAT_0013ac27);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
cVar2 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
uVar5 = (ulong)(byte)((char)uVar5 + cVar2);
}
lVar8 = lVar8 + 1;
} while (lVar8 != 6);
pcVar6 = getenv("HOME");
if (pcVar6 != (char *)0x0) {
__snprintf_chk(local_248,0x200,1,0x201,"%s%c.my.%s",pcVar6,0x2f,&DAT_0013ac27);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
uVar7 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
uVar4 = (uint)CONCAT71((int7)((ulong)uVar7 >> 8),(char)uVar7 + (char)uVar5);
goto LAB_00134d13;
}
}
}
else {
uVar5 = 0;
__snprintf_chk(local_248,0x200,1,0x201,"%s%cmy.%s",param_2,0x2f,&DAT_0013ac27);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
uVar4 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
LAB_00134d13:
uVar5 = (ulong)uVar4;
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5 & 0xffffffff;
}
LAB_00134d1b:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,204 | js_date_getTimezoneOffset | bluesky950520[P]quickjs/quickjs.c | static JSValue js_date_getTimezoneOffset(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// getTimezoneOffset()
double v;
if (JS_ThisTimeValue(ctx, &v, this_val))
return JS_EXCEPTION;
if (isnan(v))
return JS_NAN;
else
/* assuming -8.64e15 <= v <= -8.64e15 */
return js_int64(getTimezoneOffset((int64_t)trunc(v)));
} | O1 | c | js_date_getTimezoneOffset:
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
leaq 0x8(%rsp), %rsi
callq 0x5aa68
testl %eax, %eax
je 0x5a478
movl $0x6, %edx
xorl %eax, %eax
jmp 0x5a4e7
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x5a4ed
callq 0xe150
cvttsd2si %xmm0, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
leaq 0x10(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0xe0f0
movq 0x28(%rbx), %rcx
movabsq $0x7777777777777777, %rdx # imm = 0x7777777777777777
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
subq %rcx, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x5, %rax
addl %ecx, %eax
xorl %edx, %edx
addq $0x50, %rsp
popq %rbx
retq
movl $0x7, %edx
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
jmp 0x5a4e7
| js_date_getTimezoneOffset:
push rbx
sub rsp, 50h
mov rcx, rdx
mov rdx, rsi
lea rsi, [rsp+58h+var_50]
call JS_ThisTimeValue
test eax, eax
jz short loc_5A478
mov edx, 6
xor eax, eax
jmp short loc_5A4E7
loc_5A478:
movsd xmm0, [rsp+58h+var_50]
ucomisd xmm0, xmm0
jp short loc_5A4ED
call _trunc
cvttsd2si rax, xmm0
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
lea rdi, [rsp+58h+var_48]
mov [rdi], rdx
lea rbx, [rsp+58h+var_40]
mov rsi, rbx
call _localtime_r
mov rcx, [rbx+28h]
mov rdx, 7777777777777777h
mov rax, rcx
imul rdx
mov rax, rdx
sub rax, rcx
mov rcx, rax
shr rcx, 3Fh
shr rax, 5
add eax, ecx
xor edx, edx
loc_5A4E7:
add rsp, 50h
pop rbx
retn
loc_5A4ED:
mov edx, 7
mov rax, 7FF8000000000000h
jmp short loc_5A4E7
| unsigned long long js_date_getTimezoneOffset(long long a1, long long a2, long long a3)
{
long long v3; // rdx
double v5; // xmm0_8
long long v6; // [rsp+8h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+10h] [rbp-48h] BYREF
char v8; // [rsp+18h] [rbp-40h] BYREF
long long v9; // [rsp+40h] [rbp-18h]
if ( (unsigned int)JS_ThisTimeValue(a1, &v6, a2, a3) )
return 0LL;
v5 = trunc(a1, &v6, v3);
v7 = ((unsigned long long)((0x20C49BA5E353F7CFLL * (unsigned __int128)(unsigned int)(int)v5) >> 64) >> 63)
+ (unsigned int)(int)v5 / 1000LL;
localtime_r(&v7, &v8);
return ((unsigned long long)(((unsigned __int128)(0x7777777777777777LL * (__int128)v9) >> 64) - v9) >> 63)
+ (unsigned int)((unsigned long long)(((unsigned __int128)(0x7777777777777777LL * (__int128)v9) >> 64) - v9) >> 5);
}
| js_date_getTimezoneOffset:
PUSH RBX
SUB RSP,0x50
MOV RCX,RDX
MOV RDX,RSI
LEA RSI,[RSP + 0x8]
CALL 0x0015aa68
TEST EAX,EAX
JZ 0x0015a478
MOV EDX,0x6
XOR EAX,EAX
JMP 0x0015a4e7
LAB_0015a478:
MOVSD XMM0,qword ptr [RSP + 0x8]
UCOMISD XMM0,XMM0
JP 0x0015a4ed
CALL 0x0010e150
CVTTSD2SI RAX,XMM0
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],RDX
LEA RBX,[RSP + 0x18]
MOV RSI,RBX
CALL 0x0010e0f0
MOV RCX,qword ptr [RBX + 0x28]
MOV RDX,0x7777777777777777
MOV RAX,RCX
IMUL RDX
MOV RAX,RDX
SUB RAX,RCX
MOV RCX,RAX
SHR RCX,0x3f
SHR RAX,0x5
ADD EAX,ECX
XOR EDX,EDX
LAB_0015a4e7:
ADD RSP,0x50
POP RBX
RET
LAB_0015a4ed:
MOV EDX,0x7
MOV RAX,0x7ff8000000000000
JMP 0x0015a4e7
|
int1 [16] js_date_getTimezoneOffset(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
ulong uVar2;
int8 uVar3;
double dVar4;
int1 auVar5 [16];
double local_50;
long local_48;
tm local_40;
iVar1 = JS_ThisTimeValue(param_1,&local_50,param_2,param_3);
if (iVar1 == 0) {
if (NAN(local_50)) {
uVar3 = 7;
uVar2 = 0x7ff8000000000000;
}
else {
dVar4 = trunc(local_50);
local_48 = (long)dVar4 / 1000;
localtime_r(&local_48,&local_40);
uVar2 = SUB168(SEXT816(local_40.tm_gmtoff) * SEXT816(0x7777777777777777),8) -
local_40.tm_gmtoff;
uVar2 = (ulong)(uint)((int)(uVar2 >> 5) - (int)((long)uVar2 >> 0x3f));
uVar3 = 0;
}
}
else {
uVar3 = 6;
uVar2 = 0;
}
auVar5._8_8_ = uVar3;
auVar5._0_8_ = uVar2;
return auVar5;
}
| |
31,205 | js_date_getTimezoneOffset | bluesky950520[P]quickjs/quickjs.c | static JSValue js_date_getTimezoneOffset(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// getTimezoneOffset()
double v;
if (JS_ThisTimeValue(ctx, &v, this_val))
return JS_EXCEPTION;
if (isnan(v))
return JS_NAN;
else
/* assuming -8.64e15 <= v <= -8.64e15 */
return js_int64(getTimezoneOffset((int64_t)trunc(v)));
} | O2 | c | js_date_getTimezoneOffset:
pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rsp, %rsi
callq 0x4dfb3
testl %eax, %eax
je 0x4dac0
pushq $0x6
popq %rdx
xorl %eax, %eax
jmp 0x4dae2
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x4dae4
callq 0xe160
cvttsd2si %xmm0, %rdi
callq 0x4e229
movslq %eax, %rdi
callq 0x245bb
popq %rcx
retq
pushq $0x7
popq %rdx
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
jmp 0x4dae2
| js_date_getTimezoneOffset:
push rax
mov rcx, rdx
mov rdx, rsi
mov rsi, rsp
call JS_ThisTimeValue
test eax, eax
jz short loc_4DAC0
push 6
pop rdx
xor eax, eax
jmp short loc_4DAE2
loc_4DAC0:
movsd xmm0, [rsp+8+var_8]
ucomisd xmm0, xmm0
jp short loc_4DAE4
call _trunc
cvttsd2si rdi, xmm0
call getTimezoneOffset
movsxd rdi, eax
call js_int64
loc_4DAE2:
pop rcx
retn
loc_4DAE4:
push 7
pop rdx
mov rax, 7FF8000000000000h
jmp short loc_4DAE2
| long long js_date_getTimezoneOffset(long long a1, long long a2, long long a3)
{
double v3; // rax
double v5; // xmm0_8
int TimezoneOffset; // eax
double v7; // [rsp+0h] [rbp-8h] BYREF
v7 = v3;
if ( (unsigned int)JS_ThisTimeValue(a1, &v7, a2, a3) )
return 0LL;
v5 = trunc(v7);
TimezoneOffset = getTimezoneOffset((unsigned int)(int)v5);
return js_int64(TimezoneOffset);
}
| js_date_getTimezoneOffset:
PUSH RAX
MOV RCX,RDX
MOV RDX,RSI
MOV RSI,RSP
CALL 0x0014dfb3
TEST EAX,EAX
JZ 0x0014dac0
PUSH 0x6
POP RDX
XOR EAX,EAX
JMP 0x0014dae2
LAB_0014dac0:
MOVSD XMM0,qword ptr [RSP]
UCOMISD XMM0,XMM0
JP 0x0014dae4
CALL 0x0010e160
CVTTSD2SI RDI,XMM0
CALL 0x0014e229
MOVSXD RDI,EAX
CALL 0x001245bb
LAB_0014dae2:
POP RCX
RET
LAB_0014dae4:
PUSH 0x7
POP RDX
MOV RAX,0x7ff8000000000000
JMP 0x0014dae2
|
int8 js_date_getTimezoneOffset(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
double in_RAX;
int8 uVar2;
double dVar3;
double local_8;
local_8 = in_RAX;
iVar1 = JS_ThisTimeValue(param_1,&local_8,param_2,param_3);
if (iVar1 == 0) {
if (NAN(local_8)) {
uVar2 = 0x7ff8000000000000;
}
else {
dVar3 = trunc(local_8);
iVar1 = getTimezoneOffset((long)dVar3);
uVar2 = js_int64((long)iVar1);
}
}
else {
uVar2 = 0;
}
return uVar2;
}
| |
31,206 | test::stdev_ts() const | monkey531[P]llama/examples/llama-bench/llama-bench.cpp | double stdev_ts() const { return ::stdev(get_ts()); } | O2 | cpp | test::stdev_ts() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x39e34
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq %r15, %rbx
subq %r14, %rbx
sarq $0x3, %rbx
xorpd %xmm0, %xmm0
cmpq $0x2, %rbx
jb 0x39c07
leaq 0x8(%rsp), %rdi
callq 0x28cec
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmpq %r15, %r14
je 0x39b8c
movsd (%r14), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
addq $0x8, %r14
jmp 0x39b74
leaq -0x1(%rbx), %rax
movq %rax, %xmm2
movq 0x604a3(%rip), %xmm3 # 0x9a040
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movapd 0x604a7(%rip), %xmm4 # 0x9a050
subpd %xmm4, %xmm2
movapd %xmm2, %xmm5
unpckhpd %xmm2, %xmm5 # xmm5 = xmm5[1],xmm2[1]
mulsd %xmm1, %xmm1
movq %rbx, %xmm6
punpckldq %xmm3, %xmm6 # xmm6 = xmm6[0],xmm3[0],xmm6[1],xmm3[1]
subpd %xmm4, %xmm6
movapd %xmm6, %xmm3
unpckhpd %xmm6, %xmm3 # xmm3 = xmm3[1],xmm6[1]
addsd %xmm6, %xmm3
mulsd %xmm1, %xmm3
unpcklpd %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0]
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
addpd %xmm5, %xmm2
divpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
subsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x39c02
sqrtsd %xmm0, %xmm0
jmp 0x39c07
callq 0x22630
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3a09a
movsd (%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZNK4test8stdev_tsEv:
push r15
push r14
push rbx
sub rsp, 20h
mov rsi, rdi
lea rbx, [rsp+38h+var_30]
mov rdi, rbx; this
call _ZNK4test6get_tsEv; test::get_ts(void)
mov r14, [rbx]
mov r15, [rbx+8]
mov rbx, r15
sub rbx, r14
sar rbx, 3
xorpd xmm0, xmm0
cmp rbx, 2
jb loc_39C07
lea rdi, [rsp+38h+var_30]
call _ZL3avgIdET_RKSt6vectorIS0_SaIS0_EE; avg<double>(std::vector<double> const&)
movapd xmm1, xmm0
xorpd xmm0, xmm0
loc_39B74:
cmp r14, r15
jz short loc_39B8C
movsd xmm2, qword ptr [r14]
mulsd xmm2, xmm2
addsd xmm0, xmm2
add r14, 8
jmp short loc_39B74
loc_39B8C:
lea rax, [rbx-1]
movq xmm2, rax
movq xmm3, qword ptr cs:xmmword_9A040
punpckldq xmm2, xmm3
movapd xmm4, cs:xmmword_9A050
subpd xmm2, xmm4
movapd xmm5, xmm2
unpckhpd xmm5, xmm2
mulsd xmm1, xmm1
movq xmm6, rbx
punpckldq xmm6, xmm3
subpd xmm6, xmm4
movapd xmm3, xmm6
unpckhpd xmm3, xmm6
addsd xmm3, xmm6
mulsd xmm3, xmm1
unpcklpd xmm0, xmm3
unpcklpd xmm2, xmm2
addpd xmm2, xmm5
divpd xmm0, xmm2
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
subsd xmm0, xmm1
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_39C02
sqrtsd xmm0, xmm0
jmp short loc_39C07
loc_39C02:
call _sqrt
loc_39C07:
movsd [rsp+38h+var_38], xmm0
lea rdi, [rsp+38h+var_30]
call _ZNSt12_Vector_baseIdSaIdEED2Ev; std::_Vector_base<double>::~_Vector_base()
movsd xmm0, [rsp+38h+var_38]
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| double test::stdev_ts(test *this)
{
double *v1; // r14
double *v2; // r15
unsigned long long v3; // rbx
double result; // xmm0_8
double v5; // xmm1_8
__m128d v6; // xmm0
__m128i v7; // xmm3
__m128d v8; // xmm2
__m128d v9; // xmm6
__m128d v10; // xmm3
__m128d v11; // xmm0
double v12; // xmm0_8
double *v13; // [rsp+8h] [rbp-30h] BYREF
double *v14; // [rsp+10h] [rbp-28h]
test::get_ts((test *)&v13);
v1 = v13;
v2 = v14;
v3 = v14 - v13;
result = 0.0;
if ( v3 >= 2 )
{
v5 = avg<double>(&v13);
v6 = 0LL;
while ( v1 != v2 )
{
v6.m128d_f64[0] = v6.m128d_f64[0] + *v1 * *v1;
++v1;
}
v7 = _mm_loadl_epi64((const __m128i *)&xmmword_9A040);
v8 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)(v3 - 1), v7), (__m128d)xmmword_9A050);
v9 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v3, v7), (__m128d)xmmword_9A050);
v10 = _mm_unpackhi_pd(v9, v9);
v10.m128d_f64[0] = (v10.m128d_f64[0] + v9.m128d_f64[0]) * (v5 * v5);
v11 = _mm_div_pd(_mm_unpacklo_pd(v6, v10), _mm_add_pd(_mm_unpacklo_pd(v8, v8), _mm_unpackhi_pd(v8, v8)));
v12 = v11.m128d_f64[0] - _mm_unpackhi_pd(v11, v11).m128d_f64[0];
if ( v12 < 0.0 )
result = sqrt(v12);
else
result = sqrt(v12);
}
std::_Vector_base<double>::~_Vector_base(&v13, this);
return result;
}
| stdev_ts:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RSI,RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00139e34
MOV R14,qword ptr [RBX]
MOV R15,qword ptr [RBX + 0x8]
MOV RBX,R15
SUB RBX,R14
SAR RBX,0x3
XORPD XMM0,XMM0
CMP RBX,0x2
JC 0x00139c07
LEA RDI,[RSP + 0x8]
CALL 0x00128cec
MOVAPD XMM1,XMM0
XORPD XMM0,XMM0
LAB_00139b74:
CMP R14,R15
JZ 0x00139b8c
MOVSD XMM2,qword ptr [R14]
MULSD XMM2,XMM2
ADDSD XMM0,XMM2
ADD R14,0x8
JMP 0x00139b74
LAB_00139b8c:
LEA RAX,[RBX + -0x1]
MOVQ XMM2,RAX
MOVQ XMM3,qword ptr [0x0019a040]
PUNPCKLDQ XMM2,XMM3
MOVAPD XMM4,xmmword ptr [0x0019a050]
SUBPD XMM2,XMM4
MOVAPD XMM5,XMM2
UNPCKHPD XMM5,XMM2
MULSD XMM1,XMM1
MOVQ XMM6,RBX
PUNPCKLDQ XMM6,XMM3
SUBPD XMM6,XMM4
MOVAPD XMM3,XMM6
UNPCKHPD XMM3,XMM6
ADDSD XMM3,XMM6
MULSD XMM3,XMM1
UNPCKLPD XMM0,XMM3
UNPCKLPD XMM2,XMM2
ADDPD XMM2,XMM5
DIVPD XMM0,XMM2
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
SUBSD XMM0,XMM1
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x00139c02
SQRTSD XMM0,XMM0
JMP 0x00139c07
LAB_00139c02:
CALL 0x00122630
LAB_00139c07:
MOVSD qword ptr [RSP],XMM0
LEA RDI,[RSP + 0x8]
CALL 0x0013a09a
MOVSD XMM0,qword ptr [RSP]
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* test::stdev_ts() const */
double test::stdev_ts(void)
{
long lVar1;
long lVar2;
ulong uVar3;
double dVar4;
double dVar5;
int1 auVar6 [16];
double dVar7;
int1 auVar8 [16];
double dVar10;
int1 auVar9 [16];
int1 auVar11 [16];
double *local_30;
double *local_28;
get_ts();
lVar2 = (long)local_28 - (long)local_30;
uVar3 = lVar2 >> 3;
dVar4 = 0.0;
if (1 < uVar3) {
dVar4 = avg<double>((vector *)&local_30);
dVar5 = 0.0;
for (; local_30 != local_28; local_30 = local_30 + 1) {
dVar5 = dVar5 + *local_30 * *local_30;
}
lVar1 = uVar3 - 1;
auVar8._8_4_ = (int)((ulong)lVar1 >> 0x20);
auVar8._0_8_ = lVar1;
auVar8._12_4_ = DAT_0019a040._4_4_;
dVar7 = (double)CONCAT44((int4)DAT_0019a040,(int)lVar1) - _DAT_0019a050;
dVar10 = auVar8._8_8_ - _UNK_0019a058;
auVar11._8_4_ = (int)(lVar2 >> 0x23);
auVar11._0_8_ = uVar3;
auVar11._12_4_ = DAT_0019a040._4_4_;
auVar6._8_8_ = ((auVar11._8_8_ - _UNK_0019a058) +
((double)CONCAT44((int4)DAT_0019a040,(int)uVar3) - _DAT_0019a050)) *
dVar4 * dVar4;
auVar6._0_8_ = dVar5;
auVar9._0_8_ = dVar7 + dVar10;
auVar9._8_8_ = dVar7 + dVar10;
auVar6 = divpd(auVar6,auVar9);
dVar4 = auVar6._0_8_ - auVar6._8_8_;
if (dVar4 < 0.0) {
dVar4 = sqrt(dVar4);
}
else {
dVar4 = SQRT(dVar4);
}
}
std::_Vector_base<double,std::allocator<double>>::~_Vector_base
((_Vector_base<double,std::allocator<double>> *)&local_30);
return dVar4;
}
| |
31,207 | lre_is_in_table | bluesky950520[P]quickjs/libunicode.c | static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, b, bit;
int pos;
const uint8_t *p;
pos = get_index_pos(&code, c, index_table, index_table_len);
if (pos < 0)
return FALSE; /* outside the table */
p = table + pos;
bit = 0;
for(;;) {
b = *p++;
if (b < 64) {
code += (b >> 3) + 1;
if (c < code)
return bit;
bit ^= 1;
code += (b & 7) + 1;
} else if (b >= 0x80) {
code += b - 0x80 + 1;
} else if (b < 0x60) {
code += (((b - 0x40) << 8) | p[0]) + 1;
p++;
} else {
code += (((b - 0x60) << 16) | (p[0] << 8) | p[1]) + 1;
p += 2;
}
if (c < code)
return bit;
bit ^= 1;
}
} | O1 | c | lre_is_in_table:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x4(%rsp), %rdi
movl %ebx, %esi
callq 0x9a557
testl %eax, %eax
js 0x98616
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
movl 0x4(%rsp), %ecx
leaq 0x1(%r14), %rdx
movzbl (%r14), %esi
cmpl $0x3f, %esi
ja 0x985b5
movl %esi, %edi
shrl $0x3, %edi
addl %edi, %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
cmpl %ebx, %ecx
ja 0x98618
xorl $0x1, %eax
andl $0x7, %esi
addl %esi, %ecx
incl %ecx
jmp 0x985df
testb %sil, %sil
js 0x985da
movzbl (%rdx), %edx
cmpb $0x5f, %sil
ja 0x985e5
shll $0x8, %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffffc001, %ecx # imm = 0xFFFFC001
movl %ecx, 0x4(%rsp)
addq $0x2, %r14
jmp 0x98604
addl %esi, %ecx
addl $-0x7f, %ecx
movl %ecx, 0x4(%rsp)
jmp 0x98607
shll $0x10, %esi
shll $0x8, %edx
orl %esi, %edx
movzbl 0x2(%r14), %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffa00001, %ecx # imm = 0xFFA00001
movl %ecx, 0x4(%rsp)
addq $0x3, %r14
movq %r14, %rdx
cmpl %ebx, %ecx
ja 0x98618
xorl $0x1, %eax
movq %rdx, %r14
jmp 0x9858b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| lre_is_in_table:
push r14
push rbx
push rax
mov r14, rsi
mov ebx, edi
lea rdi, [rsp+18h+var_14]
mov esi, ebx
call get_index_pos
test eax, eax
js loc_98616
mov eax, eax
add r14, rax
xor eax, eax
mov ecx, [rsp+18h+var_14]
loc_9858B:
lea rdx, [r14+1]
movzx esi, byte ptr [r14]
cmp esi, 3Fh ; '?'
ja short loc_985B5
mov edi, esi
shr edi, 3
add ecx, edi
inc ecx
mov [rsp+18h+var_14], ecx
cmp ecx, ebx
ja short loc_98618
xor eax, 1
and esi, 7
add ecx, esi
inc ecx
jmp short loc_985DF
loc_985B5:
test sil, sil
js short loc_985DA
movzx edx, byte ptr [rdx]
cmp sil, 5Fh ; '_'
ja short loc_985E5
shl esi, 8
or esi, edx
add ecx, esi
add ecx, 0FFFFC001h
mov [rsp+18h+var_14], ecx
add r14, 2
jmp short loc_98604
loc_985DA:
add ecx, esi
add ecx, 0FFFFFF81h
loc_985DF:
mov [rsp+18h+var_14], ecx
jmp short loc_98607
loc_985E5:
shl esi, 10h
shl edx, 8
or edx, esi
movzx esi, byte ptr [r14+2]
or esi, edx
add ecx, esi
add ecx, 0FFA00001h
mov [rsp+18h+var_14], ecx
add r14, 3
loc_98604:
mov rdx, r14
loc_98607:
cmp ecx, ebx
ja short loc_98618
xor eax, 1
mov r14, rdx
jmp loc_9858B
loc_98616:
xor eax, eax
loc_98618:
add rsp, 8
pop rbx
pop r14
retn
| long long lre_is_in_table(unsigned int a1, long long a2)
{
long long v2; // rax
int index_pos; // eax
unsigned __int8 *v4; // r14
long long result; // rax
unsigned int v6; // ecx
unsigned __int8 *v7; // rdx
unsigned int v8; // esi
unsigned int v9; // ecx
int v10; // edx
unsigned __int8 *v11; // r14
unsigned int v12[5]; // [rsp+0h] [rbp-14h] BYREF
v12[0] = HIDWORD(v2);
index_pos = get_index_pos(v12, a1);
if ( index_pos >= 0 )
{
v4 = (unsigned __int8 *)((unsigned int)index_pos + a2);
result = 0LL;
v6 = v12[0];
while ( 1 )
{
v7 = v4 + 1;
v8 = *v4;
if ( v8 <= 0x3F )
break;
if ( (v8 & 0x80u) != 0 )
{
v6 = v8 + v6 - 127;
LABEL_10:
v12[0] = v6;
goto LABEL_13;
}
v10 = *v7;
if ( (unsigned __int8)v8 > 0x5Fu )
{
v6 = ((v8 << 16) | (v10 << 8) | v4[2]) + v6 - 6291455;
v12[0] = v6;
v11 = v4 + 3;
}
else
{
v6 = (v10 | (v8 << 8)) + v6 - 0x3FFF;
v12[0] = v6;
v11 = v4 + 2;
}
v7 = v11;
LABEL_13:
if ( v6 > a1 )
return result;
result = (unsigned int)result ^ 1;
v4 = v7;
}
v9 = (v8 >> 3) + v6 + 1;
v12[0] = v9;
if ( v9 > a1 )
return result;
result = (unsigned int)result ^ 1;
v6 = (v8 & 7) + v9 + 1;
goto LABEL_10;
}
return 0LL;
}
| lre_is_in_table:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV EBX,EDI
LEA RDI,[RSP + 0x4]
MOV ESI,EBX
CALL 0x0019a557
TEST EAX,EAX
JS 0x00198616
MOV EAX,EAX
ADD R14,RAX
XOR EAX,EAX
MOV ECX,dword ptr [RSP + 0x4]
LAB_0019858b:
LEA RDX,[R14 + 0x1]
MOVZX ESI,byte ptr [R14]
CMP ESI,0x3f
JA 0x001985b5
MOV EDI,ESI
SHR EDI,0x3
ADD ECX,EDI
INC ECX
MOV dword ptr [RSP + 0x4],ECX
CMP ECX,EBX
JA 0x00198618
XOR EAX,0x1
AND ESI,0x7
ADD ECX,ESI
INC ECX
JMP 0x001985df
LAB_001985b5:
TEST SIL,SIL
JS 0x001985da
MOVZX EDX,byte ptr [RDX]
CMP SIL,0x5f
JA 0x001985e5
SHL ESI,0x8
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffffc001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x2
JMP 0x00198604
LAB_001985da:
ADD ECX,ESI
ADD ECX,-0x7f
LAB_001985df:
MOV dword ptr [RSP + 0x4],ECX
JMP 0x00198607
LAB_001985e5:
SHL ESI,0x10
SHL EDX,0x8
OR EDX,ESI
MOVZX ESI,byte ptr [R14 + 0x2]
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffa00001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x3
LAB_00198604:
MOV RDX,R14
LAB_00198607:
CMP ECX,EBX
JA 0x00198618
XOR EAX,0x1
MOV R14,RDX
JMP 0x0019858b
LAB_00198616:
XOR EAX,EAX
LAB_00198618:
ADD RSP,0x8
POP RBX
POP R14
RET
|
uint lre_is_in_table(uint param_1,long param_2)
{
byte bVar1;
uint uVar2;
uint uVar3;
int8 in_RAX;
byte *pbVar4;
byte *pbVar5;
uint local_14;
local_14 = (uint)((ulong)in_RAX >> 0x20);
uVar2 = get_index_pos(&local_14,param_1);
if ((int)uVar2 < 0) {
return 0;
}
uVar3 = 0;
pbVar4 = (byte *)(param_2 + (ulong)uVar2);
while( true ) {
pbVar5 = pbVar4 + 1;
bVar1 = *pbVar4;
if (bVar1 < 0x40) {
uVar2 = local_14 + (bVar1 >> 3) + 1;
if (param_1 < uVar2) {
return uVar3;
}
uVar3 = uVar3 ^ 1;
local_14 = uVar2 + (bVar1 & 7) + 1;
}
else if ((char)bVar1 < '\0') {
local_14 = (local_14 + bVar1) - 0x7f;
}
else if (bVar1 < 0x60) {
local_14 = (local_14 + CONCAT11(bVar1,*pbVar5)) - 0x3fff;
pbVar5 = pbVar4 + 2;
}
else {
local_14 = (local_14 + ((uint)pbVar4[2] | (uint)*pbVar5 << 8 | (uint)bVar1 << 0x10)) -
0x5fffff;
pbVar5 = pbVar4 + 3;
}
if (param_1 < local_14) break;
uVar3 = uVar3 ^ 1;
pbVar4 = pbVar5;
}
return uVar3;
}
| |
31,208 | lre_is_in_table | bluesky950520[P]quickjs/libunicode.c | static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, b, bit;
int pos;
const uint8_t *p;
pos = get_index_pos(&code, c, index_table, index_table_len);
if (pos < 0)
return FALSE; /* outside the table */
p = table + pos;
bit = 0;
for(;;) {
b = *p++;
if (b < 64) {
code += (b >> 3) + 1;
if (c < code)
return bit;
bit ^= 1;
code += (b & 7) + 1;
} else if (b >= 0x80) {
code += b - 0x80 + 1;
} else if (b < 0x60) {
code += (((b - 0x40) << 8) | p[0]) + 1;
p++;
} else {
code += (((b - 0x60) << 16) | (p[0] << 8) | p[1]) + 1;
p += 2;
}
if (c < code)
return bit;
bit ^= 1;
}
} | O2 | c | lre_is_in_table:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x4(%rsp), %rdi
movl %ebx, %esi
callq 0x80da5
testl %eax, %eax
js 0x7f3d4
movl %eax, %eax
addq %rax, %r14
xorl %eax, %eax
movl 0x4(%rsp), %ecx
leaq 0x1(%r14), %rdx
movzbl (%r14), %esi
cmpl $0x3f, %esi
ja 0x7f373
movl %esi, %edi
shrl $0x3, %edi
addl %edi, %ecx
incl %ecx
cmpl %ebx, %ecx
ja 0x7f3d6
xorl $0x1, %eax
andl $0x7, %esi
addl %esi, %ecx
incl %ecx
jmp 0x7f39d
testb %sil, %sil
js 0x7f398
movzbl (%rdx), %edx
cmpb $0x5f, %sil
ja 0x7f3a3
shll $0x8, %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffffc001, %ecx # imm = 0xFFFFC001
movl %ecx, 0x4(%rsp)
addq $0x2, %r14
jmp 0x7f3c2
addl %esi, %ecx
addl $-0x7f, %ecx
movl %ecx, 0x4(%rsp)
jmp 0x7f3c5
shll $0x10, %esi
shll $0x8, %edx
orl %esi, %edx
movzbl 0x2(%r14), %esi
orl %edx, %esi
addl %esi, %ecx
addl $0xffa00001, %ecx # imm = 0xFFA00001
movl %ecx, 0x4(%rsp)
addq $0x3, %r14
movq %r14, %rdx
cmpl %ebx, %ecx
ja 0x7f3d6
xorl $0x1, %eax
movq %rdx, %r14
jmp 0x7f34d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| lre_is_in_table:
push r14
push rbx
push rax
mov r14, rsi
mov ebx, edi
lea rdi, [rsp+18h+var_14]
mov esi, ebx
call get_index_pos
test eax, eax
js loc_7F3D4
mov eax, eax
add r14, rax
xor eax, eax
mov ecx, [rsp+18h+var_14]
loc_7F34D:
lea rdx, [r14+1]
movzx esi, byte ptr [r14]
cmp esi, 3Fh ; '?'
ja short loc_7F373
mov edi, esi
shr edi, 3
add ecx, edi
inc ecx
cmp ecx, ebx
ja short loc_7F3D6
xor eax, 1
and esi, 7
add ecx, esi
inc ecx
jmp short loc_7F39D
loc_7F373:
test sil, sil
js short loc_7F398
movzx edx, byte ptr [rdx]
cmp sil, 5Fh ; '_'
ja short loc_7F3A3
shl esi, 8
or esi, edx
add ecx, esi
add ecx, 0FFFFC001h
mov [rsp+18h+var_14], ecx
add r14, 2
jmp short loc_7F3C2
loc_7F398:
add ecx, esi
add ecx, 0FFFFFF81h
loc_7F39D:
mov [rsp+18h+var_14], ecx
jmp short loc_7F3C5
loc_7F3A3:
shl esi, 10h
shl edx, 8
or edx, esi
movzx esi, byte ptr [r14+2]
or esi, edx
add ecx, esi
add ecx, 0FFA00001h
mov [rsp+18h+var_14], ecx
add r14, 3
loc_7F3C2:
mov rdx, r14
loc_7F3C5:
cmp ecx, ebx
ja short loc_7F3D6
xor eax, 1
mov r14, rdx
jmp loc_7F34D
loc_7F3D4:
xor eax, eax
loc_7F3D6:
add rsp, 8
pop rbx
pop r14
retn
| long long lre_is_in_table(unsigned int a1, long long a2)
{
long long v2; // rax
int index_pos; // eax
unsigned __int8 *v4; // r14
long long result; // rax
unsigned int v6; // ecx
unsigned __int8 *v7; // rdx
unsigned int v8; // esi
unsigned int v9; // ecx
int v10; // edx
unsigned __int8 *v11; // r14
unsigned int v12[5]; // [rsp+0h] [rbp-14h] BYREF
v12[0] = HIDWORD(v2);
index_pos = get_index_pos(v12, a1);
if ( index_pos >= 0 )
{
v4 = (unsigned __int8 *)((unsigned int)index_pos + a2);
result = 0LL;
v6 = v12[0];
while ( 1 )
{
v7 = v4 + 1;
v8 = *v4;
if ( v8 <= 0x3F )
break;
if ( (v8 & 0x80u) != 0 )
{
v6 = v8 + v6 - 127;
LABEL_10:
v12[0] = v6;
goto LABEL_13;
}
v10 = *v7;
if ( (unsigned __int8)v8 > 0x5Fu )
{
v6 = ((v8 << 16) | (v10 << 8) | v4[2]) + v6 - 6291455;
v12[0] = v6;
v11 = v4 + 3;
}
else
{
v6 = (v10 | (v8 << 8)) + v6 - 0x3FFF;
v12[0] = v6;
v11 = v4 + 2;
}
v7 = v11;
LABEL_13:
if ( v6 > a1 )
return result;
result = (unsigned int)result ^ 1;
v4 = v7;
}
v9 = (v8 >> 3) + v6 + 1;
if ( v9 > a1 )
return result;
result = (unsigned int)result ^ 1;
v6 = (v8 & 7) + v9 + 1;
goto LABEL_10;
}
return 0LL;
}
| lre_is_in_table:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV EBX,EDI
LEA RDI,[RSP + 0x4]
MOV ESI,EBX
CALL 0x00180da5
TEST EAX,EAX
JS 0x0017f3d4
MOV EAX,EAX
ADD R14,RAX
XOR EAX,EAX
MOV ECX,dword ptr [RSP + 0x4]
LAB_0017f34d:
LEA RDX,[R14 + 0x1]
MOVZX ESI,byte ptr [R14]
CMP ESI,0x3f
JA 0x0017f373
MOV EDI,ESI
SHR EDI,0x3
ADD ECX,EDI
INC ECX
CMP ECX,EBX
JA 0x0017f3d6
XOR EAX,0x1
AND ESI,0x7
ADD ECX,ESI
INC ECX
JMP 0x0017f39d
LAB_0017f373:
TEST SIL,SIL
JS 0x0017f398
MOVZX EDX,byte ptr [RDX]
CMP SIL,0x5f
JA 0x0017f3a3
SHL ESI,0x8
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffffc001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x2
JMP 0x0017f3c2
LAB_0017f398:
ADD ECX,ESI
ADD ECX,-0x7f
LAB_0017f39d:
MOV dword ptr [RSP + 0x4],ECX
JMP 0x0017f3c5
LAB_0017f3a3:
SHL ESI,0x10
SHL EDX,0x8
OR EDX,ESI
MOVZX ESI,byte ptr [R14 + 0x2]
OR ESI,EDX
ADD ECX,ESI
ADD ECX,0xffa00001
MOV dword ptr [RSP + 0x4],ECX
ADD R14,0x3
LAB_0017f3c2:
MOV RDX,R14
LAB_0017f3c5:
CMP ECX,EBX
JA 0x0017f3d6
XOR EAX,0x1
MOV R14,RDX
JMP 0x0017f34d
LAB_0017f3d4:
XOR EAX,EAX
LAB_0017f3d6:
ADD RSP,0x8
POP RBX
POP R14
RET
|
uint lre_is_in_table(uint param_1,long param_2)
{
byte bVar1;
uint uVar2;
uint uVar3;
int8 in_RAX;
byte *pbVar4;
byte *pbVar5;
uint local_14;
local_14 = (uint)((ulong)in_RAX >> 0x20);
uVar2 = get_index_pos(&local_14,param_1);
if ((int)uVar2 < 0) {
return 0;
}
uVar3 = 0;
pbVar4 = (byte *)(param_2 + (ulong)uVar2);
while( true ) {
pbVar5 = pbVar4 + 1;
bVar1 = *pbVar4;
if (bVar1 < 0x40) {
uVar2 = local_14 + (bVar1 >> 3) + 1;
if (param_1 < uVar2) {
return uVar3;
}
uVar3 = uVar3 ^ 1;
local_14 = uVar2 + (bVar1 & 7) + 1;
}
else if ((char)bVar1 < '\0') {
local_14 = (local_14 + bVar1) - 0x7f;
}
else if (bVar1 < 0x60) {
local_14 = (local_14 + CONCAT11(bVar1,*pbVar5)) - 0x3fff;
pbVar5 = pbVar4 + 2;
}
else {
local_14 = (local_14 + ((uint)pbVar4[2] | (uint)*pbVar5 << 8 | (uint)bVar1 << 0x10)) -
0x5fffff;
pbVar5 = pbVar4 + 3;
}
if (param_1 < local_14) break;
uVar3 = uVar3 ^ 1;
pbVar4 = pbVar5;
}
return uVar3;
}
| |
31,209 | translog_wait_for_writers | eloqsql/storage/maria/ma_loghandler.c | static void translog_wait_for_writers(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_wait_for_writers");
DBUG_PRINT("enter", ("Buffer #%u %p copies in progress: %u "
"is closing %u File: %d size: %lu",
(uint) buffer->buffer_no, buffer,
(uint) buffer->copy_to_buffer_in_progress,
(uint) buffer->is_closing_buffer,
(buffer->file ? buffer->file->handler.file : -1),
(ulong) buffer->size));
translog_buffer_lock_assert_owner(buffer);
while (buffer->copy_to_buffer_in_progress)
{
DBUG_PRINT("info", ("wait for writers... buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
DBUG_ASSERT(buffer->file != NULL);
mysql_cond_wait(&buffer->waiting_filling_buffer, &buffer->mutex);
DBUG_PRINT("info", ("wait for writers done buffer: #%u %p",
(uint) buffer->buffer_no, buffer));
}
DBUG_VOID_RETURN;
} | O3 | c | translog_wait_for_writers:
cmpl $0x0, 0x100078(%rdi)
je 0x4ec6d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x100040(%rdi), %r14
leaq 0x100090(%rdi), %r15
leaq 0x8af28(%rip), %r12 # 0xd9b58
cmpq $0x0, 0x100070(%rbx)
jne 0x4ec50
movq %r14, %rdi
movq %r15, %rsi
callq 0x29430
cmpl $0x0, 0x100078(%rbx)
jne 0x4ec30
jmp 0x4ec65
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl $0x806, %ecx # imm = 0x806
callq 0x2eea0
jmp 0x4ec45
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| translog_wait_for_writers:
cmp ds:dword_100078[rdi], 0
jz short locret_4EC6D
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdi
lea r14, unk_100040[rdi]
lea r15, unk_100090[rdi]
lea r12, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/eloqsq"...
loc_4EC30:
cmp ds:qword_100070[rbx], 0
jnz short loc_4EC50
mov rdi, r14
mov rsi, r15
call _pthread_cond_wait
loc_4EC45:
cmp ds:dword_100078[rbx], 0
jnz short loc_4EC30
jmp short loc_4EC65
loc_4EC50:
mov rdi, r14
mov rsi, r15
mov rdx, r12
mov ecx, 806h
call psi_cond_wait
jmp short loc_4EC45
loc_4EC65:
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_4EC6D:
retn
| long long translog_wait_for_writers(long long a1)
{
char *v1; // r14
char *v2; // r15
long long result; // rax
if ( *(int *)((char *)&dword_100078 + a1) )
{
v1 = (char *)&unk_100040 + a1;
v2 = (char *)&unk_100090 + a1;
do
{
if ( *(long long *)((char *)&qword_100070 + a1) )
result = psi_cond_wait(
(long long)v1,
(long long)v2,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x806u);
else
result = pthread_cond_wait(v1, v2);
}
while ( *(int *)((char *)&dword_100078 + a1) );
}
return result;
}
| translog_wait_for_writers:
CMP dword ptr [RDI + 0x100078],0x0
JZ 0x0014ec6d
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x100040]
LEA R15,[RDI + 0x100090]
LEA R12,[0x1d9b58]
LAB_0014ec30:
CMP qword ptr [RBX + 0x100070],0x0
JNZ 0x0014ec50
MOV RDI,R14
MOV RSI,R15
CALL 0x00129430
LAB_0014ec45:
CMP dword ptr [RBX + 0x100078],0x0
JNZ 0x0014ec30
JMP 0x0014ec65
LAB_0014ec50:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
MOV ECX,0x806
CALL 0x0012eea0
JMP 0x0014ec45
LAB_0014ec65:
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_0014ec6d:
RET
|
void translog_wait_for_writers(long param_1)
{
pthread_cond_t *__cond;
pthread_mutex_t *__mutex;
if (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0) {
__cond = (pthread_cond_t *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_type + param_1);
__mutex = (pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + param_1);
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[0].p_align + param_1) == 0) {
pthread_cond_wait(__cond,__mutex);
}
else {
psi_cond_wait(__cond,__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x806
);
}
} while (*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) != 0);
}
return;
}
| |
31,210 | POINTonE1_Uncompress_Z | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/e1.c | static BLST_ERROR POINTonE1_Uncompress_Z(POINTonE1_affine *out,
const unsigned char in[48])
{
unsigned char in0 = in[0];
limb_t sgn0_pty;
if ((in0 & 0x80) == 0) /* compressed bit */
return BLST_BAD_ENCODING;
if (in0 & 0x40) { /* infinity bit */
if (byte_is_zero(in0 & 0x3f) & bytes_are_zero(in+1, 47)) {
vec_zero(out, sizeof(*out));
return BLST_SUCCESS;
} else {
return BLST_BAD_ENCODING;
}
}
sgn0_pty = POINTonE1_Uncompress_BE(out, in);
if (sgn0_pty > 3)
return (BLST_ERROR)(0 - sgn0_pty); /* POINT_NOT_ON_CURVE */
sgn0_pty >>= 1; /* skip over parity bit */
sgn0_pty ^= (in0 & 0x20) >> 5;
cneg_fp(out->Y, out->Y, sgn0_pty);
/* (0,±2) is not in group, but application might want to ignore? */
return vec_is_zero(out->X, sizeof(out->X)) ? BLST_POINT_NOT_IN_GROUP
: BLST_SUCCESS;
} | O0 | c | POINTonE1_Uncompress_Z:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xa92f3
movl $0x1, -0x4(%rbp)
jmp 0xa93d4
movzbl -0x19(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xa9357
movzbl -0x19(%rbp), %eax
andl $0x3f, %eax
movzbl %al, %edi
callq 0xb8370
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x2f, %esi
callq 0xb5b50
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
je 0xa934e
movq -0x10(%rbp), %rdi
movl $0x60, %esi
callq 0xa87c0
movl $0x0, -0x4(%rbp)
jmp 0xa93d4
movl $0x1, -0x4(%rbp)
jmp 0xa93d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb83a0
movq %rax, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jbe 0xa937a
xorl %eax, %eax
subq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0xa93d4
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x28(%rbp)
movzbl -0x19(%rbp), %eax
andl $0x20, %eax
sarl $0x5, %eax
cltq
xorq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x28(%rbp), %rdx
callq 0xafe20
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0xa8cd0
movq %rax, %rdx
xorl %eax, %eax
movl $0x3, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| POINTonE1_Uncompress_Z:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
movzx eax, [rbp+var_19]
and eax, 80h
cmp eax, 0
jnz short loc_A92F3
mov [rbp+var_4], 1
jmp loc_A93D4
loc_A92F3:
movzx eax, [rbp+var_19]
and eax, 40h
cmp eax, 0
jz short loc_A9357
movzx eax, [rbp+var_19]
and eax, 3Fh
movzx edi, al
call _byte_is_zero
mov [rbp+var_30], rax
mov rdi, [rbp+var_18]
add rdi, 1
mov esi, 2Fh ; '/'
call bytes_are_zero
mov rcx, rax
mov rax, [rbp+var_30]
and rax, rcx
cmp rax, 0
jz short loc_A934E
mov rdi, [rbp+var_10]
mov esi, 60h ; '`'
call vec_zero
mov [rbp+var_4], 0
jmp loc_A93D4
loc_A934E:
mov [rbp+var_4], 1
jmp short loc_A93D4
loc_A9357:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call POINTonE1_Uncompress_BE
mov [rbp+var_28], rax
cmp [rbp+var_28], 3
jbe short loc_A937A
xor eax, eax
sub rax, [rbp+var_28]
mov [rbp+var_4], eax
jmp short loc_A93D4
loc_A937A:
mov rax, [rbp+var_28]
shr rax, 1
mov [rbp+var_28], rax
movzx eax, [rbp+var_19]
and eax, 20h
sar eax, 5
cdqe
xor rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
add rdi, 30h ; '0'
mov rsi, [rbp+var_10]
add rsi, 30h ; '0'
mov rdx, [rbp+var_28]
call cneg_fp
mov rdi, [rbp+var_10]
mov esi, 30h ; '0'
call vec_is_zero
mov rdx, rax
xor eax, eax
mov ecx, 3
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_A93D4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long POINTonE1_Uncompress_Z(long long a1, char *a2)
{
unsigned long long v2; // rdx
unsigned int v3; // eax
long long is_zero; // [rsp+0h] [rbp-30h]
unsigned long long v6; // [rsp+8h] [rbp-28h]
char v7; // [rsp+17h] [rbp-19h]
v7 = *a2;
if ( *a2 < 0 )
{
if ( (v7 & 0x40) != 0 )
{
is_zero = byte_is_zero(v7 & 0x3F);
if ( (bytes_are_zero(a2 + 1, 47LL) & is_zero) != 0 )
{
vec_zero(a1, 0x60uLL);
return 0;
}
else
{
return 1;
}
}
else
{
v6 = POINTonE1_Uncompress_BE(a1, a2);
if ( v6 <= 3 )
{
cneg_fp(a1 + 48, a1 + 48, (v6 >> 1) ^ ((v7 & 0x20) >> 5));
v2 = vec_is_zero(a1, 0x30uLL);
v3 = 0;
if ( v2 )
return 3;
return v3;
}
else
{
return (unsigned int)-(int)v6;
}
}
}
else
{
return 1;
}
}
| POINTonE1_Uncompress_Z:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOVZX EAX,byte ptr [RBP + -0x19]
AND EAX,0x80
CMP EAX,0x0
JNZ 0x001a92f3
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a93d4
LAB_001a92f3:
MOVZX EAX,byte ptr [RBP + -0x19]
AND EAX,0x40
CMP EAX,0x0
JZ 0x001a9357
MOVZX EAX,byte ptr [RBP + -0x19]
AND EAX,0x3f
MOVZX EDI,AL
CALL 0x001b8370
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x1
MOV ESI,0x2f
CALL 0x001b5b50
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,RCX
CMP RAX,0x0
JZ 0x001a934e
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x60
CALL 0x001a87c0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a93d4
LAB_001a934e:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001a93d4
LAB_001a9357:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001b83a0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x3
JBE 0x001a937a
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a93d4
LAB_001a937a:
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOVZX EAX,byte ptr [RBP + -0x19]
AND EAX,0x20
SAR EAX,0x5
CDQE
XOR RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x30
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001afe20
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x30
CALL 0x001a8cd0
MOV RDX,RAX
XOR EAX,EAX
MOV ECX,0x3
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001a93d4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int POINTonE1_Uncompress_Z(long param_1,byte *param_2)
{
byte bVar1;
ulong uVar2;
ulong uVar3;
long lVar4;
int local_c;
bVar1 = *param_2;
if ((bVar1 & 0x80) == 0) {
local_c = 1;
}
else if ((bVar1 & 0x40) == 0) {
uVar2 = POINTonE1_Uncompress_BE(param_1,param_2);
if (uVar2 < 4) {
cneg_fp(param_1 + 0x30,param_1 + 0x30,(long)((int)(bVar1 & 0x20) >> 5) ^ uVar2 >> 1);
lVar4 = vec_is_zero(param_1,0x30);
local_c = 0;
if (lVar4 != 0) {
local_c = 3;
}
}
else {
local_c = -(int)uVar2;
}
}
else {
uVar2 = byte_is_zero(bVar1 & 0x3f);
uVar3 = bytes_are_zero(param_2 + 1,0x2f);
if ((uVar2 & uVar3) == 0) {
local_c = 1;
}
else {
vec_zero(param_1,0x60);
local_c = 0;
}
}
return local_c;
}
| |
31,211 | sapphire_plugins::gravy::getDescriptor() | sapphire-plugins/src/gravy/processor.cpp | const clap_plugin_descriptor *getDescriptor()
{
static const char *features[] = {CLAP_PLUGIN_FEATURE_AUDIO_EFFECT, CLAP_PLUGIN_FEATURE_FILTER,
nullptr};
static clap_plugin_descriptor desc = {
CLAP_VERSION,
pluginId,
"Gravy",
"Sapphire",
"",
"",
"",
sst::plugininfra::VersionInformation::project_version_and_hash,
"A Fun Filter",
&features[0]};
return &desc;
} | O3 | cpp | sapphire_plugins::gravy::getDescriptor():
movb 0x4c754e(%rip), %al # 0x5ae880
testb %al, %al
je 0xe733e
leaq 0x4c74eb(%rip), %rax # 0x5ae828
retq
pushq %rax
callq 0x7b3da
addq $0x8, %rsp
jmp 0xe7336
| _ZN16sapphire_plugins5gravy13getDescriptorEv:
mov al, cs:_ZGVZN16sapphire_plugins5gravy13getDescriptorEvE4desc; `guard variable for'sapphire_plugins::gravy::getDescriptor(void)::desc
test al, al
jz short loc_E733E
loc_E7336:
lea rax, _ZZN16sapphire_plugins5gravy13getDescriptorEvE4desc; sapphire_plugins::gravy::getDescriptor(void)::desc
retn
loc_E733E:
push rax
call _ZN16sapphire_plugins5gravy13getDescriptorEv_cold_1; sapphire_plugins::gravy::getDescriptor(void) [clone]
add rsp, 8
jmp short loc_E7336
| long long * sapphire_plugins::gravy::getDescriptor(sapphire_plugins::gravy *this)
{
if ( !(_BYTE)`guard variable for'sapphire_plugins::gravy::getDescriptor(void)::desc )
sapphire_plugins::gravy::getDescriptor();
return &sapphire_plugins::gravy::getDescriptor(void)::desc;
}
| getDescriptor:
MOV AL,byte ptr [0x006ae880]
TEST AL,AL
JZ 0x001e733e
LAB_001e7336:
LEA RAX,[0x6ae828]
RET
LAB_001e733e:
PUSH RAX
CALL 0x0017b3da
ADD RSP,0x8
JMP 0x001e7336
|
/* sapphire_plugins::gravy::getDescriptor() */
int1 * sapphire_plugins::gravy::getDescriptor(void)
{
if (getDescriptor()::desc == '\0') {
getDescriptor();
}
return getDescriptor()::desc;
}
| |
31,212 | evmone::VM::VM() | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/vm.cpp | VM::VM() noexcept
: evmc_vm{
EVMC_ABI_VERSION,
"evmone",
PROJECT_VERSION,
evmone::destroy,
evmone::baseline::execute,
evmone::get_capabilities,
evmone::set_option,
}
{
m_execution_states.reserve(1025);
} | O0 | cpp | evmone::VM::VM():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0xc, (%rdi)
leaq 0xa5a08(%rip), %rax # 0xde189
movq %rax, 0x8(%rdi)
leaq 0xa5a04(%rip), %rax # 0xde190
movq %rax, 0x10(%rdi)
leaq 0x69(%rip), %rax # 0x38800
movq %rax, 0x18(%rdi)
leaq 0x1807e(%rip), %rax # 0x50820
movq %rax, 0x20(%rdi)
leaq 0xb3(%rip), %rax # 0x38860
movq %rax, 0x28(%rdi)
leaq 0xb8(%rip), %rax # 0x38870
movq %rax, 0x30(%rdi)
movb $0x1, 0x38(%rdi)
movb $0x0, 0x39(%rdi)
addq $0x40, %rdi
movq %rdi, -0x10(%rbp)
callq 0x38c70
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x38c90
movq -0x10(%rbp), %rdi
movl $0x401, %esi # imm = 0x401
callq 0x38cc0
jmp 0x387ee
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x37a70
nopl (%rax)
| _ZN6evmone2VMC2Ev:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov [rbp+var_18], rdi
mov dword ptr [rdi], 0Ch
lea rax, aEvmone; "evmone"
mov [rdi+8], rax
lea rax, a0141; "0.14.1"
mov [rdi+10h], rax
lea rax, _ZN6evmone12_GLOBAL__N_17destroyEP7evmc_vm; evmone::`anonymous namespace'::destroy(evmc_vm *)
mov [rdi+18h], rax
lea rax, _ZN6evmone8baseline7executeEP7evmc_vmPK19evmc_host_interfaceP17evmc_host_context13evmc_revisionPK12evmc_messagePKhm; evmone::baseline::execute(evmc_vm *,evmc_host_interface const*,evmc_host_context *,evmc_revision,evmc_message const*,uchar const*,ulong)
mov [rdi+20h], rax
lea rax, _ZN6evmone12_GLOBAL__N_116get_capabilitiesEP7evmc_vm; evmone::`anonymous namespace'::get_capabilities(evmc_vm *)
mov [rdi+28h], rax
lea rax, _ZN6evmone12_GLOBAL__N_110set_optionEP7evmc_vmPKcS4_; evmone::`anonymous namespace'::set_option(evmc_vm *,char const*,char const*)
mov [rdi+30h], rax
mov byte ptr [rdi+38h], 1
mov byte ptr [rdi+39h], 0
add rdi, 40h ; '@'
mov [rbp+var_10], rdi
call _ZNSt6vectorIN6evmone14ExecutionStateESaIS1_EEC2Ev; std::vector<evmone::ExecutionState>::vector(void)
mov rdi, [rbp+var_18]
add rdi, 58h ; 'X'
call _ZNSt10unique_ptrIN6evmone6TracerESt14default_deleteIS1_EEC2IS3_vEEv; std::unique_ptr<evmone::Tracer>::unique_ptr<std::default_delete<evmone::Tracer>,void>(void)
mov rdi, [rbp+var_10]
mov esi, 401h
call _ZNSt6vectorIN6evmone14ExecutionStateESaIS1_EE7reserveEm; std::vector<evmone::ExecutionState>::reserve(ulong)
jmp short $+2
loc_387EE:
add rsp, 20h
pop rbp
retn
mov rdi, rax
call __clang_call_terminate
| long long evmone::VM::VM(evmone::VM *this)
{
*(_DWORD *)this = 12;
*((_QWORD *)this + 1) = "evmone";
*((_QWORD *)this + 2) = "0.14.1";
*((_QWORD *)this + 3) = evmone::`anonymous namespace'::destroy;
*((_QWORD *)this + 4) = evmone::baseline::execute;
*((_QWORD *)this + 5) = evmone::`anonymous namespace'::get_capabilities;
*((_QWORD *)this + 6) = evmone::`anonymous namespace'::set_option;
*((_BYTE *)this + 56) = 1;
*((_BYTE *)this + 57) = 0;
std::vector<evmone::ExecutionState>::vector();
std::unique_ptr<evmone::Tracer>::unique_ptr<std::default_delete<evmone::Tracer>,void>((char *)this + 88);
return std::vector<evmone::ExecutionState>::reserve((char *)this + 64, 1025LL);
}
| VM:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RDI],0xc
LEA RAX,[0x1de189]
MOV qword ptr [RDI + 0x8],RAX
LEA RAX,[0x1de190]
MOV qword ptr [RDI + 0x10],RAX
LEA RAX,[0x138800]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x150820]
MOV qword ptr [RDI + 0x20],RAX
LEA RAX,[0x138860]
MOV qword ptr [RDI + 0x28],RAX
LEA RAX,[0x138870]
MOV qword ptr [RDI + 0x30],RAX
MOV byte ptr [RDI + 0x38],0x1
MOV byte ptr [RDI + 0x39],0x0
ADD RDI,0x40
MOV qword ptr [RBP + -0x10],RDI
CALL 0x00138c70
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x58
CALL 0x00138c90
MOV RDI,qword ptr [RBP + -0x10]
LAB_001387e2:
MOV ESI,0x401
CALL 0x00138cc0
JMP 0x001387ee
LAB_001387ee:
ADD RSP,0x20
POP RBP
RET
|
/* evmone::VM::VM() */
void __thiscall evmone::VM::VM(VM *this)
{
*(int4 *)this = 0xc;
*(char **)(this + 8) = "evmone";
*(char **)(this + 0x10) = "0.14.1";
*(code **)(this + 0x18) = (anonymous_namespace)::destroy;
*(code **)(this + 0x20) = baseline::execute;
*(code **)(this + 0x28) = (anonymous_namespace)::get_capabilities;
*(code **)(this + 0x30) = (anonymous_namespace)::set_option;
this[0x38] = (VM)0x1;
this[0x39] = (VM)0x0;
std::vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>>::vector
((vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>> *)(this + 0x40))
;
std::unique_ptr<evmone::Tracer,std::default_delete<evmone::Tracer>>::
unique_ptr<std::default_delete<evmone::Tracer>,void>
((unique_ptr<evmone::Tracer,std::default_delete<evmone::Tracer>> *)(this + 0x58));
/* try { // try from 001387e2 to 001387eb has its CatchHandler @ 001387f4 */
std::vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>>::reserve
((vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>> *)(this + 0x40),
0x401);
return;
}
| |
31,213 | my_string_repertoire_8bit | eloqsql/strings/ctype.c | uint
my_string_repertoire_8bit(CHARSET_INFO *cs, const char *str, size_t length)
{
const char *strend;
if ((cs->state & MY_CS_NONASCII) && length > 0)
return MY_REPERTOIRE_UNICODE30;
for (strend= str + length; str < strend; str++)
{
if (((uchar) *str) > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
return MY_REPERTOIRE_ASCII;
} | O0 | c | my_string_repertoire_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0x75731
cmpq $0x0, -0x20(%rbp)
jbe 0x75731
movl $0x3, -0x4(%rbp)
jmp 0x75773
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7576c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jle 0x7575c
movl $0x3, -0x4(%rbp)
jmp 0x75773
jmp 0x7575e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7573d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_string_repertoire_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jz short loc_75731
cmp [rbp+var_20], 0
jbe short loc_75731
mov [rbp+var_4], 3
jmp short loc_75773
loc_75731:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_7573D:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
jnb short loc_7576C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 7Fh
jle short loc_7575C
mov [rbp+var_4], 3
jmp short loc_75773
loc_7575C:
jmp short $+2
loc_7575E:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_7573D
loc_7576C:
mov [rbp+var_4], 1
loc_75773:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_string_repertoire_8bit(long long a1, unsigned __int8 *a2, long long a3)
{
unsigned __int8 *v4; // [rsp+10h] [rbp-18h]
v4 = a2;
if ( (*(_DWORD *)(a1 + 12) & 0x2000) != 0 && a3 )
{
return 3;
}
else
{
while ( v4 < &a2[a3] )
{
if ( *v4 > 0x7Fu )
return 3;
++v4;
}
return 1;
}
}
| my_string_repertoire_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 RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JZ 0x00175731
CMP qword ptr [RBP + -0x20],0x0
JBE 0x00175731
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00175773
LAB_00175731:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_0017573d:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0017576c
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x7f
JLE 0x0017575c
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00175773
LAB_0017575c:
JMP 0x0017575e
LAB_0017575e:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0017573d
LAB_0017576c:
MOV dword ptr [RBP + -0x4],0x1
LAB_00175773:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_string_repertoire_8bit(long param_1,byte *param_2,long param_3)
{
byte *local_20;
int4 local_c;
if (((*(uint *)(param_1 + 0xc) & 0x2000) == 0) || (param_3 == 0)) {
for (local_20 = param_2; local_20 < param_2 + param_3; local_20 = local_20 + 1) {
if (0x7f < *local_20) {
return 3;
}
}
local_c = 1;
}
else {
local_c = 3;
}
return local_c;
}
| |
31,214 | Write_rows_log_event::do_after_row_operations(Slave_reporting_capability const*, int) | eloqsql/sql/log_event_server.cc | int
Write_rows_log_event::do_after_row_operations(const Slave_reporting_capability *const,
int error)
{
int local_error= 0;
/**
Clear the write_set bit for auto_inc field that only
existed on the destination table as an extra column.
*/
if (is_auto_inc_in_extra_columns())
{
bitmap_clear_bit(m_table->rpl_write_set,
m_table->next_number_field->field_index);
bitmap_clear_bit(m_table->read_set,
m_table->next_number_field->field_index);
if (get_flags(STMT_END_F))
m_table->file->ha_release_auto_increment();
}
m_table->next_number_field=0;
m_table->auto_increment_field_not_null= FALSE;
if (slave_exec_mode == SLAVE_EXEC_MODE_IDEMPOTENT)
{
m_table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
m_table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
/*
resetting the extra with
table->file->extra(HA_EXTRA_NO_IGNORE_NO_KEY);
fires bug#27077
explanation: file->reset() performs this duty
ultimately. Still todo: fix
*/
}
if (unlikely((local_error= m_table->file->ha_end_bulk_insert())))
{
m_table->file->print_error(local_error, MYF(0));
}
return error? error : local_error;
} | O0 | cpp | Write_rows_log_event::do_after_row_operations(Slave_reporting_capability const*, int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x87f790
testb $0x1, %al
jne 0x87a00d
jmp 0x87a080
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
movq 0x200(%rcx), %rdi
movq 0x70(%rax), %rax
movq 0xc8(%rax), %rax
movzwl 0x8c(%rax), %esi
callq 0x87a130
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
movq 0x1f0(%rcx), %rdi
movq 0x70(%rax), %rax
movq 0xc8(%rax), %rax
movzwl 0x8c(%rax), %esi
callq 0x87a130
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x8664e0
cmpw $0x0, %ax
je 0x87a07e
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xd10f50
jmp 0x87a080
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rcx
movq $0x0, 0xc8(%rcx)
movq 0x70(%rax), %rcx
movb $0x0, 0x2b7(%rcx)
cmpq $0x1, 0x50(%rax)
jne 0x87a0d9
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movl $0x1a, %esi
callq *0x298(%rax)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movl $0x26, %esi
callq *0x298(%rax)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rdi
callq 0xd12df0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x87a10b
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
callq *0x50(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x87a119
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x87a11f
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN20Write_rows_log_event23do_after_row_operationsEPK26Slave_reporting_capabilityi:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rdi, [rbp+var_8]; this
mov [rbp+var_20], rdi
mov [rbp+var_18], 0
call _ZN14Rows_log_event28is_auto_inc_in_extra_columnsEv; Rows_log_event::is_auto_inc_in_extra_columns(void)
test al, 1
jnz short loc_87A00D
jmp short loc_87A080
loc_87A00D:
mov rax, [rbp+var_20]
mov rcx, [rax+70h]
mov rdi, [rcx+200h]
mov rax, [rax+70h]
mov rax, [rax+0C8h]
movzx esi, word ptr [rax+8Ch]
call _ZL16bitmap_clear_bitP9st_bitmapj; bitmap_clear_bit(st_bitmap *,uint)
mov rax, [rbp+var_20]
mov rcx, [rax+70h]
mov rdi, [rcx+1F0h]
mov rax, [rax+70h]
mov rax, [rax+0C8h]
movzx esi, word ptr [rax+8Ch]
call _ZL16bitmap_clear_bitP9st_bitmapj; bitmap_clear_bit(st_bitmap *,uint)
mov rdi, [rbp+var_20]; this
mov esi, 1; unsigned __int16
call _ZNK14Rows_log_event9get_flagsEt; Rows_log_event::get_flags(ushort)
cmp ax, 0
jz short loc_87A07E
mov rax, [rbp+var_20]
mov rax, [rax+70h]
mov rdi, [rax+8]; this
call _ZN7handler25ha_release_auto_incrementEv; handler::ha_release_auto_increment(void)
loc_87A07E:
jmp short $+2
loc_87A080:
mov rax, [rbp+var_20]
mov rcx, [rax+70h]
mov qword ptr [rcx+0C8h], 0
mov rcx, [rax+70h]
mov byte ptr [rcx+2B7h], 0
cmp qword ptr [rax+50h], 1
jnz short loc_87A0D9
mov rax, [rbp+var_20]
mov rax, [rax+70h]
mov rdi, [rax+8]
mov rax, [rdi]
mov esi, 1Ah
call qword ptr [rax+298h]
mov rax, [rbp+var_20]
mov rax, [rax+70h]
mov rdi, [rax+8]
mov rax, [rdi]
mov esi, 26h ; '&'
call qword ptr [rax+298h]
loc_87A0D9:
mov rax, [rbp+var_20]
mov rax, [rax+70h]
mov rdi, [rax+8]; this
call _ZN7handler18ha_end_bulk_insertEv; handler::ha_end_bulk_insert(void)
mov [rbp+var_18], eax
cmp eax, 0
jz short loc_87A10B
mov rax, [rbp+var_20]
mov rax, [rax+70h]
mov rdi, [rax+8]
mov esi, [rbp+var_18]
mov rax, [rdi]
xor ecx, ecx
mov edx, ecx
call qword ptr [rax+50h]
loc_87A10B:
cmp [rbp+var_14], 0
jz short loc_87A119
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
jmp short loc_87A11F
loc_87A119:
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
loc_87A11F:
mov eax, [rbp+var_24]
add rsp, 30h
pop rbp
retn
| long long Write_rows_log_event::do_after_row_operations(
Write_rows_log_event *this,
const Slave_reporting_capability *a2,
unsigned int a3)
{
unsigned int v5; // [rsp+18h] [rbp-18h]
if ( (Rows_log_event::is_auto_inc_in_extra_columns(this) & 1) != 0 )
{
bitmap_clear_bit(
*(_QWORD *)(*((_QWORD *)this + 14) + 512LL),
*(unsigned __int16 *)(*(_QWORD *)(*((_QWORD *)this + 14) + 200LL) + 140LL));
bitmap_clear_bit(
*(_QWORD *)(*((_QWORD *)this + 14) + 496LL),
*(unsigned __int16 *)(*(_QWORD *)(*((_QWORD *)this + 14) + 200LL) + 140LL));
if ( (unsigned __int16)Rows_log_event::get_flags(this, 1) )
handler::ha_release_auto_increment(*(handler **)(*((_QWORD *)this + 14) + 8LL));
}
*(_QWORD *)(*((_QWORD *)this + 14) + 200LL) = 0LL;
*(_BYTE *)(*((_QWORD *)this + 14) + 695LL) = 0;
if ( *((_QWORD *)this + 10) == 1LL )
{
(*(void ( **)(_QWORD, long long))(**(_QWORD **)(*((_QWORD *)this + 14) + 8LL) + 664LL))(
*(_QWORD *)(*((_QWORD *)this + 14) + 8LL),
26LL);
(*(void ( **)(_QWORD, long long))(**(_QWORD **)(*((_QWORD *)this + 14) + 8LL) + 664LL))(
*(_QWORD *)(*((_QWORD *)this + 14) + 8LL),
38LL);
}
v5 = handler::ha_end_bulk_insert(*(handler **)(*((_QWORD *)this + 14) + 8LL));
if ( v5 )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(**(_QWORD **)(*((_QWORD *)this + 14) + 8LL) + 80LL))(
*(_QWORD *)(*((_QWORD *)this + 14) + 8LL),
v5,
0LL);
if ( a3 )
return a3;
else
return v5;
}
| __cxx_global_var_init.5:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1e458a4]
MOV ESI,0x800000
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_5(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_NO_ZERO_IN_DATE,0x800000);
return;
}
| |
31,215 | gray_convert_glyph_inner | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-raster.c | static int
gray_convert_glyph_inner( RAS_ARG )
{
volatile int error = 0;
if ( pvg_ft_setjmp( ras.jump_buffer ) == 0 )
{
error = PVG_FT_Outline_Decompose( &ras.outline, &ras );
if ( !ras.invalid )
gray_record_cell( RAS_VAR );
}
else
{
error = ErrRaster_Memory_Overflow;
}
return error;
} | O3 | c | gray_convert_glyph_inner:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
addq $0x10e8, %rdi # imm = 0x10E8
callq 0xa430
testl %eax, %eax
je 0x3bb85
movl $0xfffffffc, 0xc(%rsp) # imm = 0xFFFFFFFC
jmp 0x3bec3
cmpl $0x0, 0x78(%rbx)
jle 0x3beaf
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %r12
movq 0x90(%rbx), %rcx
movslq (%rcx,%r12,4), %r14
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
testq %r14, %r14
js 0x3bed6
movq %r14, %rdi
shlq $0x4, %rdi
movq 0x80(%rbx), %r9
movq 0x88(%rbx), %r8
leaq (%r9,%rdi), %rcx
movl %eax, %eax
movl %eax, %edx
leaq (%r8,%rdx), %rax
movzbl (%r8,%rdx), %r11d
movq %rdx, %rsi
shlq $0x4, %rsi
leaq (%r9,%rsi), %rdx
movq (%r9,%rsi), %r10
movq 0x8(%r9,%rsi), %rsi
andl $0x3, %r11d
je 0x3bbfb
cmpl $0x2, %r11d
jne 0x3bc4b
jmp 0x3bed6
movq (%r9,%rdi), %r11
movq 0x8(%r9,%rdi), %rdi
movb (%r8,%r14), %r8b
andb $0x3, %r8b
cmpb $0x1, %r8b
jne 0x3bc18
addq $-0x10, %rcx
jmp 0x3bc3e
addq %r10, %r11
movq %r11, %r8
shrq $0x3f, %r8
addq %r11, %r8
sarq %r8
addq %rsi, %rdi
movq %rdi, %rsi
shrq $0x3f, %rsi
addq %rdi, %rsi
sarq %rsi
movq %r8, %r11
movq %rsi, %rdi
addq $-0x10, %rdx
decq %rax
movq %r11, %r10
movq %rdi, %rsi
movq %r12, 0x10(%rsp)
movq %r14, 0x40(%rsp)
movq %rax, 0x28(%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %r10, %r14
cmpl $0x0, 0x4c(%rbx)
jne 0x3bc77
movq %rbx, %rdi
movq %rsi, %r12
callq 0x3bedb
movq %r12, %rsi
leaq (,%r14,4), %r12
leaq (,%rsi,4), %rbp
movq %r14, 0x20(%rsp)
movq %r14, %rax
sarq $0x6, %rax
movq %rsi, 0x18(%rsp)
movq %rsi, %rdx
sarq $0x6, %rdx
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rsi
cmpq %rax, %rsi
cmovlq %rsi, %rax
leaq -0x1(%rcx), %rsi
cmpq %rcx, %rax
cmovgeq %rax, %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rsi, %rax
subq %rcx, %rax
movq %rax, (%rbx)
movq %rdx, %rax
subq 0x20(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3c8a9
movq %r12, 0x38(%rsp)
movq %r12, 0x68(%rbx)
movq %rbp, 0x30(%rsp)
movq %rbp, 0x70(%rbx)
cmpq %r15, %r13
movq 0x10(%rsp), %rbp
jae 0x3be3b
movq 0x28(%rsp), %rdi
movq %r13, %rax
leaq 0x10(%rax), %r13
movzbl 0x1(%rdi), %ecx
andl $0x3, %ecx
je 0x3bd3d
cmpl $0x1, %ecx
jne 0x3bdb8
movq %rdi, %r14
incq %r14
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
shlq $0x2, %rsi
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0x3bfab
jmp 0x3be2c
movq 0x10(%rax), %r12
movq 0x18(%rax), %rdx
cmpq %r15, %r13
jae 0x3be4f
movq %rdi, %r14
addq $0x2, %r14
addq $0x20, %rax
movq %r12, %rsi
movq %rax, %r13
movzbl (%r14), %eax
movq (%r13), %r12
movq 0x8(%r13), %rbp
andl $0x3, %eax
jne 0x3be10
leaq (%r12,%rsi), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
sarq %rcx
leaq (%rdx,%rbp), %rax
movq %rax, %rdi
shrq $0x3f, %rdi
addq %rax, %rdi
movq %rdi, %r8
sarq %r8
movq %rbx, %rdi
callq 0x3c37f
incq %r14
leaq 0x10(%r13), %rax
movq %rbp, %rdx
movq %r12, %rsi
cmpq %r15, %r13
jb 0x3bd5c
jmp 0x3be52
leaq 0x20(%rax), %rcx
cmpq %r15, %rcx
ja 0x3bea8
movb 0x2(%rdi), %cl
andb $0x3, %cl
cmpb $0x2, %cl
jne 0x3bea8
leaq 0x30(%rax), %r13
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq 0x28(%rax), %r8
cmpq %r15, %r13
ja 0x3be8e
movq %rdi, %r14
addq $0x3, %r14
movq 0x30(%rax), %r9
movq 0x38(%rax), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rbx, %rdi
callq 0x3c56d
jmp 0x3be2c
cmpl $0x1, %eax
jne 0x3bea8
movq %rbx, %rdi
movq %r12, %rcx
movq %rbp, %r8
callq 0x3c37f
movq 0x10(%rsp), %rbp
movq %r14, %rdi
movq %r13, %rax
cmpq %r15, %r13
jb 0x3bd04
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x3bfab
jmp 0x3be6f
movq %rdx, %rbp
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x3c37f
movq 0x10(%rsp), %rbp
movq 0x40(%rsp), %rax
incl %eax
movq %rbp, %rdx
incq %rdx
movslq 0x78(%rbx), %rsi
movq %rdx, %rcx
cmpq %rsi, %rdx
jl 0x3bb93
jmp 0x3beaf
movq %rsp, %rax
movq 0x18(%rsp), %rdi
movq %rdi, (%rax)
movq %rbx, %rdi
movq 0x20(%rsp), %r9
callq 0x3c56d
jmp 0x3be6f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x3beb1
xorl %eax, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x4c(%rbx)
jne 0x3bec3
movq %rbx, %rdi
callq 0x3bedb
movl 0xc(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %eax
jmp 0x3beb1
| gray_convert_glyph_inner:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
mov [rsp+78h+var_6C], 0
add rdi, 10E8h
call __setjmp
test eax, eax
jz short loc_3BB85
mov [rsp+78h+var_6C], 0FFFFFFFCh
jmp loc_3BEC3
loc_3BB85:
cmp dword ptr [rbx+78h], 0
jle loc_3BEAF
xor eax, eax
mov ecx, eax
loc_3BB93:
mov r12, rcx
mov rcx, [rbx+90h]
movsxd r14, dword ptr [rcx+r12*4]
mov r15d, 0FFFFFFFFh
test r14, r14
js loc_3BED6
mov rdi, r14
shl rdi, 4
mov r9, [rbx+80h]
mov r8, [rbx+88h]
lea rcx, [r9+rdi]
mov eax, eax
mov edx, eax
lea rax, [r8+rdx]
movzx r11d, byte ptr [r8+rdx]
mov rsi, rdx
shl rsi, 4
lea rdx, [r9+rsi]
mov r10, [r9+rsi]
mov rsi, [r9+rsi+8]
and r11d, 3
jz short loc_3BBFB
cmp r11d, 2
jnz short loc_3BC4B
jmp loc_3BED6
loc_3BBFB:
mov r11, [r9+rdi]
mov rdi, [r9+rdi+8]
mov r8b, [r8+r14]
and r8b, 3
cmp r8b, 1
jnz short loc_3BC18
add rcx, 0FFFFFFFFFFFFFFF0h
jmp short loc_3BC3E
loc_3BC18:
add r11, r10
mov r8, r11
shr r8, 3Fh
add r8, r11
sar r8, 1
add rdi, rsi
mov rsi, rdi
shr rsi, 3Fh
add rsi, rdi
sar rsi, 1
mov r11, r8
mov rdi, rsi
loc_3BC3E:
add rdx, 0FFFFFFFFFFFFFFF0h
dec rax
mov r10, r11
mov rsi, rdi
loc_3BC4B:
mov [rsp+78h+var_68], r12
mov [rsp+78h+var_38], r14
mov [rsp+78h+var_50], rax
mov r15, rcx
mov r13, rdx
mov r14, r10
cmp dword ptr [rbx+4Ch], 0
jnz short loc_3BC77
mov rdi, rbx
mov r12, rsi
call gray_record_cell
mov rsi, r12
loc_3BC77:
lea r12, ds:0[r14*4]
lea rbp, ds:0[rsi*4]
mov [rsp+78h+var_58], r14
mov rax, r14
sar rax, 6
mov [rsp+78h+var_60], rsi
mov rdx, rsi
sar rdx, 6
mov rcx, [rbx+10h]
mov rsi, [rbx+18h]
cmp rsi, rax
cmovl rax, rsi
lea rsi, [rcx-1]
cmp rax, rcx
cmovge rsi, rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+40h], xmm0
mov rax, rsi
sub rax, rcx
mov [rbx], rax
mov rax, rdx
sub rax, [rbx+20h]
mov [rbx+8], rax
mov rdi, rbx
call gray_set_cell
mov [rsp+78h+var_40], r12
mov [rbx+68h], r12
mov [rsp+78h+var_48], rbp
mov [rbx+70h], rbp
cmp r13, r15
mov rbp, [rsp+78h+var_68]
jnb loc_3BE3B
mov rdi, [rsp+78h+var_50]
mov rax, r13
loc_3BD04:
lea r13, [rax+10h]
movzx ecx, byte ptr [rdi+1]
and ecx, 3
jz short loc_3BD3D
cmp ecx, 1
jnz loc_3BDB8
mov r14, rdi
inc r14
mov rsi, [rax+10h]
mov rdx, [rax+18h]
shl rsi, 2
shl rdx, 2
mov rdi, rbx
call gray_render_line
jmp loc_3BE2C
loc_3BD3D:
mov r12, [rax+10h]
mov rdx, [rax+18h]
cmp r13, r15
jnb loc_3BE4F
mov r14, rdi
add r14, 2
add rax, 20h ; ' '
mov rsi, r12
loc_3BD5C:
mov r13, rax
movzx eax, byte ptr [r14]
mov r12, [r13+0]
mov rbp, [r13+8]
and eax, 3
jnz loc_3BE10
lea rax, [r12+rsi]
mov rcx, rax
shr rcx, 3Fh
add rcx, rax
sar rcx, 1
lea rax, [rdx+rbp]
mov rdi, rax
shr rdi, 3Fh
add rdi, rax
mov r8, rdi
sar r8, 1
mov rdi, rbx
call gray_render_conic
inc r14
lea rax, [r13+10h]
mov rdx, rbp
mov rsi, r12
cmp r13, r15
jb short loc_3BD5C
jmp loc_3BE52
loc_3BDB8:
lea rcx, [rax+20h]
cmp rcx, r15
ja loc_3BEA8
mov cl, [rdi+2]
and cl, 3
cmp cl, 2
jnz loc_3BEA8
lea r13, [rax+30h]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov r8, [rax+28h]
cmp r13, r15
ja loc_3BE8E
mov r14, rdi
add r14, 3
mov r9, [rax+30h]
mov rax, [rax+38h]
mov rdi, rsp
mov [rdi], rax
mov rdi, rbx
call gray_render_cubic
jmp short loc_3BE2C
loc_3BE10:
cmp eax, 1
jnz loc_3BEA8
mov rdi, rbx
mov rcx, r12
mov r8, rbp
call gray_render_conic
mov rbp, [rsp+78h+var_68]
loc_3BE2C:
mov rdi, r14
mov rax, r13
cmp r13, r15
jb loc_3BD04
loc_3BE3B:
mov rdi, rbx
mov rsi, [rsp+78h+var_40]
mov rdx, [rsp+78h+var_48]
call gray_render_line
jmp short loc_3BE6F
loc_3BE4F:
mov rbp, rdx
loc_3BE52:
mov rdi, rbx
mov rsi, r12
mov rdx, rbp
mov rcx, [rsp+78h+var_58]
mov r8, [rsp+78h+var_60]
call gray_render_conic
mov rbp, [rsp+78h+var_68]
loc_3BE6F:
mov rax, [rsp+78h+var_38]
inc eax
mov rdx, rbp
inc rdx
movsxd rsi, dword ptr [rbx+78h]
mov rcx, rdx
cmp rdx, rsi
jl loc_3BB93
jmp short loc_3BEAF
loc_3BE8E:
mov rax, rsp
mov rdi, [rsp+78h+var_60]
mov [rax], rdi
mov rdi, rbx
mov r9, [rsp+78h+var_58]
call gray_render_cubic
jmp short loc_3BE6F
loc_3BEA8:
mov eax, 0FFFFFFFFh
jmp short loc_3BEB1
loc_3BEAF:
xor eax, eax
loc_3BEB1:
mov [rsp+78h+var_6C], eax
cmp dword ptr [rbx+4Ch], 0
jnz short loc_3BEC3
mov rdi, rbx
call gray_record_cell
loc_3BEC3:
mov eax, [rsp+78h+var_6C]
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3BED6:
mov eax, r15d
jmp short loc_3BEB1
| long long gray_convert_glyph_inner(long long a1)
{
unsigned int v2; // eax
long long v3; // rcx
long long v4; // r12
long long v5; // r14
long long v6; // r9
long long v7; // r8
unsigned long long v8; // rcx
long long v9; // rdx
_BYTE *v10; // rax
char v11; // r11
long long *v12; // rdx
long long v13; // r10
long long v14; // rsi
int v15; // r11d
long long v16; // r11
long long v17; // rdi
unsigned long long v18; // r15
long long *v19; // r13
long long v20; // r14
long long v21; // rbp
long long v22; // rax
long long v23; // rdx
long long v24; // rcx
long long v25; // rsi
long long v26; // rbp
_BYTE *v27; // rdi
long long *v28; // rax
long long *v29; // r13
_BYTE *v30; // r14
long long v31; // r12
long long v32; // rdx
long long *v33; // rax
long long v34; // rsi
long long v35; // rbp
long long v36; // rsi
long long v37; // rdx
long long v38; // rcx
long long v39; // r8
int v40; // eax
unsigned int v42; // [rsp+Ch] [rbp-6Ch]
long long v43; // [rsp+10h] [rbp-68h]
long long v44; // [rsp+18h] [rbp-60h]
long long v45; // [rsp+20h] [rbp-58h]
_BYTE *v46; // [rsp+28h] [rbp-50h]
long long v47; // [rsp+30h] [rbp-48h]
long long v48; // [rsp+38h] [rbp-40h]
int v49; // [rsp+40h] [rbp-38h]
if ( (unsigned int)_setjmp(a1 + 4328) )
return (unsigned int)-4;
if ( *(int *)(a1 + 120) <= 0 )
goto LABEL_43;
v2 = 0;
v3 = 0LL;
do
{
v4 = v3;
v5 = *(int *)(*(_QWORD *)(a1 + 144) + 4 * v3);
if ( v5 < 0 )
{
LABEL_47:
v40 = -1;
goto LABEL_44;
}
v6 = *(_QWORD *)(a1 + 128);
v7 = *(_QWORD *)(a1 + 136);
v8 = v6 + 16 * v5;
v9 = v2;
v10 = (_BYTE *)(v7 + v9);
v11 = *(_BYTE *)(v7 + v9);
v12 = (long long *)(v6 + 16 * v9);
v13 = *v12;
v14 = v12[1];
v15 = v11 & 3;
if ( v15 )
{
if ( v15 == 2 )
goto LABEL_47;
}
else
{
v16 = *(_QWORD *)(v6 + 16 * v5);
v17 = *(_QWORD *)(v6 + 16 * v5 + 8);
if ( (*(_BYTE *)(v7 + v5) & 3) == 1 )
{
v8 -= 16LL;
}
else
{
v16 = (v13 + v16) / 2;
v17 = (v14 + v17) / 2;
}
v12 -= 2;
--v10;
v13 = v16;
v14 = v17;
}
v43 = v4;
v49 = v5;
v46 = v10;
v18 = v8;
v19 = v12;
v20 = v13;
if ( !*(_DWORD *)(a1 + 76) )
gray_record_cell(a1);
v21 = 4 * v14;
v45 = v20;
v22 = v20 >> 6;
v44 = v14;
v23 = v14 >> 6;
v24 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 24) < v20 >> 6 )
v22 = *(_QWORD *)(a1 + 24);
v25 = v24 - 1;
if ( v22 >= v24 )
v25 = v22;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)a1 = v25 - v24;
*(_QWORD *)(a1 + 8) = v23 - *(_QWORD *)(a1 + 32);
gray_set_cell(a1);
v48 = 4 * v20;
*(_QWORD *)(a1 + 104) = 4 * v20;
v47 = v21;
*(_QWORD *)(a1 + 112) = v21;
v26 = v4;
if ( (unsigned long long)v19 >= v18 )
{
LABEL_36:
gray_render_line(a1, v48, v47);
goto LABEL_39;
}
v27 = v46;
v28 = v19;
while ( 1 )
{
v29 = v28 + 2;
if ( (v27[1] & 3) != 0 )
{
if ( (v27[1] & 3) == 1 )
{
v30 = v27 + 1;
gray_render_line(a1, 4 * v28[2], 4 * v28[3]);
}
else
{
if ( (unsigned long long)(v28 + 4) > v18 || (v27[2] & 3) != 2 )
goto LABEL_42;
v29 = v28 + 6;
v36 = v28[2];
v37 = v28[3];
v38 = v28[4];
v39 = v28[5];
if ( (unsigned long long)(v28 + 6) > v18 )
{
gray_render_cubic(a1, v36, v37, v38, v39, v45, v44);
goto LABEL_39;
}
v30 = v27 + 3;
gray_render_cubic(a1, v36, v37, v38, v39, v28[6], v28[7]);
}
goto LABEL_35;
}
v31 = v28[2];
v32 = v28[3];
if ( (unsigned long long)v29 >= v18 )
break;
v30 = v27 + 2;
v33 = v28 + 4;
v34 = v31;
while ( 1 )
{
v29 = v33;
v31 = *v33;
v35 = v33[1];
if ( (*v30 & 3) != 0 )
break;
gray_render_conic(a1, v34, v32, (v31 + v34) / 2, (v32 + v35) / 2);
++v30;
v33 = v29 + 2;
v32 = v35;
v34 = v31;
if ( (unsigned long long)v29 >= v18 )
goto LABEL_38;
}
if ( (*v30 & 3) != 1 )
{
LABEL_42:
v40 = -1;
goto LABEL_44;
}
gray_render_conic(a1, v34, v32, v31, v35);
v26 = v43;
LABEL_35:
v27 = v30;
v28 = v29;
if ( (unsigned long long)v29 >= v18 )
goto LABEL_36;
}
v35 = v28[3];
LABEL_38:
gray_render_conic(a1, v31, v35, v45, v44);
v26 = v43;
LABEL_39:
v2 = v49 + 1;
v3 = v26 + 1;
}
while ( v26 + 1 < *(int *)(a1 + 120) );
LABEL_43:
v40 = 0;
LABEL_44:
v42 = v40;
if ( !*(_DWORD *)(a1 + 76) )
gray_record_cell(a1);
return v42;
}
| gray_convert_glyph_inner:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
MOV dword ptr [RSP + 0xc],0x0
ADD RDI,0x10e8
CALL 0x0010a430
TEST EAX,EAX
JZ 0x0013bb85
MOV dword ptr [RSP + 0xc],0xfffffffc
JMP 0x0013bec3
LAB_0013bb85:
CMP dword ptr [RBX + 0x78],0x0
JLE 0x0013beaf
XOR EAX,EAX
MOV ECX,EAX
LAB_0013bb93:
MOV R12,RCX
MOV RCX,qword ptr [RBX + 0x90]
MOVSXD R14,dword ptr [RCX + R12*0x4]
MOV R15D,0xffffffff
TEST R14,R14
JS 0x0013bed6
MOV RDI,R14
SHL RDI,0x4
MOV R9,qword ptr [RBX + 0x80]
MOV R8,qword ptr [RBX + 0x88]
LEA RCX,[R9 + RDI*0x1]
MOV EAX,EAX
MOV EDX,EAX
LEA RAX,[R8 + RDX*0x1]
MOVZX R11D,byte ptr [R8 + RDX*0x1]
MOV RSI,RDX
SHL RSI,0x4
LEA RDX,[R9 + RSI*0x1]
MOV R10,qword ptr [R9 + RSI*0x1]
MOV RSI,qword ptr [R9 + RSI*0x1 + 0x8]
AND R11D,0x3
JZ 0x0013bbfb
CMP R11D,0x2
JNZ 0x0013bc4b
JMP 0x0013bed6
LAB_0013bbfb:
MOV R11,qword ptr [R9 + RDI*0x1]
MOV RDI,qword ptr [R9 + RDI*0x1 + 0x8]
MOV R8B,byte ptr [R8 + R14*0x1]
AND R8B,0x3
CMP R8B,0x1
JNZ 0x0013bc18
ADD RCX,-0x10
JMP 0x0013bc3e
LAB_0013bc18:
ADD R11,R10
MOV R8,R11
SHR R8,0x3f
ADD R8,R11
SAR R8,0x1
ADD RDI,RSI
MOV RSI,RDI
SHR RSI,0x3f
ADD RSI,RDI
SAR RSI,0x1
MOV R11,R8
MOV RDI,RSI
LAB_0013bc3e:
ADD RDX,-0x10
DEC RAX
MOV R10,R11
MOV RSI,RDI
LAB_0013bc4b:
MOV qword ptr [RSP + 0x10],R12
MOV qword ptr [RSP + 0x40],R14
MOV qword ptr [RSP + 0x28],RAX
MOV R15,RCX
MOV R13,RDX
MOV R14,R10
CMP dword ptr [RBX + 0x4c],0x0
JNZ 0x0013bc77
MOV RDI,RBX
MOV R12,RSI
CALL 0x0013bedb
MOV RSI,R12
LAB_0013bc77:
LEA R12,[R14*0x4]
LEA RBP,[RSI*0x4]
MOV qword ptr [RSP + 0x20],R14
MOV RAX,R14
SAR RAX,0x6
MOV qword ptr [RSP + 0x18],RSI
MOV RDX,RSI
SAR RDX,0x6
MOV RCX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,RAX
CMOVL RAX,RSI
LEA RSI,[RCX + -0x1]
CMP RAX,RCX
CMOVGE RSI,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RAX,RSI
SUB RAX,RCX
MOV qword ptr [RBX],RAX
MOV RAX,RDX
SUB RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,RBX
CALL 0x0013c8a9
MOV qword ptr [RSP + 0x38],R12
MOV qword ptr [RBX + 0x68],R12
MOV qword ptr [RSP + 0x30],RBP
MOV qword ptr [RBX + 0x70],RBP
CMP R13,R15
MOV RBP,qword ptr [RSP + 0x10]
JNC 0x0013be3b
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,R13
LAB_0013bd04:
LEA R13,[RAX + 0x10]
MOVZX ECX,byte ptr [RDI + 0x1]
AND ECX,0x3
JZ 0x0013bd3d
CMP ECX,0x1
JNZ 0x0013bdb8
MOV R14,RDI
INC R14
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
SHL RSI,0x2
SHL RDX,0x2
MOV RDI,RBX
CALL 0x0013bfab
JMP 0x0013be2c
LAB_0013bd3d:
MOV R12,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CMP R13,R15
JNC 0x0013be4f
MOV R14,RDI
ADD R14,0x2
ADD RAX,0x20
MOV RSI,R12
LAB_0013bd5c:
MOV R13,RAX
MOVZX EAX,byte ptr [R14]
MOV R12,qword ptr [R13]
MOV RBP,qword ptr [R13 + 0x8]
AND EAX,0x3
JNZ 0x0013be10
LEA RAX,[R12 + RSI*0x1]
MOV RCX,RAX
SHR RCX,0x3f
ADD RCX,RAX
SAR RCX,0x1
LEA RAX,[RDX + RBP*0x1]
MOV RDI,RAX
SHR RDI,0x3f
ADD RDI,RAX
MOV R8,RDI
SAR R8,0x1
MOV RDI,RBX
CALL 0x0013c37f
INC R14
LEA RAX,[R13 + 0x10]
MOV RDX,RBP
MOV RSI,R12
CMP R13,R15
JC 0x0013bd5c
JMP 0x0013be52
LAB_0013bdb8:
LEA RCX,[RAX + 0x20]
CMP RCX,R15
JA 0x0013bea8
MOV CL,byte ptr [RDI + 0x2]
AND CL,0x3
CMP CL,0x2
JNZ 0x0013bea8
LEA R13,[RAX + 0x30]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RAX + 0x28]
CMP R13,R15
JA 0x0013be8e
MOV R14,RDI
ADD R14,0x3
MOV R9,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RAX + 0x38]
MOV RDI,RSP
MOV qword ptr [RDI],RAX
MOV RDI,RBX
CALL 0x0013c56d
JMP 0x0013be2c
LAB_0013be10:
CMP EAX,0x1
JNZ 0x0013bea8
MOV RDI,RBX
MOV RCX,R12
MOV R8,RBP
CALL 0x0013c37f
MOV RBP,qword ptr [RSP + 0x10]
LAB_0013be2c:
MOV RDI,R14
MOV RAX,R13
CMP R13,R15
JC 0x0013bd04
LAB_0013be3b:
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0013bfab
JMP 0x0013be6f
LAB_0013be4f:
MOV RBP,RDX
LAB_0013be52:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RBP
MOV RCX,qword ptr [RSP + 0x20]
MOV R8,qword ptr [RSP + 0x18]
CALL 0x0013c37f
MOV RBP,qword ptr [RSP + 0x10]
LAB_0013be6f:
MOV RAX,qword ptr [RSP + 0x40]
INC EAX
MOV RDX,RBP
INC RDX
MOVSXD RSI,dword ptr [RBX + 0x78]
MOV RCX,RDX
CMP RDX,RSI
JL 0x0013bb93
JMP 0x0013beaf
LAB_0013be8e:
MOV RAX,RSP
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RDI
MOV RDI,RBX
MOV R9,qword ptr [RSP + 0x20]
CALL 0x0013c56d
JMP 0x0013be6f
LAB_0013bea8:
MOV EAX,0xffffffff
JMP 0x0013beb1
LAB_0013beaf:
XOR EAX,EAX
LAB_0013beb1:
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RBX + 0x4c],0x0
JNZ 0x0013bec3
MOV RDI,RBX
CALL 0x0013bedb
LAB_0013bec3:
MOV EAX,dword ptr [RSP + 0xc]
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013bed6:
MOV EAX,R15D
JMP 0x0013beb1
|
int4 gray_convert_glyph_inner(long *param_1)
{
long lVar1;
int iVar2;
uint uVar3;
long lVar4;
long *plVar5;
long *plVar6;
ulong uVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
long lVar12;
long lVar13;
byte *pbVar14;
bool bVar15;
int4 local_6c;
iVar2 = _setjmp((__jmp_buf_tag *)(param_1 + 0x21d));
if (iVar2 == 0) {
if (0 < (int)param_1[0xf]) {
uVar3 = 0;
lVar9 = 0;
do {
iVar2 = *(int *)(param_1[0x12] + lVar9 * 4);
lVar13 = (long)iVar2;
if (lVar13 < 0) {
LAB_0013bed6:
local_6c = 0xffffffff;
goto LAB_0013beb1;
}
lVar11 = lVar13 * 0x10;
lVar4 = param_1[0x10];
lVar8 = param_1[0x11];
plVar6 = (long *)(lVar4 + lVar11);
uVar7 = (ulong)uVar3;
pbVar14 = (byte *)(lVar8 + uVar7);
lVar10 = uVar7 * 0x10;
plVar5 = (long *)(lVar4 + lVar10);
lVar12 = *(long *)(lVar4 + lVar10);
lVar10 = *(long *)(lVar4 + 8 + lVar10);
if ((*(byte *)(lVar8 + uVar7) & 3) == 0) {
lVar1 = *(long *)(lVar4 + 8 + lVar11);
if ((*(byte *)(lVar8 + lVar13) & 3) == 1) {
plVar6 = plVar6 + -2;
lVar10 = lVar1;
lVar12 = *(long *)(lVar4 + lVar11);
}
else {
lVar12 = (*(long *)(lVar4 + lVar11) + lVar12) / 2;
lVar10 = (lVar1 + lVar10) / 2;
}
plVar5 = plVar5 + -2;
pbVar14 = pbVar14 + -1;
}
else if ((*(byte *)(lVar8 + uVar7) & 3) == 2) goto LAB_0013bed6;
if (*(int *)((long)param_1 + 0x4c) == 0) {
gray_record_cell(param_1);
}
lVar13 = param_1[2];
lVar4 = lVar12 >> 6;
if (param_1[3] < lVar12 >> 6) {
lVar4 = param_1[3];
}
lVar8 = lVar13 + -1;
if (lVar13 <= lVar4) {
lVar8 = lVar4;
}
param_1[8] = 0;
param_1[9] = 0;
*param_1 = lVar8 - lVar13;
param_1[1] = (lVar10 >> 6) - param_1[4];
gray_set_cell(param_1);
param_1[0xd] = lVar12 * 4;
param_1[0xe] = lVar10 * 4;
while (plVar5 < plVar6) {
if ((pbVar14[1] & 3) == 0) {
lVar13 = plVar5[2];
lVar4 = plVar5[3];
if (plVar6 <= plVar5 + 2) {
LAB_0013be52:
gray_render_conic(param_1,lVar13,lVar4,lVar12,lVar10);
goto LAB_0013be6f;
}
pbVar14 = pbVar14 + 2;
plVar5 = plVar5 + 4;
lVar8 = lVar4;
lVar11 = lVar13;
while( true ) {
lVar13 = *plVar5;
lVar4 = plVar5[1];
if ((*pbVar14 & 3) != 0) break;
gray_render_conic(param_1,lVar11,lVar8,(lVar13 + lVar11) / 2,(lVar8 + lVar4) / 2);
pbVar14 = pbVar14 + 1;
bVar15 = plVar6 <= plVar5;
plVar5 = plVar5 + 2;
lVar8 = lVar4;
lVar11 = lVar13;
if (bVar15) goto LAB_0013be52;
}
if ((*pbVar14 & 3) != 1) goto LAB_0013bea8;
gray_render_conic(param_1,lVar11,lVar8,lVar13,lVar4);
}
else if ((pbVar14[1] & 3) == 1) {
pbVar14 = pbVar14 + 1;
gray_render_line(param_1,plVar5[2] << 2,plVar5[3] << 2);
plVar5 = plVar5 + 2;
}
else {
if ((plVar6 < plVar5 + 4) || ((pbVar14[2] & 3) != 2)) {
LAB_0013bea8:
local_6c = 0xffffffff;
goto LAB_0013beb1;
}
if (plVar6 < plVar5 + 6) {
gray_render_cubic(param_1,plVar5[2],plVar5[3],plVar5[4],plVar5[5],lVar12,lVar10);
goto LAB_0013be6f;
}
pbVar14 = pbVar14 + 3;
gray_render_cubic(param_1,plVar5[2],plVar5[3],plVar5[4],plVar5[5],plVar5[6],plVar5[7]);
plVar5 = plVar5 + 6;
}
}
gray_render_line(param_1,lVar12 * 4,lVar10 * 4);
LAB_0013be6f:
uVar3 = iVar2 + 1;
lVar9 = lVar9 + 1;
} while (lVar9 < (int)param_1[0xf]);
}
local_6c = 0;
LAB_0013beb1:
if (*(int *)((long)param_1 + 0x4c) == 0) {
gray_record_cell(param_1);
}
}
else {
local_6c = 0xfffffffc;
}
return local_6c;
}
| |
31,216 | parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]) | llama.cpp/common/common.cpp | bool parse_cpu_mask(const std::string & mask, bool (&boolmask)[GGML_MAX_N_THREADS]) {
// Discard potential 0x prefix
size_t start_i = 0;
if (mask.length() >= 2 && mask.substr(0, 2) == "0x") {
start_i = 2;
}
size_t num_digits = mask.length() - start_i;
if (num_digits > 128) num_digits = 128;
size_t end_i = num_digits + start_i;
for (size_t i = start_i, n = (num_digits*4 - 1); i < end_i; i++, n-=4) {
char c = mask.at(i);
int8_t id = c;
if ((c >= '0' && c <= '9')) {
id -= '0';
} else if (c >= 'a' && c <= 'f') {
id -= 'a' - 10;
} else if (c >= 'A' && c <= 'F') {
id -= 'A' - 10;
} else {
LOG_ERR("Invalid hex character '%c' at position %d\n", c, int32_t(i));
return false;
}
boolmask[ n ] = boolmask[ n ] || ((id & 8) != 0);
boolmask[n - 1] = boolmask[n - 1] || ((id & 4) != 0);
boolmask[n - 2] = boolmask[n - 2] || ((id & 2) != 0);
boolmask[n - 3] = boolmask[n - 3] || ((id & 1) != 0);
}
return true;
} | O3 | cpp | parse_cpu_mask(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool (&) [512]):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdx
cmpq $0x2, %rdx
jb 0xf5d84
leaq 0x8(%rsp), %rbx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x220c0
leaq 0x26b86(%rip), %rsi # 0x11c8d7
movq %rbx, %rdi
callq 0x21f50
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xf5d75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21170
xorl %ebx, %ebx
testl %ebp, %ebp
sete %bl
addl %ebx, %ebx
movq 0x8(%r15), %rdx
jmp 0xf5d86
xorl %ebx, %ebx
movq %rdx, %rax
subq %rbx, %rax
movl $0x80, %ecx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movb $0x1, %bpl
cmpq %rbx, %rdx
je 0xf5e3c
movq (%r15), %rcx
leaq (%r14,%rax,4), %rsi
addq $-0x4, %rsi
addq %rbx, %rax
movdqa 0x300c6(%rip), %xmm0 # 0x125e80
movdqa 0x300ce(%rip), %xmm1 # 0x125e90
cmpq %rbx, %rdx
jbe 0xf5e7e
movsbl (%rcx,%rbx), %r14d
leal -0x30(%r14), %edi
cmpb $0xa, %dil
jb 0xf5dfb
leal -0x61(%r14), %edi
cmpb $0x5, %dil
ja 0xf5dea
addb $-0x57, %r14b
jmp 0xf5df8
leal -0x41(%r14), %edi
cmpb $0x5, %dil
ja 0xf5e49
addb $-0x37, %r14b
movl %r14d, %edi
movzbl %dil, %edi
movd (%rsi), %xmm2
punpcklbw %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1,2,2,3,3]
movd %edi, %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pand %xmm0, %xmm3
pcmpeqd %xmm0, %xmm3
por %xmm2, %xmm3
pand %xmm1, %xmm3
packuswb %xmm3, %xmm3
packuswb %xmm3, %xmm3
movd %xmm3, (%rsi)
incq %rbx
addq $-0x4, %rsi
cmpq %rax, %rbx
jb 0xf5dc2
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x70a80(%rip), %rax # 0x1668d0
cmpl $0x0, (%rax)
js 0xf5e7a
callq 0x10ca47
leaq 0x301b5(%rip), %rdx # 0x126016
xorl %ebp, %ebp
movq %rax, %rdi
movl $0x4, %esi
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x10cae4
jmp 0xf5e3c
xorl %ebp, %ebp
jmp 0xf5e3c
leaq 0x30c08(%rip), %rdi # 0x126a8d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21090
| _Z14parse_cpu_maskRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA512_b:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov r15, rdi
mov rdx, [rdi+8]
cmp rdx, 2
jb short loc_F5D84
lea rbx, [rsp+48h+var_40]
mov ecx, 2
mov rdi, rbx
mov rsi, r15
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, aIncompleteUtf8+24h; "0x"
mov rdi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
mov ebp, eax
mov rdi, [rbx]; void *
lea rax, [rsp+48h+var_30]
cmp rdi, rax
jz short loc_F5D75
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F5D75:
xor ebx, ebx
test ebp, ebp
setz bl
add ebx, ebx
mov rdx, [r15+8]
jmp short loc_F5D86
loc_F5D84:
xor ebx, ebx
loc_F5D86:
mov rax, rdx
sub rax, rbx
mov ecx, 80h
cmp rax, rcx
cmovnb rax, rcx
mov bpl, 1
cmp rdx, rbx
jz loc_F5E3C
mov rcx, [r15]
lea rsi, [r14+rax*4]
add rsi, 0FFFFFFFFFFFFFFFCh
add rax, rbx
movdqa xmm0, cs:xmmword_125E80
movdqa xmm1, cs:xmmword_125E90
loc_F5DC2:
cmp rdx, rbx
jbe loc_F5E7E
movsx r14d, byte ptr [rcx+rbx]
lea edi, [r14-30h]
cmp dil, 0Ah
jb short loc_F5DFB
lea edi, [r14-61h]
cmp dil, 5
ja short loc_F5DEA
add r14b, 0A9h
jmp short loc_F5DF8
loc_F5DEA:
lea edi, [r14-41h]
cmp dil, 5
ja short loc_F5E49
add r14b, 0C9h
loc_F5DF8:
mov edi, r14d
loc_F5DFB:
movzx edi, dil
movd xmm2, dword ptr [rsi]
punpcklbw xmm2, xmm2
punpcklwd xmm2, xmm2
movd xmm3, edi
pshufd xmm3, xmm3, 0
pand xmm3, xmm0
pcmpeqd xmm3, xmm0
por xmm3, xmm2
pand xmm3, xmm1
packuswb xmm3, xmm3
packuswb xmm3, xmm3
movd dword ptr [rsi], xmm3
inc rbx
add rsi, 0FFFFFFFFFFFFFFFCh
cmp rbx, rax
jb short loc_F5DC2
loc_F5E3C:
mov eax, ebp
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_F5E49:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_F5E7A
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aInvalidHexChar; "Invalid hex character '%c' at position "...
xor ebp, ebp
mov rdi, rax
mov esi, 4
mov ecx, r14d
mov r8d, ebx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp short loc_F5E3C
loc_F5E7A:
xor ebp, ebp
jmp short loc_F5E3C
loc_F5E7E:
lea rdi, aBasicStringAtN; "basic_string::at: __n (which is %zu) >="...
mov rsi, rbx
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
| long long parse_cpu_mask(long long *a1, long long a2)
{
unsigned int v2; // ebp
unsigned long long v3; // rdx
unsigned long long v4; // rbx
long long v5; // rax
long long v6; // rcx
unsigned int *v7; // rsi
unsigned long long v8; // rax
__m128i si128; // xmm0
__m128i v10; // xmm1
int v11; // r14d
unsigned __int8 v12; // di
unsigned __int8 v13; // r14
__m128i v14; // xmm2
__m128i v15; // xmm2
__m128i v16; // xmm3
__m128i v17; // xmm3
int v19; // eax
int v20; // r9d
void *v21[2]; // [rsp+8h] [rbp-40h] BYREF
long long v22; // [rsp+18h] [rbp-30h] BYREF
v3 = a1[1];
if ( v3 < 2 )
{
v4 = 0LL;
}
else
{
std::string::substr(v21, a1, 0LL, 2LL);
v2 = std::string::compare(v21, "0x");
if ( v21[0] != &v22 )
operator delete(v21[0], v22 + 1);
v4 = 2 * (unsigned int)(v2 == 0);
v3 = a1[1];
}
v5 = v3 - v4;
if ( v3 - v4 >= 0x80 )
v5 = 128LL;
LOBYTE(v2) = 1;
if ( v3 != v4 )
{
v6 = *a1;
v7 = (unsigned int *)(a2 + 4 * v5 - 4);
v8 = v4 + v5;
si128 = _mm_load_si128((const __m128i *)&xmmword_125E80);
v10 = _mm_load_si128((const __m128i *)&xmmword_125E90);
do
{
if ( v3 <= v4 )
std::__throw_out_of_range_fmt("basic_string::at: __n (which is %zu) >= this->size() (which is %zu)", v4, v3);
v11 = *(char *)(v6 + v4);
v12 = *(_BYTE *)(v6 + v4) - 48;
if ( v12 >= 0xAu )
{
if ( (unsigned __int8)(v11 - 97) > 5u )
{
if ( (unsigned __int8)(v11 - 65) > 5u )
{
if ( common_log_verbosity_thold < 0 )
{
return 0;
}
else
{
v19 = common_log_main();
v2 = 0;
common_log_add(v19, 4, (unsigned int)"Invalid hex character '%c' at position %d\n", v11, v4, v20);
}
return v2;
}
v13 = v11 - 55;
}
else
{
v13 = v11 - 87;
}
v12 = v13;
}
v14 = _mm_cvtsi32_si128(*v7);
v15 = _mm_unpacklo_epi8(v14, v14);
v16 = _mm_and_si128(
_mm_or_si128(
_mm_cmpeq_epi32(_mm_and_si128(_mm_shuffle_epi32(_mm_cvtsi32_si128(v12), 0), si128), si128),
_mm_unpacklo_epi16(v15, v15)),
v10);
v17 = _mm_packus_epi16(v16, v16);
*v7 = _mm_cvtsi128_si32(_mm_packus_epi16(v17, v17));
++v4;
--v7;
}
while ( v4 < v8 );
}
return v2;
}
| parse_cpu_mask:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV R15,RDI
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,0x2
JC 0x001f5d84
LEA RBX,[RSP + 0x8]
MOV ECX,0x2
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL 0x001220c0
LEA RSI,[0x21c8d7]
MOV RDI,RBX
CALL 0x00121f50
MOV EBP,EAX
MOV RDI,qword ptr [RBX]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001f5d75
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00121170
LAB_001f5d75:
XOR EBX,EBX
TEST EBP,EBP
SETZ BL
ADD EBX,EBX
MOV RDX,qword ptr [R15 + 0x8]
JMP 0x001f5d86
LAB_001f5d84:
XOR EBX,EBX
LAB_001f5d86:
MOV RAX,RDX
SUB RAX,RBX
MOV ECX,0x80
CMP RAX,RCX
CMOVNC RAX,RCX
MOV BPL,0x1
CMP RDX,RBX
JZ 0x001f5e3c
MOV RCX,qword ptr [R15]
LEA RSI,[R14 + RAX*0x4]
ADD RSI,-0x4
ADD RAX,RBX
MOVDQA XMM0,xmmword ptr [0x00225e80]
MOVDQA XMM1,xmmword ptr [0x00225e90]
LAB_001f5dc2:
CMP RDX,RBX
JBE 0x001f5e7e
MOVSX R14D,byte ptr [RCX + RBX*0x1]
LEA EDI,[R14 + -0x30]
CMP DIL,0xa
JC 0x001f5dfb
LEA EDI,[R14 + -0x61]
CMP DIL,0x5
JA 0x001f5dea
ADD R14B,0xa9
JMP 0x001f5df8
LAB_001f5dea:
LEA EDI,[R14 + -0x41]
CMP DIL,0x5
JA 0x001f5e49
ADD R14B,0xc9
LAB_001f5df8:
MOV EDI,R14D
LAB_001f5dfb:
MOVZX EDI,DIL
MOVD XMM2,dword ptr [RSI]
PUNPCKLBW XMM2,XMM2
PUNPCKLWD XMM2,XMM2
MOVD XMM3,EDI
PSHUFD XMM3,XMM3,0x0
PAND XMM3,XMM0
PCMPEQD XMM3,XMM0
POR XMM3,XMM2
PAND XMM3,XMM1
PACKUSWB XMM3,XMM3
PACKUSWB XMM3,XMM3
MOVD dword ptr [RSI],XMM3
INC RBX
ADD RSI,-0x4
CMP RBX,RAX
JC 0x001f5dc2
LAB_001f5e3c:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001f5e49:
LEA RAX,[0x2668d0]
CMP dword ptr [RAX],0x0
JS 0x001f5e7a
CALL 0x0020ca47
LEA RDX,[0x226016]
XOR EBP,EBP
MOV RDI,RAX
MOV ESI,0x4
MOV ECX,R14D
MOV R8D,EBX
XOR EAX,EAX
CALL 0x0020cae4
JMP 0x001f5e3c
LAB_001f5e7a:
XOR EBP,EBP
JMP 0x001f5e3c
LAB_001f5e7e:
LEA RDI,[0x226a8d]
MOV RSI,RBX
XOR EAX,EAX
CALL 0x00121090
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* parse_cpu_mask(std::__cxx11::string const&, bool (&) [512]) */
ulong parse_cpu_mask(string *param_1,bool *param_2)
{
char cVar1;
long lVar2;
char cVar3;
short sVar6;
short sVar7;
short sVar8;
ulong uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
uint uVar12;
ulong uVar13;
int8 uVar14;
ulong uVar15;
ulong uVar16;
ulong unaff_RBP;
ulong uVar17;
bool *pbVar18;
byte bVar19;
int1 uVar23;
int1 auVar20 [16];
short sVar25;
int1 auVar28 [16];
int1 auVar29 [16];
int1 auVar30 [16];
long *local_40 [2];
long local_30 [2];
char cVar4;
char cVar5;
int1 auVar21 [16];
int1 auVar22 [16];
int2 uVar24;
int4 uVar26;
int6 uVar27;
uVar15 = *(ulong *)(param_1 + 8);
if (uVar15 < 2) {
uVar16 = 0;
}
else {
std::__cxx11::string::substr((ulong)local_40,(ulong)param_1);
uVar12 = std::__cxx11::string::compare((char *)local_40);
unaff_RBP = (ulong)uVar12;
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
uVar16 = (ulong)((uint)(uVar12 == 0) * 2);
uVar15 = *(ulong *)(param_1 + 8);
}
auVar11 = _DAT_00225e90;
auVar10 = _DAT_00225e80;
uVar13 = uVar15 - uVar16;
if (0x7f < uVar13) {
uVar13 = 0x80;
}
uVar17 = CONCAT71((int7)(unaff_RBP >> 8),1);
if (uVar15 != uVar16) {
lVar2 = *(long *)param_1;
pbVar18 = param_2 + uVar13 * 4;
uVar13 = uVar13 + uVar16;
do {
pbVar18 = pbVar18 + -4;
if (uVar15 <= uVar16) {
uVar15 = std::__throw_out_of_range_fmt
("basic_string::at: __n (which is %zu) >= this->size() (which is %zu)",
uVar16);
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar14 = common_log_main();
common_log_add(uVar14,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,
LLAMA_COMMIT,LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return uVar15;
}
cVar1 = *(char *)(lVar2 + uVar16);
bVar19 = cVar1 - 0x30;
if (9 < bVar19) {
if ((byte)(cVar1 + 0x9fU) < 6) {
bVar19 = cVar1 + 0xa9;
}
else {
if (5 < (byte)(cVar1 + 0xbfU)) {
if (common_log_verbosity_thold < 0) {
uVar17 = 0;
}
else {
uVar14 = common_log_main();
uVar17 = 0;
common_log_add(uVar14,4,"Invalid hex character \'%c\' at position %d\n",(int)cVar1,
uVar16 & 0xffffffff);
}
break;
}
bVar19 = cVar1 - 0x37;
}
}
uVar26 = *(int4 *)pbVar18;
uVar23 = (int1)((uint)uVar26 >> 0x18);
uVar24 = CONCAT11(uVar23,uVar23);
uVar23 = (int1)((uint)uVar26 >> 0x10);
uVar14 = CONCAT35(CONCAT21(uVar24,uVar23),CONCAT14(uVar23,uVar26));
uVar23 = (int1)((uint)uVar26 >> 8);
uVar27 = CONCAT51(CONCAT41((int)((ulong)uVar14 >> 0x20),uVar23),uVar23);
auVar30._0_2_ = CONCAT11((char)uVar26,(char)uVar26);
uVar9 = CONCAT62(uVar27,auVar30._0_2_);
auVar22._8_4_ = 0;
auVar22._0_8_ = uVar9;
auVar22._12_2_ = uVar24;
auVar22._14_2_ = uVar24;
uVar24 = (int2)((ulong)uVar14 >> 0x20);
auVar21._12_4_ = auVar22._12_4_;
auVar21._8_2_ = 0;
auVar21._0_8_ = uVar9;
auVar21._10_2_ = uVar24;
auVar20._10_6_ = auVar21._10_6_;
auVar20._8_2_ = uVar24;
auVar20._0_8_ = uVar9;
uVar24 = (int2)uVar27;
auVar30._8_8_ = auVar20._8_8_;
auVar30._6_2_ = uVar24;
auVar30._4_2_ = uVar24;
auVar30._2_2_ = auVar30._0_2_;
auVar28._1_3_ = 0;
auVar28[0] = bVar19;
auVar28[4] = bVar19;
auVar28._5_3_ = 0;
auVar28[8] = bVar19;
auVar28._9_3_ = 0;
auVar28[0xc] = bVar19;
auVar28._13_3_ = 0;
auVar28 = auVar28 & auVar10;
auVar29._0_4_ = -(uint)(auVar28._0_4_ == auVar10._0_4_);
auVar29._4_4_ = -(uint)(auVar28._4_4_ == auVar10._4_4_);
auVar29._8_4_ = -(uint)(auVar28._8_4_ == auVar10._8_4_);
auVar29._12_4_ = -(uint)(auVar28._12_4_ == auVar10._12_4_);
auVar30 = (auVar29 | auVar30) & auVar11;
sVar6 = auVar30._0_2_;
cVar1 = (0 < sVar6) * (sVar6 < 0x100) * auVar30[0] - (0xff < sVar6);
sVar6 = auVar30._2_2_;
sVar25 = CONCAT11((0 < sVar6) * (sVar6 < 0x100) * auVar30[2] - (0xff < sVar6),cVar1);
sVar6 = auVar30._4_2_;
cVar3 = (0 < sVar6) * (sVar6 < 0x100) * auVar30[4] - (0xff < sVar6);
sVar6 = auVar30._6_2_;
uVar26 = CONCAT13((0 < sVar6) * (sVar6 < 0x100) * auVar30[6] - (0xff < sVar6),
CONCAT12(cVar3,sVar25));
sVar6 = auVar30._8_2_;
cVar4 = (0 < sVar6) * (sVar6 < 0x100) * auVar30[8] - (0xff < sVar6);
sVar6 = auVar30._10_2_;
uVar27 = CONCAT15((0 < sVar6) * (sVar6 < 0x100) * auVar30[10] - (0xff < sVar6),
CONCAT14(cVar4,uVar26));
sVar6 = auVar30._12_2_;
cVar5 = (0 < sVar6) * (sVar6 < 0x100) * auVar30[0xc] - (0xff < sVar6);
sVar8 = auVar30._14_2_;
sVar6 = (short)((uint)uVar26 >> 0x10);
sVar7 = (short)((uint6)uVar27 >> 0x20);
sVar8 = (short)(CONCAT17((0 < sVar8) * (sVar8 < 0x100) * auVar30[0xe] - (0xff < sVar8),
CONCAT16(cVar5,uVar27)) >> 0x30);
*(uint *)pbVar18 =
CONCAT13((0 < sVar8) * (sVar8 < 0x100) * cVar5 - (0xff < sVar8),
CONCAT12((0 < sVar7) * (sVar7 < 0x100) * cVar4 - (0xff < sVar7),
CONCAT11((0 < sVar6) * (sVar6 < 0x100) * cVar3 - (0xff < sVar6),
(0 < sVar25) * (sVar25 < 0x100) * cVar1 - (0xff < sVar25))));
uVar16 = uVar16 + 1;
} while (uVar16 < uVar13);
}
return uVar17 & 0xffffffff;
}
| |
31,217 | my_scan_8bit | eloqsql/strings/ctype-simple.c | size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
} | O0 | c | my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x597e7
jmp 0x597c8
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x59858
jmp 0x597d6
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x598a3
jmp 0x598ee
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5984b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x35(%rbp)
je 0x5981e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x59827
jmp 0x59837
jmp 0x59829
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x597ff
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x598f6
movq $0x0, -0x8(%rbp)
jmp 0x598f6
jmp 0x5985a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x59892
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x59882
jmp 0x59892
jmp 0x59884
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5985a
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x598f6
jmp 0x598a5
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x598dd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x598cd
jmp 0x598dd
jmp 0x598cf
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x598a5
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x598f6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| my_scan_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 rax, [rbp+var_18]
mov [rbp+var_30], rax
mov eax, [rbp+var_24]
mov [rbp+var_34], eax
sub eax, 1
jz short loc_597E7
jmp short $+2
loc_597C8:
mov eax, [rbp+var_34]
sub eax, 2
jz loc_59858
jmp short $+2
loc_597D6:
mov eax, [rbp+var_34]
sub eax, 3
jz loc_598A3
jmp loc_598EE
loc_597E7:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz short loc_5984B
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
loc_597FF:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_35], al
jz short loc_5981E
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
setz al
mov [rbp+var_35], al
loc_5981E:
mov al, [rbp+var_35]
test al, 1
jnz short loc_59827
jmp short loc_59837
loc_59827:
jmp short $+2
loc_59829:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_597FF
loc_59837:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp loc_598F6
loc_5984B:
mov [rbp+var_8], 0
jmp loc_598F6
loc_59858:
jmp short $+2
loc_5985A:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_59892
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jnz short loc_59882
jmp short loc_59892
loc_59882:
jmp short $+2
loc_59884:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_5985A
loc_59892:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_598F6
loc_598A3:
jmp short $+2
loc_598A5:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_598DD
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_598CD
jmp short loc_598DD
loc_598CD:
jmp short $+2
loc_598CF:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_598A5
loc_598DD:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_598F6
loc_598EE:
mov [rbp+var_8], 0
loc_598F6:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
bool v5; // [rsp+1h] [rbp-35h]
unsigned __int8 *v6; // [rsp+1Eh] [rbp-18h]
unsigned __int8 *i; // [rsp+1Eh] [rbp-18h]
v6 = a2;
switch ( a4 )
{
case 1:
if ( *a2 == 46 )
{
for ( i = a2 + 1; ; ++i )
{
v5 = 0;
if ( i != a3 )
v5 = *i == 48;
if ( !v5 )
break;
}
return i - a2;
}
else
{
return 0LL;
}
case 2:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) != 0 )
++v6;
return v6 - a2;
case 3:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) == 0 )
++v6;
return v6 - a2;
default:
return 0LL;
}
}
| my_scan_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 RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x34],EAX
SUB EAX,0x1
JZ 0x001597e7
JMP 0x001597c8
LAB_001597c8:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x2
JZ 0x00159858
JMP 0x001597d6
LAB_001597d6:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x3
JZ 0x001598a3
JMP 0x001598ee
LAB_001597e7:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x0015984b
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
LAB_001597ff:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x35],AL
JZ 0x0015981e
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
SETZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0015981e:
MOV AL,byte ptr [RBP + -0x35]
TEST AL,0x1
JNZ 0x00159827
JMP 0x00159837
LAB_00159827:
JMP 0x00159829
LAB_00159829:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001597ff
LAB_00159837:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001598f6
LAB_0015984b:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001598f6
LAB_00159858:
JMP 0x0015985a
LAB_0015985a:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00159892
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JNZ 0x00159882
JMP 0x00159892
LAB_00159882:
JMP 0x00159884
LAB_00159884:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0015985a
LAB_00159892:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001598f6
LAB_001598a3:
JMP 0x001598a5
LAB_001598a5:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001598dd
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001598cd
JMP 0x001598dd
LAB_001598cd:
JMP 0x001598cf
LAB_001598cf:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001598a5
LAB_001598dd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001598f6
LAB_001598ee:
MOV qword ptr [RBP + -0x8],0x0
LAB_001598f6:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
bool bVar1;
byte *local_20;
long local_10;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
local_20 = param_2 + 1;
while( true ) {
bVar1 = false;
if (local_20 != param_3) {
bVar1 = *local_20 == 0x30;
}
if (!bVar1) break;
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
else {
local_20 = param_2;
if (param_4 == 2) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) != 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else if (param_4 == 3) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) == 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
return local_10;
}
| |
31,218 | mysql_fetch_row_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_fetch_row_cont(MYSQL_ROW *ret, MYSQL_RES *result, int ready_status)
{
MK_ASYNC_CONT_BODY(
result->handle,
NULL,
r_ptr)
} | O3 | c | mysql_fetch_row_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x2ca98
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x31297
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2caff
movl (%r15), %r15d
jmp 0x2cb74
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x78(%r14), %rdi
leaq 0x222de(%rip), %rax # 0x4ed90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x78(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x78(%r14), %rdi
leaq 0x222c3(%rip), %rax # 0x4eda0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x78(%r14), %rax
movb %r15b, 0x296(%rax)
movq $0x0, (%rbx)
jmp 0x2cb74
movb $0x0, 0x15(%r15)
js 0x2cb0c
movq 0x8(%r15), %r15
jmp 0x2cb6e
movq 0x78(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x78(%r14), %rdi
leaq 0x22266(%rip), %rax # 0x4ed90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x78(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x78(%r14), %rdi
leaq 0x2224b(%rip), %rax # 0x4eda0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x78(%r14), %rax
movb %r15b, 0x296(%rax)
movq %r15, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_fetch_row_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+78h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2CA98
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_2CAFF
mov r15d, [r15]
jmp loc_2CB74
loc_2CA98:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+78h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+78h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+78h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+78h]
mov [rax+296h], r15b
mov qword ptr [rbx], 0
jmp short loc_2CB74
loc_2CAFF:
mov byte ptr [r15+15h], 0
js short loc_2CB0C
mov r15, [r15+8]
jmp short loc_2CB6E
loc_2CB0C:
mov rax, [r14+78h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+78h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+78h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+78h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+78h]
mov [rax+296h], r15b
loc_2CB6E:
mov [rbx], r15
xor r15d, r15d
loc_2CB74:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_fetch_row_cont(_QWORD *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
long long v7; // r15
v3 = *(_QWORD *)(a2 + 120);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 120) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 120) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v7 = 0LL;
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 120) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 662LL) = 0;
}
else
{
v7 = *((_QWORD *)v4 + 1);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 120) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 120) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 662LL) = 0;
*a1 = 0LL;
}
return v6;
}
| mysql_fetch_row_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x78]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012ca98
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x00131297
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012caff
MOV R15D,dword ptr [R15]
JMP 0x0012cb74
LAB_0012ca98:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14ed90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14eda0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
MOV byte ptr [RAX + 0x296],R15B
MOV qword ptr [RBX],0x0
JMP 0x0012cb74
LAB_0012caff:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0012cb0c
MOV R15,qword ptr [R15 + 0x8]
JMP 0x0012cb6e
LAB_0012cb0c:
MOV RAX,qword ptr [R14 + 0x78]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14ed90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14eda0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
MOV byte ptr [RAX + 0x296],R15B
LAB_0012cb6e:
MOV qword ptr [RBX],R15
XOR R15D,R15D
LAB_0012cb74:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_fetch_row_cont(int8 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
int8 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x78) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x78) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x297),SQLSTATE_UNKNOWN,5);
uVar3 = 0;
*(int1 *)(*(long *)(param_2 + 0x78) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0014ee10,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x78) + 0x296) = 0;
*param_1 = 0;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar2 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar2 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x78) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x78) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x97),PTR_s_Client_run_out_of_memory_0014ede0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x78) + 0x296) = 0;
}
else {
uVar4 = *(int8 *)(puVar1 + 2);
}
*param_1 = uVar4;
uVar3 = 0;
}
else {
uVar3 = *puVar1;
}
}
return uVar3;
}
| |
31,219 | my_once_alloc | eloqsql/mysys/my_once.c | void* my_once_alloc(size_t Size, myf MyFlags)
{
size_t get_size, max_left;
uchar* point;
reg1 USED_MEM *next;
reg2 USED_MEM **prev;
Size= ALIGN_SIZE(Size);
prev= &my_once_root_block;
max_left=0;
for (next=my_once_root_block ; next && next->left < Size ; next= next->next)
{
if (next->left > max_left)
max_left=next->left;
prev= &next->next;
}
if (! next)
{ /* Time to alloc new block */
get_size= Size+ALIGN_SIZE(sizeof(USED_MEM));
if (max_left*4 < my_once_extra && get_size < my_once_extra)
get_size=my_once_extra; /* Normal alloc */
if ((next = (USED_MEM*) malloc(get_size)) == 0)
{
my_errno=errno;
if (MyFlags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_FATAL), get_size);
return((uchar*) 0);
}
DBUG_PRINT("test",("my_once_malloc %lu byte malloced", (ulong) get_size));
next->next= 0;
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next;
}
point= (uchar*) ((char*) next+ (next->size-next->left));
next->left-= Size;
if (MyFlags & MY_ZEROFILL)
bzero(point, Size);
return((void*) point);
} | O0 | c | my_once_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
leaq 0xb8e745(%rip), %rax # 0xc81c20
movq %rax, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0xb8e732(%rip), %rax # 0xc81c20
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
je 0xf3513
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xf351c
jmp 0xf354b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0xf3536
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xf34f5
cmpq $0x0, -0x38(%rbp)
jne 0xf3624
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x2, %rax
leaq 0x1cb63f(%rip), %rcx # 0x2bebb0
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xf3597
movq -0x20(%rbp), %rax
leaq 0x1cb62d(%rip), %rcx # 0x2bebb0
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0xf3597
leaq 0x1cb61f(%rip), %rax # 0x2bebb0
movl (%rax), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2a6b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xf35ee
callq 0x2a740
movl (%rax), %eax
movl %eax, -0x48(%rbp)
callq 0xf55f0
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xf35e1
movq -0x20(%rbp), %rdx
movl $0x5, %edi
movl $0x1004, %esi # imm = 0x1004
movb $0x0, %al
callq 0xef140
movq $0x0, -0x8(%rbp)
jmp 0xf3677
jmp 0xf35f0
jmp 0xf35f2
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
subq $0x18, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x38(%rbp), %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0xf366f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2a2b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_once_alloc:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
lea rax, my_once_root_block
mov [rbp+var_40], rax
mov [rbp+var_28], 0
lea rax, my_once_root_block
mov rax, [rax]
mov [rbp+var_38], rax
loc_F34F5:
xor eax, eax
cmp [rbp+var_38], 0
mov [rbp+var_41], al
jz short loc_F3513
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_10]
setb al
mov [rbp+var_41], al
loc_F3513:
mov al, [rbp+var_41]
test al, 1
jnz short loc_F351C
jmp short loc_F354B
loc_F351C:
mov rax, [rbp+var_38]
mov rax, [rax+8]
cmp rax, [rbp+var_28]
jbe short loc_F3536
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_F3536:
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_F34F5
loc_F354B:
cmp [rbp+var_38], 0
jnz loc_F3624
mov rax, [rbp+var_10]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
shl rax, 2
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_F3597
mov rax, [rbp+var_20]
lea rcx, my_once_extra
mov ecx, [rcx]
cmp rax, rcx
jnb short loc_F3597
lea rax, my_once_extra
mov eax, [rax]
mov [rbp+var_20], rax
loc_F3597:
mov rdi, [rbp+var_20]
call _malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_F35EE
call ___errno_location
mov eax, [rax]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 18h
cmp rax, 0
jz short loc_F35E1
mov rdx, [rbp+var_20]
mov edi, 5
mov esi, 1004h
mov al, 0
call my_error
loc_F35E1:
mov [rbp+var_8], 0
jmp loc_F3677
loc_F35EE:
jmp short $+2
loc_F35F0:
jmp short $+2
loc_F35F2:
mov rax, [rbp+var_38]
mov qword ptr [rax], 0
mov rcx, [rbp+var_20]
mov rax, [rbp+var_38]
mov [rax+10h], rcx
mov rcx, [rbp+var_20]
sub rcx, 18h
mov rax, [rbp+var_38]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov [rax], rcx
loc_F3624:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_38]
mov rcx, [rcx+10h]
mov rdx, [rbp+var_38]
sub rcx, [rdx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rdx, [rbp+var_10]
mov rax, [rbp+var_38]
mov rcx, [rax+8]
sub rcx, rdx
mov [rax+8], rcx
mov rax, [rbp+var_18]
and rax, 20h
cmp rax, 0
jz short loc_F366F
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
xor esi, esi
call _memset
loc_F366F:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_F3677:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| char * my_once_alloc(long long a1, char a2, double a3)
{
int v4; // [rsp+8h] [rbp-48h]
bool v5; // [rsp+Fh] [rbp-41h]
_QWORD *v6; // [rsp+10h] [rbp-40h]
_QWORD *i; // [rsp+18h] [rbp-38h]
char *v8; // [rsp+20h] [rbp-30h]
unsigned long long v9; // [rsp+28h] [rbp-28h]
unsigned long long v10; // [rsp+30h] [rbp-20h]
unsigned long long v11; // [rsp+40h] [rbp-10h]
v11 = (a1 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v6 = &my_once_root_block;
v9 = 0LL;
for ( i = (_QWORD *)my_once_root_block; ; i = (_QWORD *)*i )
{
v5 = 0;
if ( i )
v5 = i[1] < v11;
if ( !v5 )
break;
if ( i[1] > v9 )
v9 = i[1];
v6 = i;
}
if ( !i )
{
v10 = v11 + 24;
if ( 4 * v9 < my_once_extra && v10 < my_once_extra )
v10 = my_once_extra;
i = (_QWORD *)malloc(v10);
if ( !i )
{
v4 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a3) = v4;
if ( (a2 & 0x18) != 0 )
my_error(5u, 4100LL, v10);
return 0LL;
}
*i = 0LL;
i[2] = v10;
i[1] = v10 - 24;
*v6 = i;
}
v8 = (char *)i + i[2] - i[1];
i[1] -= v11;
if ( (a2 & 0x20) != 0 )
memset(v8, 0LL, v11);
return v8;
}
| my_once_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0xd81c20]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x28],0x0
LEA RAX,[0xd81c20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_001f34f5:
XOR EAX,EAX
CMP qword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x41],AL
JZ 0x001f3513
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
MOV byte ptr [RBP + -0x41],AL
LAB_001f3513:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001f351c
JMP 0x001f354b
LAB_001f351c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001f3536
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f3536:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001f34f5
LAB_001f354b:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001f3624
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x2
LEA RCX,[0x3bebb0]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x001f3597
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x3bebb0]
MOV ECX,dword ptr [RCX]
CMP RAX,RCX
JNC 0x001f3597
LEA RAX,[0x3bebb0]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001f3597:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012a6b0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001f35ee
CALL 0x0012a740
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x001f55f0
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001f35e1
MOV RDX,qword ptr [RBP + -0x20]
MOV EDI,0x5
MOV ESI,0x1004
MOV AL,0x0
CALL 0x001ef140
LAB_001f35e1:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f3677
LAB_001f35ee:
JMP 0x001f35f0
LAB_001f35f0:
JMP 0x001f35f2
LAB_001f35f2:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x20]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
LAB_001f3624:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x10]
MOV RDX,qword ptr [RBP + -0x38]
SUB RCX,qword ptr [RDX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x20
CMP RAX,0x0
JZ 0x001f366f
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x0012a2b0
LAB_001f366f:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f3677:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
void * my_once_alloc(long param_1,ulong param_2)
{
int iVar1;
ulong __n;
int *piVar2;
void *__s;
bool bVar3;
int8 *local_48;
int8 *local_40;
ulong local_30;
size_t local_28;
__n = param_1 + 7U & 0xfffffffffffffff8;
local_48 = &my_once_root_block;
local_30 = 0;
local_40 = my_once_root_block;
while( true ) {
bVar3 = false;
if (local_40 != (int8 *)0x0) {
bVar3 = (ulong)local_40[1] < __n;
}
if (!bVar3) break;
if (local_30 < (ulong)local_40[1]) {
local_30 = local_40[1];
}
local_48 = local_40;
local_40 = (int8 *)*local_40;
}
if (local_40 == (int8 *)0x0) {
local_28 = __n + 0x18;
if ((local_30 << 2 < (ulong)my_once_extra) && (local_28 < my_once_extra)) {
local_28 = (size_t)my_once_extra;
}
local_40 = (int8 *)malloc(local_28);
if (local_40 == (int8 *)0x0) {
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_2 & 0x18) != 0) {
my_error(5,0x1004,local_28);
}
return (void *)0x0;
}
*local_40 = 0;
local_40[2] = local_28;
local_40[1] = local_28 - 0x18;
*local_48 = local_40;
}
__s = (void *)((long)local_40 + (local_40[2] - local_40[1]));
local_40[1] = local_40[1] - __n;
if ((param_2 & 0x20) != 0) {
memset(__s,0,__n);
}
return __s;
}
| |
31,220 | process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | llama.cpp/common/chat.cpp | static common_chat_tool_call process_tool_call(const json & tool_call) {
const auto & arguments = tool_call.at("arguments");
return {
/* .name = */ tool_call.at("name"),
/* .arguments = */ arguments.is_string() ? arguments.get<std::string>() : arguments.dump(),
/* .id = */ tool_call.contains("id") ? tool_call.at("id") : "",
};
} | O3 | cpp | process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x73d13(%rip), %rsi # 0x12301c
movq %r14, %rdi
callq 0xb40c4
movq %rax, %r15
leaq 0x760c5(%rip), %rsi # 0x1253e0
movq %r14, %rdi
callq 0xb371c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc2dba
leaq 0x20(%rbx), %rdi
cmpb $0x3, (%r15)
jne 0xaf342
movq %r15, %rsi
callq 0xc2dba
jmp 0xaf35a
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xb3302
leaq 0x72df8(%rip), %rsi # 0x122159
movq %r14, %rdi
callq 0xb4288
testb %al, %al
je 0xaf389
leaq 0x72de5(%rip), %rsi # 0x122159
movq %r14, %rdi
callq 0xb42ea
movq %rsp, %rdi
movq %rax, %rsi
callq 0x8ccc4
jmp 0xaf398
leaq 0x73841(%rip), %rsi # 0x122bd1
movq %rsp, %rdi
callq 0xd28b2
leaq 0x40(%rbx), %rdi
movq %rsp, %rsi
callq 0xc2dba
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x88a76
movq %rbx, %rdi
callq 0x8d190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x88a76
movq %r15, %rdi
callq 0x8d190
jmp 0xaf3e5
movq %rax, %r14
jmp 0xaf3fd
movq %rax, %r14
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xaf3fd
movq (%rax), %rsi
incq %rsi
callq 0x20180
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xaf414
movq (%rbx), %rsi
incq %rsi
callq 0x20180
movq %r14, %rdi
callq 0x20b50
| _ZL17process_tool_callRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEE:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
lea rsi, aKeywordArgumen+9; "arguments"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov r15, rax
lea rsi, aNamespacedSetO+2Fh; "name"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov rdi, rbx
mov rsi, rax
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
lea rdi, [rbx+20h]
cmp byte ptr [r15], 3
jnz short loc_AF342
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
jmp short loc_AF35A
loc_AF342:
mov rsi, r15
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; 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(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
loc_AF35A:
lea rsi, aToolCallId+0Ah; "id"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz short loc_AF389
lea rsi, aToolCallId+0Ah; "id"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov rdi, rsp
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_AF398
loc_AF389:
lea rsi, aExampleToolCal+1Dh; ""
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
loc_AF398:
lea rdi, [rbx+40h]
mov rsi, rsp
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov r15, rsp
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_AF3E5
mov r14, rax
jmp short loc_AF3FD
mov r14, rax
loc_AF3E5:
mov rdi, [rbx+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_AF3FD
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF3FD:
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_AF414
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AF414:
mov rdi, r14
call __Unwind_Resume
| long long process_tool_call(long long a1, long long a2)
{
_BYTE *v3; // r15
long long v4; // rax
long long v5; // rdi
unsigned __int8 *v6; // rax
unsigned __int8 v8[40]; // [rsp+0h] [rbp-28h] BYREF
v3 = (_BYTE *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"arguments");
v4 = ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"name");
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1,
v4);
v5 = a1 + 32;
if ( *v3 == 3 )
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
v5,
v3);
else
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(
v5,
(_DWORD)v3,
-1,
32,
0,
0);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
a2,
"id") )
{
v6 = (unsigned __int8 *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"id");
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v8,
v6);
}
else
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_(
v8,
"");
}
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1 + 64,
v8);
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 *)v8);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v8);
}
| process_tool_call:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x22301c]
MOV RDI,R14
CALL 0x001b40c4
MOV R15,RAX
LEA RSI,[0x2253e0]
MOV RDI,R14
CALL 0x001b371c
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001c2dba
LEA RDI,[RBX + 0x20]
CMP byte ptr [R15],0x3
JNZ 0x001af342
LAB_001af338:
MOV RSI,R15
CALL 0x001c2dba
JMP 0x001af35a
LAB_001af342:
MOV RSI,R15
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001b3302
LAB_001af35a:
LEA RSI,[0x222159]
MOV RDI,R14
CALL 0x001b4288
TEST AL,AL
JZ 0x001af389
LEA RSI,[0x222159]
MOV RDI,R14
CALL 0x001b42ea
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0018ccc4
JMP 0x001af398
LAB_001af389:
LEA RSI,[0x222bd1]
MOV RDI,RSP
CALL 0x001d28b2
LAB_001af398:
LEA RDI,[RBX + 0x40]
LAB_001af39c:
MOV RSI,RSP
CALL 0x001c2dba
LAB_001af3a4:
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00188a76
MOV RDI,RBX
CALL 0x0018d190
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
void process_tool_call(basic_json *param_1)
{
char *pcVar1;
int8 uVar2;
basic_json *pbVar3;
char cVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_28 [16];
pcVar1 = (char *)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
uVar2 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1,uVar2);
if (*pcVar1 == '\x03') {
/* try { // try from 001af338 to 001af359 has its CatchHandler @ 001af3dd */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1 + 0x20,pcVar1);
}
else {
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(param_1 + 0x20,pcVar1,0xffffffff,0x20,0,0);
}
/* try { // try from 001af35a to 001af397 has its CatchHandler @ 001af3e2 */
cVar4 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
();
if (cVar4 == '\0') {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
(abStack_28,"");
}
else {
pbVar3 = (basic_json *)
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(abStack_28,pbVar3);
}
/* try { // try from 001af39c to 001af3a3 has its CatchHandler @ 001af3c3 */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1 + 0x40,abStack_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(abStack_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)abStack_28);
return;
}
| |
31,221 | ma_apply_redo_insert_row_head_or_tail | eloqsql/storage/maria/ma_blockrec.c | uint _ma_apply_redo_insert_row_head_or_tail(MARIA_HA *info, LSN lsn,
uint page_type,
my_bool new_page,
const uchar *header,
const uchar *data,
size_t data_length)
{
MARIA_SHARE *share= info->s;
pgcache_page_no_t page;
uint rownr, empty_space;
uint block_size= share->block_size;
uint rec_offset;
uchar *buff, *dir;
uint result;
MARIA_PINNED_PAGE page_link;
enum pagecache_page_lock lock_method;
enum pagecache_page_pin pin_method;
my_off_t end_of_page;
uint error;
DBUG_ENTER("_ma_apply_redo_insert_row_head_or_tail");
page= page_korr(header);
rownr= dirpos_korr(header + PAGE_STORE_SIZE);
DBUG_PRINT("enter", ("rowid: %lu page: %lu rownr: %u data_length: %u",
(ulong) ma_recordpos(page, rownr),
(ulong) page, rownr, (uint) data_length));
share->state.changed|= (STATE_CHANGED | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
end_of_page= (page + 1) * share->block_size;
if (end_of_page > share->state.state.data_file_length)
{
DBUG_PRINT("info", ("Enlarging data file from %lu to %lu",
(ulong) share->state.state.data_file_length,
(ulong) end_of_page));
/*
New page at end of file. Note that the test above is also positive if
data_file_length is not a multiple of block_size (system crashed while
writing the last page): in this case we just extend the last page and
fill it entirely with zeroes, then the REDO will put correct data on
it.
*/
lock_method= PAGECACHE_LOCK_WRITE;
pin_method= PAGECACHE_PIN;
DBUG_ASSERT(rownr == 0 && new_page);
if (rownr != 0 || !new_page)
goto crashed_file;
buff= info->keyread_buff;
info->keyread_buff_used= 1;
make_empty_page(info, buff, page_type, 1);
empty_space= (block_size - PAGE_OVERHEAD_SIZE(share));
rec_offset= PAGE_HEADER_SIZE(share);
dir= buff+ block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE;
}
else
{
lock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
pin_method= PAGECACHE_PIN_LEFT_PINNED;
share->pagecache->readwrite_flags&= ~MY_WME;
share->silence_encryption_errors= 1;
buff= pagecache_read(share->pagecache, &info->dfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link);
share->pagecache->readwrite_flags= share->pagecache->org_readwrite_flags;
share->silence_encryption_errors= 0;
if (!buff)
{
/* Skip errors when reading outside of file and uninitialized pages */
if (!new_page || (my_errno != HA_ERR_FILE_TOO_SHORT &&
my_errno != HA_ERR_WRONG_CRC &&
my_errno != HA_ERR_DECRYPTION_FAILED))
{
DBUG_PRINT("error", ("Error %d when reading page", (int) my_errno));
goto err;
}
/* Create new page */
buff= pagecache_block_link_to_buffer(page_link.link);
buff[PAGE_TYPE_OFFSET]= UNALLOCATED_PAGE;
}
else if (lsn_korr(buff) >= lsn) /* Test if already applied */
{
check_skipped_lsn(info, lsn_korr(buff), 1, page);
/* Fix bitmap, just in case */
empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
if (!enough_free_entries_on_page(share, buff))
empty_space= 0; /* Page is full */
if (_ma_bitmap_set(info, page, page_type == HEAD_PAGE, empty_space))
goto err;
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(0);
}
if (((uint) (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK) != page_type))
{
/*
This is a page that has been freed before and now should be
changed to new type.
*/
if (!new_page)
{
DBUG_PRINT("error",
("Found page of wrong type: %u, should have been %u",
(uint) (buff[PAGE_TYPE_OFFSET] & PAGE_TYPE_MASK),
page_type));
goto crashed_file;
}
make_empty_page(info, buff, page_type, 0);
empty_space= block_size - PAGE_HEADER_SIZE(share) - PAGE_SUFFIX_SIZE;
(void) extend_directory(info, buff, block_size, 0, rownr, &empty_space,
page_type == HEAD_PAGE);
rec_offset= PAGE_HEADER_SIZE(share);
dir= dir_entry_pos(buff, block_size, rownr);
empty_space+= uint2korr(dir+2);
}
else
{
uint max_entry= (uint) buff[DIR_COUNT_OFFSET];
uint length;
DBUG_ASSERT(!new_page);
dir= dir_entry_pos(buff, block_size, rownr);
empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
if (max_entry <= rownr)
{
/* Add directory entry first in directory and data last on page */
if (extend_directory(info, buff, block_size, max_entry, rownr,
&empty_space, page_type == HEAD_PAGE))
goto crashed_file;
}
if (extend_area_on_page(info, buff, dir, rownr,
(uint) data_length, &empty_space,
&rec_offset, &length, page_type == HEAD_PAGE))
goto crashed_file;
}
}
/* Copy data */
int2store(dir+2, data_length);
memcpy(buff + rec_offset, data, data_length);
empty_space-= (uint) data_length;
int2store(buff + EMPTY_SPACE_OFFSET, empty_space);
/* Fix bitmap */
if (!enough_free_entries_on_page(share, buff))
empty_space= 0; /* Page is full */
if (_ma_bitmap_set(info, page, page_type == HEAD_PAGE, empty_space))
goto err;
/*
If page was not read before, write it but keep it pinned.
We don't update its LSN When we have processed all REDOs for this page
in the current REDO's group, we will stamp page with UNDO's LSN
(if we stamped it now, a next REDO, in
this group, for this page, would be skipped) and unpin then.
*/
result= 0;
if (lock_method == PAGECACHE_LOCK_WRITE &&
pagecache_write(share->pagecache,
&info->dfile, page, 0,
buff, PAGECACHE_PLAIN_PAGE,
lock_method, pin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE))
result= my_errno;
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
/*
Data page and bitmap page are in place, we can update data_file_length in
case we extended the file. We could not do it earlier: bitmap code tests
data_file_length to know if it has to create a new page or not.
*/
set_if_bigger(share->state.state.data_file_length, end_of_page);
DBUG_RETURN(result);
crashed_file:
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
err:
error= my_errno;
if (lock_method == PAGECACHE_LOCK_LEFT_WRITELOCKED)
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
_ma_mark_file_crashed(share);
DBUG_ASSERT(!maria_assert_if_crashed_table); /* catch recovery error early */
DBUG_RETURN((my_errno= error));
} | O3 | c | ma_apply_redo_insert_row_head_or_tail:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r12d
movq %rsi, %r14
movq (%rdi), %rbx
movl 0x7bc(%rbx), %r13d
movl (%r8), %eax
movzbl 0x4(%r8), %ecx
shlq $0x20, %rcx
leaq (%rcx,%rax), %r10
movzbl 0x5(%r8), %r11d
orl $0x181, 0x170(%rbx) # imm = 0x181
leaq (%rcx,%rax), %rsi
incq %rsi
imulq %r13, %rsi
movq 0x40(%rbx), %r8
cmpq %r8, %rsi
jbe 0x5ef23
testl %r11d, %r11d
setne %al
testb %r12b, %r12b
sete %cl
movl $0x4, %r14d
orb %al, %cl
jne 0x5f2d8
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movq %r10, -0x60(%rbp)
movq %rsi, -0x58(%rbp)
movq 0x380(%rdi), %r15
movb $0x1, 0x685(%rdi)
movq %rdi, -0x38(%rbp)
movq %r15, %rsi
movl %edx, -0x30(%rbp)
movl $0x1, %ecx
callq 0x5f36a
movl 0xc18(%rbx), %eax
movl %r13d, %ecx
subl %eax, %ecx
addl $-0x14, %ecx
movl %ecx, -0x2c(%rbp)
addl $0xc, %eax
movl %eax, -0x3c(%rbp)
addq %r15, %r13
addq $-0x8, %r13
movl $0x4, -0x48(%rbp)
movl $0x2, %eax
movq %rax, -0x50(%rbp)
jmp 0x5f1cf
movq %r11, -0x48(%rbp)
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movl %edx, -0x30(%rbp)
movq %rsi, -0x58(%rbp)
movq 0x600(%rbx), %rax
movl $0xffffffef, %ecx # imm = 0xFFFFFFEF
andq %rcx, 0x198(%rax)
movb $0x1, 0x7ec(%rbx)
movq 0x600(%rbx), %rcx
movq %rdi, -0x38(%rbp)
leaq 0x470(%rdi), %rsi
leaq -0x88(%rbp), %rax
movq %rcx, %rdi
movq %r10, -0x60(%rbp)
movq %r10, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
pushq %rax
pushq $0x4
callq 0x3251e
addq $0x10, %rsp
movq %rax, %r15
movq 0x600(%rbx), %rax
movq 0x1a0(%rax), %rcx
movq %rcx, 0x198(%rax)
movb $0x0, 0x7ec(%rbx)
testq %r15, %r15
je 0x5efdc
movzwl (%r15), %eax
shlq $0x20, %rax
movzbl 0x2(%r15), %ecx
shlq $0x30, %rcx
orq %rax, %rcx
movl 0x3(%r15), %esi
orq %rcx, %rsi
cmpq %r14, %rsi
jge 0x5f0e4
movzbl 0x7(%r15), %eax
andl $0x7, %eax
jmp 0x5f025
testb %r12b, %r12b
je 0x5f132
callq 0xa1a06
cmpl $0xaf, (%rax)
je 0x5f010
callq 0xa1a06
cmpl $0xb0, (%rax)
je 0x5f010
callq 0xa1a06
cmpl $0xc0, (%rax)
jne 0x5f132
movq -0x88(%rbp), %rdi
callq 0x34a01
movq %rax, %r15
movb $0x0, 0x7(%rax)
xorl %eax, %eax
movl -0x30(%rbp), %edx
cmpl %edx, %eax
movq -0x38(%rbp), %rdi
jne 0x5f13f
movzbl 0x8(%r15), %ecx
movzwl 0xa(%r15), %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %r14
cmpb %r14b, %cl
ja 0x5f07c
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
subq $0x8, %rsp
leaq -0x2c(%rbp), %r9
movq %r15, %rsi
movl %r13d, %edx
movl %r14d, %r8d
pushq %rax
callq 0x5f400
movl -0x30(%rbp), %edx
movq -0x38(%rbp), %rdi
addq $0x10, %rsp
testb %al, %al
jne 0x5f2d2
addq %r15, %r13
leal (,%r14,4), %eax
subq %rax, %r13
addq $-0x8, %r13
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
subq $0x8, %rsp
leaq -0x8c(%rbp), %r10
leaq -0x3c(%rbp), %r11
leaq -0x2c(%rbp), %r9
movq %r15, %rsi
movq %r13, %rdx
movl %r14d, %ecx
movq 0x10(%rbp), %r8
pushq %rax
pushq %r10
pushq %r11
callq 0x5f576
movq -0x38(%rbp), %rdi
addq $0x20, %rsp
testb %al, %al
jne 0x5f2d2
movl $0x2, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
jmp 0x5f1cf
movq -0x38(%rbp), %rdi
movl $0x1, %edx
movq -0x60(%rbp), %r13
movq %r13, %rcx
callq 0x4c6e1
movzwl 0xa(%r15), %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5bee2
xorl %r12d, %r12d
testb %al, %al
cmovel %r12d, %r14d
xorl %edx, %edx
cmpl $0x1, -0x30(%rbp)
sete %dl
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %r14d, %ecx
callq 0x41b8b
testb %al, %al
je 0x5f33d
callq 0xa1a06
movl (%rax), %r12d
jmp 0x5f2f0
testb %r12b, %r12b
je 0x5f2d2
movq $0x0, -0x50(%rbp)
movq %rdi, %r12
movq %r15, %rsi
xorl %ecx, %ecx
movl %edx, %r14d
callq 0x5f36a
movl %r13d, %eax
subl 0xc18(%rbx), %eax
addl $-0x10, %eax
leaq -0x2c(%rbp), %rcx
movl %eax, (%rcx)
movq %rcx, %r9
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
subq $0x8, %rsp
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
xorl %ecx, %ecx
movq -0x48(%rbp), %r14
movl %r14d, %r8d
movq %r9, %r12
pushq %rax
callq 0x5f400
addq $0x10, %rsp
movl 0xc18(%rbx), %eax
addl $0xc, %eax
movl %eax, -0x3c(%rbp)
addq %r15, %r13
leal (,%r14,4), %eax
subq %rax, %r13
movzwl -0x6(%r13), %eax
addq $-0x8, %r13
addl %eax, (%r12)
movl $0x2, -0x48(%rbp)
movq 0x10(%rbp), %r12
movw %r12w, 0x2(%r13)
movl -0x3c(%rbp), %edi
addq %r15, %rdi
movq -0x70(%rbp), %rsi
movq %r12, %rdx
callq 0x29080
movl -0x2c(%rbp), %r14d
subl %r12d, %r14d
movl %r14d, -0x2c(%rbp)
movw %r14w, 0xa(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5bee2
testb %al, %al
jne 0x5f213
movl $0x0, -0x2c(%rbp)
xorl %r14d, %r14d
xorl %edx, %edx
cmpl $0x1, -0x30(%rbp)
sete %dl
movq -0x38(%rbp), %r12
movq %r12, %rdi
movq -0x60(%rbp), %r13
movq %r13, %rsi
movl %r14d, %ecx
callq 0x41b8b
testb %al, %al
movl -0x48(%rbp), %r14d
jne 0x5f2e2
movq %r12, %r14
xorl %r12d, %r12d
movq -0x68(%rbp), %rax
cmpq %rax, -0x58(%rbp)
jbe 0x5f2a1
movq 0x600(%rbx), %rdi
leaq 0x470(%r14), %rsi
movl 0x80(%rdi), %eax
subq $0x8, %rsp
xorl %r12d, %r12d
leaq -0x88(%rbp), %r10
movq %r13, %rdx
xorl %ecx, %ecx
movq %r15, %r8
movl $0x1, %r9d
pushq %rax
pushq %r12
pushq $0x0
pushq %r10
pushq %r12
pushq -0x50(%rbp)
pushq $0x4
callq 0x33982
addq $0x40, %rsp
testb %al, %al
je 0x5f2a1
callq 0xa1a06
movl (%rax), %r12d
leaq -0x88(%rbp), %rsi
movl $0x6, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movq %r14, %rdi
addq $0x2e8, %rdi # imm = 0x2E8
callq 0x91aaa
movq -0x58(%rbp), %rax
cmpq %rax, 0x40(%rbx)
jae 0x5f32b
movq %rax, 0x40(%rbx)
jmp 0x5f32b
movl $0x2, %r14d
movl $0x7f, %esi
callq 0x36930
callq 0xa1a06
movl (%rax), %r12d
cmpl $0x2, %r14d
jne 0x5f31b
movq 0x600(%rbx), %rdi
movq -0x88(%rbp), %rsi
xorl %eax, %eax
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
callq 0x32239
addq $0x10, %rsp
movq %rbx, %rdi
callq 0x3812e
callq 0xa1a06
movl %r12d, (%rax)
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x600(%rbx), %rdi
movq -0x88(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r12
pushq %r12
callq 0x32239
addq $0x10, %rsp
jmp 0x5f32b
| _ma_apply_redo_insert_row_head_or_tail:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, ecx
mov r14, rsi
mov rbx, [rdi]
mov r13d, [rbx+7BCh]
mov eax, [r8]
movzx ecx, byte ptr [r8+4]
shl rcx, 20h
lea r10, [rcx+rax]
movzx r11d, byte ptr [r8+5]
or dword ptr [rbx+170h], 181h
lea rsi, [rcx+rax]
inc rsi
imul rsi, r13
mov r8, [rbx+40h]
cmp rsi, r8
jbe short loc_5EF23
test r11d, r11d
setnz al
test r12b, r12b
setz cl
mov r14d, 4
or cl, al
jnz loc_5F2D8
mov [rbp+var_70], r9
mov [rbp+var_68], r8
mov [rbp+var_60], r10
mov [rbp+var_58], rsi
mov r15, [rdi+380h]
mov byte ptr [rdi+685h], 1
mov [rbp+var_38], rdi
mov rsi, r15
mov [rbp+var_30], edx
mov ecx, 1
call make_empty_page
mov eax, [rbx+0C18h]
mov ecx, r13d
sub ecx, eax
add ecx, 0FFFFFFECh
mov [rbp+var_2C], ecx
add eax, 0Ch
mov [rbp+var_3C], eax
add r13, r15
add r13, 0FFFFFFFFFFFFFFF8h
mov dword ptr [rbp+var_48], 4
mov eax, 2
mov [rbp+var_50], rax
jmp loc_5F1CF
loc_5EF23:
mov [rbp+var_48], r11
mov [rbp+var_70], r9
mov [rbp+var_68], r8
mov [rbp+var_30], edx
mov [rbp+var_58], rsi
mov rax, [rbx+600h]
mov ecx, 0FFFFFFEFh
and [rax+198h], rcx
mov byte ptr [rbx+7ECh], 1
mov rcx, [rbx+600h]
mov [rbp+var_38], rdi
lea rsi, [rdi+470h]
lea rax, [rbp+var_88]
mov rdi, rcx
mov [rbp+var_60], r10
mov rdx, r10
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
push rax
push 4
call pagecache_read
add rsp, 10h
mov r15, rax
mov rax, [rbx+600h]
mov rcx, [rax+1A0h]
mov [rax+198h], rcx
mov byte ptr [rbx+7ECh], 0
test r15, r15
jz short loc_5EFDC
movzx eax, word ptr [r15]
shl rax, 20h
movzx ecx, byte ptr [r15+2]
shl rcx, 30h
or rcx, rax
mov esi, [r15+3]
or rsi, rcx
cmp rsi, r14
jge loc_5F0E4
movzx eax, byte ptr [r15+7]
and eax, 7
jmp short loc_5F025
loc_5EFDC:
test r12b, r12b
jz loc_5F132
call _my_thread_var
cmp dword ptr [rax], 0AFh
jz short loc_5F010
call _my_thread_var
cmp dword ptr [rax], 0B0h
jz short loc_5F010
call _my_thread_var
cmp dword ptr [rax], 0C0h
jnz loc_5F132
loc_5F010:
mov rdi, [rbp+var_88]
call pagecache_block_link_to_buffer
mov r15, rax
mov byte ptr [rax+7], 0
xor eax, eax
loc_5F025:
mov edx, [rbp+var_30]
cmp eax, edx
mov rdi, [rbp+var_38]
jnz loc_5F13F
movzx ecx, byte ptr [r15+8]
movzx eax, word ptr [r15+0Ah]
mov [rbp+var_2C], eax
mov r14, [rbp+var_48]
cmp cl, r14b
ja short loc_5F07C
xor eax, eax
cmp edx, 1
setz al
sub rsp, 8
lea r9, [rbp+var_2C]
mov rsi, r15
mov edx, r13d
mov r8d, r14d
push rax
call extend_directory
mov edx, [rbp+var_30]
mov rdi, [rbp+var_38]
add rsp, 10h
test al, al
jnz loc_5F2D2
loc_5F07C:
add r13, r15
lea eax, ds:0[r14*4]
sub r13, rax
add r13, 0FFFFFFFFFFFFFFF8h
xor eax, eax
cmp edx, 1
setz al
sub rsp, 8
lea r10, [rbp+var_8C]
lea r11, [rbp+var_3C]
lea r9, [rbp+var_2C]
mov rsi, r15
mov rdx, r13
mov ecx, r14d
mov r8, [rbp+arg_0]
push rax
push r10
push r11
call extend_area_on_page
mov rdi, [rbp+var_38]
add rsp, 20h
test al, al
jnz loc_5F2D2
mov dword ptr [rbp+var_48], 2
mov [rbp+var_50], 0
jmp loc_5F1CF
loc_5F0E4:
mov rdi, [rbp+var_38]
mov edx, 1
mov r13, [rbp+var_60]
mov rcx, r13
call check_skipped_lsn
movzx r14d, word ptr [r15+0Ah]
mov rdi, rbx
mov rsi, r15
call enough_free_entries_on_page
xor r12d, r12d
test al, al
cmovz r14d, r12d
xor edx, edx
cmp [rbp+var_30], 1
setz dl
mov rdi, [rbp+var_38]
mov rsi, r13
mov ecx, r14d
call _ma_bitmap_set
test al, al
jz loc_5F33D
loc_5F132:
call _my_thread_var
mov r12d, [rax]
jmp loc_5F2F0
loc_5F13F:
test r12b, r12b
jz loc_5F2D2
mov [rbp+var_50], 0
mov r12, rdi
mov rsi, r15
xor ecx, ecx
mov r14d, edx
call make_empty_page
mov eax, r13d
sub eax, [rbx+0C18h]
add eax, 0FFFFFFF0h
lea rcx, [rbp+var_2C]
mov [rcx], eax
mov r9, rcx
xor eax, eax
cmp r14d, 1
setz al
sub rsp, 8
mov rdi, r12
mov rsi, r15
mov edx, r13d
xor ecx, ecx
mov r14, [rbp+var_48]
mov r8d, r14d
mov r12, r9
push rax
call extend_directory
add rsp, 10h
mov eax, [rbx+0C18h]
add eax, 0Ch
mov [rbp+var_3C], eax
add r13, r15
lea eax, ds:0[r14*4]
sub r13, rax
movzx eax, word ptr [r13-6]
add r13, 0FFFFFFFFFFFFFFF8h
add [r12], eax
mov dword ptr [rbp+var_48], 2
loc_5F1CF:
mov r12, [rbp+arg_0]
mov [r13+2], r12w
mov edi, [rbp+var_3C]
add rdi, r15
mov rsi, [rbp+var_70]
mov rdx, r12
call _memcpy
mov r14d, [rbp+var_2C]
sub r14d, r12d
mov [rbp+var_2C], r14d
mov [r15+0Ah], r14w
mov rdi, rbx
mov rsi, r15
call enough_free_entries_on_page
test al, al
jnz short loc_5F213
mov [rbp+var_2C], 0
xor r14d, r14d
loc_5F213:
xor edx, edx
cmp [rbp+var_30], 1
setz dl
mov r12, [rbp+var_38]
mov rdi, r12
mov r13, [rbp+var_60]
mov rsi, r13
mov ecx, r14d
call _ma_bitmap_set
test al, al
mov r14d, dword ptr [rbp+var_48]
jnz loc_5F2E2
mov r14, r12
xor r12d, r12d
mov rax, [rbp+var_68]
cmp [rbp+var_58], rax
jbe short loc_5F2A1
mov rdi, [rbx+600h]
lea rsi, [r14+470h]
mov eax, [rdi+80h]
sub rsp, 8
xor r12d, r12d
lea r10, [rbp+var_88]
mov rdx, r13
xor ecx, ecx
mov r8, r15
mov r9d, 1
push rax
push r12
push 0
push r10
push r12
push [rbp+var_50]
push 4
call pagecache_write_part
add rsp, 40h
test al, al
jz short loc_5F2A1
call _my_thread_var
mov r12d, [rax]
loc_5F2A1:
lea rsi, [rbp+var_88]
mov dword ptr [rsi+8], 6
mov byte ptr [rsi+10h], 1
mov rdi, r14
add rdi, 2E8h
call insert_dynamic
mov rax, [rbp+var_58]
cmp [rbx+40h], rax
jnb short loc_5F32B
mov [rbx+40h], rax
jmp short loc_5F32B
loc_5F2D2:
mov r14d, 2
loc_5F2D8:
mov esi, 7Fh
call _ma_set_fatal_error
loc_5F2E2:
call _my_thread_var
mov r12d, [rax]
cmp r14d, 2
jnz short loc_5F31B
loc_5F2F0:
mov rdi, [rbx+600h]
mov rsi, [rbp+var_88]
xor eax, eax
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push rax
push rax
call pagecache_unlock_by_link
add rsp, 10h
loc_5F31B:
mov rdi, rbx
call _ma_mark_file_crashed
call _my_thread_var
mov [rax], r12d
loc_5F32B:
mov eax, r12d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5F33D:
mov rdi, [rbx+600h]
mov rsi, [rbp+var_88]
mov edx, 6
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push r12
push r12
call pagecache_unlock_by_link
add rsp, 10h
jmp short loc_5F32B
| long long ma_apply_redo_insert_row_head_or_tail(
long long *a1,
long long a2,
long long a3,
char a4,
unsigned int *a5,
long long a6,
long long a7)
{
long long v9; // rbx
long long v10; // r13
long long v11; // rax
unsigned long long v12; // rcx
long long v13; // r10
long long v14; // r11
unsigned long long v15; // rsi
unsigned long long v16; // r8
int v17; // r14d
unsigned __int16 *v18; // r15
int v19; // eax
long long v20; // r13
long long v21; // rcx
const char *v22; // rsi
long long *v23; // rdi
long long v24; // rsi
int v25; // eax
int v26; // ecx
int v27; // r14d
char v28; // al
char v29; // al
unsigned long long v30; // r13
unsigned int v31; // r14d
unsigned int v32; // r12d
unsigned int v33; // r14d
char v34; // al
int v35; // r14d
char *v36; // r13
int v37; // eax
unsigned int v38; // r14d
long long *v39; // r12
long long v40; // r13
const char *v41; // rsi
char v42; // al
long long *v43; // r14
__m128i *v44; // rdi
_BYTE v46[4]; // [rsp+4h] [rbp-8Ch] BYREF
const char *v47; // [rsp+8h] [rbp-88h] BYREF
int v48; // [rsp+10h] [rbp-80h]
char v49; // [rsp+18h] [rbp-78h]
long long v50; // [rsp+20h] [rbp-70h]
unsigned long long v51; // [rsp+28h] [rbp-68h]
const char *v52; // [rsp+30h] [rbp-60h]
unsigned long long v53; // [rsp+38h] [rbp-58h]
long long v54; // [rsp+40h] [rbp-50h]
long long v55; // [rsp+48h] [rbp-48h]
unsigned int v56; // [rsp+54h] [rbp-3Ch] BYREF
long long *v57; // [rsp+58h] [rbp-38h]
unsigned int v58; // [rsp+60h] [rbp-30h]
_DWORD v59[11]; // [rsp+64h] [rbp-2Ch] BYREF
v9 = *a1;
v10 = *(unsigned int *)(*a1 + 1980);
v11 = *a5;
v12 = (unsigned long long)*((unsigned __int8 *)a5 + 4) << 32;
v13 = v12 + v11;
v14 = *((unsigned __int8 *)a5 + 5);
*(_DWORD *)(v9 + 368) |= 0x181u;
v15 = v10 * (v12 + v11 + 1);
v16 = *(_QWORD *)(v9 + 64);
if ( v15 > v16 )
{
v17 = 4;
LOBYTE(v12) = (_DWORD)v14 != 0 || a4 == 0;
if ( !(_BYTE)v12 )
{
v50 = a6;
v51 = v16;
v52 = (const char *)v13;
v53 = v15;
v18 = (unsigned __int16 *)a1[112];
*((_BYTE *)a1 + 1669) = 1;
v57 = a1;
v58 = a3;
make_empty_page(a1, v18, a3, 1LL);
v19 = *(_DWORD *)(v9 + 3096);
v59[0] = v10 - v19 - 20;
v56 = v19 + 12;
v20 = (long long)v18 + v10 - 8;
LODWORD(v55) = 4;
v54 = 2LL;
goto LABEL_23;
}
LABEL_32:
v41 = (_BYTE *)(&dword_7C + 3);
ma_set_fatal_error(a1, 127LL, a3, v12, v16, a6);
goto LABEL_33;
}
v55 = v14;
v50 = a6;
v51 = v16;
v58 = a3;
v53 = v10 * (v12 + v11 + 1);
*(_QWORD *)(*(_QWORD *)(v9 + 1536) + 408LL) &= 0xFFFFFFEFuLL;
*(_BYTE *)(v9 + 2028) = 1;
v21 = *(_QWORD *)(v9 + 1536);
v57 = a1;
v22 = (const char *)(a1 + 142);
v23 = (long long *)v21;
v52 = (const char *)v13;
v18 = (unsigned __int16 *)pagecache_read(v21, (long long)v22, v13, 0, 0LL, 1, 4u, &v47);
*(_QWORD *)(*(_QWORD *)(v9 + 1536) + 408LL) = *(_QWORD *)(*(_QWORD *)(v9 + 1536) + 416LL);
*(_BYTE *)(v9 + 2028) = 0;
if ( v18 )
{
v12 = ((unsigned long long)*v18 << 32) | ((unsigned long long)*((unsigned __int8 *)v18 + 2) << 48);
v24 = v12 | *(unsigned int *)((char *)v18 + 3);
if ( v24 < a2 )
{
v25 = *((_BYTE *)v18 + 7) & 7;
goto LABEL_12;
}
v30 = (unsigned long long)v52;
check_skipped_lsn((long long)v57, v24, 1, (int)v52);
v31 = v18[5];
v32 = 0;
if ( !enough_free_entries_on_page(v9, v18) )
v31 = 0;
v23 = v57;
v22 = (const char *)v30;
if ( !(unsigned __int8)ma_bitmap_set(v57, v30, v58 == 1, v31) )
{
pagecache_unlock_by_link(*(_QWORD *)(v9 + 1536), (long long)v47, 6, 3, 0LL, 0LL, 0);
return v32;
}
LABEL_20:
v32 = *(_DWORD *)my_thread_var(v23, v22);
goto LABEL_34;
}
if ( !a4
|| *(_DWORD *)my_thread_var(v23, v22) != 175
&& *(_DWORD *)my_thread_var(v23, v22) != 176
&& *(_DWORD *)my_thread_var(v23, v22) != 192 )
{
goto LABEL_20;
}
v18 = (unsigned __int16 *)pagecache_block_link_to_buffer((long long)v47);
*((_BYTE *)v18 + 7) = 0;
v25 = 0;
LABEL_12:
a3 = v58;
a1 = v57;
if ( v25 == v58 )
{
v26 = *((unsigned __int8 *)v18 + 8);
v59[0] = v18[5];
v27 = v55;
if ( (unsigned __int8)v26 > (unsigned __int8)v55
|| (v28 = extend_directory((_DWORD)v57, (_DWORD)v18, v10, v26, v55, (unsigned int)v59, v58 == 1),
a3 = v58,
a1 = v57,
!v28) )
{
v20 = (long long)v18 + v10 - (unsigned int)(4 * v27) - 8;
v29 = extend_area_on_page(
(_DWORD)a1,
(_DWORD)v18,
v20,
v27,
a7,
(unsigned int)v59,
(long long)&v56,
(long long)v46,
(_DWORD)a3 == 1);
a1 = v57;
if ( !v29 )
{
LODWORD(v55) = 2;
v54 = 0LL;
goto LABEL_23;
}
}
LABEL_31:
v17 = 2;
goto LABEL_32;
}
if ( !a4 )
goto LABEL_31;
v54 = 0LL;
v33 = v58;
make_empty_page(v57, v18, v58, 0LL);
v59[0] = v10 - *(_DWORD *)(v9 + 3096) - 16;
v34 = v33 == 1;
v35 = v55;
extend_directory((_DWORD)a1, (_DWORD)v18, v10, 0, v55, (unsigned int)v59, v34);
v56 = *(_DWORD *)(v9 + 3096) + 12;
v36 = (char *)v18 + v10 - (unsigned int)(4 * v35);
v37 = *((unsigned __int16 *)v36 - 3);
v20 = (long long)(v36 - 8);
v59[0] += v37;
LODWORD(v55) = 2;
LABEL_23:
*(_WORD *)(v20 + 2) = a7;
memcpy((char *)v18 + v56, v50, a7);
v38 = v59[0] - a7;
v59[0] = v38;
v18[5] = v38;
if ( !enough_free_entries_on_page(v9, v18) )
{
v59[0] = 0;
v38 = 0;
}
v39 = v57;
a1 = v57;
v40 = (long long)v52;
v41 = v52;
v42 = ma_bitmap_set(v57, (unsigned long long)v52, v58 == 1, v38);
v17 = v55;
if ( v42 )
{
LABEL_33:
v32 = *(_DWORD *)my_thread_var(a1, v41);
if ( v17 != 2 )
{
LABEL_35:
ma_mark_file_crashed(v9);
*(_DWORD *)my_thread_var(v9, v41) = v32;
return v32;
}
LABEL_34:
v41 = v47;
pagecache_unlock_by_link(*(_QWORD *)(v9 + 1536), (long long)v47, 6, 3, 0LL, 0LL, 0);
goto LABEL_35;
}
v43 = v39;
v32 = 0;
if ( v53 > v51 )
{
v44 = *(__m128i **)(v9 + 1536);
v32 = 0;
if ( (unsigned __int8)pagecache_write_part(
v44,
(char *)v43 + 1136,
v40,
0,
(char *)v18,
1,
4u,
v54,
0,
&v47,
0LL,
0,
v44[8].m128i_u32[0]) )
v32 = *(_DWORD *)my_thread_var(v44, (const char *)v43 + 1136);
}
v48 = 6;
v49 = 1;
insert_dynamic(v43 + 93, &v47);
if ( *(_QWORD *)(v9 + 64) < v53 )
*(_QWORD *)(v9 + 64) = v53;
return v32;
}
| _ma_apply_redo_insert_row_head_or_tail:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,ECX
MOV R14,RSI
MOV RBX,qword ptr [RDI]
MOV R13D,dword ptr [RBX + 0x7bc]
MOV EAX,dword ptr [R8]
MOVZX ECX,byte ptr [R8 + 0x4]
SHL RCX,0x20
LEA R10,[RCX + RAX*0x1]
MOVZX R11D,byte ptr [R8 + 0x5]
OR dword ptr [RBX + 0x170],0x181
LEA RSI,[RCX + RAX*0x1]
INC RSI
IMUL RSI,R13
MOV R8,qword ptr [RBX + 0x40]
CMP RSI,R8
JBE 0x0015ef23
TEST R11D,R11D
SETNZ AL
TEST R12B,R12B
SETZ CL
MOV R14D,0x4
OR CL,AL
JNZ 0x0015f2d8
MOV qword ptr [RBP + -0x70],R9
MOV qword ptr [RBP + -0x68],R8
MOV qword ptr [RBP + -0x60],R10
MOV qword ptr [RBP + -0x58],RSI
MOV R15,qword ptr [RDI + 0x380]
MOV byte ptr [RDI + 0x685],0x1
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R15
MOV dword ptr [RBP + -0x30],EDX
MOV ECX,0x1
CALL 0x0015f36a
MOV EAX,dword ptr [RBX + 0xc18]
MOV ECX,R13D
SUB ECX,EAX
ADD ECX,-0x14
MOV dword ptr [RBP + -0x2c],ECX
ADD EAX,0xc
MOV dword ptr [RBP + -0x3c],EAX
ADD R13,R15
ADD R13,-0x8
MOV dword ptr [RBP + -0x48],0x4
MOV EAX,0x2
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015f1cf
LAB_0015ef23:
MOV qword ptr [RBP + -0x48],R11
MOV qword ptr [RBP + -0x70],R9
MOV qword ptr [RBP + -0x68],R8
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x58],RSI
MOV RAX,qword ptr [RBX + 0x600]
MOV ECX,0xffffffef
AND qword ptr [RAX + 0x198],RCX
MOV byte ptr [RBX + 0x7ec],0x1
MOV RCX,qword ptr [RBX + 0x600]
MOV qword ptr [RBP + -0x38],RDI
LEA RSI,[RDI + 0x470]
LEA RAX,[RBP + -0x88]
MOV RDI,RCX
MOV qword ptr [RBP + -0x60],R10
MOV RDX,R10
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
PUSH RAX
PUSH 0x4
CALL 0x0013251e
ADD RSP,0x10
MOV R15,RAX
MOV RAX,qword ptr [RBX + 0x600]
MOV RCX,qword ptr [RAX + 0x1a0]
MOV qword ptr [RAX + 0x198],RCX
MOV byte ptr [RBX + 0x7ec],0x0
TEST R15,R15
JZ 0x0015efdc
MOVZX EAX,word ptr [R15]
SHL RAX,0x20
MOVZX ECX,byte ptr [R15 + 0x2]
SHL RCX,0x30
OR RCX,RAX
MOV ESI,dword ptr [R15 + 0x3]
OR RSI,RCX
CMP RSI,R14
JGE 0x0015f0e4
MOVZX EAX,byte ptr [R15 + 0x7]
AND EAX,0x7
JMP 0x0015f025
LAB_0015efdc:
TEST R12B,R12B
JZ 0x0015f132
CALL 0x001a1a06
CMP dword ptr [RAX],0xaf
JZ 0x0015f010
CALL 0x001a1a06
CMP dword ptr [RAX],0xb0
JZ 0x0015f010
CALL 0x001a1a06
CMP dword ptr [RAX],0xc0
JNZ 0x0015f132
LAB_0015f010:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00134a01
MOV R15,RAX
MOV byte ptr [RAX + 0x7],0x0
XOR EAX,EAX
LAB_0015f025:
MOV EDX,dword ptr [RBP + -0x30]
CMP EAX,EDX
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x0015f13f
MOVZX ECX,byte ptr [R15 + 0x8]
MOVZX EAX,word ptr [R15 + 0xa]
MOV dword ptr [RBP + -0x2c],EAX
MOV R14,qword ptr [RBP + -0x48]
CMP CL,R14B
JA 0x0015f07c
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
SUB RSP,0x8
LEA R9,[RBP + -0x2c]
MOV RSI,R15
MOV EDX,R13D
MOV R8D,R14D
PUSH RAX
CALL 0x0015f400
MOV EDX,dword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
ADD RSP,0x10
TEST AL,AL
JNZ 0x0015f2d2
LAB_0015f07c:
ADD R13,R15
LEA EAX,[R14*0x4]
SUB R13,RAX
ADD R13,-0x8
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
SUB RSP,0x8
LEA R10,[RBP + -0x8c]
LEA R11,[RBP + -0x3c]
LEA R9,[RBP + -0x2c]
MOV RSI,R15
MOV RDX,R13
MOV ECX,R14D
MOV R8,qword ptr [RBP + 0x10]
PUSH RAX
PUSH R10
PUSH R11
CALL 0x0015f576
MOV RDI,qword ptr [RBP + -0x38]
ADD RSP,0x20
TEST AL,AL
JNZ 0x0015f2d2
MOV dword ptr [RBP + -0x48],0x2
MOV qword ptr [RBP + -0x50],0x0
JMP 0x0015f1cf
LAB_0015f0e4:
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x1
MOV R13,qword ptr [RBP + -0x60]
MOV RCX,R13
CALL 0x0014c6e1
MOVZX R14D,word ptr [R15 + 0xa]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0015bee2
XOR R12D,R12D
TEST AL,AL
CMOVZ R14D,R12D
XOR EDX,EDX
CMP dword ptr [RBP + -0x30],0x1
SETZ DL
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,R13
MOV ECX,R14D
CALL 0x00141b8b
TEST AL,AL
JZ 0x0015f33d
LAB_0015f132:
CALL 0x001a1a06
MOV R12D,dword ptr [RAX]
JMP 0x0015f2f0
LAB_0015f13f:
TEST R12B,R12B
JZ 0x0015f2d2
MOV qword ptr [RBP + -0x50],0x0
MOV R12,RDI
MOV RSI,R15
XOR ECX,ECX
MOV R14D,EDX
CALL 0x0015f36a
MOV EAX,R13D
SUB EAX,dword ptr [RBX + 0xc18]
ADD EAX,-0x10
LEA RCX,[RBP + -0x2c]
MOV dword ptr [RCX],EAX
MOV R9,RCX
XOR EAX,EAX
CMP R14D,0x1
SETZ AL
SUB RSP,0x8
MOV RDI,R12
MOV RSI,R15
MOV EDX,R13D
XOR ECX,ECX
MOV R14,qword ptr [RBP + -0x48]
MOV R8D,R14D
MOV R12,R9
PUSH RAX
CALL 0x0015f400
ADD RSP,0x10
MOV EAX,dword ptr [RBX + 0xc18]
ADD EAX,0xc
MOV dword ptr [RBP + -0x3c],EAX
ADD R13,R15
LEA EAX,[R14*0x4]
SUB R13,RAX
MOVZX EAX,word ptr [R13 + -0x6]
ADD R13,-0x8
ADD dword ptr [R12],EAX
MOV dword ptr [RBP + -0x48],0x2
LAB_0015f1cf:
MOV R12,qword ptr [RBP + 0x10]
MOV word ptr [R13 + 0x2],R12W
MOV EDI,dword ptr [RBP + -0x3c]
ADD RDI,R15
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,R12
CALL 0x00129080
MOV R14D,dword ptr [RBP + -0x2c]
SUB R14D,R12D
MOV dword ptr [RBP + -0x2c],R14D
MOV word ptr [R15 + 0xa],R14W
MOV RDI,RBX
MOV RSI,R15
CALL 0x0015bee2
TEST AL,AL
JNZ 0x0015f213
MOV dword ptr [RBP + -0x2c],0x0
XOR R14D,R14D
LAB_0015f213:
XOR EDX,EDX
CMP dword ptr [RBP + -0x30],0x1
SETZ DL
MOV R12,qword ptr [RBP + -0x38]
MOV RDI,R12
MOV R13,qword ptr [RBP + -0x60]
MOV RSI,R13
MOV ECX,R14D
CALL 0x00141b8b
TEST AL,AL
MOV R14D,dword ptr [RBP + -0x48]
JNZ 0x0015f2e2
MOV R14,R12
XOR R12D,R12D
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RBP + -0x58],RAX
JBE 0x0015f2a1
MOV RDI,qword ptr [RBX + 0x600]
LEA RSI,[R14 + 0x470]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
XOR R12D,R12D
LEA R10,[RBP + -0x88]
MOV RDX,R13
XOR ECX,ECX
MOV R8,R15
MOV R9D,0x1
PUSH RAX
PUSH R12
PUSH 0x0
PUSH R10
PUSH R12
PUSH qword ptr [RBP + -0x50]
PUSH 0x4
CALL 0x00133982
ADD RSP,0x40
TEST AL,AL
JZ 0x0015f2a1
CALL 0x001a1a06
MOV R12D,dword ptr [RAX]
LAB_0015f2a1:
LEA RSI,[RBP + -0x88]
MOV dword ptr [RSI + 0x8],0x6
MOV byte ptr [RSI + 0x10],0x1
MOV RDI,R14
ADD RDI,0x2e8
CALL 0x00191aaa
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RBX + 0x40],RAX
JNC 0x0015f32b
MOV qword ptr [RBX + 0x40],RAX
JMP 0x0015f32b
LAB_0015f2d2:
MOV R14D,0x2
LAB_0015f2d8:
MOV ESI,0x7f
CALL 0x00136930
LAB_0015f2e2:
CALL 0x001a1a06
MOV R12D,dword ptr [RAX]
CMP R14D,0x2
JNZ 0x0015f31b
LAB_0015f2f0:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [RBP + -0x88]
XOR EAX,EAX
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH RAX
PUSH RAX
CALL 0x00132239
ADD RSP,0x10
LAB_0015f31b:
MOV RDI,RBX
CALL 0x0013812e
CALL 0x001a1a06
MOV dword ptr [RAX],R12D
LAB_0015f32b:
MOV EAX,R12D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015f33d:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [RBP + -0x88]
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH R12
PUSH R12
CALL 0x00132239
ADD RSP,0x10
JMP 0x0015f32b
|
int4
_ma_apply_redo_insert_row_head_or_tail
(long *param_1,long param_2,int8 param_3,char param_4,uint5 *param_5,void *param_6,
size_t param_7)
{
ulong *puVar1;
ulong uVar2;
byte bVar3;
long lVar4;
uint5 uVar5;
long lVar6;
long *plVar7;
uint uVar8;
char cVar9;
uint uVar10;
ushort *puVar11;
int *piVar12;
int4 *puVar13;
ulong uVar14;
ulong uVar15;
int4 uVar16;
ulong uVar17;
long lVar18;
ushort uVar19;
uint uVar20;
int iVar21;
int1 local_94 [4];
int8 local_90;
int4 local_88;
int1 local_80;
void *local_78;
ulong local_70;
ulong local_68;
ulong local_60;
int8 local_58;
ulong local_50;
uint local_44;
long *local_40;
uint local_38;
uint local_34;
lVar4 = *param_1;
uVar20 = *(uint *)(lVar4 + 0x7bc);
uVar17 = (ulong)uVar20;
uVar5 = *param_5;
uVar2 = (ulong)*param_5;
bVar3 = *(byte *)((long)param_5 + 5);
*(uint *)(lVar4 + 0x170) = *(uint *)(lVar4 + 0x170) | 0x181;
uVar14 = ((ulong)uVar5 + 1) * uVar17;
uVar15 = *(ulong *)(lVar4 + 0x40);
if (uVar14 < uVar15 || uVar14 - uVar15 == 0) {
puVar1 = (ulong *)(*(long *)(lVar4 + 0x600) + 0x198);
*puVar1 = *puVar1 & 0xffffffef;
*(int1 *)(lVar4 + 0x7ec) = 1;
local_78 = param_6;
local_70 = uVar15;
local_68 = uVar2;
local_60 = uVar14;
local_50 = (ulong)bVar3;
local_40 = param_1;
local_38 = (uint)param_3;
puVar11 = (ushort *)
pagecache_read(*(int8 *)(lVar4 + 0x600),param_1 + 0x8e,uVar2,0,0,1,4,&local_90);
uVar2 = local_68;
*(int8 *)(*(long *)(lVar4 + 0x600) + 0x198) =
*(int8 *)(*(long *)(lVar4 + 0x600) + 0x1a0);
*(int1 *)(lVar4 + 0x7ec) = 0;
if (puVar11 == (ushort *)0x0) {
if ((param_4 != '\0') &&
(((piVar12 = (int *)_my_thread_var(), *piVar12 == 0xaf ||
(piVar12 = (int *)_my_thread_var(), *piVar12 == 0xb0)) ||
(piVar12 = (int *)_my_thread_var(), *piVar12 == 0xc0)))) {
puVar11 = (ushort *)pagecache_block_link_to_buffer(local_90);
*(int1 *)((long)puVar11 + 7) = 0;
uVar10 = 0;
goto LAB_0015f025;
}
}
else {
uVar15 = (ulong)*(uint *)((long)puVar11 + 3) |
(ulong)(byte)puVar11[1] << 0x30 | (ulong)*puVar11 << 0x20;
if ((long)uVar15 < param_2) {
uVar10 = *(byte *)((long)puVar11 + 7) & 7;
LAB_0015f025:
uVar8 = local_38;
plVar7 = local_40;
uVar2 = local_50;
if (uVar10 == local_38) {
local_34 = (uint)puVar11[5];
if (((byte)local_50 < (byte)puVar11[4]) ||
(cVar9 = extend_directory(local_40,puVar11,uVar17,(byte)puVar11[4],
local_50 & 0xffffffff,&local_34,local_38 == 1), cVar9 == '\0'
)) {
lVar18 = (long)puVar11 + (uVar17 - (uint)((int)uVar2 * 4)) + -8;
cVar9 = extend_area_on_page(local_40,puVar11,lVar18,uVar2 & 0xffffffff,param_7,&local_34
,&local_44,local_94,local_38 == 1);
if (cVar9 == '\0') {
local_50 = CONCAT44(local_50._4_4_,2);
local_58 = 0;
goto LAB_0015f1cf;
}
}
LAB_0015f2d2:
iVar21 = 2;
param_1 = local_40;
goto LAB_0015f2d8;
}
if (param_4 == '\0') goto LAB_0015f2d2;
local_58 = 0;
make_empty_page(local_40,puVar11,local_38,0);
uVar2 = local_50;
local_34 = (uVar20 - *(int *)(lVar4 + 0xc18)) - 0x10;
extend_directory(plVar7,puVar11,uVar17,0,local_50 & 0xffffffff,&local_34,uVar8 == 1);
local_44 = *(int *)(lVar4 + 0xc18) + 0xc;
lVar6 = uVar17 - (uint)((int)uVar2 * 4);
lVar18 = (long)puVar11 + lVar6 + -8;
local_34 = local_34 + *(ushort *)((long)puVar11 + lVar6 + -6);
local_50 = CONCAT44(local_50._4_4_,2);
LAB_0015f1cf:
*(short *)(lVar18 + 2) = (short)param_7;
memcpy((void *)((ulong)local_44 + (long)puVar11),local_78,param_7);
uVar20 = local_34 - (int)param_7;
puVar11[5] = (ushort)uVar20;
local_34 = uVar20;
cVar9 = enough_free_entries_on_page(lVar4,puVar11);
plVar7 = local_40;
uVar2 = local_68;
if (cVar9 == '\0') {
local_34 = 0;
uVar20 = 0;
}
cVar9 = _ma_bitmap_set(local_40,local_68,local_38 == 1,uVar20);
iVar21 = (int)local_50;
if (cVar9 == '\0') {
uVar16 = 0;
if (local_70 < local_60) {
uVar16 = 0;
cVar9 = pagecache_write_part
(*(long *)(lVar4 + 0x600),plVar7 + 0x8e,uVar2,0,puVar11,1,4,local_58,0
,&local_90,0,0,*(int4 *)(*(long *)(lVar4 + 0x600) + 0x80));
if (cVar9 != '\0') {
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
}
}
local_88 = 6;
local_80 = 1;
insert_dynamic(plVar7 + 0x5d);
if (local_60 <= *(ulong *)(lVar4 + 0x40)) {
return uVar16;
}
*(ulong *)(lVar4 + 0x40) = local_60;
return uVar16;
}
goto LAB_0015f2e2;
}
check_skipped_lsn(local_40,uVar15,1,local_68);
uVar19 = puVar11[5];
cVar9 = enough_free_entries_on_page(lVar4,puVar11);
if (cVar9 == '\0') {
uVar19 = 0;
}
cVar9 = _ma_bitmap_set(local_40,uVar2,local_38 == 1,uVar19);
if (cVar9 == '\0') {
pagecache_unlock_by_link(*(int8 *)(lVar4 + 0x600),local_90,6,3,0,0,0,0);
return 0;
}
}
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
}
else {
iVar21 = 4;
if (param_4 != '\0' && bVar3 == 0) {
puVar11 = (ushort *)param_1[0x70];
*(int1 *)((long)param_1 + 0x685) = 1;
local_78 = param_6;
local_70 = uVar15;
local_68 = uVar2;
local_60 = uVar14;
local_40 = param_1;
local_38 = (uint)param_3;
make_empty_page(param_1,puVar11,param_3,1);
local_34 = (uVar20 - *(int *)(lVar4 + 0xc18)) - 0x14;
local_44 = *(int *)(lVar4 + 0xc18) + 0xc;
lVar18 = (long)puVar11 + (uVar17 - 8);
local_50 = CONCAT44(local_50._4_4_,4);
local_58 = 2;
goto LAB_0015f1cf;
}
LAB_0015f2d8:
_ma_set_fatal_error(param_1,0x7f);
LAB_0015f2e2:
puVar13 = (int4 *)_my_thread_var();
uVar16 = *puVar13;
if (iVar21 != 2) goto LAB_0015f31b;
}
pagecache_unlock_by_link(*(int8 *)(lVar4 + 0x600),local_90,6,3,0,0,0,0);
LAB_0015f31b:
_ma_mark_file_crashed(lVar4);
puVar13 = (int4 *)_my_thread_var();
*puVar13 = uVar16;
return uVar16;
}
| |
31,222 | ggml_threadpool_resume | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_threadpool_resume(struct ggml_threadpool * threadpool) {
#ifndef GGML_USE_OPENMP
ggml_mutex_lock(&threadpool->mutex);
if (threadpool->pause) {
ggml_threadpool_resume_locked(threadpool);
}
ggml_mutex_unlock(&threadpool->mutex);
#else
UNUSED(threadpool);
#endif
} | O0 | c | ggml_threadpool_resume:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdfa0
movq -0x8(%rbp), %rax
testb $0x1, 0xc9(%rax)
je 0x1068b
movq -0x8(%rbp), %rdi
callq 0x106a0
movq -0x8(%rbp), %rdi
callq 0xd7a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| ggml_threadpool_resume:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
test byte ptr [rax+0C9h], 1
jz short loc_1068B
mov rdi, [rbp+var_8]
call ggml_threadpool_resume_locked
loc_1068B:
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
add rsp, 10h
pop rbp
retn
| long long ggml_threadpool_resume(long long a1)
{
pthread_mutex_lock(a1);
if ( (*(_BYTE *)(a1 + 201) & 1) != 0 )
ggml_threadpool_resume_locked(a1);
return pthread_mutex_unlock(a1);
}
| ggml_threadpool_resume:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010dfa0
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX + 0xc9],0x1
JZ 0x0011068b
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001106a0
LAB_0011068b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010d7a0
ADD RSP,0x10
POP RBP
RET
|
void ggml_threadpool_resume(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
if ((*(byte *)((long)param_1 + 0xc9) & 1) != 0) {
ggml_threadpool_resume_locked(param_1);
}
pthread_mutex_unlock(param_1);
return;
}
| |
31,223 | ggml_threadpool_resume | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_threadpool_resume(struct ggml_threadpool * threadpool) {
#ifndef GGML_USE_OPENMP
ggml_mutex_lock(&threadpool->mutex);
if (threadpool->pause) {
ggml_threadpool_resume_locked(threadpool);
}
ggml_mutex_unlock(&threadpool->mutex);
#else
UNUSED(threadpool);
#endif
} | O1 | c | ggml_threadpool_resume:
pushq %rbx
movq %rdi, %rbx
callq 0x8850
movb 0xc9(%rbx), %al
testb $0x1, %al
je 0xa523
xorl %eax, %eax
xchgb %al, 0xc9(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x81e0
movq %rbx, %rdi
popq %rbx
jmp 0x8430
| ggml_threadpool_resume:
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov al, [rbx+0C9h]
test al, 1
jz short loc_A523
xor eax, eax
xchg al, [rbx+0C9h]
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
loc_A523:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
| long long ggml_threadpool_resume(long long a1)
{
pthread_mutex_lock(a1);
if ( (*(_BYTE *)(a1 + 201) & 1) != 0 )
{
*(_BYTE *)(a1 + 201) = 0;
pthread_cond_broadcast(a1 + 40);
}
return pthread_mutex_unlock(a1);
}
| ggml_threadpool_resume:
PUSH RBX
MOV RBX,RDI
CALL 0x00108850
MOV AL,byte ptr [RBX + 0xc9]
TEST AL,0x1
JZ 0x0010a523
XOR EAX,EAX
XCHG byte ptr [RBX + 0xc9],AL
LEA RDI,[RBX + 0x28]
CALL 0x001081e0
LAB_0010a523:
MOV RDI,RBX
POP RBX
JMP 0x00108430
|
void ggml_threadpool_resume(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
if ((*(byte *)((long)param_1 + 0xc9) & 1) != 0) {
LOCK();
*(int1 *)((long)param_1 + 0xc9) = 0;
UNLOCK();
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 1));
}
pthread_mutex_unlock(param_1);
return;
}
| |
31,224 | ggml_threadpool_resume | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_threadpool_resume(struct ggml_threadpool * threadpool) {
#ifndef GGML_USE_OPENMP
ggml_mutex_lock(&threadpool->mutex);
if (threadpool->pause) {
ggml_threadpool_resume_locked(threadpool);
}
ggml_mutex_unlock(&threadpool->mutex);
#else
UNUSED(threadpool);
#endif
} | O2 | c | ggml_threadpool_resume:
pushq %rbx
movq %rdi, %rbx
callq 0x8980
movb 0xc9(%rbx), %al
testb $0x1, %al
je 0xa395
movq %rbx, %rdi
callq 0xa39e
movq %rbx, %rdi
popq %rbx
jmp 0x84f0
| ggml_threadpool_resume:
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov al, [rbx+0C9h]
test al, 1
jz short loc_A395
mov rdi, rbx
call ggml_threadpool_resume_locked
loc_A395:
mov rdi, rbx
pop rbx
jmp _pthread_mutex_unlock
| long long ggml_threadpool_resume(long long a1)
{
pthread_mutex_lock();
if ( (*(_BYTE *)(a1 + 201) & 1) != 0 )
ggml_threadpool_resume_locked(a1);
return pthread_mutex_unlock(a1);
}
| ggml_threadpool_resume:
PUSH RBX
MOV RBX,RDI
CALL 0x00108980
MOV AL,byte ptr [RBX + 0xc9]
TEST AL,0x1
JZ 0x0010a395
MOV RDI,RBX
CALL 0x0010a39e
LAB_0010a395:
MOV RDI,RBX
POP RBX
JMP 0x001084f0
|
void ggml_threadpool_resume(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
if ((*(byte *)((long)param_1 + 0xc9) & 1) != 0) {
ggml_threadpool_resume_locked(param_1);
}
pthread_mutex_unlock(param_1);
return;
}
| |
31,225 | OpenSubdiv::v3_6_0::Far::PatchDescriptor::print() const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchDescriptor.cpp | void
PatchDescriptor::print() const {
static char const * types[13] = {
"NON_PATCH", "POINTS", "LINES", "QUADS", "TRIANGLES", "LOOP",
"REGULAR", "GREGORY", "GREGORY_BOUNDARY", "GREGORY_BASIS",
"GREGORY_TRIANGLE"};
printf(" type %s\n",
types[_type]);
} | O3 | cpp | OpenSubdiv::v3_6_0::Far::PatchDescriptor::print() const:
movl (%rdi), %eax
leaq 0x783dd(%rip), %rcx # 0xe18e0
movq (%rcx,%rax,8), %rsi
leaq 0x5280c(%rip), %rdi # 0xbbd1a
xorl %eax, %eax
jmp 0x38100
nopl (%rax)
| _ZNK10OpenSubdiv6v3_6_03Far15PatchDescriptor5printEv:
mov eax, [rdi]
lea rcx, _ZZNK10OpenSubdiv6v3_6_03Far15PatchDescriptor5printEvE5types; OpenSubdiv::v3_6_0::Far::PatchDescriptor::print(void)::types
mov rsi, [rcx+rax*8]
lea rdi, aTypeS; " type %s\n"
xor eax, eax
jmp _printf
| long long OpenSubdiv::v3_6_0::Far::PatchDescriptor::print(OpenSubdiv::v3_6_0::Far::PatchDescriptor *this)
{
return printf(
" type %s\n",
OpenSubdiv::v3_6_0::Far::PatchDescriptor::print(void)const::types[*(unsigned int *)this]);
}
| print:
MOV EAX,dword ptr [RDI]
LEA RCX,[0x1e18e0]
MOV RSI,qword ptr [RCX + RAX*0x8]
LEA RDI,[0x1bbd1a]
XOR EAX,EAX
JMP 0x00138100
|
/* OpenSubdiv::v3_6_0::Far::PatchDescriptor::print() const */
void __thiscall OpenSubdiv::v3_6_0::Far::PatchDescriptor::print(PatchDescriptor *this)
{
printf(" type %s\n",*(int8 *)(print()::types + (ulong)*(uint *)this * 8));
return;
}
| |
31,226 | mp_mul_basecase | bluesky950520[P]quickjs/libbf.c | static void mp_mul_basecase(limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
limb_t i, r;
result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
result[i + op1_size] = r;
}
} | O1 | c | mp_mul_basecase:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r9
testq %rdx, %rdx
je 0x85097
movq (%rcx), %r10
xorl %ebx, %ebx
xorl %r11d, %r11d
movq %r10, %rax
mulq (%rsi,%r11,8)
addq %rbx, %rax
adcq $0x0, %rdx
movq %rax, (%rdi,%r11,8)
incq %r11
movq %rdx, %rbx
cmpq %r11, %r9
jne 0x85078
jmp 0x85099
xorl %edx, %edx
movq %rdx, (%rdi,%r9,8)
cmpq $0x2, %r8
jb 0x850f4
leaq 0x8(%rdi), %r11
movl $0x1, %ebx
testq %r9, %r9
je 0x850de
movq (%rcx,%rbx,8), %r10
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r10, %rax
mulq (%rsi,%r14,8)
addq %r15, %rax
adcq $0x0, %rdx
addq %rax, (%r11,%r14,8)
adcq $0x0, %rdx
incq %r14
movq %rdx, %r15
cmpq %r14, %r9
jne 0x850bb
jmp 0x850e0
xorl %edx, %edx
leaq (%rdi,%rbx,8), %rax
movq %rdx, (%rax,%r9,8)
incq %rbx
addq $0x8, %r11
cmpq %r8, %rbx
jne 0x850ac
popq %rbx
popq %r14
popq %r15
retq
| mp_mul_basecase:
push r15
push r14
push rbx
mov r9, rdx
test rdx, rdx
jz short loc_85097
mov r10, [rcx]
xor ebx, ebx
xor r11d, r11d
loc_85078:
mov rax, r10
mul qword ptr [rsi+r11*8]
add rax, rbx
adc rdx, 0
mov [rdi+r11*8], rax
inc r11
mov rbx, rdx
cmp r9, r11
jnz short loc_85078
jmp short loc_85099
loc_85097:
xor edx, edx
loc_85099:
mov [rdi+r9*8], rdx
cmp r8, 2
jb short loc_850F4
lea r11, [rdi+8]
mov ebx, 1
loc_850AC:
test r9, r9
jz short loc_850DE
mov r10, [rcx+rbx*8]
xor r14d, r14d
xor r15d, r15d
loc_850BB:
mov rax, r10
mul qword ptr [rsi+r14*8]
add rax, r15
adc rdx, 0
add [r11+r14*8], rax
adc rdx, 0
inc r14
mov r15, rdx
cmp r9, r14
jnz short loc_850BB
jmp short loc_850E0
loc_850DE:
xor edx, edx
loc_850E0:
lea rax, [rdi+rbx*8]
mov [rax+r9*8], rdx
inc rbx
add r11, 8
cmp rbx, r8
jnz short loc_850AC
loc_850F4:
pop rbx
pop r14
pop r15
retn
| long long mp_mul_basecase(long long a1, long long a2, long long a3, unsigned long long *a4, unsigned long long a5)
{
unsigned long long v6; // r10
unsigned long long v7; // rbx
long long i; // r11
unsigned __int128 v9; // rax
long long v10; // r11
long long j; // rbx
unsigned long long v12; // r10
long long v13; // r14
unsigned long long v14; // r15
bool v15; // cf
if ( a3 )
{
v6 = *a4;
v7 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v9 = v7 + *(unsigned long long *)(a2 + 8 * i) * (unsigned __int128)v6;
*(_QWORD *)(a1 + 8 * i) = v9;
v7 = *((_QWORD *)&v9 + 1);
}
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)(a1 + 8 * a3) = *((_QWORD *)&v9 + 1);
if ( a5 >= 2 )
{
v10 = a1 + 8;
for ( j = 1LL; j != a5; ++j )
{
if ( a3 )
{
v12 = a4[j];
v13 = 0LL;
v14 = 0LL;
do
{
v9 = v14 + *(unsigned long long *)(a2 + 8 * v13) * (unsigned __int128)v12;
v15 = __CFADD__((_QWORD)v9, *(_QWORD *)(v10 + 8 * v13));
*(_QWORD *)(v10 + 8 * v13) += v9;
*((_QWORD *)&v9 + 1) += v15;
++v13;
v14 = *((_QWORD *)&v9 + 1);
}
while ( a3 != v13 );
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)&v9 = a1 + 8 * j;
*(_QWORD *)(v9 + 8 * a3) = *((_QWORD *)&v9 + 1);
v10 += 8LL;
}
}
return v9;
}
| mp_mul_basecase:
PUSH R15
PUSH R14
PUSH RBX
MOV R9,RDX
TEST RDX,RDX
JZ 0x00185097
MOV R10,qword ptr [RCX]
XOR EBX,EBX
XOR R11D,R11D
LAB_00185078:
MOV RAX,R10
MUL qword ptr [RSI + R11*0x8]
ADD RAX,RBX
ADC RDX,0x0
MOV qword ptr [RDI + R11*0x8],RAX
INC R11
MOV RBX,RDX
CMP R9,R11
JNZ 0x00185078
JMP 0x00185099
LAB_00185097:
XOR EDX,EDX
LAB_00185099:
MOV qword ptr [RDI + R9*0x8],RDX
CMP R8,0x2
JC 0x001850f4
LEA R11,[RDI + 0x8]
MOV EBX,0x1
LAB_001850ac:
TEST R9,R9
JZ 0x001850de
MOV R10,qword ptr [RCX + RBX*0x8]
XOR R14D,R14D
XOR R15D,R15D
LAB_001850bb:
MOV RAX,R10
MUL qword ptr [RSI + R14*0x8]
ADD RAX,R15
ADC RDX,0x0
ADD qword ptr [R11 + R14*0x8],RAX
ADC RDX,0x0
INC R14
MOV R15,RDX
CMP R9,R14
JNZ 0x001850bb
JMP 0x001850e0
LAB_001850de:
XOR EDX,EDX
LAB_001850e0:
LEA RAX,[RDI + RBX*0x8]
MOV qword ptr [RAX + R9*0x8],RDX
INC RBX
ADD R11,0x8
CMP RBX,R8
JNZ 0x001850ac
LAB_001850f4:
POP RBX
POP R14
POP R15
RET
|
void mp_mul_basecase(long param_1,long param_2,long param_3,ulong *param_4,ulong param_5)
{
ulong *puVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long lVar13;
if (param_3 == 0) {
uVar10 = 0;
}
else {
uVar11 = *param_4;
uVar10 = 0;
lVar12 = 0;
do {
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar10;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_2 + lVar12 * 8);
auVar7 = auVar3 * auVar5 + auVar7;
uVar10 = auVar7._8_8_;
*(long *)(param_1 + lVar12 * 8) = auVar7._0_8_;
lVar12 = lVar12 + 1;
} while (param_3 != lVar12);
}
*(ulong *)(param_1 + param_3 * 8) = uVar10;
if (1 < param_5) {
lVar12 = param_1 + 8;
uVar10 = 1;
do {
if (param_3 == 0) {
uVar11 = 0;
}
else {
uVar2 = param_4[uVar10];
lVar13 = 0;
uVar11 = 0;
do {
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar11;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = *(ulong *)(param_2 + lVar13 * 8);
auVar8 = auVar4 * auVar6 + auVar8;
uVar9 = auVar8._0_8_;
puVar1 = (ulong *)(lVar12 + lVar13 * 8);
uVar11 = *puVar1;
*puVar1 = *puVar1 + uVar9;
uVar11 = auVar8._8_8_ + (ulong)CARRY8(uVar11,uVar9);
lVar13 = lVar13 + 1;
} while (param_3 != lVar13);
}
*(ulong *)(param_1 + uVar10 * 8 + param_3 * 8) = uVar11;
uVar10 = uVar10 + 1;
lVar12 = lVar12 + 8;
} while (uVar10 != param_5);
}
return;
}
| |
31,227 | mp_mul_basecase | bluesky950520[P]quickjs/libbf.c | static void mp_mul_basecase(limb_t *result,
const limb_t *op1, limb_t op1_size,
const limb_t *op2, limb_t op2_size)
{
limb_t i, r;
result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
for(i=1;i<op2_size;i++) {
r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
result[i + op1_size] = r;
}
} | O3 | c | mp_mul_basecase:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r9
testq %rdx, %rdx
je 0x87ab1
movq (%rcx), %r10
xorl %ebx, %ebx
xorl %r11d, %r11d
movq %r10, %rax
mulq (%rsi,%r11,8)
addq %rbx, %rax
adcq $0x0, %rdx
movq %rax, (%rdi,%r11,8)
incq %r11
movq %rdx, %rbx
cmpq %r11, %r9
jne 0x87a92
jmp 0x87ab3
xorl %edx, %edx
movq %rdx, (%rdi,%r9,8)
cmpq $0x2, %r8
jb 0x87b0e
leaq 0x8(%rdi), %r11
movl $0x1, %ebx
testq %r9, %r9
je 0x87af8
movq (%rcx,%rbx,8), %r10
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r10, %rax
mulq (%rsi,%r14,8)
addq %r15, %rax
adcq $0x0, %rdx
addq %rax, (%r11,%r14,8)
adcq $0x0, %rdx
incq %r14
movq %rdx, %r15
cmpq %r14, %r9
jne 0x87ad5
jmp 0x87afa
xorl %edx, %edx
leaq (%rdi,%rbx,8), %rax
movq %rdx, (%rax,%r9,8)
incq %rbx
addq $0x8, %r11
cmpq %r8, %rbx
jne 0x87ac6
popq %rbx
popq %r14
popq %r15
retq
| mp_mul_basecase:
push r15
push r14
push rbx
mov r9, rdx
test rdx, rdx
jz short loc_87AB1
mov r10, [rcx]
xor ebx, ebx
xor r11d, r11d
loc_87A92:
mov rax, r10
mul qword ptr [rsi+r11*8]
add rax, rbx
adc rdx, 0
mov [rdi+r11*8], rax
inc r11
mov rbx, rdx
cmp r9, r11
jnz short loc_87A92
jmp short loc_87AB3
loc_87AB1:
xor edx, edx
loc_87AB3:
mov [rdi+r9*8], rdx
cmp r8, 2
jb short loc_87B0E
lea r11, [rdi+8]
mov ebx, 1
loc_87AC6:
test r9, r9
jz short loc_87AF8
mov r10, [rcx+rbx*8]
xor r14d, r14d
xor r15d, r15d
loc_87AD5:
mov rax, r10
mul qword ptr [rsi+r14*8]
add rax, r15
adc rdx, 0
add [r11+r14*8], rax
adc rdx, 0
inc r14
mov r15, rdx
cmp r9, r14
jnz short loc_87AD5
jmp short loc_87AFA
loc_87AF8:
xor edx, edx
loc_87AFA:
lea rax, [rdi+rbx*8]
mov [rax+r9*8], rdx
inc rbx
add r11, 8
cmp rbx, r8
jnz short loc_87AC6
loc_87B0E:
pop rbx
pop r14
pop r15
retn
| long long mp_mul_basecase(long long a1, long long a2, long long a3, unsigned long long *a4, unsigned long long a5)
{
unsigned long long v6; // r10
unsigned long long v7; // rbx
long long i; // r11
unsigned __int128 v9; // rax
long long v10; // r11
long long j; // rbx
unsigned long long v12; // r10
long long v13; // r14
unsigned long long v14; // r15
bool v15; // cf
if ( a3 )
{
v6 = *a4;
v7 = 0LL;
for ( i = 0LL; i != a3; ++i )
{
v9 = v7 + *(unsigned long long *)(a2 + 8 * i) * (unsigned __int128)v6;
*(_QWORD *)(a1 + 8 * i) = v9;
v7 = *((_QWORD *)&v9 + 1);
}
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)(a1 + 8 * a3) = *((_QWORD *)&v9 + 1);
if ( a5 >= 2 )
{
v10 = a1 + 8;
for ( j = 1LL; j != a5; ++j )
{
if ( a3 )
{
v12 = a4[j];
v13 = 0LL;
v14 = 0LL;
do
{
v9 = v14 + *(unsigned long long *)(a2 + 8 * v13) * (unsigned __int128)v12;
v15 = __CFADD__((_QWORD)v9, *(_QWORD *)(v10 + 8 * v13));
*(_QWORD *)(v10 + 8 * v13) += v9;
*((_QWORD *)&v9 + 1) += v15;
++v13;
v14 = *((_QWORD *)&v9 + 1);
}
while ( a3 != v13 );
}
else
{
*((_QWORD *)&v9 + 1) = 0LL;
}
*(_QWORD *)&v9 = a1 + 8 * j;
*(_QWORD *)(v9 + 8 * a3) = *((_QWORD *)&v9 + 1);
v10 += 8LL;
}
}
return v9;
}
| mp_mul_basecase:
PUSH R15
PUSH R14
PUSH RBX
MOV R9,RDX
TEST RDX,RDX
JZ 0x00187ab1
MOV R10,qword ptr [RCX]
XOR EBX,EBX
XOR R11D,R11D
LAB_00187a92:
MOV RAX,R10
MUL qword ptr [RSI + R11*0x8]
ADD RAX,RBX
ADC RDX,0x0
MOV qword ptr [RDI + R11*0x8],RAX
INC R11
MOV RBX,RDX
CMP R9,R11
JNZ 0x00187a92
JMP 0x00187ab3
LAB_00187ab1:
XOR EDX,EDX
LAB_00187ab3:
MOV qword ptr [RDI + R9*0x8],RDX
CMP R8,0x2
JC 0x00187b0e
LEA R11,[RDI + 0x8]
MOV EBX,0x1
LAB_00187ac6:
TEST R9,R9
JZ 0x00187af8
MOV R10,qword ptr [RCX + RBX*0x8]
XOR R14D,R14D
XOR R15D,R15D
LAB_00187ad5:
MOV RAX,R10
MUL qword ptr [RSI + R14*0x8]
ADD RAX,R15
ADC RDX,0x0
ADD qword ptr [R11 + R14*0x8],RAX
ADC RDX,0x0
INC R14
MOV R15,RDX
CMP R9,R14
JNZ 0x00187ad5
JMP 0x00187afa
LAB_00187af8:
XOR EDX,EDX
LAB_00187afa:
LEA RAX,[RDI + RBX*0x8]
MOV qword ptr [RAX + R9*0x8],RDX
INC RBX
ADD R11,0x8
CMP RBX,R8
JNZ 0x00187ac6
LAB_00187b0e:
POP RBX
POP R14
POP R15
RET
|
void mp_mul_basecase(long param_1,long param_2,long param_3,ulong *param_4,ulong param_5)
{
ulong *puVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
ulong uVar11;
long lVar12;
long lVar13;
if (param_3 == 0) {
uVar10 = 0;
}
else {
uVar11 = *param_4;
uVar10 = 0;
lVar12 = 0;
do {
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar10;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar11;
auVar5._8_8_ = 0;
auVar5._0_8_ = *(ulong *)(param_2 + lVar12 * 8);
auVar7 = auVar3 * auVar5 + auVar7;
uVar10 = auVar7._8_8_;
*(long *)(param_1 + lVar12 * 8) = auVar7._0_8_;
lVar12 = lVar12 + 1;
} while (param_3 != lVar12);
}
*(ulong *)(param_1 + param_3 * 8) = uVar10;
if (1 < param_5) {
lVar12 = param_1 + 8;
uVar10 = 1;
do {
if (param_3 == 0) {
uVar11 = 0;
}
else {
uVar2 = param_4[uVar10];
lVar13 = 0;
uVar11 = 0;
do {
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar11;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = *(ulong *)(param_2 + lVar13 * 8);
auVar8 = auVar4 * auVar6 + auVar8;
uVar9 = auVar8._0_8_;
puVar1 = (ulong *)(lVar12 + lVar13 * 8);
uVar11 = *puVar1;
*puVar1 = *puVar1 + uVar9;
uVar11 = auVar8._8_8_ + (ulong)CARRY8(uVar11,uVar9);
lVar13 = lVar13 + 1;
} while (param_3 != lVar13);
}
*(ulong *)(param_1 + uVar10 * 8 + param_3 * 8) = uVar11;
uVar10 = uVar10 + 1;
lVar12 = lVar12 + 8;
} while (uVar10 != param_5);
}
return;
}
| |
31,228 | translog_write_variable_record_1chunk | eloqsql/storage/maria/ma_loghandler.c | static my_bool
translog_write_variable_record_1chunk(LSN *lsn,
enum translog_record_type type,
MARIA_HA *tbl_info,
SHORT_TRANSACTION_ID short_trid,
struct st_translog_parts *parts,
struct st_translog_buffer
*buffer_to_flush, uint16 header_length,
TRN *trn, void *hook_arg)
{
int rc;
uchar chunk0_header[1 + 2 + 5 + 2];
DBUG_ENTER("translog_write_variable_record_1chunk");
translog_lock_assert_owner();
if (buffer_to_flush)
translog_buffer_lock_assert_owner(buffer_to_flush);
translog_write_variable_record_1group_header(parts, type, short_trid,
header_length, chunk0_header);
set_lsn(lsn, log_descriptor.horizon);
if (translog_set_lsn_for_files(LSN_FILE_NO(*lsn), LSN_FILE_NO(*lsn),
*lsn, TRUE) ||
(log_record_type_descriptor[type].inwrite_hook &&
(*log_record_type_descriptor[type].inwrite_hook)(type, trn, tbl_info,
lsn, hook_arg)))
{
translog_unlock();
rc= 1;
goto err;
}
rc= translog_write_parts_on_page(&log_descriptor.horizon,
&log_descriptor.bc,
parts->total_record_length, parts);
log_descriptor.bc.buffer->last_lsn= *lsn;
DBUG_PRINT("info", ("last_lsn set to " LSN_FMT " buffer: %p",
LSN_IN_PARTS(log_descriptor.bc.buffer->last_lsn),
log_descriptor.bc.buffer));
translog_unlock();
/*
check if we switched buffer and need process it (current buffer is
unlocked already => we will not delay other threads
*/
err:
if (buffer_to_flush != NULL)
{
if (!rc)
rc= translog_buffer_flush(buffer_to_flush);
translog_buffer_unlock(buffer_to_flush);
}
DBUG_RETURN(rc);
} | O0 | c | translog_write_variable_record_1chunk:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %cx, %ax
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %rcx
movw 0x10(%rbp), %cx
movq %fs:0x28, %rcx
movq %rcx, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %rdx, -0x30(%rbp)
movw %ax, -0x32(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x91b14
jmp 0x91b14
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
movw -0x32(%rbp), %cx
movw 0x10(%rbp), %ax
leaq -0x12(%rbp), %r8
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x92f70
movq -0x20(%rbp), %rdi
movq 0xbf359b(%rip), %rsi # 0xc850d8
callq 0x93040
movq -0x20(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %edi
movq -0x20(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movl %eax, %esi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movl $0x1, %ecx
callq 0x93070
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x91bc3
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x3f170f(%rip), %rax # 0x483290
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x91bd1
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x3f16f5(%rip), %rax # 0x483290
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %edi
movq 0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq 0x20(%rbp), %r8
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0x91bd1
callq 0x87e30
movl $0x1, -0x4c(%rbp)
jmp 0x91c1b
movq -0x40(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x40(%rbp), %rcx
leaq 0x3f28ad(%rip), %rsi # 0x484490
movq %rsi, %rdi
addq $0x800c48, %rdi # imm = 0x800C48
addq $0x800c50, %rsi # imm = 0x800C50
callq 0x93210
movsbl %al, %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0xbf34fb(%rip), %rax # 0xc85108
movq %rcx, 0x100000(%rax)
jmp 0x91c16
callq 0x87e30
cmpq $0x0, -0x48(%rbp)
je 0x91c40
cmpl $0x0, -0x4c(%rbp)
jne 0x91c37
movq -0x48(%rbp), %rdi
callq 0x8dff0
movsbl %al, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x87e00
jmp 0x91c42
movl -0x4c(%rbp), %eax
movb %al, -0x4d(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x91c63
movb -0x4d(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
callq 0x2a260
nopl (%rax,%rax)
| translog_write_variable_record_1chunk:
push rbp
mov rbp, rsp
sub rsp, 50h
mov ax, cx
mov rcx, [rbp+arg_10]
mov rcx, [rbp+arg_8]
mov cx, [rbp+arg_0]
mov rcx, fs:28h
mov [rbp+var_8], rcx
mov [rbp+var_20], rdi
mov [rbp+var_24], esi
mov [rbp+var_30], rdx
mov [rbp+var_32], ax
mov [rbp+var_40], r8
mov [rbp+var_48], r9
cmp [rbp+var_48], 0
jz short loc_91B14
jmp short $+2
loc_91B14:
mov rdi, [rbp+var_40]
mov esi, [rbp+var_24]
mov cx, [rbp+var_32]
mov ax, [rbp+arg_0]
lea r8, [rbp+var_12]
movzx edx, cx
movzx ecx, ax
call translog_write_variable_record_1group_header
mov rdi, [rbp+var_20]
mov rsi, cs:qword_C850D8
call set_lsn
mov rax, [rbp+var_20]
mov rax, [rax]
sar rax, 20h
mov edi, eax
mov rax, [rbp+var_20]
mov rax, [rax]
sar rax, 20h
mov esi, eax
mov rax, [rbp+var_20]
mov rdx, [rax]
mov ecx, 1
call translog_set_lsn_for_files
movsx eax, al
cmp eax, 0
jnz short loc_91BC3
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
cmp qword ptr [rax+10h], 0
jz short loc_91BD1
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
mov rax, [rax+10h]
mov edi, [rbp+var_24]
mov rsi, [rbp+arg_8]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_20]
mov r8, [rbp+arg_10]
call rax
movsx eax, al
cmp eax, 0
jz short loc_91BD1
loc_91BC3:
call translog_unlock
mov [rbp+var_4C], 1
jmp short loc_91C1B
loc_91BD1:
mov rax, [rbp+var_40]
mov edx, [rax+4]
mov rcx, [rbp+var_40]
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800C48h
add rsi, 800C50h
call translog_write_parts_on_page
movsx eax, al
mov [rbp+var_4C], eax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, cs:qword_C85108
mov [rax+100000h], rcx
jmp short $+2
loc_91C16:
call translog_unlock
loc_91C1B:
cmp [rbp+var_48], 0
jz short loc_91C40
cmp [rbp+var_4C], 0
jnz short loc_91C37
mov rdi, [rbp+var_48]
call translog_buffer_flush
movsx eax, al
mov [rbp+var_4C], eax
loc_91C37:
mov rdi, [rbp+var_48]
call translog_buffer_unlock
loc_91C40:
jmp short $+2
loc_91C42:
mov eax, [rbp+var_4C]
mov [rbp+var_4D], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_91C63
mov al, [rbp+var_4D]
add rsp, 50h
pop rbp
retn
loc_91C63:
call ___stack_chk_fail
| char translog_write_variable_record_1chunk(
_QWORD *a1,
unsigned int a2,
long long a3,
unsigned __int16 a4,
long long a5,
long long a6,
unsigned __int16 a7,
long long a8,
long long a9)
{
int v10; // [rsp+4h] [rbp-4Ch]
_BYTE v14[10]; // [rsp+3Eh] [rbp-12h] BYREF
unsigned long long v15; // [rsp+48h] [rbp-8h]
v15 = __readfsqword(0x28u);
translog_write_variable_record_1group_header(a5, a2, a4, a7, v14);
set_lsn(a1, qword_C850D8);
if ( (unsigned __int8)translog_set_lsn_for_files((unsigned int)HIDWORD(*a1), (unsigned int)HIDWORD(*a1), *a1, 1LL)
|| *(_QWORD *)&log_record_type_descriptor[18 * a2 + 4]
&& (*(unsigned __int8 ( **)(_QWORD, long long, long long, _QWORD *, long long))&log_record_type_descriptor[18 * a2 + 4])(
a2,
a8,
a3,
a1,
a9) )
{
translog_unlock();
v10 = 1;
}
else
{
v10 = (char)translog_write_parts_on_page(
&log_descriptor[1048969],
&log_descriptor[1048970],
*(unsigned int *)(a5 + 4),
a5);
*(_QWORD *)(qword_C85108 + 0x100000) = *a1;
translog_unlock();
}
if ( a6 )
{
if ( !v10 )
LOBYTE(v10) = translog_buffer_flush(a6);
translog_buffer_unlock(a6);
}
return v10;
}
| translog_write_variable_record_1chunk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AX,CX
MOV RCX,qword ptr [RBP + 0x20]
MOV RCX,qword ptr [RBP + 0x18]
MOV CX,word ptr [RBP + 0x10]
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV dword ptr [RBP + -0x24],ESI
MOV qword ptr [RBP + -0x30],RDX
MOV word ptr [RBP + -0x32],AX
MOV qword ptr [RBP + -0x40],R8
MOV qword ptr [RBP + -0x48],R9
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00191b14
JMP 0x00191b14
LAB_00191b14:
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x24]
MOV CX,word ptr [RBP + -0x32]
MOV AX,word ptr [RBP + 0x10]
LEA R8,[RBP + -0x12]
MOVZX EDX,CX
MOVZX ECX,AX
CALL 0x00192f70
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [0x00d850d8]
CALL 0x00193040
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX]
MOV ECX,0x1
CALL 0x00193070
MOVSX EAX,AL
CMP EAX,0x0
JNZ 0x00191bc3
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
LEA RAX,[0x583290]
IMUL RCX,RCX,0x48
ADD RAX,RCX
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00191bd1
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
LEA RAX,[0x583290]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV EDI,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + 0x20]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00191bd1
LAB_00191bc3:
CALL 0x00187e30
MOV dword ptr [RBP + -0x4c],0x1
JMP 0x00191c1b
LAB_00191bd1:
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[0x584490]
MOV RDI,RSI
ADD RDI,0x800c48
ADD RSI,0x800c50
CALL 0x00193210
MOVSX EAX,AL
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [0x00d85108]
MOV qword ptr [RAX + 0x100000],RCX
JMP 0x00191c16
LAB_00191c16:
CALL 0x00187e30
LAB_00191c1b:
CMP qword ptr [RBP + -0x48],0x0
JZ 0x00191c40
CMP dword ptr [RBP + -0x4c],0x0
JNZ 0x00191c37
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0018dff0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x4c],EAX
LAB_00191c37:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00187e00
LAB_00191c40:
JMP 0x00191c42
LAB_00191c42:
MOV EAX,dword ptr [RBP + -0x4c]
MOV byte ptr [RBP + -0x4d],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00191c63
MOV AL,byte ptr [RBP + -0x4d]
ADD RSP,0x50
POP RBP
RET
LAB_00191c63:
CALL 0x0012a260
|
int8
translog_write_variable_record_1chunk
(long *param_1,uint param_2,int8 param_3,int2 param_4,long param_5,
long param_6,int2 param_7,int8 param_8,int8 param_9)
{
char cVar1;
long in_FS_OFFSET;
int1 local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
translog_write_variable_record_1group_header(param_5,param_2,param_4,param_7,local_1a);
set_lsn(param_1,DAT_00d850d8);
cVar1 = translog_set_lsn_for_files
(*param_1 >> 0x20 & 0xffffffff,*param_1 >> 0x20 & 0xffffffff,*param_1,1);
if ((cVar1 == '\0') &&
((*(long *)(log_record_type_descriptor + (ulong)param_2 * 0x48 + 0x10) == 0 ||
(cVar1 = (**(code **)(log_record_type_descriptor + (ulong)param_2 * 0x48 + 0x10))
(param_2,param_8,param_3,param_1,param_9), cVar1 == '\0')))) {
cVar1 = translog_write_parts_on_page
(&DAT_00d850d8,&DAT_00d850e0,*(int4 *)(param_5 + 4),param_5);
*(long *)(DAT_00d85108 + 0x100000) = *param_1;
translog_unlock();
}
else {
translog_unlock();
cVar1 = '\x01';
}
if (param_6 != 0) {
if (cVar1 == '\0') {
cVar1 = translog_buffer_flush(param_6);
}
translog_buffer_unlock(param_6);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),cVar1);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,229 | trnman_get_min_safe_trid | eloqsql/storage/maria/trnman.c | TrID trnman_get_min_safe_trid()
{
TrID trid;
mysql_mutex_lock(&LOCK_trn_list);
trid= MY_MIN(active_list_min.next->min_read_from,
global_trid_generator);
mysql_mutex_unlock(&LOCK_trn_list);
return trid;
} | O0 | c | trnman_get_min_safe_trid:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x449b21(%rip), %rdi # 0x4763b0
leaq 0x1239fb(%rip), %rsi # 0x150291
movl $0x37a, %edx # imm = 0x37A
callq 0x2b950
movq 0x4497c9(%rip), %rax # 0x476070
movq 0x80(%rax), %rax
cmpq 0x449a2b(%rip), %rax # 0x4762e0
jae 0x2c8cb
movq 0x4497b2(%rip), %rax # 0x476070
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2c8d6
movq 0x449a0e(%rip), %rax # 0x4762e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x449acb(%rip), %rdi # 0x4763b0
callq 0x2b9c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| trnman_get_min_safe_trid:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 37Ah
call inline_mysql_mutex_lock
mov rax, cs:qword_476070
mov rax, [rax+80h]
cmp rax, cs:global_trid_generator
jnb short loc_2C8CB
mov rax, cs:qword_476070
mov rax, [rax+80h]
mov [rbp+var_10], rax
jmp short loc_2C8D6
loc_2C8CB:
mov rax, cs:global_trid_generator
mov [rbp+var_10], rax
loc_2C8D6:
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long trnman_get_min_safe_trid()
{
long long v1; // [rsp+0h] [rbp-10h]
inline_mysql_mutex_lock(
(long long)&LOCK_trn_list,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",
0x37Au);
if ( *(_QWORD *)(qword_476070 + 128) >= (unsigned long long)global_trid_generator )
v1 = global_trid_generator;
else
v1 = *(_QWORD *)(qword_476070 + 128);
inline_mysql_mutex_unlock((long long)&LOCK_trn_list);
return v1;
}
| trnman_get_min_safe_trid:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x5763b0]
LEA RSI,[0x250291]
MOV EDX,0x37a
CALL 0x0012b950
MOV RAX,qword ptr [0x00576070]
MOV RAX,qword ptr [RAX + 0x80]
CMP RAX,qword ptr [0x005762e0]
JNC 0x0012c8cb
MOV RAX,qword ptr [0x00576070]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0012c8d6
LAB_0012c8cb:
MOV RAX,qword ptr [0x005762e0]
MOV qword ptr [RBP + -0x10],RAX
LAB_0012c8d6:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[0x5763b0]
CALL 0x0012b9c0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
ulong trnman_get_min_safe_trid(void)
{
ulong local_18;
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x37a);
if (*(ulong *)(active_list_min._104_8_ + 0x80) < global_trid_generator) {
local_18 = *(ulong *)(active_list_min._104_8_ + 0x80);
}
else {
local_18 = global_trid_generator;
}
inline_mysql_mutex_unlock(LOCK_trn_list);
return local_18;
}
| |
31,230 | cpu_get_num_physical_cores() | monkey531[P]llama/common/common.cpp | int32_t cpu_get_num_physical_cores() {
#ifdef __linux__
// enumerate the set of thread siblings, num entries is num cores
std::unordered_set<std::string> siblings;
for (uint32_t cpu=0; cpu < UINT32_MAX; ++cpu) {
std::ifstream thread_siblings("/sys/devices/system/cpu/cpu"
+ std::to_string(cpu) + "/topology/thread_siblings");
if (!thread_siblings.is_open()) {
break; // no more cpus
}
std::string line;
if (std::getline(thread_siblings, line)) {
siblings.insert(line);
}
}
if (!siblings.empty()) {
return static_cast<int32_t>(siblings.size());
}
#elif defined(__APPLE__) && defined(__MACH__)
int32_t num_physical_cores;
size_t len = sizeof(num_physical_cores);
int result = sysctlbyname("hw.perflevel0.physicalcpu", &num_physical_cores, &len, NULL, 0);
if (result == 0) {
return num_physical_cores;
}
result = sysctlbyname("hw.physicalcpu", &num_physical_cores, &len, NULL, 0);
if (result == 0) {
return num_physical_cores;
}
#elif defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
unsigned int n_threads_win = std::thread::hardware_concurrency();
unsigned int default_threads = n_threads_win > 0 ? (n_threads_win <= 4 ? n_threads_win : n_threads_win / 2) : 4;
DWORD buffer_size = 0;
if (!GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &buffer_size)) {
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
return default_threads;
}
}
std::vector<char> buffer(buffer_size);
if (!GetLogicalProcessorInformationEx(RelationProcessorCore, reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(buffer.data()), &buffer_size)) {
return default_threads;
}
int32_t num_physical_cores = 0;
PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX info = reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(buffer.data());
while (buffer_size > 0) {
if (info->Relationship == RelationProcessorCore) {
num_physical_cores += info->Processor.GroupCount;
}
buffer_size -= info->Size;
info = reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(reinterpret_cast<char*>(info) + info->Size);
}
return num_physical_cores > 0 ? num_physical_cores : default_threads;
#endif
unsigned int n_threads = std::thread::hardware_concurrency();
return n_threads > 0 ? (n_threads <= 4 ? n_threads : n_threads / 2) : 4;
} | O0 | cpp | cpu_get_num_physical_cores():
subq $0x328, %rsp # imm = 0x328
leaq 0x2e8(%rsp), %rdi
callq 0xf9080
movl $0x0, 0x2e4(%rsp)
cmpl $-0x1, 0x2e4(%rsp)
jae 0xed140
movl 0x2e4(%rsp), %esi
leaq 0x78(%rsp), %rdi
callq 0xf90e0
jmp 0xecf30
leaq 0x124c8d(%rip), %rsi # 0x211bc4
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xf9090
jmp 0xecf4b
leaq 0x124c8e(%rip), %rdx # 0x211be0
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x676e0
jmp 0xecf69
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
movl $0x8, %edx
callq 0x5b270
jmp 0xecf85
leaq 0xb8(%rsp), %rdi
callq 0x5b568
leaq 0x98(%rsp), %rdi
callq 0x5b568
leaq 0x78(%rsp), %rdi
callq 0x5b568
leaq 0xd8(%rsp), %rdi
callq 0x5b040
movb %al, 0x33(%rsp)
jmp 0xecfbc
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0xed054
jmp 0xecfca
movl $0x2, 0x68(%rsp)
jmp 0xed0fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xed1de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xed032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xed025
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x5b568
leaq 0x98(%rsp), %rdi
callq 0x5b568
leaq 0x78(%rsp), %rdi
callq 0x5b568
jmp 0xed1de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xed12e
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5a5f0
movq 0x20(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x5a8e0
movq %rax, 0x28(%rsp)
jmp 0xed07c
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5a630
movb %al, 0x1f(%rsp)
jmp 0xed096
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xed0a0
jmp 0xed0eb
leaq 0x2e8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf91e0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0xed0bd
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movb %al, 0x40(%rsp)
jmp 0xed0eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b568
jmp 0xed12e
leaq 0x48(%rsp), %rdi
callq 0x5b568
movl $0x0, 0x68(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x5a0b0
movl 0x68(%rsp), %eax
testl %eax, %eax
je 0xed116
jmp 0xed114
jmp 0xed140
jmp 0xed118
movl 0x2e4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2e4(%rsp)
jmp 0xecf0f
leaq 0xd8(%rsp), %rdi
callq 0x5a0b0
jmp 0xed1de
leaq 0x2e8(%rsp), %rdi
callq 0xf9230
testb $0x1, %al
jne 0xed16f
leaq 0x2e8(%rsp), %rdi
callq 0xf9250
movl %eax, 0x324(%rsp)
movl $0x1, 0x68(%rsp)
jmp 0xed1c2
callq 0x5ae50
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jbe 0xed1a4
cmpl $0x4, 0x34(%rsp)
ja 0xed190
movl 0x34(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0xed19a
movl 0x34(%rsp), %eax
shrl %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0xed1af
movl $0x4, %eax
movl %eax, 0x4(%rsp)
jmp 0xed1af
movl 0x4(%rsp), %eax
movl %eax, 0x324(%rsp)
movl $0x1, 0x68(%rsp)
leaq 0x2e8(%rsp), %rdi
callq 0xf9260
movl 0x324(%rsp), %eax
addq $0x328, %rsp # imm = 0x328
retq
leaq 0x2e8(%rsp), %rdi
callq 0xf9260
movq 0x70(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
| _Z26cpu_get_num_physical_coresv:
sub rsp, 328h
lea rdi, [rsp+328h+var_40]
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EEC2Ev; std::unordered_set<std::string>::unordered_set(void)
mov [rsp+328h+var_44], 0
loc_ECF0F:
cmp [rsp+328h+var_44], 0FFFFFFFFh
jnb loc_ED140
mov esi, [rsp+328h+var_44]; unsigned int
lea rdi, [rsp+328h+var_2B0]; this
call _ZNSt7__cxx119to_stringEj; std::to_string(uint)
jmp short $+2
loc_ECF30:
lea rsi, aSysDevicesSyst; "/sys/devices/system/cpu/cpu"
lea rdi, [rsp+328h+var_290]
lea rdx, [rsp+328h+var_2B0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_ECF4B:
lea rdx, aTopologyThread; "/topology/thread_siblings"
lea rdi, [rsp+328h+var_270]
lea rsi, [rsp+328h+var_290]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_ECF69:
lea rdi, [rsp+328h+var_250]
lea rsi, [rsp+328h+var_270]
mov edx, 8
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ifstream::basic_ifstream(std::string const&,std::_Ios_Openmode)
jmp short $+2
loc_ECF85:
lea rdi, [rsp+328h+var_270]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+328h+var_290]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+328h+var_2B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+328h+var_250]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv; std::ifstream::is_open(void)
mov [rsp+328h+var_2F5], al
jmp short $+2
loc_ECFBC:
mov al, [rsp+328h+var_2F5]
test al, 1
jnz loc_ED054
jmp short $+2
loc_ECFCA:
mov [rsp+328h+var_2C0], 2
jmp loc_ED0FD
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
jmp loc_ED1DE
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
jmp short loc_ED032
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
jmp short loc_ED025
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_ED025:
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_ED032:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_ED1DE
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
jmp loc_ED12E
loc_ED054:
lea rdi, [rsp+328h+var_2E0]
mov [rsp+328h+var_308], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rsi, [rsp+328h+var_308]
lea rdi, [rsp+328h+var_250]
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &)
mov [rsp+328h+var_300], rax
jmp short $+2
loc_ED07C:
mov rdi, [rsp+328h+var_300]
mov rax, [rdi]
mov rax, [rax-18h]
add rdi, rax
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
mov [rsp+328h+var_309], al
jmp short $+2
loc_ED096:
mov al, [rsp+328h+var_309]
test al, 1
jnz short loc_ED0A0
jmp short loc_ED0EB
loc_ED0A0:
lea rdi, [rsp+328h+var_40]
lea rsi, [rsp+328h+var_2E0]
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EE6insertERKS5_; std::unordered_set<std::string>::insert(std::string const&)
mov [rsp+328h+var_319], dl
mov [rsp+328h+var_318], rax
jmp short $+2
loc_ED0BD:
mov al, [rsp+328h+var_319]
mov rcx, [rsp+328h+var_318]
mov [rsp+328h+var_2F0], rcx
mov [rsp+328h+var_2E8], al
jmp short loc_ED0EB
mov rcx, rax
mov eax, edx
mov [rsp+arg_68], rcx
mov [rsp+arg_64], eax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_ED12E
loc_ED0EB:
lea rdi, [rsp+328h+var_2E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov [rsp+328h+var_2C0], 0
loc_ED0FD:
lea rdi, [rsp+328h+var_250]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
mov eax, [rsp+328h+var_2C0]
test eax, eax
jz short loc_ED116
jmp short $+2
loc_ED114:
jmp short loc_ED140
loc_ED116:
jmp short $+2
loc_ED118:
mov eax, [rsp+328h+var_44]
add eax, 1
mov [rsp+328h+var_44], eax
jmp loc_ECF0F
loc_ED12E:
lea rdi, [rsp+arg_D0]
call __ZNSt14basic_ifstreamIcSt11char_traitsIcEED1Ev; std::ifstream::~ifstream()
jmp loc_ED1DE
loc_ED140:
lea rdi, [rsp+328h+var_40]; this
call _ZNKSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EE5emptyEv; std::unordered_set<std::string>::empty(void)
test al, 1
jnz short loc_ED16F
lea rdi, [rsp+328h+var_40]
call _ZNKSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EE4sizeEv; std::unordered_set<std::string>::size(void)
mov [rsp+328h+var_4], eax
mov [rsp+328h+var_2C0], 1
jmp short loc_ED1C2
loc_ED16F:
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov [rsp+328h+var_2F4], eax
cmp [rsp+328h+var_2F4], 0
jbe short loc_ED1A4
cmp [rsp+328h+var_2F4], 4
ja short loc_ED190
mov eax, [rsp+328h+var_2F4]
mov [rsp+328h+var_320], eax
jmp short loc_ED19A
loc_ED190:
mov eax, [rsp+328h+var_2F4]
shr eax, 1
mov [rsp+328h+var_320], eax
loc_ED19A:
mov eax, [rsp+328h+var_320]
mov [rsp+328h+var_324], eax
jmp short loc_ED1AF
loc_ED1A4:
mov eax, 4
mov [rsp+328h+var_324], eax
jmp short $+2
loc_ED1AF:
mov eax, [rsp+328h+var_324]
mov [rsp+328h+var_4], eax
mov [rsp+328h+var_2C0], 1
loc_ED1C2:
lea rdi, [rsp+328h+var_40]; void *
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EED2Ev; std::unordered_set<std::string>::~unordered_set()
mov eax, [rsp+328h+var_4]
add rsp, 328h
retn
loc_ED1DE:
lea rdi, [rsp+arg_2E0]; void *
call _ZNSt13unordered_setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4hashIS5_ESt8equal_toIS5_ESaIS5_EED2Ev; std::unordered_set<std::string>::~unordered_set()
mov rdi, [rsp+arg_68]
call __Unwind_Resume
| long long cpu_get_num_physical_cores(void)
{
int v1; // [rsp+4h] [rbp-324h]
unsigned int v2; // [rsp+8h] [rbp-320h]
_QWORD *v3; // [rsp+28h] [rbp-300h]
unsigned int v4; // [rsp+34h] [rbp-2F4h]
_BYTE v5[32]; // [rsp+48h] [rbp-2E0h] BYREF
int v6; // [rsp+68h] [rbp-2C0h]
_BYTE v7[32]; // [rsp+78h] [rbp-2B0h] BYREF
_BYTE v8[32]; // [rsp+98h] [rbp-290h] BYREF
_BYTE v9[32]; // [rsp+B8h] [rbp-270h] BYREF
_BYTE v10[524]; // [rsp+D8h] [rbp-250h] BYREF
unsigned int i; // [rsp+2E4h] [rbp-44h]
_BYTE v12[60]; // [rsp+2E8h] [rbp-40h] BYREF
unsigned int v13; // [rsp+324h] [rbp-4h]
std::unordered_set<std::string>::unordered_set(v12);
for ( i = 0; i != -1; ++i )
{
std::to_string((std::__cxx11 *)v7, i);
std::operator+<char>(v8, "/sys/devices/system/cpu/cpu", v7);
std::operator+<char>((long long)v9, (long long)v8, (long long)"/topology/thread_siblings");
std::ifstream::basic_ifstream(v10, v9, 8LL);
std::string::~string(v9);
std::string::~string(v8);
std::string::~string(v7);
if ( (std::ifstream::is_open(v10) & 1) != 0 )
{
std::string::basic_string(v5);
v3 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v10, v5);
if ( (std::ios::operator bool((char *)v3 + *(_QWORD *)(*v3 - 24LL)) & 1) != 0 )
std::unordered_set<std::string>::insert(v12, v5);
std::string::~string(v5);
v6 = 0;
}
else
{
v6 = 2;
}
std::ifstream::~ifstream(v10);
if ( v6 )
break;
}
if ( (std::unordered_set<std::string>::empty(v12) & 1) != 0 )
{
v4 = std::thread::hardware_concurrency((std::thread *)v12);
if ( v4 )
{
if ( v4 > 4 )
v2 = v4 >> 1;
else
v2 = v4;
v1 = v2;
}
else
{
v1 = 4;
}
v13 = v1;
v6 = 1;
}
else
{
v13 = std::unordered_set<std::string>::size(v12);
v6 = 1;
}
std::unordered_set<std::string>::~unordered_set(v12);
return v13;
}
| cpu_get_num_physical_cores:
SUB RSP,0x328
LEA RDI,[RSP + 0x2e8]
CALL 0x001f9080
MOV dword ptr [RSP + 0x2e4],0x0
LAB_001ecf0f:
CMP dword ptr [RSP + 0x2e4],-0x1
JNC 0x001ed140
MOV ESI,dword ptr [RSP + 0x2e4]
LAB_001ecf24:
LEA RDI,[RSP + 0x78]
CALL 0x001f90e0
JMP 0x001ecf30
LAB_001ecf30:
LEA RSI,[0x311bc4]
LEA RDI,[RSP + 0x98]
LEA RDX,[RSP + 0x78]
CALL 0x001f9090
JMP 0x001ecf4b
LAB_001ecf4b:
LEA RDX,[0x311be0]
LEA RDI,[RSP + 0xb8]
LEA RSI,[RSP + 0x98]
CALL 0x001676e0
JMP 0x001ecf69
LAB_001ecf69:
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0xb8]
MOV EDX,0x8
CALL 0x0015b270
JMP 0x001ecf85
LAB_001ecf85:
LEA RDI,[RSP + 0xb8]
CALL 0x0015b568
LEA RDI,[RSP + 0x98]
CALL 0x0015b568
LEA RDI,[RSP + 0x78]
CALL 0x0015b568
LAB_001ecfa9:
LEA RDI,[RSP + 0xd8]
CALL 0x0015b040
MOV byte ptr [RSP + 0x33],AL
JMP 0x001ecfbc
LAB_001ecfbc:
MOV AL,byte ptr [RSP + 0x33]
TEST AL,0x1
JNZ 0x001ed054
JMP 0x001ecfca
LAB_001ecfca:
MOV dword ptr [RSP + 0x68],0x2
JMP 0x001ed0fd
LAB_001ed054:
LEA RDI,[RSP + 0x48]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x0015a5f0
MOV RSI,qword ptr [RSP + 0x20]
LAB_001ed068:
LEA RDI,[RSP + 0xd8]
CALL 0x0015a8e0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001ed07c
LAB_001ed07c:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
ADD RDI,RAX
CALL 0x0015a630
MOV byte ptr [RSP + 0x1f],AL
JMP 0x001ed096
LAB_001ed096:
MOV AL,byte ptr [RSP + 0x1f]
TEST AL,0x1
JNZ 0x001ed0a0
JMP 0x001ed0eb
LAB_001ed0a0:
LEA RDI,[RSP + 0x2e8]
LEA RSI,[RSP + 0x48]
CALL 0x001f91e0
LAB_001ed0b2:
MOV byte ptr [RSP + 0xf],DL
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001ed0bd
LAB_001ed0bd:
MOV AL,byte ptr [RSP + 0xf]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RCX
MOV byte ptr [RSP + 0x40],AL
JMP 0x001ed0eb
LAB_001ed0eb:
LEA RDI,[RSP + 0x48]
CALL 0x0015b568
MOV dword ptr [RSP + 0x68],0x0
LAB_001ed0fd:
LEA RDI,[RSP + 0xd8]
CALL 0x0015a0b0
MOV EAX,dword ptr [RSP + 0x68]
TEST EAX,EAX
JZ 0x001ed116
JMP 0x001ed114
LAB_001ed114:
JMP 0x001ed140
LAB_001ed116:
JMP 0x001ed118
LAB_001ed118:
MOV EAX,dword ptr [RSP + 0x2e4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2e4],EAX
JMP 0x001ecf0f
LAB_001ed140:
LEA RDI,[RSP + 0x2e8]
CALL 0x001f9230
TEST AL,0x1
JNZ 0x001ed16f
LEA RDI,[RSP + 0x2e8]
CALL 0x001f9250
MOV dword ptr [RSP + 0x324],EAX
MOV dword ptr [RSP + 0x68],0x1
JMP 0x001ed1c2
LAB_001ed16f:
CALL 0x0015ae50
MOV dword ptr [RSP + 0x34],EAX
CMP dword ptr [RSP + 0x34],0x0
JBE 0x001ed1a4
CMP dword ptr [RSP + 0x34],0x4
JA 0x001ed190
MOV EAX,dword ptr [RSP + 0x34]
MOV dword ptr [RSP + 0x8],EAX
JMP 0x001ed19a
LAB_001ed190:
MOV EAX,dword ptr [RSP + 0x34]
SHR EAX,0x1
MOV dword ptr [RSP + 0x8],EAX
LAB_001ed19a:
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001ed1af
LAB_001ed1a4:
MOV EAX,0x4
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001ed1af
LAB_001ed1af:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x324],EAX
MOV dword ptr [RSP + 0x68],0x1
LAB_001ed1c2:
LEA RDI,[RSP + 0x2e8]
CALL 0x001f9260
MOV EAX,dword ptr [RSP + 0x324]
ADD RSP,0x328
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_physical_cores() */
uint cpu_get_num_physical_cores(void)
{
byte bVar1;
bool bVar2;
istream *piVar3;
ulong uVar4;
uint local_324;
uint local_320;
string local_2e0 [32];
int local_2c0;
__cxx11 local_2b0 [32];
string local_290 [32];
string local_270 [32];
ifstream local_250 [524];
uint local_44;
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
local_40 [60];
uint local_4;
std::
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::unordered_set(local_40);
for (local_44 = 0; local_44 != 0xffffffff; local_44 = local_44 + 1) {
/* try { // try from 001ecf24 to 001ecf2d has its CatchHandler @ 001ecfd7 */
std::__cxx11::to_string(local_2b0,local_44);
/* try { // try from 001ecf30 to 001ecf48 has its CatchHandler @ 001ecfea */
std::operator+((char *)local_290,(string *)"/sys/devices/system/cpu/cpu");
/* try { // try from 001ecf4b to 001ecf66 has its CatchHandler @ 001ecffa */
std::operator+(local_270,(char *)local_290);
/* try { // try from 001ecf69 to 001ecf82 has its CatchHandler @ 001ed00a */
std::ifstream::ifstream(local_250,local_270,8);
std::__cxx11::string::~string(local_270);
std::__cxx11::string::~string(local_290);
std::__cxx11::string::~string((string *)local_2b0);
/* try { // try from 001ecfa9 to 001ecfb5 has its CatchHandler @ 001ed041 */
bVar1 = std::ifstream::is_open();
if ((bVar1 & 1) == 0) {
local_2c0 = 2;
}
else {
std::__cxx11::string::string(local_2e0);
/* try { // try from 001ed068 to 001ed0b1 has its CatchHandler @ 001ed0d1 */
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_250,local_2e0);
bVar2 = std::ios::operator_cast_to_bool((ios *)(piVar3 + *(long *)(*(long *)piVar3 + -0x18)));
if (bVar2) {
std::
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::insert(local_40,local_2e0);
}
std::__cxx11::string::~string(local_2e0);
local_2c0 = 0;
}
std::ifstream::~ifstream(local_250);
if (local_2c0 != 0) break;
}
uVar4 = std::
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::empty(local_40);
if ((uVar4 & 1) == 0) {
local_4 = std::
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::size(local_40);
}
else {
local_320 = std::thread::hardware_concurrency();
if (local_320 == 0) {
local_324 = 4;
}
else {
if (4 < local_320) {
local_320 = local_320 >> 1;
}
local_324 = local_320;
}
local_4 = local_324;
}
local_2c0 = 1;
std::
unordered_set<std::__cxx11::string,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::~unordered_set(local_40);
return local_4;
}
| |
31,231 | test_fetch_null | eloqsql/libmariadb/unittest/libmariadb/fetch.c | static int test_fetch_null(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int rc;
int i;
int nData= 0;
MYSQL_BIND my_bind[11];
ulong length[11];
my_bool is_null[11];
char query[MAX_TEST_QUERY_LENGTH];
rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_fetch_null");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE TABLE test_fetch_null("
" col1 tinyint, col2 smallint, "
" col3 int, col4 bigint, "
" col5 float, col6 double, "
" col7 date, col8 time, "
" col9 varbinary(10), "
" col10 varchar(50), "
" col11 char(20))");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "INSERT INTO test_fetch_null (col11) "
"VALUES (1000), (88), (389789)");
check_mysql_rc(rc, mysql);
rc= mysql_commit(mysql);
FAIL_IF(rc, mysql_error(mysql));
/* fetch */
memset(my_bind, '\0', sizeof(my_bind));
for (i= 0; i < (int) array_elements(my_bind); i++)
{
my_bind[i].buffer_type= MYSQL_TYPE_LONG;
my_bind[i].is_null= &is_null[i];
my_bind[i].length= &length[i];
}
my_bind[i-1].buffer= (void *)&nData; /* Last column is not null */
strcpy((char *)query , "SELECT * FROM test_fetch_null");
rc= my_stmt_result(mysql, query);
FAIL_UNLESS(rc == 3, "Expected 3 rows");
stmt = mysql_stmt_init(mysql);
FAIL_IF(!stmt, mysql_error(mysql));
rc= mysql_stmt_prepare(stmt, SL(query));
check_stmt_rc(rc, stmt);
rc= mysql_stmt_bind_result(stmt, my_bind);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
rc= 0;
while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
{
rc++;
for (i= 0; i < 10; i++)
{
FAIL_IF(!is_null[i], "Expected is_null");
}
FAIL_UNLESS(nData == 1000 || nData == 88 || nData == 389789, "Wrong value for nData");
FAIL_UNLESS(is_null[i] == 0, "Expected !is_null");
FAIL_UNLESS(length[i] == 4, "Expected length=4");
}
FAIL_UNLESS(rc == 3, "Expected 3 rows");
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE test_fetch_null");
check_mysql_rc(rc, mysql);
return OK;
} | O3 | c | test_fetch_null:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x678, %rsp # imm = 0x678
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x164(%rbp)
leaq 0x2198e(%rip), %rsi # 0x37caa
callq 0x1d541
testl %eax, %eax
je 0x1635c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1f5ba
movq %rax, %r15
movq %rbx, %rdi
callq 0x1f5a5
leaq 0x20f13(%rip), %rdi # 0x37255
leaq 0x2150e(%rip), %r8 # 0x37857
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0x242, %r9d # imm = 0x242
jmp 0x163e8
leaq 0x2196c(%rip), %rsi # 0x37ccf
movq %rbx, %rdi
callq 0x1d541
testl %eax, %eax
je 0x163a3
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1f5ba
movq %rax, %r15
movq %rbx, %rdi
callq 0x1f5a5
leaq 0x20ec9(%rip), %rdi # 0x37255
leaq 0x214c4(%rip), %r8 # 0x37857
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0x24c, %r9d # imm = 0x24C
jmp 0x163e8
leaq 0x219e3(%rip), %rsi # 0x37d8d
movq %rbx, %rdi
callq 0x1d541
testl %eax, %eax
je 0x16415
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1f5ba
movq %rax, %r15
movq %rbx, %rdi
callq 0x1f5a5
leaq 0x20e82(%rip), %rdi # 0x37255
leaq 0x2147d(%rip), %r8 # 0x37857
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0x250, %r9d # imm = 0x250
xorl %eax, %eax
callq 0x17e37
movl $0x1, %eax
movq %fs:0x28, %rcx
cmpq -0x20(%rbp), %rcx
jne 0x1671c
addq $0x678, %rsp # imm = 0x678
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1f56a
testb %al, %al
je 0x16444
movq %rbx, %rdi
callq 0x1f5ba
leaq 0x20ce0(%rip), %rdi # 0x37110
leaq 0x21420(%rip), %rdx # 0x37857
movq %rax, %rsi
movl $0x253, %ecx # imm = 0x253
jmp 0x16657
leaq -0x690(%rbp), %rdi
xorl %r14d, %r14d
movl $0x4d0, %edx # imm = 0x4D0
xorl %esi, %esi
callq 0x13260
leaq -0x1c0(%rbp), %rax
leaq -0x2b(%rbp), %rcx
movl $0x3, -0x630(%rbp,%r14,8)
movq %rcx, -0x688(%rbp,%r14,8)
movq %rax, -0x690(%rbp,%r14,8)
addq $0x8, %rax
incq %rcx
addq $0xe, %r14
cmpq $0x9a, %r14
jne 0x16465
leaq -0x164(%rbp), %rax
movq %rax, -0x220(%rbp)
movups 0x21925(%rip), %xmm0 # 0x37dcf
leaq -0x160(%rbp), %rsi
movaps %xmm0, (%rsi)
movups 0x21922(%rip), %xmm0 # 0x37ddd
movups %xmm0, 0xe(%rsi)
movq %rbx, %rdi
callq 0x13b34
cmpl $0x3, %eax
jne 0x16520
movq %rbx, %rdi
callq 0x23c00
testq %rax, %rax
je 0x1653f
movq %rax, %r14
leaq -0x160(%rbp), %r15
movq %r15, %rdi
callq 0x131c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x23fc4
testl %eax, %eax
je 0x16562
movq %r14, %rdi
callq 0x236a0
leaq 0x20c04(%rip), %rdi # 0x37110
leaq 0x21344(%rip), %rdx # 0x37857
movq %rax, %rsi
movl $0x268, %ecx # imm = 0x268
jmp 0x16657
leaq 0x20be9(%rip), %rdi # 0x37110
leaq 0x218bf(%rip), %rsi # 0x37ded
leaq 0x21322(%rip), %rdx # 0x37857
movl $0x262, %ecx # imm = 0x262
jmp 0x16657
movq %rbx, %rdi
callq 0x1f5ba
leaq 0x20bc2(%rip), %rdi # 0x37110
leaq 0x21302(%rip), %rdx # 0x37857
movq %rax, %rsi
movl $0x265, %ecx # imm = 0x265
jmp 0x16657
leaq -0x690(%rbp), %rsi
movq %r14, %rdi
callq 0x23368
testb %al, %al
je 0x16598
movq %r14, %rdi
callq 0x236a0
leaq 0x20b8c(%rip), %rdi # 0x37110
leaq 0x212cc(%rip), %rdx # 0x37857
movq %rax, %rsi
movl $0x26b, %ecx # imm = 0x26B
jmp 0x16657
movq %r14, %rdi
callq 0x24b95
testl %eax, %eax
je 0x165c7
movq %r14, %rdi
callq 0x236a0
leaq 0x20b5d(%rip), %rdi # 0x37110
leaq 0x2129d(%rip), %rdx # 0x37857
movq %rax, %rsi
movl $0x26e, %ecx # imm = 0x26E
jmp 0x16657
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x236bb
cmpl $0x64, %eax
je 0x16663
incl %r15d
xorl %eax, %eax
cmpb $0x0, -0x2b(%rbp,%rax)
je 0x1663d
incq %rax
cmpq $0xa, %rax
jne 0x165e0
movl -0x164(%rbp), %eax
cmpl $0x58, %eax
je 0x1660d
cmpl $0x3e8, %eax # imm = 0x3E8
je 0x1660d
cmpl $0x5f29d, %eax # imm = 0x5F29D
jne 0x166fd
cmpb $0x0, -0x21(%rbp)
jne 0x166d7
cmpq $0x4, -0x170(%rbp)
je 0x165ca
leaq 0x20ae8(%rip), %rdi # 0x37110
leaq 0x21807(%rip), %rsi # 0x37e36
leaq 0x21221(%rip), %rdx # 0x37857
movl $0x27a, %ecx # imm = 0x27A
jmp 0x16657
leaq 0x20acc(%rip), %rdi # 0x37110
leaq 0x217b2(%rip), %rsi # 0x37dfd
leaq 0x21205(%rip), %rdx # 0x37857
movl $0x276, %ecx # imm = 0x276
xorl %eax, %eax
callq 0x17e37
jmp 0x163ef
cmpl $0x3, %r15d
jne 0x166bb
movq %r14, %rdi
callq 0x23611
leaq 0x217d0(%rip), %rsi # 0x37e48
movq %rbx, %rdi
callq 0x1d541
testl %eax, %eax
je 0x166f6
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1f5ba
movq %rax, %r15
movq %rbx, %rdi
callq 0x1f5a5
leaq 0x20bb4(%rip), %rdi # 0x37255
leaq 0x211af(%rip), %r8 # 0x37857
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0x280, %r9d # imm = 0x280
jmp 0x163e8
leaq 0x20a4e(%rip), %rdi # 0x37110
leaq 0x21724(%rip), %rsi # 0x37ded
leaq 0x21187(%rip), %rdx # 0x37857
movl $0x27c, %ecx # imm = 0x27C
jmp 0x16657
leaq 0x20a32(%rip), %rdi # 0x37110
leaq 0x2173f(%rip), %rsi # 0x37e24
leaq 0x2116b(%rip), %rdx # 0x37857
movl $0x279, %ecx # imm = 0x279
jmp 0x16657
xorl %eax, %eax
jmp 0x163f4
leaq 0x20a0c(%rip), %rdi # 0x37110
leaq 0x21703(%rip), %rsi # 0x37e0e
leaq 0x21145(%rip), %rdx # 0x37857
movl $0x278, %ecx # imm = 0x278
jmp 0x16657
callq 0x13500
| test_fetch_null:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 678h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
mov [rbp+var_164], 0
lea rsi, aDropTableIfExi_1; "DROP TABLE IF EXISTS test_fetch_null"
call mysql_query
test eax, eax
jz short loc_1635C
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 242h
jmp loc_163E8
loc_1635C:
lea rsi, aCreateTableTes; "CREATE TABLE test_fetch_null( col1 tiny"...
mov rdi, rbx
call mysql_query
test eax, eax
jz short loc_163A3
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 24Ch
jmp short loc_163E8
loc_163A3:
lea rsi, aInsertIntoTest; "INSERT INTO test_fetch_null (col11) VAL"...
mov rdi, rbx
call mysql_query
test eax, eax
jz short loc_16415
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 250h
loc_163E8:
xor eax, eax
call diag
loc_163EF:
mov eax, 1
loc_163F4:
mov rcx, fs:28h
cmp rcx, [rbp+var_20]
jnz loc_1671C
add rsp, 678h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_16415:
mov rdi, rbx
call mysql_commit
test al, al
jz short loc_16444
mov rdi, rbx
call mysql_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 253h
jmp loc_16657
loc_16444:
lea rdi, [rbp+var_690]
xor r14d, r14d
mov edx, 4D0h
xor esi, esi
call _memset
lea rax, [rbp+var_1C0]
lea rcx, [rbp+var_2B]
loc_16465:
mov [rbp+r14*8+var_630], 3
mov [rbp+r14*8+var_688], rcx
mov [rbp+r14*8+var_690], rax
add rax, 8
inc rcx
add r14, 0Eh
cmp r14, 9Ah
jnz short loc_16465
lea rax, [rbp+var_164]
mov [rbp+var_220], rax
movups xmm0, cs:xmmword_37DCF
lea rsi, [rbp+var_160]
movaps xmmword ptr [rsi], xmm0
movups xmm0, cs:xmmword_37DCF+0Eh
movups xmmword ptr [rsi+0Eh], xmm0
mov rdi, rbx
call my_stmt_result
cmp eax, 3
jnz short loc_16520
mov rdi, rbx
call mysql_stmt_init
test rax, rax
jz short loc_1653F
mov r14, rax
lea r15, [rbp+var_160]
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call mysql_stmt_prepare
test eax, eax
jz short loc_16562
mov rdi, r14
call mysql_stmt_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 268h
jmp loc_16657
loc_16520:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpected3Rows; "Expected 3 rows"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 262h
jmp loc_16657
loc_1653F:
mov rdi, rbx
call mysql_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 265h
jmp loc_16657
loc_16562:
lea rsi, [rbp+var_690]
mov rdi, r14
call mysql_stmt_bind_result
test al, al
jz short loc_16598
mov rdi, r14
call mysql_stmt_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 26Bh
jmp loc_16657
loc_16598:
mov rdi, r14
call mysql_stmt_execute
test eax, eax
jz short loc_165C7
mov rdi, r14
call mysql_stmt_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 26Eh
jmp loc_16657
loc_165C7:
xor r15d, r15d
loc_165CA:
mov rdi, r14
call mysql_stmt_fetch
cmp eax, 64h ; 'd'
jz loc_16663
inc r15d
xor eax, eax
loc_165E0:
cmp [rbp+rax+var_2B], 0
jz short loc_1663D
inc rax
cmp rax, 0Ah
jnz short loc_165E0
mov eax, [rbp+var_164]
cmp eax, 58h ; 'X'
jz short loc_1660D
cmp eax, 3E8h
jz short loc_1660D
cmp eax, 5F29Dh
jnz loc_166FD
loc_1660D:
cmp [rbp+var_21], 0
jnz loc_166D7
cmp [rbp+var_170], 4
jz short loc_165CA
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpectedLength_0; "Expected length=4"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 27Ah
jmp short loc_16657
loc_1663D:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpectedIsNull; "Expected is_null"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 276h
loc_16657:
xor eax, eax
call diag
jmp loc_163EF
loc_16663:
cmp r15d, 3
jnz short loc_166BB
mov rdi, r14
call mysql_stmt_close
lea rsi, aDropTableTestF; "DROP TABLE test_fetch_null"
mov rdi, rbx
call mysql_query
test eax, eax
jz short loc_166F6
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 280h
jmp loc_163E8
loc_166BB:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpected3Rows; "Expected 3 rows"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 27Ch
jmp short loc_16657
loc_166D7:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aExpectedIsNull_0; "Expected !is_null"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 279h
jmp loc_16657
loc_166F6:
xor eax, eax
jmp loc_163F4
loc_166FD:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aWrongValueForN; "Wrong value for nData"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 278h
jmp loc_16657
loc_1671C:
call ___stack_chk_fail
| long long test_fetch_null(long long a1)
{
int v1; // eax
int v2; // r14d
int v3; // r15d
int v4; // eax
const char *v5; // rdi
const char *v6; // r8
const char *v7; // rsi
const char *v8; // rdx
int v9; // ecx
int v10; // r9d
int v11; // eax
int v12; // r14d
int v13; // r15d
int v14; // eax
int v15; // eax
int v16; // r14d
int v17; // r15d
int v18; // eax
int v20; // eax
long long v21; // r14
char *v22; // rax
_BYTE *v23; // rcx
long long v24; // rax
long long v25; // r14
long long v26; // rax
int v27; // eax
int v28; // eax
int v29; // eax
int v30; // eax
int v31; // r15d
long long i; // rax
int v33; // eax
int v34; // r14d
int v35; // r15d
int v36; // eax
_QWORD v37[154]; // [rsp+0h] [rbp-690h] BYREF
char v38; // [rsp+4D0h] [rbp-1C0h] BYREF
long long v39; // [rsp+520h] [rbp-170h]
int v40; // [rsp+52Ch] [rbp-164h] BYREF
char v41[309]; // [rsp+530h] [rbp-160h] BYREF
_BYTE v42[11]; // [rsp+665h] [rbp-2Bh] BYREF
unsigned long long v43; // [rsp+670h] [rbp-20h]
v43 = __readfsqword(0x28u);
v40 = 0;
v1 = mysql_query(a1, "DROP TABLE IF EXISTS test_fetch_null");
if ( v1 )
{
v2 = v1;
v3 = mysql_error(a1);
v4 = mysql_errno(a1);
v5 = "Error (%d): %s (%d) in %s line %d";
v6 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v2;
LODWORD(v8) = v3;
v9 = v4;
v10 = 578;
LABEL_7:
diag((_DWORD)v5, (_DWORD)v7, (_DWORD)v8, v9, (_DWORD)v6, v10);
return 1LL;
}
v11 = mysql_query(
a1,
"CREATE TABLE test_fetch_null( col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, "
"col7 date, col8 time, col9 varbinary(10), col10 varchar(50), col11 char(20))");
if ( v11 )
{
v12 = v11;
v13 = mysql_error(a1);
v14 = mysql_errno(a1);
v5 = "Error (%d): %s (%d) in %s line %d";
v6 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v12;
LODWORD(v8) = v13;
v9 = v14;
v10 = 588;
goto LABEL_7;
}
v15 = mysql_query(a1, "INSERT INTO test_fetch_null (col11) VALUES (1000), (88), (389789)");
if ( v15 )
{
v16 = v15;
v17 = mysql_error(a1);
v18 = mysql_errno(a1);
v5 = "Error (%d): %s (%d) in %s line %d";
v6 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v16;
LODWORD(v8) = v17;
v9 = v18;
v10 = 592;
goto LABEL_7;
}
if ( (unsigned __int8)mysql_commit(a1) )
{
v20 = mysql_error(a1);
v5 = "Error: %s (%s: %d)";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v20;
v9 = 595;
goto LABEL_7;
}
v21 = 0LL;
memset(v37, 0LL, sizeof(v37));
v22 = &v38;
v23 = v42;
do
{
LODWORD(v37[v21 + 12]) = 3;
v37[v21 + 1] = v23;
v37[v21] = v22;
v22 += 8;
++v23;
v21 += 14LL;
}
while ( v21 != 154 );
v37[142] = &v40;
strcpy(v41, "SELECT * FROM test_fetch_null");
if ( (unsigned int)my_stmt_result(a1, (long long)v41) != 3 )
{
v5 = "Error: %s (%s: %d)";
v7 = "Expected 3 rows";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 610;
goto LABEL_7;
}
v24 = mysql_stmt_init(a1);
if ( !v24 )
{
v28 = mysql_error(a1);
v5 = "Error: %s (%s: %d)";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v28;
v9 = 613;
goto LABEL_7;
}
v25 = v24;
v26 = strlen(v41);
if ( (unsigned int)mysql_stmt_prepare(v25, v41, v26) )
{
v27 = mysql_stmt_error(v25);
v5 = "Error: %s (%s: %d)";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v27;
v9 = 616;
goto LABEL_7;
}
if ( (unsigned __int8)mysql_stmt_bind_result(v25, v37) )
{
v29 = mysql_stmt_error(v25);
v5 = "Error: %s (%s: %d)";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v29;
v9 = 619;
goto LABEL_7;
}
if ( (unsigned int)mysql_stmt_execute(v25) )
{
v30 = mysql_stmt_error(v25);
v5 = "Error: %s (%s: %d)";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v30;
v9 = 622;
goto LABEL_7;
}
v31 = 0;
while ( 2 )
{
if ( (unsigned int)mysql_stmt_fetch(v25) != 100 )
{
++v31;
for ( i = 0LL; i != 10; ++i )
{
if ( !v42[i] )
{
v5 = "Error: %s (%s: %d)";
v7 = "Expected is_null";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 630;
goto LABEL_7;
}
}
if ( v40 == 88 || v40 == 1000 || v40 == 389789 )
{
if ( v42[10] )
{
v5 = "Error: %s (%s: %d)";
v7 = "Expected !is_null";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 633;
}
else
{
if ( v39 == 4 )
continue;
v5 = "Error: %s (%s: %d)";
v7 = "Expected length=4";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 634;
}
}
else
{
v5 = "Error: %s (%s: %d)";
v7 = "Wrong value for nData";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 632;
}
goto LABEL_7;
}
break;
}
if ( v31 != 3 )
{
v5 = "Error: %s (%s: %d)";
v7 = "Expected 3 rows";
v8 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
v9 = 636;
goto LABEL_7;
}
mysql_stmt_close(v25);
v33 = mysql_query(a1, "DROP TABLE test_fetch_null");
if ( v33 )
{
v34 = v33;
v35 = mysql_error(a1);
v36 = mysql_errno(a1);
v5 = "Error (%d): %s (%d) in %s line %d";
v6 = "/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c";
LODWORD(v7) = v34;
LODWORD(v8) = v35;
v9 = v36;
v10 = 640;
goto LABEL_7;
}
return 0LL;
}
| test_fetch_null:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x678
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x164],0x0
LEA RSI,[0x137caa]
CALL 0x0011d541
TEST EAX,EAX
JZ 0x0011635c
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0011f5ba
MOV R15,RAX
MOV RDI,RBX
CALL 0x0011f5a5
LEA RDI,[0x137255]
LEA R8,[0x137857]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0x242
JMP 0x001163e8
LAB_0011635c:
LEA RSI,[0x137ccf]
MOV RDI,RBX
CALL 0x0011d541
TEST EAX,EAX
JZ 0x001163a3
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0011f5ba
MOV R15,RAX
MOV RDI,RBX
CALL 0x0011f5a5
LEA RDI,[0x137255]
LEA R8,[0x137857]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0x24c
JMP 0x001163e8
LAB_001163a3:
LEA RSI,[0x137d8d]
MOV RDI,RBX
CALL 0x0011d541
TEST EAX,EAX
JZ 0x00116415
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0011f5ba
MOV R15,RAX
MOV RDI,RBX
CALL 0x0011f5a5
LEA RDI,[0x137255]
LEA R8,[0x137857]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0x250
LAB_001163e8:
XOR EAX,EAX
CALL 0x00117e37
LAB_001163ef:
MOV EAX,0x1
LAB_001163f4:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x20]
JNZ 0x0011671c
ADD RSP,0x678
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00116415:
MOV RDI,RBX
CALL 0x0011f56a
TEST AL,AL
JZ 0x00116444
MOV RDI,RBX
CALL 0x0011f5ba
LEA RDI,[0x137110]
LEA RDX,[0x137857]
MOV RSI,RAX
MOV ECX,0x253
JMP 0x00116657
LAB_00116444:
LEA RDI,[RBP + -0x690]
XOR R14D,R14D
MOV EDX,0x4d0
XOR ESI,ESI
CALL 0x00113260
LEA RAX,[RBP + -0x1c0]
LEA RCX,[RBP + -0x2b]
LAB_00116465:
MOV dword ptr [RBP + R14*0x8 + -0x630],0x3
MOV qword ptr [RBP + R14*0x8 + -0x688],RCX
MOV qword ptr [RBP + R14*0x8 + -0x690],RAX
ADD RAX,0x8
INC RCX
ADD R14,0xe
CMP R14,0x9a
JNZ 0x00116465
LEA RAX,[RBP + -0x164]
MOV qword ptr [RBP + -0x220],RAX
MOVUPS XMM0,xmmword ptr [0x00137dcf]
LEA RSI,[RBP + -0x160]
MOVAPS xmmword ptr [RSI],XMM0
MOVUPS XMM0,xmmword ptr [0x00137ddd]
MOVUPS xmmword ptr [RSI + 0xe],XMM0
MOV RDI,RBX
CALL 0x00113b34
CMP EAX,0x3
JNZ 0x00116520
MOV RDI,RBX
CALL 0x00123c00
TEST RAX,RAX
JZ 0x0011653f
MOV R14,RAX
LEA R15,[RBP + -0x160]
MOV RDI,R15
CALL 0x001131c0
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00123fc4
TEST EAX,EAX
JZ 0x00116562
MOV RDI,R14
CALL 0x001236a0
LEA RDI,[0x137110]
LEA RDX,[0x137857]
MOV RSI,RAX
MOV ECX,0x268
JMP 0x00116657
LAB_00116520:
LEA RDI,[0x137110]
LEA RSI,[0x137ded]
LEA RDX,[0x137857]
MOV ECX,0x262
JMP 0x00116657
LAB_0011653f:
MOV RDI,RBX
CALL 0x0011f5ba
LEA RDI,[0x137110]
LEA RDX,[0x137857]
MOV RSI,RAX
MOV ECX,0x265
JMP 0x00116657
LAB_00116562:
LEA RSI,[RBP + -0x690]
MOV RDI,R14
CALL 0x00123368
TEST AL,AL
JZ 0x00116598
MOV RDI,R14
CALL 0x001236a0
LEA RDI,[0x137110]
LEA RDX,[0x137857]
MOV RSI,RAX
MOV ECX,0x26b
JMP 0x00116657
LAB_00116598:
MOV RDI,R14
CALL 0x00124b95
TEST EAX,EAX
JZ 0x001165c7
MOV RDI,R14
CALL 0x001236a0
LEA RDI,[0x137110]
LEA RDX,[0x137857]
MOV RSI,RAX
MOV ECX,0x26e
JMP 0x00116657
LAB_001165c7:
XOR R15D,R15D
LAB_001165ca:
MOV RDI,R14
CALL 0x001236bb
CMP EAX,0x64
JZ 0x00116663
INC R15D
XOR EAX,EAX
LAB_001165e0:
CMP byte ptr [RBP + RAX*0x1 + -0x2b],0x0
JZ 0x0011663d
INC RAX
CMP RAX,0xa
JNZ 0x001165e0
MOV EAX,dword ptr [RBP + -0x164]
CMP EAX,0x58
JZ 0x0011660d
CMP EAX,0x3e8
JZ 0x0011660d
CMP EAX,0x5f29d
JNZ 0x001166fd
LAB_0011660d:
CMP byte ptr [RBP + -0x21],0x0
JNZ 0x001166d7
CMP qword ptr [RBP + -0x170],0x4
JZ 0x001165ca
LEA RDI,[0x137110]
LEA RSI,[0x137e36]
LEA RDX,[0x137857]
MOV ECX,0x27a
JMP 0x00116657
LAB_0011663d:
LEA RDI,[0x137110]
LEA RSI,[0x137dfd]
LEA RDX,[0x137857]
MOV ECX,0x276
LAB_00116657:
XOR EAX,EAX
CALL 0x00117e37
JMP 0x001163ef
LAB_00116663:
CMP R15D,0x3
JNZ 0x001166bb
MOV RDI,R14
CALL 0x00123611
LEA RSI,[0x137e48]
MOV RDI,RBX
CALL 0x0011d541
TEST EAX,EAX
JZ 0x001166f6
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0011f5ba
MOV R15,RAX
MOV RDI,RBX
CALL 0x0011f5a5
LEA RDI,[0x137255]
LEA R8,[0x137857]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0x280
JMP 0x001163e8
LAB_001166bb:
LEA RDI,[0x137110]
LEA RSI,[0x137ded]
LEA RDX,[0x137857]
MOV ECX,0x27c
JMP 0x00116657
LAB_001166d7:
LEA RDI,[0x137110]
LEA RSI,[0x137e24]
LEA RDX,[0x137857]
MOV ECX,0x279
JMP 0x00116657
LAB_001166f6:
XOR EAX,EAX
JMP 0x001163f4
LAB_001166fd:
LEA RDI,[0x137110]
LEA RSI,[0x137e0e]
LEA RDX,[0x137857]
MOV ECX,0x278
JMP 0x00116657
LAB_0011671c:
CALL 0x00113500
|
int8 test_fetch_null(int8 param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
int iVar4;
int8 uVar5;
char *pcVar6;
int1 *puVar7;
size_t sVar8;
long lVar9;
int8 uVar10;
long lVar11;
long in_FS_OFFSET;
long local_698 [12];
int4 auStack_638 [260];
int *local_228;
int1 local_1c8 [80];
long local_178;
int local_16c;
char local_168 [8];
char acStack_160 [6];
char acStack_15a [2];
char acStack_158 [2];
char acStack_156 [4];
char acStack_152 [4];
char acStack_14e [283];
char local_33 [10];
char local_29;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
local_16c = 0;
iVar2 = mysql_query(param_1,"DROP TABLE IF EXISTS test_fetch_null");
if (iVar2 == 0) {
iVar2 = mysql_query(param_1,
"CREATE TABLE test_fetch_null( col1 tinyint, col2 smallint, col3 int, col4 bigint, col5 float, col6 double, col7 date, col8 time, col9 varbinary(10), col10 varchar(50), col11 char(20))"
);
if (iVar2 == 0) {
iVar2 = mysql_query(param_1);
if (iVar2 == 0) {
cVar1 = mysql_commit(param_1);
if (cVar1 == '\0') {
lVar11 = 0;
memset(local_698,0,0x4d0);
puVar7 = local_1c8;
pcVar6 = local_33;
do {
auStack_638[lVar11 * 2] = 3;
local_698[lVar11 + 1] = (long)pcVar6;
local_698[lVar11] = (long)puVar7;
puVar7 = puVar7 + 8;
pcVar6 = pcVar6 + 1;
lVar11 = lVar11 + 0xe;
} while (lVar11 != 0x9a);
local_228 = &local_16c;
local_168[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0];
local_168[1] = s_SELECT___FROM_test_fetch_null_00137dcf[1];
local_168[2] = s_SELECT___FROM_test_fetch_null_00137dcf[2];
local_168[3] = s_SELECT___FROM_test_fetch_null_00137dcf[3];
local_168[4] = s_SELECT___FROM_test_fetch_null_00137dcf[4];
local_168[5] = s_SELECT___FROM_test_fetch_null_00137dcf[5];
local_168[6] = s_SELECT___FROM_test_fetch_null_00137dcf[6];
local_168[7] = s_SELECT___FROM_test_fetch_null_00137dcf[7];
acStack_160[0] = s_SELECT___FROM_test_fetch_null_00137dcf[8];
acStack_160[1] = s_SELECT___FROM_test_fetch_null_00137dcf[9];
acStack_160[2] = s_SELECT___FROM_test_fetch_null_00137dcf[10];
acStack_160[3] = s_SELECT___FROM_test_fetch_null_00137dcf[0xb];
acStack_160[4] = s_SELECT___FROM_test_fetch_null_00137dcf[0xc];
acStack_160[5] = s_SELECT___FROM_test_fetch_null_00137dcf[0xd];
acStack_15a[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0xe];
acStack_15a[1] = s_SELECT___FROM_test_fetch_null_00137dcf[0xf];
acStack_158[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0x10];
acStack_158[1] = s_SELECT___FROM_test_fetch_null_00137dcf[0x11];
acStack_156[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0x12];
acStack_156[1] = s_SELECT___FROM_test_fetch_null_00137dcf[0x13];
acStack_156[2] = s_SELECT___FROM_test_fetch_null_00137dcf[0x14];
acStack_156[3] = s_SELECT___FROM_test_fetch_null_00137dcf[0x15];
acStack_152[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0x16];
acStack_152[1] = s_SELECT___FROM_test_fetch_null_00137dcf[0x17];
acStack_152[2] = s_SELECT___FROM_test_fetch_null_00137dcf[0x18];
acStack_152[3] = s_SELECT___FROM_test_fetch_null_00137dcf[0x19];
acStack_14e[0] = s_SELECT___FROM_test_fetch_null_00137dcf[0x1a];
acStack_14e[1] = s_SELECT___FROM_test_fetch_null_00137dcf[0x1b];
acStack_14e[2] = s_SELECT___FROM_test_fetch_null_00137dcf[0x1c];
acStack_14e[3] = s_SELECT___FROM_test_fetch_null_00137dcf[0x1d];
iVar2 = my_stmt_result(param_1);
if (iVar2 == 3) {
lVar11 = mysql_stmt_init(param_1);
if (lVar11 == 0) {
pcVar6 = (char *)mysql_error(param_1);
uVar5 = 0x265;
}
else {
sVar8 = strlen(local_168);
iVar2 = mysql_stmt_prepare(lVar11,local_168,sVar8);
if (iVar2 == 0) {
cVar1 = mysql_stmt_bind_result(lVar11,local_698);
if (cVar1 == '\0') {
iVar2 = mysql_stmt_execute(lVar11);
if (iVar2 == 0) {
iVar2 = 0;
do {
iVar4 = mysql_stmt_fetch(lVar11);
if (iVar4 == 100) {
if (iVar2 != 3) {
pcVar6 = "Expected 3 rows";
uVar5 = 0x27c;
goto LAB_00116657;
}
mysql_stmt_close(lVar11);
iVar2 = mysql_query(param_1,"DROP TABLE test_fetch_null");
if (iVar2 != 0) {
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
uVar10 = 0x280;
goto LAB_001163e8;
}
uVar5 = 0;
goto LAB_001163f4;
}
iVar2 = iVar2 + 1;
lVar9 = 0;
do {
if (local_33[lVar9] == '\0') {
pcVar6 = "Expected is_null";
uVar5 = 0x276;
goto LAB_00116657;
}
lVar9 = lVar9 + 1;
} while (lVar9 != 10);
if (((local_16c != 0x58) && (local_16c != 1000)) && (local_16c != 0x5f29d)) {
pcVar6 = "Wrong value for nData";
uVar5 = 0x278;
goto LAB_00116657;
}
if (local_29 != '\0') {
pcVar6 = "Expected !is_null";
uVar5 = 0x279;
goto LAB_00116657;
}
} while (local_178 == 4);
pcVar6 = "Expected length=4";
uVar5 = 0x27a;
}
else {
pcVar6 = (char *)mysql_stmt_error(lVar11);
uVar5 = 0x26e;
}
}
else {
pcVar6 = (char *)mysql_stmt_error(lVar11);
uVar5 = 0x26b;
}
}
else {
pcVar6 = (char *)mysql_stmt_error(lVar11);
uVar5 = 0x268;
}
}
}
else {
pcVar6 = "Expected 3 rows";
uVar5 = 0x262;
}
}
else {
pcVar6 = (char *)mysql_error(param_1);
uVar5 = 0x253;
}
LAB_00116657:
diag("Error: %s (%s: %d)",pcVar6,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c",uVar5
);
goto LAB_001163ef;
}
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
uVar10 = 0x250;
}
else {
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
uVar10 = 0x24c;
}
}
else {
uVar5 = mysql_error(param_1);
uVar3 = mysql_errno(param_1);
uVar10 = 0x242;
}
LAB_001163e8:
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar5,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/fetch.c",uVar10);
LAB_001163ef:
uVar5 = 1;
LAB_001163f4:
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return uVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,232 | list_free | eloqsql/libmariadb/libmariadb/ma_list.c | void list_free(LIST *root, unsigned int free_data)
{
LIST *next;
while (root)
{
next=root->next;
if (free_data)
free(root->data);
free(root);
root=next;
}
} | O3 | c | list_free:
testq %rdi, %rdi
je 0x2e63e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%r14), %r15
testl %ebx, %ebx
je 0x2e624
movq 0x10(%r14), %rdi
callq 0x14590
movq %r14, %rdi
callq 0x14590
movq %r15, %r14
testq %r15, %r15
jne 0x2e613
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| list_free:
test rdi, rdi
jz short locret_2E63E
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
loc_2E613:
mov r15, [r14+8]
test ebx, ebx
jz short loc_2E624
mov rdi, [r14+10h]
call _free
loc_2E624:
mov rdi, r14
call _free
mov r14, r15
test r15, r15
jnz short loc_2E613
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_2E63E:
retn
| long long list_free(long long a1, int a2)
{
long long v2; // r14
long long v3; // r15
long long result; // rax
if ( a1 )
{
v2 = a1;
do
{
v3 = *(_QWORD *)(v2 + 8);
if ( a2 )
free(*(_QWORD *)(v2 + 16));
result = free(v2);
v2 = v3;
}
while ( v3 );
}
return result;
}
| list_free:
TEST RDI,RDI
JZ 0x0012e63e
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LAB_0012e613:
MOV R15,qword ptr [R14 + 0x8]
TEST EBX,EBX
JZ 0x0012e624
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x00114590
LAB_0012e624:
MOV RDI,R14
CALL 0x00114590
MOV R14,R15
TEST R15,R15
JNZ 0x0012e613
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0012e63e:
RET
|
void list_free(void *param_1,int param_2)
{
void *pvVar1;
if (param_1 != (void *)0x0) {
do {
pvVar1 = *(void **)((long)param_1 + 8);
if (param_2 != 0) {
free(*(void **)((long)param_1 + 0x10));
}
free(param_1);
param_1 = pvVar1;
} while (pvVar1 != (void *)0x0);
}
return;
}
| |
31,233 | my_rmtree | eloqsql/mysys/my_delete.c | int my_rmtree(const char *dir, myf MyFlags)
{
char path[FN_REFLEN];
char sep[] = { FN_LIBCHAR, 0 };
int err = 0;
uint i;
MY_DIR *dir_info = my_dir(dir, MYF(MY_DONT_SORT | MY_WANT_STAT));
if (!dir_info)
return 1;
for (i = 0; i < dir_info->number_of_files; i++)
{
FILEINFO *file = dir_info->dir_entry + i;
/* Skip "." and ".." */
if (!strcmp(file->name, ".") || !strcmp(file->name, ".."))
continue;
strxnmov(path, sizeof(path), dir, sep, file->name, NULL);
if (!MY_S_ISDIR(file->mystat->st_mode))
{
err = my_delete(path, MyFlags);
#ifdef _WIN32
/*
On Windows, check and possible reset readonly attribute.
my_delete(), or DeleteFile does not remove theses files.
*/
if (err)
{
DWORD attr = GetFileAttributes(path);
if (attr != INVALID_FILE_ATTRIBUTES &&
(attr & FILE_ATTRIBUTE_READONLY))
{
SetFileAttributes(path, attr &~FILE_ATTRIBUTE_READONLY);
err = my_delete(path, MyFlags);
}
}
#endif
}
else
err = my_rmtree(path, MyFlags);
if (err)
break;
}
my_dirend(dir_info);
if (!err)
err = rmdir(dir);
return err;
} | O3 | c | my_rmtree:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, -0x240(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movw $0x2f, -0x232(%rbp)
movl $0x4000, %esi # imm = 0x4000
movq %rdi, -0x248(%rbp)
callq 0xa69ad
testq %rax, %rax
je 0xa2f45
movq %rax, %r15
movl 0x8(%rax), %eax
testl %eax, %eax
je 0xa2f2c
movl $0x8, %r14d
leaq -0x230(%rbp), %rbx
xorl %r12d, %r12d
movq (%r15), %r13
movq -0x8(%r13,%r14), %r8
cmpb $0x2e, (%r8)
jne 0xa2eb5
cmpb $0x0, 0x1(%r8)
je 0xa2f1a
cmpb $0x2e, 0x1(%r8)
jne 0xa2eb5
cmpb $0x0, 0x2(%r8)
je 0xa2f1a
movl $0x200, %esi # imm = 0x200
movq %rbx, %rdi
movq -0x248(%rbp), %rdx
leaq -0x232(%rbp), %rcx
xorl %r9d, %r9d
xorl %eax, %eax
callq 0xdfda4
movq (%r13,%r14), %rax
movl 0x18(%rax), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
movq %rbx, %rdi
cmpl $0x4000, %eax # imm = 0x4000
jne 0xa2efc
movq -0x240(%rbp), %rsi
callq 0xa2e29
jmp 0xa2f08
movq -0x240(%rbp), %rsi
callq 0xa2d54
movl %eax, %r13d
testl %eax, %eax
jne 0xa2f4d
movl 0x8(%r15), %eax
leaq -0x230(%rbp), %rbx
incq %r12
movl %eax, %ecx
addq $0x10, %r14
cmpq %rcx, %r12
jb 0xa2e92
movq %r15, %rdi
callq 0xa697c
movq -0x248(%rbp), %rdi
callq 0x2a340
movl %eax, %r13d
jmp 0xa2f55
movl $0x1, %r13d
jmp 0xa2f55
movq %r15, %rdi
callq 0xa697c
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa2f79
movl %r13d, %eax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
nop
| my_rmtree:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov [rbp+var_240], rsi
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_232], 2Fh ; '/'
mov esi, 4000h
mov [rbp+var_248], rdi
call my_dir
test rax, rax
jz loc_A2F45
mov r15, rax
mov eax, [rax+8]
test eax, eax
jz loc_A2F2C
mov r14d, 8
lea rbx, [rbp+var_230]
xor r12d, r12d
loc_A2E92:
mov r13, [r15]
mov r8, [r13+r14-8]
cmp byte ptr [r8], 2Eh ; '.'
jnz short loc_A2EB5
cmp byte ptr [r8+1], 0
jz short loc_A2F1A
cmp byte ptr [r8+1], 2Eh ; '.'
jnz short loc_A2EB5
cmp byte ptr [r8+2], 0
jz short loc_A2F1A
loc_A2EB5:
mov esi, 200h
mov rdi, rbx
mov rdx, [rbp+var_248]
lea rcx, [rbp+var_232]
xor r9d, r9d
xor eax, eax
call strxnmov
mov rax, [r13+r14+0]
mov eax, [rax+18h]
mov ecx, 0F000h
and eax, ecx
mov rdi, rbx
cmp eax, 4000h
jnz short loc_A2EFC
mov rsi, [rbp+var_240]
call my_rmtree
jmp short loc_A2F08
loc_A2EFC:
mov rsi, [rbp+var_240]
call my_delete
loc_A2F08:
mov r13d, eax
test eax, eax
jnz short loc_A2F4D
mov eax, [r15+8]
lea rbx, [rbp+var_230]
loc_A2F1A:
inc r12
mov ecx, eax
add r14, 10h
cmp r12, rcx
jb loc_A2E92
loc_A2F2C:
mov rdi, r15
call my_dirend
mov rdi, [rbp+var_248]
call _rmdir
mov r13d, eax
jmp short loc_A2F55
loc_A2F45:
mov r13d, 1
jmp short loc_A2F55
loc_A2F4D:
mov rdi, r15
call my_dirend
loc_A2F55:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A2F79
mov eax, r13d
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A2F79:
call ___stack_chk_fail
| long long my_rmtree(long long a1, const char *a2)
{
long long v2; // rax
long long v3; // r15
unsigned int v4; // eax
long long v5; // r14
unsigned long long i; // r12
long long v7; // r13
_BYTE *v8; // r8
unsigned int v9; // eax
unsigned int v10; // r13d
char v12; // [rsp+0h] [rbp-250h]
__int16 v13; // [rsp+1Eh] [rbp-232h] BYREF
_BYTE v14[512]; // [rsp+20h] [rbp-230h] BYREF
unsigned long long v15; // [rsp+220h] [rbp-30h]
v15 = __readfsqword(0x28u);
v13 = 47;
v2 = my_dir(a1, 0x4000LL);
if ( v2 )
{
v3 = v2;
v4 = *(_DWORD *)(v2 + 8);
if ( v4 )
{
v5 = 8LL;
for ( i = 0LL; i < v4; ++i )
{
v7 = *(_QWORD *)v3;
v8 = *(_BYTE **)(*(_QWORD *)v3 + v5 - 8);
if ( *v8 != 46 || v8[1] && (v8[1] != 46 || v8[2]) )
{
strxnmov((unsigned int)v14, 512, a1, (unsigned int)&v13, (_DWORD)v8, 0, v12);
if ( (*(_DWORD *)(*(_QWORD *)(v7 + v5) + 24LL) & 0xF000) == 0x4000 )
v9 = my_rmtree(v14, a2);
else
v9 = my_delete((long long)v14, a2);
v10 = v9;
if ( v9 )
{
my_dirend(v3);
return v10;
}
v4 = *(_DWORD *)(v3 + 8);
}
v5 += 16LL;
}
}
my_dirend(v3);
return (unsigned int)rmdir(a1);
}
else
{
return 1;
}
}
| my_rmtree:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV qword ptr [RBP + -0x240],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV word ptr [RBP + -0x232],0x2f
MOV ESI,0x4000
MOV qword ptr [RBP + -0x248],RDI
CALL 0x001a69ad
TEST RAX,RAX
JZ 0x001a2f45
MOV R15,RAX
MOV EAX,dword ptr [RAX + 0x8]
TEST EAX,EAX
JZ 0x001a2f2c
MOV R14D,0x8
LEA RBX,[RBP + -0x230]
XOR R12D,R12D
LAB_001a2e92:
MOV R13,qword ptr [R15]
MOV R8,qword ptr [R13 + R14*0x1 + -0x8]
CMP byte ptr [R8],0x2e
JNZ 0x001a2eb5
CMP byte ptr [R8 + 0x1],0x0
JZ 0x001a2f1a
CMP byte ptr [R8 + 0x1],0x2e
JNZ 0x001a2eb5
CMP byte ptr [R8 + 0x2],0x0
JZ 0x001a2f1a
LAB_001a2eb5:
MOV ESI,0x200
MOV RDI,RBX
MOV RDX,qword ptr [RBP + -0x248]
LEA RCX,[RBP + -0x232]
XOR R9D,R9D
XOR EAX,EAX
CALL 0x001dfda4
MOV RAX,qword ptr [R13 + R14*0x1]
MOV EAX,dword ptr [RAX + 0x18]
MOV ECX,0xf000
AND EAX,ECX
MOV RDI,RBX
CMP EAX,0x4000
JNZ 0x001a2efc
MOV RSI,qword ptr [RBP + -0x240]
CALL 0x001a2e29
JMP 0x001a2f08
LAB_001a2efc:
MOV RSI,qword ptr [RBP + -0x240]
CALL 0x001a2d54
LAB_001a2f08:
MOV R13D,EAX
TEST EAX,EAX
JNZ 0x001a2f4d
MOV EAX,dword ptr [R15 + 0x8]
LEA RBX,[RBP + -0x230]
LAB_001a2f1a:
INC R12
MOV ECX,EAX
ADD R14,0x10
CMP R12,RCX
JC 0x001a2e92
LAB_001a2f2c:
MOV RDI,R15
CALL 0x001a697c
MOV RDI,qword ptr [RBP + -0x248]
CALL 0x0012a340
MOV R13D,EAX
JMP 0x001a2f55
LAB_001a2f45:
MOV R13D,0x1
JMP 0x001a2f55
LAB_001a2f4d:
MOV RDI,R15
CALL 0x001a697c
LAB_001a2f55:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a2f79
MOV EAX,R13D
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a2f79:
CALL 0x0012a240
|
int my_rmtree(char *param_1,int8 param_2)
{
long lVar1;
char *pcVar2;
uint uVar3;
int iVar4;
long *plVar5;
ulong uVar6;
long lVar7;
long in_FS_OFFSET;
int2 local_23a;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_23a = 0x2f;
plVar5 = (long *)my_dir(param_1,0x4000);
if (plVar5 == (long *)0x0) {
iVar4 = 1;
}
else {
uVar3 = *(uint *)(plVar5 + 1);
if (uVar3 != 0) {
lVar7 = 8;
uVar6 = 0;
do {
lVar1 = *plVar5;
pcVar2 = *(char **)(lVar1 + -8 + lVar7);
if ((*pcVar2 != '.') || ((pcVar2[1] != '\0' && ((pcVar2[1] != '.' || (pcVar2[2] != '\0')))))
) {
strxnmov(local_238,0x200,param_1,&local_23a,pcVar2,0);
if ((*(uint *)(*(long *)(lVar1 + lVar7) + 0x18) & 0xf000) == 0x4000) {
iVar4 = my_rmtree(local_238,param_2);
}
else {
iVar4 = my_delete(local_238,param_2);
}
if (iVar4 != 0) {
my_dirend(plVar5);
goto LAB_001a2f55;
}
uVar3 = *(uint *)(plVar5 + 1);
}
uVar6 = uVar6 + 1;
lVar7 = lVar7 + 0x10;
} while (uVar6 < uVar3);
}
my_dirend(plVar5);
iVar4 = rmdir(param_1);
}
LAB_001a2f55:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,234 | translog_flush_set_new_goal_and_wait | eloqsql/storage/maria/ma_loghandler.c | void translog_flush_set_new_goal_and_wait(TRANSLOG_ADDRESS lsn)
{
int flush_no= log_descriptor.flush_no;
DBUG_ENTER("translog_flush_set_new_goal_and_wait");
DBUG_PRINT("enter", ("LSN: " LSN_FMT, LSN_IN_PARTS(lsn)));
mysql_mutex_assert_owner(&log_descriptor.log_flush_lock);
if (cmp_translog_addr(lsn, log_descriptor.next_pass_max_lsn) > 0)
{
log_descriptor.next_pass_max_lsn= lsn;
log_descriptor.max_lsn_requester= pthread_self();
mysql_cond_broadcast(&log_descriptor.new_goal_cond);
}
while (flush_no == log_descriptor.flush_no)
{
mysql_cond_wait(&log_descriptor.log_flush_cond,
&log_descriptor.log_flush_lock);
}
DBUG_VOID_RETURN;
} | O0 | c | translog_flush_set_new_goal_and_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xc24382(%rip), %eax # 0xc7a294
movl %eax, -0xc(%rbp)
jmp 0x55f17
jmp 0x55f19
jmp 0x55f1b
movq -0x8(%rbp), %rax
subq 0xc24372(%rip), %rax # 0xc7a298
cmpq $0x0, %rax
jle 0x55f56
movq -0x8(%rbp), %rax
movq %rax, 0xc24361(%rip) # 0xc7a298
callq 0x2a540
movq %rax, 0xc2435d(%rip) # 0xc7a2a0
leaq 0x423476(%rip), %rdi # 0x4793c0
addq $0x800d88, %rdi # imm = 0x800D88
callq 0x55fa0
jmp 0x55f58
movl -0xc(%rbp), %eax
movl 0xc24333(%rip), %ecx # 0xc7a294
cmpl %ecx, %eax
jne 0x55f90
leaq 0x423454(%rip), %rsi # 0x4793c0
movq %rsi, %rdi
addq $0x800d50, %rdi # imm = 0x800D50
addq $0x800d08, %rsi # imm = 0x800D08
leaq 0xfbd53(%rip), %rdx # 0x151cd7
movl $0x1eac, %ecx # imm = 0x1EAC
callq 0x50080
jmp 0x55f58
jmp 0x55f92
jmp 0x55f94
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| translog_flush_set_new_goal_and_wait:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov eax, cs:dword_C7A294
mov [rbp+var_C], eax
jmp short $+2
loc_55F17:
jmp short $+2
loc_55F19:
jmp short $+2
loc_55F1B:
mov rax, [rbp+var_8]
sub rax, cs:qword_C7A298
cmp rax, 0
jle short loc_55F56
mov rax, [rbp+var_8]
mov cs:qword_C7A298, rax
call _pthread_self
mov cs:qword_C7A2A0, rax
lea rdi, log_descriptor
add rdi, 800D88h
call inline_mysql_cond_broadcast_0
loc_55F56:
jmp short $+2
loc_55F58:
mov eax, [rbp+var_C]
mov ecx, cs:dword_C7A294
cmp eax, ecx
jnz short loc_55F90
lea rsi, log_descriptor
mov rdi, rsi
add rdi, 800D50h
add rsi, 800D08h
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1EACh
call inline_mysql_cond_wait_1
jmp short loc_55F58
loc_55F90:
jmp short $+2
loc_55F92:
jmp short $+2
loc_55F94:
add rsp, 10h
pop rbp
retn
| long long translog_flush_set_new_goal_and_wait(long long a1)
{
long long result; // rax
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = dword_C7A294;
if ( a1 - qword_C7A298 > 0 )
{
qword_C7A298 = a1;
qword_C7A2A0 = pthread_self();
inline_mysql_cond_broadcast_0(&log_descriptor[1049009]);
}
while ( 1 )
{
result = v2;
if ( v2 != dword_C7A294 )
break;
inline_mysql_cond_wait_1(
(long long)&log_descriptor[1049002],
(long long)&log_descriptor[1048993],
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1EACu);
}
return result;
}
| translog_flush_set_new_goal_and_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV EAX,dword ptr [0x00d7a294]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00155f17
LAB_00155f17:
JMP 0x00155f19
LAB_00155f19:
JMP 0x00155f1b
LAB_00155f1b:
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr [0x00d7a298]
CMP RAX,0x0
JLE 0x00155f56
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [0x00d7a298],RAX
CALL 0x0012a540
MOV qword ptr [0x00d7a2a0],RAX
LEA RDI,[0x5793c0]
ADD RDI,0x800d88
CALL 0x00155fa0
LAB_00155f56:
JMP 0x00155f58
LAB_00155f58:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,dword ptr [0x00d7a294]
CMP EAX,ECX
JNZ 0x00155f90
LEA RSI,[0x5793c0]
MOV RDI,RSI
ADD RDI,0x800d50
ADD RSI,0x800d08
LEA RDX,[0x251cd7]
MOV ECX,0x1eac
CALL 0x00150080
JMP 0x00155f58
LAB_00155f90:
JMP 0x00155f92
LAB_00155f92:
JMP 0x00155f94
LAB_00155f94:
ADD RSP,0x10
POP RBP
RET
|
void translog_flush_set_new_goal_and_wait(long param_1)
{
int iVar1;
iVar1 = DAT_00d7a294;
if (0 < param_1 - DAT_00d7a298) {
DAT_00d7a298 = param_1;
DAT_00d7a2a0 = pthread_self();
inline_mysql_cond_broadcast(&DAT_00d7a148);
}
while (iVar1 == DAT_00d7a294) {
inline_mysql_cond_wait
(&DAT_00d7a110,&DAT_00d7a0c8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x1eac);
}
return;
}
| |
31,235 | my_scan_mb2 | eloqsql/strings/ctype-ucs2.c | static size_t
my_scan_mb2(CHARSET_INFO *cs __attribute__((unused)),
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int res;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for (res= mb_wc(cs, &wc, (const uchar *) str, (const uchar *) end);
res > 0 && wc == ' ';
str+= res,
res= mb_wc(cs, &wc, (const uchar *) str, (const uchar *) end))
{
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
} | O0 | c | my_scan_mb2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
subl $0x2, %eax
je 0x5aff9
jmp 0x5afef
movl -0x48(%rbp), %eax
subl $0x3, %eax
je 0x5b070
jmp 0x5b076
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x49(%rbp)
jle 0x5b028
cmpq $0x20, -0x38(%rbp)
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x5b031
jmp 0x5b05f
jmp 0x5b033
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x5b012
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5b07e
jmp 0x5b072
jmp 0x5b074
jmp 0x5b076
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_scan_mb2:
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_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov eax, [rbp+var_24]
mov [rbp+var_48], eax
sub eax, 2
jz short loc_5AFF9
jmp short $+2
loc_5AFEF:
mov eax, [rbp+var_48]
sub eax, 3
jz short loc_5B070
jmp short loc_5B076
loc_5AFF9:
mov rax, [rbp+var_40]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_44], eax
loc_5B012:
xor eax, eax
cmp [rbp+var_44], 0
mov [rbp+var_49], al
jle short loc_5B028
cmp [rbp+var_38], 20h ; ' '
setz al
mov [rbp+var_49], al
loc_5B028:
mov al, [rbp+var_49]
test al, 1
jnz short loc_5B031
jmp short loc_5B05F
loc_5B031:
jmp short $+2
loc_5B033:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call rax
mov [rbp+var_44], eax
jmp short loc_5B012
loc_5B05F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_5B07E
loc_5B070:
jmp short $+2
loc_5B072:
jmp short $+2
loc_5B074:
jmp short $+2
loc_5B076:
mov [rbp+var_8], 0
loc_5B07E:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long my_scan_mb2(long long a1, long long a2, long long a3, int a4)
{
bool v5; // [rsp+7h] [rbp-49h]
int i; // [rsp+Ch] [rbp-44h]
long long ( *v7)(long long, long long *, long long, long long); // [rsp+10h] [rbp-40h]
long long v8; // [rsp+18h] [rbp-38h] BYREF
long long v9; // [rsp+20h] [rbp-30h]
int v10; // [rsp+2Ch] [rbp-24h]
long long v11; // [rsp+30h] [rbp-20h]
long long v12; // [rsp+38h] [rbp-18h]
long long v13; // [rsp+40h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a2;
v7 = *(long long ( **)(long long, long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
if ( a4 != 2 )
return 0LL;
for ( i = v7(v13, &v8, v12, v11); ; i = v7(v13, &v8, v12, v11) )
{
v5 = 0;
if ( i > 0 )
v5 = v8 == 32;
if ( !v5 )
break;
v12 += i;
}
return v12 - v9;
}
| my_scan_mb2:
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 dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x48],EAX
SUB EAX,0x2
JZ 0x0015aff9
JMP 0x0015afef
LAB_0015afef:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x3
JZ 0x0015b070
JMP 0x0015b076
LAB_0015aff9:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
LAB_0015b012:
XOR EAX,EAX
CMP dword ptr [RBP + -0x44],0x0
MOV byte ptr [RBP + -0x49],AL
JLE 0x0015b028
CMP qword ptr [RBP + -0x38],0x20
SETZ AL
MOV byte ptr [RBP + -0x49],AL
LAB_0015b028:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x0015b031
JMP 0x0015b05f
LAB_0015b031:
JMP 0x0015b033
LAB_0015b033:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0015b012
LAB_0015b05f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015b07e
LAB_0015b070:
JMP 0x0015b072
LAB_0015b072:
JMP 0x0015b074
LAB_0015b074:
JMP 0x0015b076
LAB_0015b076:
MOV qword ptr [RBP + -0x8],0x0
LAB_0015b07e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long my_scan_mb2(long param_1,long param_2,int8 param_3,int param_4)
{
code *pcVar1;
int local_4c;
long local_40;
long local_38;
int local_2c;
int8 local_28;
long local_20;
long local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
if (param_4 == 2) {
local_38 = param_2;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_4c = (*pcVar1)(param_1,&local_40,param_2,param_3);
while (0 < local_4c && local_40 == 0x20) {
local_20 = local_20 + local_4c;
local_4c = (*pcVar1)(local_18,&local_40,local_20,local_28);
}
local_10 = local_20 - local_38;
}
else {
local_10 = 0;
}
return local_10;
}
| |
31,236 | dtoa_alloc | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static char *dtoa_alloc(int i, Stack_alloc *alloc)
{
char *rv;
int aligned_size= MY_ALIGN(i, SIZEOF_CHARP);
if (alloc->free + aligned_size <= alloc->end)
{
rv= alloc->free;
alloc->free+= aligned_size;
}
else
rv= malloc(i);
return rv;
} | O0 | c | dtoa_alloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x8, %eax
subl $0x1, %eax
andl $-0x8, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x4ecaa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4ecb7
movslq -0x4(%rbp), %rdi
callq 0x145c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| dtoa_alloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov eax, [rbp+var_4]
add eax, 8
sub eax, 1
and eax, 0FFFFFFF8h
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_1C]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_4ECAA
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_1C]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_4ECB7
loc_4ECAA:
movsxd rdi, [rbp+var_4]
call _malloc
mov [rbp+var_18], rax
loc_4ECB7:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long dtoa_alloc(int a1, long long a2)
{
signed int v3; // [rsp+4h] [rbp-1Ch]
long long v4; // [rsp+8h] [rbp-18h]
v3 = (a1 + 7) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
return malloc(a1);
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
return v4;
}
| dtoa_alloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x8
SUB EAX,0x1
AND EAX,0xfffffff8
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x0014ecaa
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0014ecb7
LAB_0014ecaa:
MOVSXD RDI,dword ptr [RBP + -0x4]
CALL 0x001145c0
MOV qword ptr [RBP + -0x18],RAX
LAB_0014ecb7:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
void * dtoa_alloc(int param_1,long param_2)
{
uint uVar1;
int8 local_20;
uVar1 = param_1 + 7U & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar1)) {
local_20 = malloc((long)param_1);
}
else {
local_20 = *(void **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar1;
}
return local_20;
}
| |
31,237 | ggml_mean | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_mean(
struct ggml_context * ctx,
struct ggml_tensor * a) {
bool is_node = false;
if (a->grad) {
GGML_ASSERT(false); // TODO: implement
is_node = true;
}
int64_t ne[4] = { 1, a->ne[1], a->ne[2], a->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_MEAN;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
} | O2 | c | ggml_mean:
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x98(%rsi)
jne 0x6a686
movq %rsi, %rbx
movq %rsp, %rcx
movq $0x1, (%rcx)
vmovups 0x18(%rsi), %xmm0
vmovups %xmm0, 0x8(%rcx)
movq 0x28(%rsi), %rax
movq %rax, 0x18(%rcx)
pushq $0x4
popq %rdx
xorl %esi, %esi
callq 0x6835b
movl $0xd, 0x50(%rax)
andq $0x0, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x20, %rsp
popq %rbx
retq
movq 0x6b8bb(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6b90c(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2fb78(%rip), %rsi # 0x9a21e
leaq 0x371d1(%rip), %rdx # 0xa187e
leaq 0x2d98b(%rip), %r8 # 0x9803f
movl $0xe2a, %ecx # imm = 0xE2A
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_mean:
push rbx
sub rsp, 20h
cmp qword ptr [rsi+98h], 0
jnz short loc_6A686
mov rbx, rsi
mov rcx, rsp
mov qword ptr [rcx], 1
vmovups xmm0, xmmword ptr [rsi+18h]
vmovups xmmword ptr [rcx+8], xmm0
mov rax, [rsi+28h]
mov [rcx+18h], rax
push 4
pop rdx
xor esi, esi
call ggml_new_tensor
mov dword ptr [rax+50h], 0Dh
and qword ptr [rax+98h], 0
mov [rax+0A0h], rbx
add rsp, 20h
pop rbx
retn
loc_6A686:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalse; "false"
mov ecx, 0E2Ah
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long ggml_mean(long long a1, long long _RSI)
{
long long result; // rax
long long v5; // rdi
_QWORD v6[5]; // [rsp+0h] [rbp-28h] BYREF
if ( *(_QWORD *)(_RSI + 152) )
{
fflush(stdout);
v5 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
3626,
"false");
ggml_print_backtrace();
abort(v5);
}
_RCX = v6;
v6[0] = 1LL;
__asm
{
vmovups xmm0, xmmword ptr [rsi+18h]
vmovups xmmword ptr [rcx+8], xmm0
}
v6[3] = *(_QWORD *)(_RSI + 40);
result = ggml_new_tensor(a1, 0LL, 4LL, (long long)v6);
*(_DWORD *)(result + 80) = 13;
*(_QWORD *)(result + 152) = 0LL;
*(_QWORD *)(result + 160) = _RSI;
return result;
}
| ggml_mean:
PUSH RBX
SUB RSP,0x20
CMP qword ptr [RSI + 0x98],0x0
JNZ 0x0016a686
MOV RBX,RSI
MOV RCX,RSP
MOV qword ptr [RCX],0x1
VMOVUPS XMM0,xmmword ptr [RSI + 0x18]
VMOVUPS xmmword ptr [RCX + 0x8],XMM0
MOV RAX,qword ptr [RSI + 0x28]
MOV qword ptr [RCX + 0x18],RAX
PUSH 0x4
POP RDX
XOR ESI,ESI
CALL 0x0016835b
MOV dword ptr [RAX + 0x50],0xd
AND qword ptr [RAX + 0x98],0x0
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x20
POP RBX
RET
LAB_0016a686:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x19803f]
MOV ECX,0xe2a
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_mean(int8 param_1,long param_2)
{
long lVar1;
if (*(long *)(param_2 + 0x98) == 0) {
lVar1 = ggml_new_tensor(param_1,0,4);
*(int4 *)(lVar1 + 0x50) = 0xd;
*(int8 *)(lVar1 + 0x98) = 0;
*(long *)(lVar1 + 0xa0) = param_2;
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
0xe2a,"false");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
31,238 | CLI::App::_process() | MikePodsytnik[P]TCRtrie/build_O3/_deps/cli11-src/include/CLI/impl/App_inl.hpp | CLI11_INLINE void App::_process() {
try {
// the config file might generate a FileError but that should not be processed until later in the process
// to allow for help, version and other errors to generate first.
_process_config_file();
// process env shouldn't throw but no reason to process it if config generated an error
_process_env();
} catch(const CLI::FileError &) {
// callbacks and help_flags can generate exceptions which should take priority
// over the config file error if one exists.
_process_callbacks();
_process_help_flags();
throw;
}
_process_callbacks();
_process_help_flags();
_process_requirements();
} | O3 | cpp | CLI::App::_process():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x281ba
movq %rbx, %rdi
callq 0x22c88
movq %rbx, %rdi
callq 0x22e6e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22f38
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23026
movq %rax, %r14
cmpl $0x1, %edx
jne 0x1eaac
movq %r14, %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x22e6e
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22f38
callq 0x7600
movq %rax, %r14
callq 0x76d0
movq %r14, %rdi
callq 0x7780
movq %rax, %rdi
callq 0xc95c
| _ZN3CLI3App8_processEv:
push r14
push rbx
push rax
mov rbx, rdi
call _ZN3CLI3App20_process_config_fileEv; CLI::App::_process_config_file(void)
mov rdi, rbx; this
call _ZN3CLI3App12_process_envEv; CLI::App::_process_env(void)
mov rdi, rbx; this
call _ZN3CLI3App18_process_callbacksEv; CLI::App::_process_callbacks(void)
mov rdi, rbx; this
xor esi, esi; bool
xor edx, edx; bool
call _ZNK3CLI3App19_process_help_flagsEbb; CLI::App::_process_help_flags(bool,bool)
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN3CLI3App21_process_requirementsEv; CLI::App::_process_requirements(void)
mov r14, rax
cmp edx, 1
jnz short loc_1EAAC
mov rdi, r14; void *
call ___cxa_begin_catch
mov rdi, rbx; this
call _ZN3CLI3App18_process_callbacksEv; CLI::App::_process_callbacks(void)
mov rdi, rbx; this
xor esi, esi; bool
xor edx, edx; bool
call _ZNK3CLI3App19_process_help_flagsEbb; CLI::App::_process_help_flags(bool,bool)
call ___cxa_rethrow
mov r14, rax
call ___cxa_end_catch
loc_1EAAC:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long CLI::App::_process(CLI::App *this)
{
CLI::App::_process_config_file(this);
CLI::App::_process_env(this);
CLI::App::_process_callbacks(this);
CLI::App::_process_help_flags(this, 0, 0);
return CLI::App::_process_requirements(this);
}
| _process:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LAB_0011ea4b:
CALL 0x001281ba
MOV RDI,RBX
CALL 0x00122c88
LAB_0011ea58:
MOV RDI,RBX
CALL 0x00122e6e
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00122f38
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00123026
|
/* CLI::App::_process() */
void __thiscall CLI::App::_process(App *this)
{
/* try { // try from 0011ea4b to 0011ea57 has its CatchHandler @ 0011ea7b */
_process_config_file(this);
_process_env(this);
_process_callbacks(this);
_process_help_flags(this,false,false);
_process_requirements(this);
return;
}
| |
31,239 | my_ll10tostr_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static size_t
my_ll10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, longlong val)
{
char buffer[65];
register char *p, *db, *de;
long long_val;
int sl= 0;
ulonglong uval= (ulonglong) val;
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
}
}
p= &buffer[sizeof(buffer)-1];
*p='\0';
if (uval == 0)
{
*--p= '0';
goto cnv;
}
while (uval > (ulonglong) LONG_MAX)
{
ulonglong quo= uval/(uint) 10;
uint rem= (uint) (uval- quo* (uint) 10);
*--p= '0' + rem;
uval= quo;
}
long_val= (long) uval;
while (long_val != 0)
{
long quo= long_val/10;
*--p= (char) ('0' + (long_val - quo*10));
long_val= quo;
}
cnv:
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst -db);
} | O3 | c | my_ll10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %sil
orb %al, %sil
movq %r8, %rcx
negq %rcx
testb %sil, %sil
cmovneq %r8, %rcx
movb $0x0, -0x40(%rbp)
testq %rcx, %rcx
je 0x4a61a
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
js 0x4a625
leaq -0x40(%rbp), %r13
jmp 0x4a645
leaq -0x41(%rbp), %r13
movb $0x30, (%r13)
jmp 0x4a669
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leaq -0x41(%rbp), %r13
imull $0xf6, %edx, %eax
addl %eax, %ecx
addb $0x30, %cl
movb %cl, (%r13)
movq %rdx, %rcx
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r13)
decq %r13
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x4a645
testb %sil, %sil
jne 0x4a676
movb $0x2d, -0x1(%r13)
decq %r13
movq %rbx, %r12
testq %r14, %r14
jle 0x4a6b2
addq %rbx, %r14
movq %rbx, %r12
movsbq (%r13), %rsi
testq %rsi, %rsi
je 0x4a6b2
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *0x30(%rax)
testl %eax, %eax
jle 0x4a6b2
movl %eax, %eax
addq %rax, %r12
incq %r13
cmpq %r14, %r12
jb 0x4a684
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4a6d6
subl %ebx, %r12d
movslq %r12d, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24350
| my_ll10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
test ecx, ecx
setns al
test r8, r8
setns sil
or sil, al
mov rcx, r8
neg rcx
test sil, sil
cmovnz rcx, r8
mov [rbp+var_40], 0
test rcx, rcx
jz short loc_4A61A
mov rdi, 0CCCCCCCCCCCCCCCDh
js short loc_4A625
lea r13, [rbp+var_40]
jmp short loc_4A645
loc_4A61A:
lea r13, [rbp+var_41]
mov byte ptr [r13+0], 30h ; '0'
jmp short loc_4A669
loc_4A625:
mov rax, rcx
mul rdi
shr rdx, 3
lea r13, [rbp+var_41]
imul eax, edx, 0F6h
add ecx, eax
add cl, 30h ; '0'
mov [r13+0], cl
mov rcx, rdx
loc_4A645:
mov rax, rcx
mul rdi
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r13-1], al
dec r13
cmp rcx, 9
mov rcx, rdx
ja short loc_4A645
loc_4A669:
test sil, sil
jnz short loc_4A676
mov byte ptr [r13-1], 2Dh ; '-'
dec r13
loc_4A676:
mov r12, rbx
test r14, r14
jle short loc_4A6B2
add r14, rbx
mov r12, rbx
loc_4A684:
movsx rsi, byte ptr [r13+0]
test rsi, rsi
jz short loc_4A6B2
mov rax, [r15+0B8h]
mov rdi, r15
mov rdx, r12
mov rcx, r14
call qword ptr [rax+30h]
test eax, eax
jle short loc_4A6B2
mov eax, eax
add r12, rax
inc r13
cmp r12, r14
jb short loc_4A684
loc_4A6B2:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4A6D6
sub r12d, ebx
movsxd rax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4A6D6:
call ___stack_chk_fail
| long long my_ll10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, signed long long a5)
{
bool v6; // si
unsigned long long v7; // rcx
char *v8; // r13
bool v9; // cc
unsigned long long v10; // r12
unsigned long long v11; // r14
int v12; // eax
char v14; // [rsp+3Fh] [rbp-41h] BYREF
char v15; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v16; // [rsp+50h] [rbp-30h]
v16 = __readfsqword(0x28u);
v6 = a4 >= 0 || a5 >= 0;
v7 = -a5;
if ( v6 )
v7 = a5;
v15 = 0;
if ( v7 )
{
if ( (v7 & 0x8000000000000000LL) != 0LL )
{
v8 = &v14;
v14 = v7 % 0xA + 48;
v7 /= 0xAuLL;
}
else
{
v8 = &v15;
}
do
{
*--v8 = v7 % 0xA + 48;
v9 = v7 <= 9;
v7 /= 0xAuLL;
}
while ( !v9 );
}
else
{
v8 = &v14;
v14 = 48;
}
if ( !v6 )
*--v8 = 45;
LODWORD(v10) = a2;
if ( a3 > 0 )
{
v11 = a2 + a3;
v10 = a2;
do
{
if ( !*v8 )
break;
v12 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
*v8,
v10,
v11);
if ( v12 <= 0 )
break;
v10 += (unsigned int)v12;
++v8;
}
while ( v10 < v11 );
}
return (int)v10 - (int)a2;
}
| my_ll10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS SIL
OR SIL,AL
MOV RCX,R8
NEG RCX
TEST SIL,SIL
CMOVNZ RCX,R8
MOV byte ptr [RBP + -0x40],0x0
TEST RCX,RCX
JZ 0x0014a61a
MOV RDI,-0x3333333333333333
JS 0x0014a625
LEA R13,[RBP + -0x40]
JMP 0x0014a645
LAB_0014a61a:
LEA R13,[RBP + -0x41]
MOV byte ptr [R13],0x30
JMP 0x0014a669
LAB_0014a625:
MOV RAX,RCX
MUL RDI
SHR RDX,0x3
LEA R13,[RBP + -0x41]
IMUL EAX,EDX,0xf6
ADD ECX,EAX
ADD CL,0x30
MOV byte ptr [R13],CL
MOV RCX,RDX
LAB_0014a645:
MOV RAX,RCX
MUL RDI
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R13 + -0x1],AL
DEC R13
CMP RCX,0x9
MOV RCX,RDX
JA 0x0014a645
LAB_0014a669:
TEST SIL,SIL
JNZ 0x0014a676
MOV byte ptr [R13 + -0x1],0x2d
DEC R13
LAB_0014a676:
MOV R12,RBX
TEST R14,R14
JLE 0x0014a6b2
ADD R14,RBX
MOV R12,RBX
LAB_0014a684:
MOVSX RSI,byte ptr [R13]
TEST RSI,RSI
JZ 0x0014a6b2
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RAX + 0x30]
TEST EAX,EAX
JLE 0x0014a6b2
MOV EAX,EAX
ADD R12,RAX
INC R13
CMP R12,R14
JC 0x0014a684
LAB_0014a6b2:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014a6d6
SUB R12D,EBX
MOVSXD RAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014a6d6:
CALL 0x00124350
|
long my_ll10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
bool bVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_49 [17];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = -param_5;
if ((long)param_5 >= 0 || param_4 >= 0) {
uVar4 = param_5;
}
local_49[1] = 0;
if (uVar4 == 0) {
pcVar5 = local_49;
local_49[0] = '0';
}
else {
if ((long)uVar4 < 0) {
uVar3 = uVar4 / 10;
pcVar5 = local_49;
local_49[0] = (char)uVar4 + (char)uVar3 * -10 + '0';
}
else {
pcVar5 = local_49 + 1;
uVar3 = uVar4;
}
do {
pcVar5[-1] = (char)(uVar3 / 10) * -10 + (char)uVar3 + '0';
pcVar5 = pcVar5 + -1;
bVar1 = 9 < uVar3;
uVar3 = uVar3 / 10;
} while (bVar1);
}
if ((long)param_5 < 0 && param_4 < 0) {
pcVar5[-1] = '-';
pcVar5 = pcVar5 + -1;
}
uVar4 = param_2;
if (0 < param_3) {
do {
if ((long)*pcVar5 == 0) break;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*pcVar5,uVar4,param_3 + param_2);
if ((int)uVar2 < 1) break;
uVar4 = uVar4 + uVar2;
pcVar5 = pcVar5 + 1;
} while (uVar4 < param_3 + param_2);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (long)((int)uVar4 - (int)param_2);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,240 | rw_pr_unlock | eloqsql/mysys/thr_rwlock.c | int rw_pr_unlock(rw_pr_lock_t *rwlock)
{
if (rwlock->active_writer)
{
/* We are unlocking wr-lock. */
#ifdef SAFE_MUTEX
rwlock->writer_thread= 0;
#endif
rwlock->active_writer= FALSE;
if (rwlock->writers_waiting_readers)
{
/*
Avoid expensive cond signal in case when there is no contention
or it is wr-only.
Note that from view point of performance it would be better to
signal on the condition variable after unlocking mutex (as it
reduces number of contex switches).
Unfortunately this would mean that such rwlock can't be safely
used by MDL subsystem, which relies on the fact that it is OK
to destroy rwlock once it is in unlocked state.
*/
pthread_cond_signal(&rwlock->no_active_readers);
}
pthread_mutex_unlock(&rwlock->lock);
}
else
{
/* We are unlocking rd-lock. */
pthread_mutex_lock(&rwlock->lock);
rwlock->active_readers--;
if (rwlock->active_readers == 0 &&
rwlock->writers_waiting_readers)
{
/*
If we are last reader and there are waiting
writers wake them up.
*/
pthread_cond_signal(&rwlock->no_active_readers);
}
pthread_mutex_unlock(&rwlock->lock);
}
return 0;
} | O0 | c | rw_pr_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x60(%rax)
je 0x2aa00
movq -0x8(%rbp), %rax
movb $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x2a9f5
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x24030
movq -0x8(%rbp), %rdi
callq 0x24210
jmp 0x2aa40
movq -0x8(%rbp), %rdi
callq 0x24420
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x2aa37
movq -0x8(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
je 0x2aa37
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x24030
movq -0x8(%rbp), %rdi
callq 0x24210
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| rw_pr_unlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp byte ptr [rax+60h], 0
jz short loc_2AA00
mov rax, [rbp+var_8]
mov byte ptr [rax+60h], 0
mov rax, [rbp+var_8]
cmp dword ptr [rax+5Ch], 0
jz short loc_2A9F5
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
call _pthread_cond_signal
loc_2A9F5:
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
jmp short loc_2AA40
loc_2AA00:
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov ecx, [rax+58h]
add ecx, 0FFFFFFFFh
mov [rax+58h], ecx
mov rax, [rbp+var_8]
cmp dword ptr [rax+58h], 0
jnz short loc_2AA37
mov rax, [rbp+var_8]
cmp dword ptr [rax+5Ch], 0
jz short loc_2AA37
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
call _pthread_cond_signal
loc_2AA37:
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
loc_2AA40:
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long rw_pr_unlock(long long a1)
{
if ( *(_BYTE *)(a1 + 96) )
{
*(_BYTE *)(a1 + 96) = 0;
if ( *(_DWORD *)(a1 + 92) )
pthread_cond_signal(a1 + 40);
}
else
{
pthread_mutex_lock(a1);
if ( !--*(_DWORD *)(a1 + 88) && *(_DWORD *)(a1 + 92) )
pthread_cond_signal(a1 + 40);
}
pthread_mutex_unlock(a1);
return 0LL;
}
| rw_pr_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x60],0x0
JZ 0x0012aa00
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x60],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x5c],0x0
JZ 0x0012a9f5
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
CALL 0x00124030
LAB_0012a9f5:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124210
JMP 0x0012aa40
LAB_0012aa00:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124420
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x58]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x58],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x58],0x0
JNZ 0x0012aa37
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x5c],0x0
JZ 0x0012aa37
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
CALL 0x00124030
LAB_0012aa37:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00124210
LAB_0012aa40:
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 rw_pr_unlock(pthread_mutex_t *param_1)
{
if (*(char *)((long)param_1 + 0x60) == '\0') {
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + -1;
if ((*(int *)((long)param_1 + 0x58) == 0) && (*(int *)((long)param_1 + 0x5c) != 0)) {
pthread_cond_signal((pthread_cond_t *)(param_1 + 1));
}
pthread_mutex_unlock(param_1);
}
else {
*(int1 *)((long)param_1 + 0x60) = 0;
if (*(int *)((long)param_1 + 0x5c) != 0) {
pthread_cond_signal((pthread_cond_t *)(param_1 + 1));
}
pthread_mutex_unlock(param_1);
}
return 0;
}
| |
31,241 | testing::internal::FilePath::FileOrDirectoryExists() const | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc | bool FilePath::FileOrDirectoryExists() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif // GTEST_OS_WINDOWS_MOBILE
} | O1 | cpp | testing::internal::FilePath::FileOrDirectoryExists() const:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x82b0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8440
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| _ZNK7testing8internal8FilePath21FileOrDirectoryExistsEv:
push r14
push rbx
sub rsp, 98h
mov rbx, rdi
lea r14, [rsp+0A8h+var_A0]
mov edx, 90h
mov rdi, r14
xor esi, esi
call _memset
mov rdi, [rbx]
mov rsi, r14
call _stat
test eax, eax
setz al
add rsp, 98h
pop rbx
pop r14
retn
| bool testing::internal::FilePath::FileOrDirectoryExists(testing::internal::FilePath *this)
{
_BYTE v2[160]; // [rsp+8h] [rbp-A0h] BYREF
memset(v2, 0LL, 144LL);
return (unsigned int)stat(*(_QWORD *)this, v2) == 0;
}
| FileOrDirectoryExists:
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV EDX,0x90
MOV RDI,R14
XOR ESI,ESI
CALL 0x001082b0
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x00108440
TEST EAX,EAX
SETZ AL
ADD RSP,0x98
POP RBX
POP R14
RET
|
/* testing::internal::FilePath::FileOrDirectoryExists() const */
int8 __thiscall testing::internal::FilePath::FileOrDirectoryExists(FilePath *this)
{
int iVar1;
int4 extraout_var;
stat local_a0;
memset(&local_a0,0,0x90);
iVar1 = stat(*(char **)this,&local_a0);
return CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),iVar1 == 0);
}
| |
31,242 | filter_flush_file_evenly | eloqsql/storage/maria/ma_checkpoint.c | static enum pagecache_flush_filter_result
filter_flush_file_evenly(enum pagecache_page_type type,
pgcache_page_no_t pageno __attribute__ ((unused)),
LSN rec_lsn, void *arg)
{
struct st_filter_param *param= (struct st_filter_param *)arg;
if (unlikely(param->max_pages == 0)) /* all flushed already */
return FLUSH_FILTER_SKIP_ALL;
if ((type == PAGECACHE_LSN_PAGE) &&
(cmp_translog_addr(rec_lsn, param->up_to_lsn) <= 0))
{
param->max_pages--;
return FLUSH_FILTER_OK;
}
return FLUSH_FILTER_SKIP_TRY_NEXT;
} | O0 | c | filter_flush_file_evenly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9e207
movl $0x2, -0x4(%rbp)
jmp 0x9e23b
cmpl $0x2, -0x8(%rbp)
jne 0x9e234
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq (%rcx), %rax
cmpq $0x0, %rax
jg 0x9e234
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9e23b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| filter_flush_file_evenly:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
cmp dword ptr [rax+8], 0
setz 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_9E207
mov [rbp+var_4], 2
jmp short loc_9E23B
loc_9E207:
cmp [rbp+var_8], 2
jnz short loc_9E234
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
sub rax, [rcx]
cmp rax, 0
jg short loc_9E234
mov rax, [rbp+var_28]
mov ecx, [rax+8]
add ecx, 0FFFFFFFFh
mov [rax+8], ecx
mov [rbp+var_4], 1
jmp short loc_9E23B
loc_9E234:
mov [rbp+var_4], 0
loc_9E23B:
mov eax, [rbp+var_4]
pop rbp
retn
| long long filter_flush_file_evenly(int a1, long long a2, long long a3, long long a4)
{
if ( *(_DWORD *)(a4 + 8) )
{
if ( a1 == 2 && a3 - *(_QWORD *)a4 <= 0 )
{
--*(_DWORD *)(a4 + 8);
return 1;
}
else
{
return 0;
}
}
else
{
return 2;
}
}
| filter_flush_file_evenly:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x8],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019e207
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0019e23b
LAB_0019e207:
CMP dword ptr [RBP + -0x8],0x2
JNZ 0x0019e234
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr [RCX]
CMP RAX,0x0
JG 0x0019e234
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x8]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x8],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0019e23b
LAB_0019e234:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019e23b:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 filter_flush_file_evenly(int param_1,int8 param_2,long param_3,long *param_4)
{
int4 local_c;
if ((int)param_4[1] == 0) {
local_c = 2;
}
else if ((param_1 == 2) && (param_3 - *param_4 < 1)) {
*(int *)(param_4 + 1) = (int)param_4[1] + -1;
local_c = 1;
}
else {
local_c = 0;
}
return local_c;
}
| |
31,243 | js_async_generator_resolve_function_create | bluesky950520[P]quickjs/quickjs.c | static int js_async_generator_resolve_function_create(JSContext *ctx,
JSValue generator,
JSValue *resolving_funcs,
BOOL is_resume_next)
{
int i;
JSValue func;
for(i = 0; i < 2; i++) {
func = JS_NewCFunctionData(ctx, js_async_generator_resolve_function, 1,
i + is_resume_next * 2, 1, &generator);
if (JS_IsException(func)) {
if (i == 1)
JS_FreeValue(ctx, resolving_funcs[0]);
return -1;
}
resolving_funcs[i] = func;
}
return 0;
} | O0 | c | js_async_generator_resolve_function_create:
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
cmpl $0x2, 0x28(%rsp)
jge 0x96636
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %ecx
movl 0x2c(%rsp), %eax
shll %eax
addl %eax, %ecx
leaq 0xb8(%rip), %rsi # 0x96650
movl $0x1, %r8d
leaq 0x40(%rsp), %r9
movl %r8d, %edx
callq 0x294f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x96604
cmpl $0x1, 0x28(%rsp)
jne 0x965fa
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x229d0
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x9663e
movq 0x30(%rsp), %rax
movslq 0x28(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x96575
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
| js_async_generator_resolve_function_create:
sub rsp, 58h
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_10], rdx
mov [rsp+58h+var_20], rdi
mov [rsp+58h+var_28], rcx
mov [rsp+58h+var_2C], r8d
mov [rsp+58h+var_30], 0
loc_96575:
cmp [rsp+58h+var_30], 2
jge loc_96636
mov rdi, [rsp+58h+var_20]
mov ecx, [rsp+58h+var_30]
mov eax, [rsp+58h+var_2C]
shl eax, 1
add ecx, eax
lea rsi, js_async_generator_resolve_function
mov r8d, 1
lea r9, [rsp+58h+var_18]
mov edx, r8d
call JS_NewCFunctionData
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_40], rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_38], rax
mov rdi, [rsp+58h+var_40]
mov rsi, [rsp+58h+var_38]
call JS_IsException_1
cmp eax, 0
jz short loc_96604
cmp [rsp+58h+var_30], 1
jnz short loc_965FA
mov rdi, [rsp+58h+var_20]
mov rax, [rsp+58h+var_28]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_FreeValue
loc_965FA:
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp short loc_9663E
loc_96604:
mov rax, [rsp+58h+var_28]
movsxd rcx, [rsp+58h+var_30]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+58h+var_40]
mov [rax], rcx
mov rcx, [rsp+58h+var_38]
mov [rax+8], rcx
mov eax, [rsp+58h+var_30]
add eax, 1
mov [rsp+58h+var_30], eax
jmp loc_96575
loc_96636:
mov [rsp+58h+var_4], 0
loc_9663E:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long js_async_generator_resolve_function_create(
long long a1,
long long a2,
long long a3,
long long *a4,
__int16 a5)
{
long long v5; // rdx
long long *v6; // rax
long long v8; // [rsp+8h] [rbp-50h]
long long v9; // [rsp+20h] [rbp-38h]
int i; // [rsp+28h] [rbp-30h]
_QWORD v13[2]; // [rsp+40h] [rbp-18h] BYREF
v13[0] = a2;
v13[1] = a3;
for ( i = 0; ; ++i )
{
if ( i >= 2 )
return 0;
v8 = JS_NewCFunctionData(a1, (long long)js_async_generator_resolve_function, 1u, 2 * a5 + i, 1, (long long)v13);
v9 = v5;
if ( JS_IsException_1(v8, v5) )
break;
v6 = &a4[2 * i];
*v6 = v8;
v6[1] = v9;
}
if ( i == 1 )
JS_FreeValue(a1, *a4, a4[1]);
return (unsigned int)-1;
}
| js_async_generator_resolve_function_create:
SUB RSP,0x58
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RCX
MOV dword ptr [RSP + 0x2c],R8D
MOV dword ptr [RSP + 0x28],0x0
LAB_00196575:
CMP dword ptr [RSP + 0x28],0x2
JGE 0x00196636
MOV RDI,qword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x28]
MOV EAX,dword ptr [RSP + 0x2c]
SHL EAX,0x1
ADD ECX,EAX
LEA RSI,[0x196650]
MOV R8D,0x1
LEA R9,[RSP + 0x40]
MOV EDX,R8D
CALL 0x001294f0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00196604
CMP dword ptr [RSP + 0x28],0x1
JNZ 0x001965fa
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001229d0
LAB_001965fa:
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x0019663e
LAB_00196604:
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x28]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x28]
ADD EAX,0x1
MOV dword ptr [RSP + 0x28],EAX
JMP 0x00196575
LAB_00196636:
MOV dword ptr [RSP + 0x54],0x0
LAB_0019663e:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4
js_async_generator_resolve_function_create
(int8 param_1,int8 param_2,int8 param_3,int8 *param_4,int param_5)
{
int iVar1;
int1 auVar2 [16];
int local_30;
int8 local_18;
int8 local_10;
local_30 = 0;
local_18 = param_2;
local_10 = param_3;
while( true ) {
if (1 < local_30) {
return 0;
}
auVar2 = JS_NewCFunctionData(param_1,js_async_generator_resolve_function,1,
local_30 + param_5 * 2,1,&local_18);
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 != 0) break;
*(int1 (*) [16])(param_4 + (long)local_30 * 2) = auVar2;
local_30 = local_30 + 1;
}
if (local_30 == 1) {
JS_FreeValue(param_1,*param_4,param_4[1]);
}
return 0xffffffff;
}
| |
31,244 | js_async_generator_resolve_function_create | bluesky950520[P]quickjs/quickjs.c | static int js_async_generator_resolve_function_create(JSContext *ctx,
JSValue generator,
JSValue *resolving_funcs,
BOOL is_resume_next)
{
int i;
JSValue func;
for(i = 0; i < 2; i++) {
func = JS_NewCFunctionData(ctx, js_async_generator_resolve_function, 1,
i + is_resume_next * 2, 1, &generator);
if (JS_IsException(func)) {
if (i == 1)
JS_FreeValue(ctx, resolving_funcs[0]);
return -1;
}
resolving_funcs[i] = func;
}
return 0;
} | O1 | c | js_async_generator_resolve_function_create:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq $-0x1, 0x8(%r15)
addl %ecx, %ebp
movq $-0x10, %r13
leaq 0x61(%rip), %r12 # 0x55193
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
movl %ebp, %ecx
movl $0x1, %r8d
movq %r15, %r9
callq 0x204d6
cmpl $0x6, %edx
je 0x55168
movq %rax, 0x10(%rbx,%r13)
movq %rdx, 0x18(%rbx,%r13)
incl %ebp
addq $0x10, %r13
je 0x55132
xorl %ebp, %ebp
jmp 0x55182
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %r13, %r13
jne 0x55182
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x18(%r14), %rdi
callq 0x1ccb2
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_async_generator_resolve_function_create:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, ecx
mov rbx, rdx
mov r14, rdi
lea r15, [rsp+48h+var_40]
mov [r15], rsi
mov qword ptr [r15+8], 0FFFFFFFFFFFFFFFFh
add ebp, ecx
mov r13, 0FFFFFFFFFFFFFFF0h
lea r12, js_async_generator_resolve_function
loc_55132:
mov rdi, r14
mov rsi, r12
mov edx, 1
mov ecx, ebp
mov r8d, 1
mov r9, r15
call JS_NewCFunctionData
cmp edx, 6
jz short loc_55168
mov [rbx+r13+10h], rax
mov [rbx+r13+18h], rdx
inc ebp
add r13, 10h
jz short loc_55132
xor ebp, ebp
jmp short loc_55182
loc_55168:
mov ebp, 0FFFFFFFFh
test r13, r13
jnz short loc_55182
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rdi, [r14+18h]
call JS_FreeValueRT
loc_55182:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_async_generator_resolve_function_create(long long *a1, long long a2, long long a3, __int16 a4)
{
__int16 v5; // bp
long long v6; // r13
unsigned long long v7; // rax
long long v8; // rdx
unsigned int v9; // ebp
_QWORD v11[8]; // [rsp+8h] [rbp-40h] BYREF
v11[0] = a2;
v11[1] = -1LL;
v5 = 2 * a4;
v6 = -16LL;
while ( 1 )
{
v7 = JS_NewCFunctionData(a1, (long long)js_async_generator_resolve_function, 1u, v5, 1, (long long)v11);
if ( (_DWORD)v8 == 6 )
break;
*(_QWORD *)(a3 + v6 + 16) = v7;
*(_QWORD *)(a3 + v6 + 24) = v8;
++v5;
v6 += 16LL;
if ( v6 )
return 0;
}
v9 = -1;
if ( !v6 )
JS_FreeValueRT(a1[3], *(_DWORD **)a3, *(_QWORD *)(a3 + 8));
return v9;
}
| js_async_generator_resolve_function_create:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RDI
LEA R15,[RSP + 0x8]
MOV qword ptr [R15],RSI
MOV qword ptr [R15 + 0x8],-0x1
ADD EBP,ECX
MOV R13,-0x10
LEA R12,[0x155193]
LAB_00155132:
MOV RDI,R14
MOV RSI,R12
MOV EDX,0x1
MOV ECX,EBP
MOV R8D,0x1
MOV R9,R15
CALL 0x001204d6
CMP EDX,0x6
JZ 0x00155168
MOV qword ptr [RBX + R13*0x1 + 0x10],RAX
MOV qword ptr [RBX + R13*0x1 + 0x18],RDX
INC EBP
ADD R13,0x10
JZ 0x00155132
XOR EBP,EBP
JMP 0x00155182
LAB_00155168:
MOV EBP,0xffffffff
TEST R13,R13
JNZ 0x00155182
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011ccb2
LAB_00155182:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
js_async_generator_resolve_function_create
(long param_1,int8 param_2,int8 *param_3,int param_4)
{
long lVar1;
int1 auVar2 [16];
int8 local_40;
int8 local_38;
local_38 = 0xffffffffffffffff;
param_4 = param_4 * 2;
lVar1 = -0x10;
local_40 = param_2;
do {
auVar2 = JS_NewCFunctionData(param_1,js_async_generator_resolve_function,1,param_4,1,&local_40);
if (auVar2._8_4_ == 6) {
if (lVar1 != 0) {
return 0xffffffff;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*param_3,param_3[1]);
return 0xffffffff;
}
*(long *)((long)param_3 + lVar1 + 0x10) = auVar2._0_8_;
*(long *)((long)param_3 + lVar1 + 0x18) = auVar2._8_8_;
param_4 = param_4 + 1;
lVar1 = lVar1 + 0x10;
} while (lVar1 == 0);
return 0;
}
| |
31,245 | destroy_pfs_thread(void*) | eloqsql/storage/perfschema/pfs_server.cc | static void destroy_pfs_thread(void *key)
{
PFS_thread* pfs= reinterpret_cast<PFS_thread*> (key);
assert(pfs);
/*
This automatic cleanup is a last resort and best effort to avoid leaks,
and may not work on windows due to the implementation of pthread_key_create().
Please either use:
- my_thread_end()
- or PSI_server->delete_current_thread()
in the instrumented code, to explicitly cleanup the instrumentation.
Avoid invalid writes when the main() thread completes after shutdown:
the memory pointed by pfs is already released.
*/
if (pfs_initialized)
destroy_thread(pfs);
} | O0 | cpp | destroy_pfs_thread(void*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x384829(%rip), %rax # 0x3cb274
testb $0x1, (%rax)
je 0x46a59
movq -0x10(%rbp), %rdi
callq 0x382b0
addq $0x10, %rsp
popq %rbp
retq
nop
| _ZL18destroy_pfs_threadPv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
lea rax, pfs_initialized
test byte ptr [rax], 1
jz short loc_46A59
mov rdi, [rbp+var_10]; PFS_thread *
call _Z14destroy_threadP10PFS_thread; destroy_thread(PFS_thread *)
loc_46A59:
add rsp, 10h
pop rbp
retn
| char * destroy_pfs_thread(PFS_host **a1)
{
char *result; // rax
result = &pfs_initialized;
if ( (pfs_initialized & 1) != 0 )
return (char *)destroy_thread(a1);
return result;
}
| destroy_pfs_thread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[0x4cb274]
TEST byte ptr [RAX],0x1
JZ 0x00146a59
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001382b0
LAB_00146a59:
ADD RSP,0x10
POP RBP
RET
|
/* destroy_pfs_thread(void*) */
void destroy_pfs_thread(void *param_1)
{
if ((pfs_initialized & 1) != 0) {
destroy_thread((PFS_thread *)param_1);
}
return;
}
| |
31,246 | my_casefold_mb | eloqsql/strings/ctype-mb.c | static size_t
my_casefold_mb(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)),
const uchar *map,
size_t is_upper)
{
const char *srcend= src + srclen;
char *dst0= dst;
DBUG_ASSERT(cs->mbmaxlen == 2);
while (src < srcend)
{
size_t mblen= my_ismbchar(cs, src, srcend);
if (mblen)
{
MY_UNICASE_CHARACTER *ch;
if ((ch= get_case_info_for_ch(cs, (uchar) src[0], (uchar) src[1])))
{
int code= is_upper ? ch->toupper : ch->tolower;
src+= 2;
if (code > 0xFF)
*dst++= code >> 8;
*dst++= code & 0xFF;
}
else
{
*dst++= *src++;
*dst++= *src++;
}
}
else
{
*dst++= (char) map[(uchar) *src++];
}
}
return (size_t) (dst - dst0);
} | O0 | c | my_casefold_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3e3da
jmp 0x3e3dc
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x3e510
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3e240
movl %eax, %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x3e4e1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %edx
callq 0x40f20
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x3e49b
cmpq $0x0, 0x10(%rbp)
je 0x3e440
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
jmp 0x3e44a
movq -0x50(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
cmpl $0xff, -0x54(%rbp)
jle 0x3e47e
movl -0x54(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x54(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x3e4df
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x3e50b
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0x3e3dc
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casefold_mb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_0]
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 [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
jmp short $+2
loc_3E3DA:
jmp short $+2
loc_3E3DC:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb loc_3E510
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_38]
call my_ismbchar_0
mov eax, eax
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jz loc_3E4E1
mov rdi, [rbp+var_8]
mov rax, [rbp+var_10]
movzx esi, byte ptr [rax]
mov rax, [rbp+var_10]
movzx edx, byte ptr [rax+1]
call get_case_info_for_ch
mov [rbp+var_50], rax
cmp rax, 0
jz short loc_3E49B
cmp [rbp+arg_0], 0
jz short loc_3E440
mov rax, [rbp+var_50]
mov eax, [rax]
mov [rbp+var_58], eax
jmp short loc_3E44A
loc_3E440:
mov rax, [rbp+var_50]
mov eax, [rax+4]
mov [rbp+var_58], eax
loc_3E44A:
mov eax, [rbp+var_58]
mov [rbp+var_54], eax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
cmp [rbp+var_54], 0FFh
jle short loc_3E47E
mov eax, [rbp+var_54]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_3E47E:
mov eax, [rbp+var_54]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
jmp short loc_3E4DF
loc_3E49B:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov cl, [rax]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov cl, [rax]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_3E4DF:
jmp short loc_3E50B
loc_3E4E1:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
loc_3E50B:
jmp loc_3E3DC
loc_3E510:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_40]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casefold_mb(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
long long a6,
long long a7)
{
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // rax
char *v9; // rax
char v10; // cl
_BYTE *v11; // rax
unsigned __int8 *v12; // rcx
unsigned __int8 *v13; // rax
int v15; // [rsp+8h] [rbp-58h]
int *case_info_for_ch; // [rsp+10h] [rbp-50h]
unsigned long long v18; // [rsp+28h] [rbp-38h]
unsigned __int8 *v20; // [rsp+40h] [rbp-20h]
unsigned __int8 *v21; // [rsp+50h] [rbp-10h]
v21 = a2;
v20 = a4;
v18 = (unsigned long long)&a2[a3];
while ( (unsigned long long)v21 < v18 )
{
if ( (unsigned int)my_ismbchar_0(a1, (long long)v21, v18) )
{
case_info_for_ch = (int *)get_case_info_for_ch(a1, *v21, v21[1]);
if ( case_info_for_ch )
{
if ( a7 )
v15 = *case_info_for_ch;
else
v15 = case_info_for_ch[1];
v21 += 2;
if ( v15 > 255 )
{
v7 = v20++;
*v7 = BYTE1(v15);
}
v8 = v20++;
*v8 = v15;
}
else
{
*v20 = *v21;
v9 = (char *)(v21 + 1);
v21 += 2;
v10 = *v9;
v11 = v20 + 1;
v20 += 2;
*v11 = v10;
}
}
else
{
v12 = v21++;
v13 = v20++;
*v13 = *(_BYTE *)(a6 + *v12);
}
}
return (_BYTE *)(v20 - a4);
}
| my_casefold_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x10]
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 qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0013e3da
LAB_0013e3da:
JMP 0x0013e3dc
LAB_0013e3dc:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0013e510
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0013e240
MOV EAX,EAX
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0013e4e1
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ESI,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EDX,byte ptr [RAX + 0x1]
CALL 0x00140f20
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JZ 0x0013e49b
CMP qword ptr [RBP + 0x10],0x0
JZ 0x0013e440
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
JMP 0x0013e44a
LAB_0013e440:
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x58],EAX
LAB_0013e44a:
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
CMP dword ptr [RBP + -0x54],0xff
JLE 0x0013e47e
MOV EAX,dword ptr [RBP + -0x54]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_0013e47e:
MOV EAX,dword ptr [RBP + -0x54]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
JMP 0x0013e4df
LAB_0013e49b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_0013e4df:
JMP 0x0013e50b
LAB_0013e4e1:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
LAB_0013e50b:
JMP 0x0013e3dc
LAB_0013e510:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casefold_mb(int8 param_1,byte *param_2,long param_3,byte *param_4,int8 param_5,
long param_6,long param_7)
{
int iVar1;
int *piVar2;
byte *pbVar3;
int local_60;
byte *local_28;
byte *local_18;
local_28 = param_4;
local_18 = param_2;
while (local_18 < param_2 + param_3) {
iVar1 = my_ismbchar(param_1,local_18,param_2 + param_3);
if (iVar1 == 0) {
*local_28 = *(byte *)(param_6 + (ulong)*local_18);
local_28 = local_28 + 1;
local_18 = local_18 + 1;
}
else {
piVar2 = (int *)get_case_info_for_ch(param_1,*local_18,local_18[1]);
if (piVar2 == (int *)0x0) {
pbVar3 = local_28 + 1;
*local_28 = *local_18;
local_28 = local_28 + 2;
*pbVar3 = local_18[1];
}
else {
if (param_7 == 0) {
local_60 = piVar2[1];
}
else {
local_60 = *piVar2;
}
if (0xff < local_60) {
*local_28 = (byte)((uint)local_60 >> 8);
local_28 = local_28 + 1;
}
*local_28 = (byte)local_60;
local_28 = local_28 + 1;
}
local_18 = local_18 + 2;
}
}
return (long)local_28 - (long)param_4;
}
| |
31,247 | my_coll_parser_scan_character_list | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
} | O3 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x5, (%rdi)
jne 0x81aad
movq %rcx, %r14
movq %rdx, %r12
testq %rdx, %rdx
je 0x81a8f
movq %rsi, %r13
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x81ae6
incq %rcx
cmpq %rcx, %r12
jne 0x81a7f
addq $0xf8, %rbx
leaq 0x27d7a(%rip), %rdx # 0xa9817
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x81acd
addq $0xf8, %rbx
leaq 0x27d6b(%rip), %rdx # 0xa9826
leaq 0x27d7a(%rip), %rcx # 0xa983c
xorl %r15d, %r15d
movl $0x80, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9b512
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%r13,%rcx,8)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x817b9
testl %eax, %eax
je 0x81b5c
movl $0x1, %r15d
cmpl $0x5, (%rbx)
jne 0x81ad4
leaq 0x28(%rbx), %rdx
movslq 0x24(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, (%r13,%rcx,8)
je 0x81b26
incq %rcx
cmpq %rcx, %r12
jne 0x81b11
jmp 0x81a8f
movq %rax, (%r13,%rcx,8)
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rbx)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8155b
movq -0x30(%rbp), %rdx
cmpl $0x5, (%rbx)
je 0x81b0b
jmp 0x81ad4
xorl %r15d, %r15d
jmp 0x81ad4
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 5
jnz short loc_81AAD
mov r14, rcx
mov r12, rdx
test rdx, rdx
jz short loc_81A8F
mov r13, rsi
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_81A7F:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_81AE6
inc rcx
cmp r12, rcx
jnz short loc_81A7F
loc_81A8F:
add rbx, 0F8h
lea rdx, aSIsTooLong; "%s is too long"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
mov rcx, r14
jmp short loc_81ACD
loc_81AAD:
add rbx, 0F8h
lea rdx, aSExpected; "%s expected"
lea rcx, aCharacter; "Character"
xor r15d, r15d
mov esi, 80h
mov rdi, rbx
loc_81ACD:
xor eax, eax
call my_snprintf
loc_81AD4:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_81AE6:
mov [r13+rcx*8+0], rax
mov rdi, rbx
mov esi, 5
call my_coll_parser_scan_term
test eax, eax
jz short loc_81B5C
mov r15d, 1
cmp dword ptr [rbx], 5
jnz short loc_81AD4
lea rdx, [rbx+28h]
loc_81B0B:
movsxd rax, dword ptr [rbx+24h]
xor ecx, ecx
loc_81B11:
cmp qword ptr [r13+rcx*8+0], 0
jz short loc_81B26
inc rcx
cmp r12, rcx
jnz short loc_81B11
jmp loc_81A8F
loc_81B26:
mov [r13+rcx*8+0], rax
mov rax, [rdx+20h]
mov [rbx+20h], rax
movups xmm0, xmmword ptr [rdx]
movups xmm1, xmmword ptr [rdx+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov [rbp+var_30], rdx
mov rdi, [rbp+var_30]
call my_coll_lexem_next
mov rdx, [rbp+var_30]
cmp dword ptr [rbx], 5
jz short loc_81B0B
jmp loc_81AD4
loc_81B5C:
xor r15d, r15d
jmp loc_81AD4
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, int a4, int a5, int a6)
{
long long v8; // rcx
const char *v9; // rdx
unsigned int v10; // r15d
int v11; // edi
const char *v12; // rcx
long long v14; // rdx
long long v15; // rcx
__int128 v16; // xmm0
long long v17; // [rsp+0h] [rbp-30h]
if ( *(_DWORD *)a1 != 5 )
{
v9 = "%s expected";
v12 = "Character";
v10 = 0;
v11 = a1 + 248;
goto LABEL_8;
}
if ( !a3 )
{
LABEL_6:
v9 = "%s is too long";
v10 = 0;
v11 = a1 + 248;
LODWORD(v12) = a4;
LABEL_8:
my_snprintf(v11, 128, (_DWORD)v9, (_DWORD)v12, a5, a6);
return v10;
}
v8 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v8) )
{
if ( a3 == ++v8 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v8) = *(int *)(a1 + 36);
if ( (unsigned int)my_coll_parser_scan_term(a1, 5) )
{
v10 = 1;
if ( *(_DWORD *)a1 == 5 )
{
v14 = a1 + 40;
do
{
v15 = 0LL;
while ( *(_QWORD *)(a2 + 8 * v15) )
{
if ( a3 == ++v15 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v15) = *(int *)(a1 + 36);
*(_QWORD *)(a1 + 32) = *(_QWORD *)(v14 + 32);
v16 = *(_OWORD *)v14;
*(_OWORD *)(a1 + 16) = *(_OWORD *)(v14 + 16);
*(_OWORD *)a1 = v16;
v17 = v14;
my_coll_lexem_next(v14);
v14 = v17;
}
while ( *(_DWORD *)a1 == 5 );
}
}
else
{
return 0;
}
return v10;
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x5
JNZ 0x00181aad
MOV R14,RCX
MOV R12,RDX
TEST RDX,RDX
JZ 0x00181a8f
MOV R13,RSI
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_00181a7f:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x00181ae6
INC RCX
CMP R12,RCX
JNZ 0x00181a7f
LAB_00181a8f:
ADD RBX,0xf8
LEA RDX,[0x1a9817]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
MOV RCX,R14
JMP 0x00181acd
LAB_00181aad:
ADD RBX,0xf8
LEA RDX,[0x1a9826]
LEA RCX,[0x1a983c]
XOR R15D,R15D
MOV ESI,0x80
MOV RDI,RBX
LAB_00181acd:
XOR EAX,EAX
CALL 0x0019b512
LAB_00181ad4:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00181ae6:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RDI,RBX
MOV ESI,0x5
CALL 0x001817b9
TEST EAX,EAX
JZ 0x00181b5c
MOV R15D,0x1
CMP dword ptr [RBX],0x5
JNZ 0x00181ad4
LEA RDX,[RBX + 0x28]
LAB_00181b0b:
MOVSXD RAX,dword ptr [RBX + 0x24]
XOR ECX,ECX
LAB_00181b11:
CMP qword ptr [R13 + RCX*0x8],0x0
JZ 0x00181b26
INC RCX
CMP R12,RCX
JNZ 0x00181b11
JMP 0x00181a8f
LAB_00181b26:
MOV qword ptr [R13 + RCX*0x8],RAX
MOV RAX,qword ptr [RDX + 0x20]
MOV qword ptr [RBX + 0x20],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS XMM1,xmmword ptr [RDX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBP + -0x30],RDX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0018155b
MOV RDX,qword ptr [RBP + -0x30]
CMP dword ptr [RBX],0x5
JZ 0x00181b0b
JMP 0x00181ad4
LAB_00181b5c:
XOR R15D,R15D
JMP 0x00181ad4
|
int8 my_coll_parser_scan_character_list(int *param_1,long param_2,long param_3,char *param_4)
{
int iVar1;
long lVar2;
char *pcVar3;
if (*param_1 == 5) {
if (param_3 != 0) {
lVar2 = 0;
do {
if (*(long *)(param_2 + lVar2 * 8) == 0) {
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
return 0;
}
if (*param_1 != 5) {
return 1;
}
do {
lVar2 = 0;
while (*(long *)(param_2 + lVar2 * 8) != 0) {
lVar2 = lVar2 + 1;
if (param_3 == lVar2) goto LAB_00181a8f;
}
*(long *)(param_2 + lVar2 * 8) = (long)param_1[9];
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
if (*param_1 != 5) {
return 1;
}
} while( true );
}
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
LAB_00181a8f:
pcVar3 = "%s is too long";
}
else {
pcVar3 = "%s expected";
param_4 = "Character";
}
my_snprintf(param_1 + 0x3e,0x80,pcVar3,param_4);
return 0;
}
| |
31,248 | LefDefParser::defiNet::polyMask(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp | int defiNet::polyMask(int index) const {
char errMsg[128];
if (index < 0 || index > numPolys_) {
sprintf (errMsg, "ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again.",
index, numPolys_);
defiError(0, 6085, errMsg, defData);
return 0;
}
return polyMasks_[index];
} | O3 | cpp | LefDefParser::defiNet::polyMask(int) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %edx
movq %rdi, %rbx
testl %esi, %esi
sets %al
movl 0x170(%rdi), %ecx
cmpl %esi, %ecx
setl %sil
orb %al, %sil
cmpb $0x1, %sil
jne 0x23c1a
leaq 0x1f18b(%rip), %rsi # 0x42d7e
xorl %ebp, %ebp
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x6060
movq 0x240(%rbx), %rcx
xorl %edi, %edi
movl $0x17c5, %esi # imm = 0x17C5
movq %r14, %rdx
callq 0x18f80
jmp 0x23c26
movq 0x190(%rbx), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| _ZNK12LefDefParser7defiNet8polyMaskEi:
push rbp
push r14
push rbx
sub rsp, 80h
mov edx, esi
mov rbx, rdi
test esi, esi
sets al
mov ecx, [rdi+170h]
cmp ecx, esi
setl sil
or sil, al
cmp sil, 1
jnz short loc_23C1A
lea rsi, aErrorDefpars60_6; "ERROR (DEFPARS-6085): The index number "...
xor ebp, ebp
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
mov rcx, [rbx+240h]; LefDefParser::defrData *
xor edi, edi; this
mov esi, 17C5h; int
mov rdx, r14; char *
call _ZN12LefDefParser9defiErrorEiiPKcPNS_8defrDataE; LefDefParser::defiError(int,int,char const*,LefDefParser::defrData *)
jmp short loc_23C26
loc_23C1A:
mov rax, [rbx+190h]
mov ecx, edx
mov ebp, [rax+rcx*4]
loc_23C26:
mov eax, ebp
add rsp, 80h
pop rbx
pop r14
pop rbp
retn
| long long LefDefParser::defiNet::polyMask(LefDefParser::defiNet *this, int a2)
{
int v2; // ecx
unsigned int v3; // ebp
LefDefParser::defrData *v4; // r8
char v6[152]; // [rsp+0h] [rbp-98h] BYREF
v2 = *((_DWORD *)this + 92);
if ( a2 < 0 || v2 < a2 )
{
v3 = 0;
sprintf(
v6,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\n"
"Valid index is from 0 to %d. Specify a valid index number and then try again.",
a2,
v2);
LefDefParser::defiError(0LL, 6085, v6, *((LefDefParser::defrData **)this + 72), v4);
}
else
{
return *(unsigned int *)(*((_QWORD *)this + 50) + 4LL * (unsigned int)a2);
}
return v3;
}
| polyMask:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x80
MOV EDX,ESI
MOV RBX,RDI
TEST ESI,ESI
SETS AL
MOV ECX,dword ptr [RDI + 0x170]
CMP ECX,ESI
SETL SIL
OR SIL,AL
CMP SIL,0x1
JNZ 0x00123c1a
LEA RSI,[0x142d7e]
XOR EBP,EBP
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00106060
MOV RCX,qword ptr [RBX + 0x240]
XOR EDI,EDI
MOV ESI,0x17c5
MOV RDX,R14
CALL 0x00118f80
JMP 0x00123c26
LAB_00123c1a:
MOV RAX,qword ptr [RBX + 0x190]
MOV ECX,EDX
MOV EBP,dword ptr [RAX + RCX*0x4]
LAB_00123c26:
MOV EAX,EBP
ADD RSP,0x80
POP RBX
POP R14
POP RBP
RET
|
/* LefDefParser::defiNet::polyMask(int) const */
int4 __thiscall LefDefParser::defiNet::polyMask(defiNet *this,int param_1)
{
int4 uVar1;
char acStack_98 [128];
if (*(int *)(this + 0x170) < param_1 || param_1 < 0) {
uVar1 = 0;
sprintf(acStack_98,
"ERROR (DEFPARS-6085): The index number %d specified for the NET POLYGON is invalid.\nValid index is from 0 to %d. Specify a valid index number and then try again."
);
defiError(0,0x17c5,acStack_98,*(defrData **)(this + 0x240));
}
else {
uVar1 = *(int4 *)(*(long *)(this + 400) + (ulong)(uint)param_1 * 4);
}
return uVar1;
}
| |
31,249 | apply_one_rule | eloqsql/strings/ctype-uca.c | static my_bool
apply_one_rule(MY_CHARSET_LOADER *loader,
MY_COLL_RULES *rules, MY_COLL_RULE *r,
MY_UCA_WEIGHT_LEVEL *dst)
{
size_t nweights;
size_t nreset= my_coll_rule_reset_length(r); /* Length of reset sequence */
size_t nshift= my_coll_rule_shift_length(r); /* Length of shift sequence */
uint16 *to;
my_bool rc;
if ((rules->shift_after_method == my_shift_method_expand && r->diff[0]) ||
r->before_level == 1)
{
/*
Suppose we have this rule: &B[before primary] < C
i.e. we need to put C before B, but after A, so
the result order is: A < C < B.
Let primary weight of B be [BBBB].
We cannot just use [BBBB-1] as weight for C:
DUCET does not have enough unused weights between any two characters,
so using [BBBB-1] will likely make C equal to the previous character,
which is A, so we'll get this order instead of the desired: A = C < B.
To guarantee that that C is sorted after A, we'll use expansion
with a kind of "biggest possible character".
As "biggest possible character" we'll use "last_non_ignorable":
We'll compose weight for C as: [BBBB-1][MMMM+1]
where [MMMM] is weight for "last_non_ignorable".
We also do the same trick for "reset after" if the collation
option says so. E.g. for the rules "&B < C", weight for
C will be calculated as: [BBBB][MMMM+1]
At this point we only need to store codepoints
'B' and 'last_non_ignorable'. Actual weights for 'C'
will be calculated according to the above formula later,
in create_tailoring().
*/
if (!my_coll_rule_expand(r->base, MY_UCA_MAX_EXPANSION,
rules->uca->last_non_ignorable))
{
my_charset_loader_error_for_rule(loader, r, "Expansion", r->base, nreset);
return TRUE;
}
nreset= my_coll_rule_reset_length(r);
}
if (nshift >= 2) /* Contraction */
{
MY_CONTRACTIONS *contractions= &dst->contractions;
to= my_uca_init_one_contraction(contractions,
r->curr, (uint)nshift, r->with_context);
/* Store weights of the "reset to" character */
dst->contractions.nitems--; /* Temporarily hide - it's incomplete */
rc= my_char_weight_put(dst,
to, MY_UCA_CONTRACTION_MAX_WEIGHT_SIZE, &nweights,
r->base, nreset);
dst->contractions.nitems++; /* Activate, now it's complete */
}
else
{
my_wc_t pagec= (r->curr[0] >> 8);
DBUG_ASSERT(dst->weights[pagec]);
to= my_char_weight_addr(dst, r->curr[0]);
/* Store weights of the "reset to" character */
rc= my_char_weight_put(dst, to, dst->lengths[pagec], &nweights, r->base, nreset);
}
if (rc)
{
my_charset_loader_error_for_rule(loader, r, "Expansion", r->base, nreset);
return rc;
}
/* Apply level difference. */
return apply_shift(loader, rules, r, dst->levelno, to, nweights);
} | O0 | c | apply_one_rule:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa0290
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa02b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x9fc69
movq -0x20(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x9fc77
movq -0x20(%rbp), %rax
cmpq $0x1, 0x90(%rax)
jne 0x9fcc8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x78(%rax), %rdx
movl $0xa, %esi
callq 0x9f670
cmpl $0x0, %eax
jne 0x9fcbb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x2f217(%rip), %rdx # 0xceec4
callq 0xa02e0
movb $0x1, -0x1(%rbp)
jmp 0x9fde8
movq -0x20(%rbp), %rdi
callq 0xa0290
movq %rax, -0x38(%rbp)
cmpq $0x2, -0x40(%rbp)
jb 0x9fd44
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x50, %rsi
movq -0x40(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movsbl 0x98(%rax), %ecx
callq 0x9fe00
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x11, %edx
leaq -0x30(%rbp), %rcx
callq 0xa03a0
movb %al, -0x49(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x9fd9b
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
shrq $0x8, %rax
movq %rax, -0x60(%rbp)
jmp 0x9fd56
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movl %eax, %esi
callq 0x9db60
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x60(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
movq -0x20(%rbp), %r8
movq -0x38(%rbp), %r9
leaq -0x30(%rbp), %rcx
callq 0xa03a0
movb %al, -0x49(%rbp)
cmpb $0x0, -0x49(%rbp)
je 0x9fdc5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x2f10c(%rip), %rdx # 0xceec4
callq 0xa02e0
movb -0x49(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x9fde8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x48(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0xa05a0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| apply_one_rule:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_20]
call my_coll_rule_reset_length
mov [rbp+var_38], rax
mov rdi, [rbp+var_20]
call my_coll_rule_shift_length
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax+30h], 1
jnz short loc_9FC69
mov rax, [rbp+var_20]
cmp dword ptr [rax+80h], 0
jnz short loc_9FC77
loc_9FC69:
mov rax, [rbp+var_20]
cmp qword ptr [rax+90h], 1
jnz short loc_9FCC8
loc_9FC77:
mov rdi, [rbp+var_20]
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdx, [rax+78h]
mov esi, 0Ah
call my_coll_rule_expand
cmp eax, 0
jnz short loc_9FCBB
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_38]
lea rdx, aExpansion; "Expansion"
call my_charset_loader_error_for_rule
mov [rbp+var_1], 1
jmp loc_9FDE8
loc_9FCBB:
mov rdi, [rbp+var_20]
call my_coll_rule_reset_length
mov [rbp+var_38], rax
loc_9FCC8:
cmp [rbp+var_40], 2
jb short loc_9FD44
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_58], rax
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_20]
add rsi, 50h ; 'P'
mov rax, [rbp+var_40]
mov edx, eax
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax+98h]
call my_uca_init_one_contraction
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rcx, [rax+18h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+18h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_48]
mov r8, [rbp+var_20]
mov r9, [rbp+var_38]
mov edx, 11h
lea rcx, [rbp+var_30]
call my_char_weight_put
mov [rbp+var_49], al
mov rax, [rbp+var_28]
mov rcx, [rax+18h]
add rcx, 1
mov [rax+18h], rcx
jmp short loc_9FD9B
loc_9FD44:
mov rax, [rbp+var_20]
mov rax, [rax+50h]
shr rax, 8
mov [rbp+var_60], rax
jmp short $+2
loc_9FD56:
mov rdi, [rbp+var_28]
mov rax, [rbp+var_20]
mov rax, [rax+50h]
mov esi, eax
call my_char_weight_addr
mov [rbp+var_48], rax
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_48]
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov rcx, [rbp+var_60]
movzx eax, byte ptr [rax+rcx]
mov edx, eax
mov r8, [rbp+var_20]
mov r9, [rbp+var_38]
lea rcx, [rbp+var_30]
call my_char_weight_put
mov [rbp+var_49], al
loc_9FD9B:
cmp [rbp+var_49], 0
jz short loc_9FDC5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_38]
lea rdx, aExpansion; "Expansion"
call my_charset_loader_error_for_rule
mov al, [rbp+var_49]
mov [rbp+var_1], al
jmp short loc_9FDE8
loc_9FDC5:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_28]
mov ecx, [rax+30h]
mov r8, [rbp+var_48]
mov r9, [rbp+var_30]
call apply_shift
mov [rbp+var_1], al
loc_9FDE8:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| char apply_one_rule(long long a1, long long a2, long long a3, _QWORD *a4)
{
long long v5; // [rsp+0h] [rbp-60h]
char v6; // [rsp+17h] [rbp-49h]
long long inited; // [rsp+18h] [rbp-48h]
unsigned long long v8; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+28h] [rbp-38h]
long long v10; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v11; // [rsp+38h] [rbp-28h]
long long v12; // [rsp+40h] [rbp-20h]
long long v13; // [rsp+48h] [rbp-18h]
long long v14; // [rsp+50h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
v9 = my_coll_rule_reset_length(a3);
v8 = my_coll_rule_shift_length(v12);
if ( *(_DWORD *)(a2 + 48) == 1 && *(_DWORD *)(v12 + 128) || *(_QWORD *)(v12 + 144) == 1LL )
{
if ( !(unsigned int)my_coll_rule_expand(v12, 0xAuLL, *(_QWORD *)(*(_QWORD *)(v13 + 8) + 120LL)) )
{
my_charset_loader_error_for_rule(v14, v12, "Expansion", v12, v9);
return 1;
}
v9 = my_coll_rule_reset_length(v12);
}
if ( v8 < 2 )
{
v5 = *(_QWORD *)(v12 + 80) >> 8;
inited = my_char_weight_addr(v11, *(_QWORD *)(v12 + 80));
v6 = my_char_weight_put(v11, inited, *(unsigned __int8 *)(v11[1] + v5), &v10, v12, v9);
}
else
{
inited = my_uca_init_one_contraction(v11 + 3, v12 + 80, (unsigned int)v8, (unsigned int)*(char *)(v12 + 152));
--v11[3];
v6 = my_char_weight_put(v11, inited, 17LL, &v10, v12, v9);
++v11[3];
}
if ( !v6 )
return apply_shift(v14, v13, v12, *((unsigned int *)v11 + 12), inited, v10);
my_charset_loader_error_for_rule(v14, v12, "Expansion", v12, v9);
return v6;
}
| apply_one_rule:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001a0290
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001a02b0
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x30],0x1
JNZ 0x0019fc69
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x80],0x0
JNZ 0x0019fc77
LAB_0019fc69:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x90],0x1
JNZ 0x0019fcc8
LAB_0019fc77:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x78]
MOV ESI,0xa
CALL 0x0019f670
CMP EAX,0x0
JNZ 0x0019fcbb
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x38]
LEA RDX,[0x1ceec4]
CALL 0x001a02e0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0019fde8
LAB_0019fcbb:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001a0290
MOV qword ptr [RBP + -0x38],RAX
LAB_0019fcc8:
CMP qword ptr [RBP + -0x40],0x2
JC 0x0019fd44
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x50
MOV RAX,qword ptr [RBP + -0x40]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX + 0x98]
CALL 0x0019fe00
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x38]
MOV EDX,0x11
LEA RCX,[RBP + -0x30]
CALL 0x001a03a0
MOV byte ptr [RBP + -0x49],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x1
MOV qword ptr [RAX + 0x18],RCX
JMP 0x0019fd9b
LAB_0019fd44:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x50]
SHR RAX,0x8
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0019fd56
LAB_0019fd56:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x50]
MOV ESI,EAX
CALL 0x0019db60
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV EDX,EAX
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x38]
LEA RCX,[RBP + -0x30]
CALL 0x001a03a0
MOV byte ptr [RBP + -0x49],AL
LAB_0019fd9b:
CMP byte ptr [RBP + -0x49],0x0
JZ 0x0019fdc5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x38]
LEA RDX,[0x1ceec4]
CALL 0x001a02e0
MOV AL,byte ptr [RBP + -0x49]
MOV byte ptr [RBP + -0x1],AL
JMP 0x0019fde8
LAB_0019fdc5:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x30]
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x30]
CALL 0x001a05a0
MOV byte ptr [RBP + -0x1],AL
LAB_0019fde8:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int8 apply_one_rule(int8 param_1,long param_2,long param_3,long param_4)
{
char extraout_AL;
int iVar1;
ulong uVar2;
int7 extraout_var;
int8 uVar3;
int7 uVar4;
int7 extraout_var_00;
char local_51;
int8 local_50;
int8 local_40;
int8 local_38;
long local_30;
long local_28;
long local_20;
int8 local_18;
char local_9;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_40 = my_coll_rule_reset_length(param_3);
uVar2 = my_coll_rule_shift_length(local_28);
if (((*(int *)(local_20 + 0x30) == 1) && (*(int *)(local_28 + 0x80) != 0)) ||
(*(long *)(local_28 + 0x90) == 1)) {
iVar1 = my_coll_rule_expand(local_28,10,*(int8 *)(*(long *)(local_20 + 8) + 0x78));
if (iVar1 == 0) {
my_charset_loader_error_for_rule(local_18,local_28,"Expansion",local_28,local_40);
local_9 = '\x01';
uVar4 = extraout_var;
goto LAB_0019fde8;
}
local_40 = my_coll_rule_reset_length(local_28);
}
if (uVar2 < 2) {
uVar2 = *(ulong *)(local_28 + 0x50);
local_50 = my_char_weight_addr(local_30,*(ulong *)(local_28 + 0x50) & 0xffffffff);
local_51 = my_char_weight_put(local_30,local_50,
*(int1 *)(*(long *)(local_30 + 8) + (uVar2 >> 8)),&local_38,
local_28,local_40);
}
else {
local_50 = my_uca_init_one_contraction
(local_30 + 0x18,local_28 + 0x50,uVar2 & 0xffffffff,
(int)*(char *)(local_28 + 0x98));
*(long *)(local_30 + 0x18) = *(long *)(local_30 + 0x18) + -1;
local_51 = my_char_weight_put(local_30,local_50,0x11,&local_38,local_28,local_40);
*(long *)(local_30 + 0x18) = *(long *)(local_30 + 0x18) + 1;
}
if (local_51 == '\0') {
apply_shift(local_18,local_20,local_28,*(int4 *)(local_30 + 0x30),local_50,local_38);
uVar4 = extraout_var_00;
local_9 = extraout_AL;
}
else {
uVar3 = my_charset_loader_error_for_rule(local_18,local_28,"Expansion",local_28,local_40);
uVar4 = (int7)((ulong)uVar3 >> 8);
local_9 = local_51;
}
LAB_0019fde8:
return CONCAT71(uVar4,local_9);
}
| |
31,250 | google::protobuf::compiler::objectivec::ImportWriter::ParseFrameworkMappings() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/objectivec/objectivec_helpers.cc | void ImportWriter::ParseFrameworkMappings() {
need_to_parse_mapping_file_ = false;
if (named_framework_to_proto_path_mappings_path_.empty()) {
return; // Nothing to do.
}
ProtoFrameworkCollector collector(&proto_file_to_framework_name_);
std::string parse_error;
if (!ParseSimpleFile(named_framework_to_proto_path_mappings_path_,
&collector, &parse_error)) {
std::cerr << "error parsing " << named_framework_to_proto_path_mappings_path_
<< " : " << parse_error << std::endl;
std::cerr.flush();
}
} | O3 | cpp | google::protobuf::compiler::objectivec::ImportWriter::ParseFrameworkMappings():
pushq %r14
pushq %rbx
subq $0x38, %rsp
movb $0x0, 0x98(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x51f76
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x68(%rbx), %rax
leaq 0x22538f(%rip), %rcx # 0x277238
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdx
callq 0x50d34
testb %al, %al
jne 0x51f67
movq 0x22d0fd(%rip), %rdi # 0x27efe0
leaq 0x150d13(%rip), %rsi # 0x1a2bfd
movl $0xe, %edx
callq 0x1f560
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x22d0dd(%rip), %rdi # 0x27efe0
callq 0x1f560
movq %rax, %rbx
leaq 0x1a2137(%rip), %rsi # 0x1f4049
movl $0x3, %edx
movq %rax, %rdi
callq 0x1f560
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f560
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1f4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1f040
movq %rax, %rdi
callq 0x1f310
movq 0x22d07e(%rip), %rdi # 0x27efe0
callq 0x1f310
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x51f76
callq 0x1f4a0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x51f90
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf8compiler10objectivec12ImportWriter22ParseFrameworkMappingsEv:
push r14; int
push rbx; void *
sub rsp, 38h
mov byte ptr [rdi+98h], 0
cmp qword ptr [rdi+28h], 0
jz loc_51F76
mov rbx, rdi
add rdi, 20h ; ' '; int
lea rax, [rbx+68h]
lea rcx, off_277238
lea rsi, [rsp+48h+var_20]; int
mov [rsi], rcx
mov [rsi+8], rax
lea r14, [rsp+48h+var_30]
mov [r14-10h], r14
mov qword ptr [r14-8], 0
mov byte ptr [r14], 0
lea rdx, [rsp+48h+var_40]; int
call _ZN6google8protobuf8compiler10objectivec15ParseSimpleFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS2_12LineConsumerEPS8_; google::protobuf::compiler::objectivec::ParseSimpleFile(std::string const&,google::protobuf::compiler::objectivec::LineConsumer *,std::string*)
test al, al
jnz loc_51F67
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aErrorParsing; "error parsing "
mov edx, 0Eh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rbx+20h]
mov rdx, [rbx+28h]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
lea rsi, aField+0Eh; " : "
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+48h+var_40]
mov rdx, [rsp+48h+var_38]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, rbx; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov rdi, cs:_ZSt4cerr_ptr; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_51F67:
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r14
jz short loc_51F76
call __ZdlPv; operator delete(void *)
loc_51F76:
add rsp, 38h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_51F90
call __ZdlPv; operator delete(void *)
loc_51F90:
mov rdi, rbx
call __Unwind_Resume
| void google::protobuf::compiler::objectivec::ImportWriter::ParseFrameworkMappings(
google::protobuf::compiler::objectivec::ImportWriter *this)
{
long long v1; // rbx
std::ostream *v2; // rbx
char v3; // al
std::ostream *v4; // rax
void *v5; // [rsp+8h] [rbp-40h] BYREF
long long v6; // [rsp+10h] [rbp-38h]
_BYTE v7[16]; // [rsp+18h] [rbp-30h] BYREF
_QWORD v8[4]; // [rsp+28h] [rbp-20h] BYREF
*((_BYTE *)this + 152) = 0;
if ( *((_QWORD *)this + 5) )
{
v8[0] = off_277238;
v8[1] = (char *)this + 104;
v5 = v7;
v6 = 0LL;
v7[0] = 0;
if ( !(unsigned __int8)google::protobuf::compiler::objectivec::ParseSimpleFile(
(_QWORD *)this + 4,
(int)v8,
(long long)&v5) )
{
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "error parsing ", 14LL);
v1 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *((_QWORD *)this + 4), *((_QWORD *)this + 5));
std::__ostream_insert<char,std::char_traits<char>>(v1, " : ", 3LL);
v2 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(v1, v5, v6);
v3 = std::ios::widen((char *)v2 + *(_QWORD *)(*(_QWORD *)v2 - 24LL), 10LL);
v4 = (std::ostream *)std::ostream::put(v2, v3);
std::ostream::flush(v4);
std::ostream::flush((std::ostream *)&std::cerr);
}
if ( v5 != v7 )
operator delete(v5);
}
}
| ParseFrameworkMappings:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV byte ptr [RDI + 0x98],0x0
CMP qword ptr [RDI + 0x28],0x0
JZ 0x00151f76
MOV RBX,RDI
ADD RDI,0x20
LEA RAX,[RBX + 0x68]
LEA RCX,[0x377238]
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],RCX
MOV qword ptr [RSI + 0x8],RAX
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV qword ptr [R14 + -0x8],0x0
MOV byte ptr [R14],0x0
LAB_00151eca:
LEA RDX,[RSP + 0x8]
CALL 0x00150d34
TEST AL,AL
JNZ 0x00151f67
MOV RDI,qword ptr [0x0037efe0]
LEA RSI,[0x2a2bfd]
MOV EDX,0xe
CALL 0x0011f560
MOV RSI,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RBX + 0x28]
MOV RDI,qword ptr [0x0037efe0]
CALL 0x0011f560
MOV RBX,RAX
LEA RSI,[0x2f4049]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x0011f560
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,RBX
CALL 0x0011f560
MOV RBX,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x0011f4d0
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x0011f040
MOV RDI,RAX
CALL 0x0011f310
MOV RDI,qword ptr [0x0037efe0]
CALL 0x0011f310
LAB_00151f67:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x00151f76
CALL 0x0011f4a0
LAB_00151f76:
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* google::protobuf::compiler::objectivec::ImportWriter::ParseFrameworkMappings() */
void __thiscall
google::protobuf::compiler::objectivec::ImportWriter::ParseFrameworkMappings(ImportWriter *this)
{
char cVar1;
ostream *poVar2;
char *local_40;
long local_38;
char local_30 [16];
int **local_20;
ImportWriter *local_18;
this[0x98] = (ImportWriter)0x0;
if (*(long *)(this + 0x28) != 0) {
local_18 = this + 0x68;
local_20 = &PTR__LineConsumer_00377238;
local_38 = 0;
local_30[0] = '\0';
/* try { // try from 00151eca to 00151f66 has its CatchHandler @ 00151f7e */
local_40 = local_30;
cVar1 = ParseSimpleFile((string *)(this + 0x20),(LineConsumer *)&local_20,(string *)&local_40);
if (cVar1 == '\0') {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_0037efe0,"error parsing ",0xe);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_0037efe0,*(char **)(this + 0x20),
*(long *)(this + 0x28));
std::__ostream_insert<char,std::char_traits<char>>(poVar2," : ",3);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>(poVar2,local_40,local_38);
std::ios::widen((char)*(int8 *)(*(long *)poVar2 + -0x18) + (char)poVar2);
std::ostream::put((char)poVar2);
std::ostream::flush();
std::ostream::flush();
}
if (local_40 != local_30) {
operator_delete(local_40);
}
}
return;
}
| |
31,251 | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O1 | cpp | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x61427
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %esi, %esi
cmpq %r15, %rcx
setbe %sil
movq -0x8(%rax,%rsi,8), %rax
btq %rdx, %rax
jae 0x612ba
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x59800
movq %r14, %rdi
movl $0x1, %esi
callq 0x59800
testb %bpl, %bpl
jne 0x61267
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x61448
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x613fb
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x612c4
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x613fb
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x6131e
cmpl $0x2, %ecx
jne 0x6144d
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5e632
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x613f7
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x61417
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59800
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x59800
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5c19c
movq %r15, %rdi
xorl %esi, %esi
callq 0x59800
movq %r15, %rdi
callq 0x5efec
movq (%rbx), %r14
jmp 0x613f7
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x6145b
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x61390
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x613fb
cmpq $0x0, 0x70(%rbx)
je 0x6147c
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59800
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x59800
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x5c19c
movq %r15, %rdi
xorl %esi, %esi
callq 0x59800
movq %r15, %rdi
callq 0x5efec
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x61400
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x59800
movq %r15, %rdi
callq 0x5efec
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8d87b(%rip), %rdi # 0xeeca9
leaq 0x8d8be(%rip), %rdx # 0xeecf3
leaq 0x8e7e9(%rip), %rcx # 0xefc25
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x1beb0
callq 0x1b300
leaq 0x8e7e5(%rip), %rcx # 0xefc39
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x61467
leaq 0x8e815(%rip), %rcx # 0xefc77
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8d83b(%rip), %rdi # 0xeeca9
leaq 0x8d87e(%rip), %rdx # 0xeecf3
xorl %eax, %eax
callq 0x1beb0
leaq 0x8d826(%rip), %rdi # 0xeeca9
leaq 0x8d869(%rip), %rdx # 0xeecf3
leaq 0x8e7fe(%rip), %rcx # 0xefc8f
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x1beb0
jmp 0x6149f
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x59800
movq %r14, %rdi
callq 0x5efec
movq %rbx, %rdi
callq 0x1bfb0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_61427
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor esi, esi
cmp rcx, r15
setbe sil
mov rax, [rax+rsi*8-8]
bt rax, rdx
jnb loc_612BA
mov rbx, rdi
lea r14, [rsp+68h+var_58]
mov byte ptr [r14], 0
mov qword ptr [r14+8], 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)
test bpl, bpl
jnz short loc_61267
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_61448
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_613FB
loc_61267:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_612C4
mov rax, [rax-8]
test rax, rax
jz loc_613FB
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_6131E
cmp ecx, 2
jnz loc_6144D
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; 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>>::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>>(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 rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_613F7
loc_612BA:
xor ebx, ebx
xor r14d, r14d
jmp loc_61417
loc_612C4:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_613F7
loc_6131E:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_6145B
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_61390
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_61390:
test rdx, rdx
jz short loc_613FB
cmp qword ptr [rbx+70h], 0
jz loc_6147C
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_613F7:
mov bl, 1
jmp short loc_61400
loc_613FB:
xor ebx, ebx
xor r14d, r14d
loc_61400:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_61417:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_61427:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_61448:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_6144D:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_61467
loc_6145B:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_61467:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_6147C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_6149F:
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<decltype(nullptr)>(
long long a1,
long long a2,
char a3)
{
long long v4; // rax
unsigned int v5; // ecx
signed long long v6; // rdx
long long v7; // rcx
long long v8; // rax
unsigned int v9; // ebx
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rbx
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = *(_QWORD *)(a1 + 48);
v5 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v4 && v5 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v6 = v5 - 1LL;
v7 = v5 + 62LL;
if ( v6 >= 0 )
v7 = v6;
v8 = *(_QWORD *)(v4 + 8 * (v7 >> 6) + 8LL * ((v6 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v8, v6) )
{
v9 = a1;
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
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 *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v27);
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
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>>::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>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v9) = 1;
LABEL_25:
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
return v9;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v21,
"GGML_ASSERT(%s) failed",
v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v26);
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v9 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<decltype(nullptr)>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x00161427
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR ESI,ESI
CMP RCX,R15
SETBE SIL
MOV RAX,qword ptr [RAX + RSI*0x8 + -0x8]
BT RAX,RDX
JNC 0x001612ba
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x00159800
MOV RDI,R14
MOV ESI,0x1
CALL 0x00159800
TEST BPL,BPL
JNZ 0x00161267
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x00161448
LEA RDI,[RBX + 0x80]
LAB_0016124a:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x001613fb
LAB_00161267:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001612c4
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x001613fb
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0016131e
CMP ECX,0x2
JNZ 0x0016144d
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0015e632
LAB_001612a1:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x001613f7
LAB_001612ba:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x00161417
LAB_001612c4:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159800
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00159800
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0015c19c
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159800
MOV RDI,R15
CALL 0x0015efec
MOV R14,qword ptr [RBX]
JMP 0x001613f7
LAB_0016131e:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0016145b
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x00161390
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_00161390:
TEST RDX,RDX
JZ 0x001613fb
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0016147c
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159800
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00159800
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x0015c19c
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159800
MOV RDI,R15
CALL 0x0015efec
MOV R14,qword ptr [RBX + 0x70]
LAB_001613f7:
MOV BL,0x1
JMP 0x00161400
LAB_001613fb:
XOR EBX,EBX
XOR R14D,R14D
LAB_00161400:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159800
MOV RDI,R15
CALL 0x0015efec
LAB_00161417:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00161427:
LEA RDI,[0x1eeca9]
LEA RDX,[0x1eecf3]
LEA RCX,[0x1efc25]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x0011beb0
LAB_00161448:
CALL 0x0011b300
LAB_0016144d:
LEA RCX,[0x1efc39]
MOV ESI,0x1c4b
JMP 0x00161467
LAB_0016145b:
LEA RCX,[0x1efc77]
MOV ESI,0x1c57
LAB_00161467:
LEA RDI,[0x1eeca9]
LEA RDX,[0x1eecf3]
XOR EAX,EAX
CALL 0x0011beb0
LAB_0016147c:
LEA RDI,[0x1eeca9]
LEA RDX,[0x1eecf3]
LEA RCX,[0x1efc8f]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x0011beb0
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<decltype(nullptr)>(decltype(nullptr)&&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<decltype(nullptr)>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,_func_decltype_nullptr **param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58;
int7 uStack_57;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_00161417;
}
local_58 = (basic_json)0x0;
uStack_50 = 0;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_00161267:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = CONCAT71(uStack_57,local_58);
uStack_30 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_001613fb;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_00161467;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_001613fb;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0016147c to 0016149c has its CatchHandler @ 0016149d */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
local_48 = CONCAT71(uStack_57,local_58);
uStack_40 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_00161467:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
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>>>
::
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>>
(*(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>>>
**)(pcVar4 + 8),&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 00161448 to 0016147b has its CatchHandler @ 0016149f */
std::__throw_bad_function_call();
}
/* try { // try from 0016124a to 001612a0 has its CatchHandler @ 0016149f */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_00161267;
LAB_001613fb:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_00161417:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
31,252 | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O2 | cpp | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x44b29
cmpl $0x0, 0x38(%rbx)
je 0x44c80
leaq 0x20(%rbx), %rdi
callq 0x422ac
testq %rdx, (%rax)
je 0x44bc3
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x3de46
testb %bpl, %bpl
jne 0x44b74
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x5
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x422da
testb %al, %al
je 0x44c61
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x44bcd
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x44c61
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x44bf7
cmpl $0x2, %ecx
jne 0x44ca1
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x42710
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x44c5d
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x44c70
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x426dc
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x409b8
movq %r14, %rdi
callq 0x3de32
movq (%rbx), %r14
jmp 0x44c5d
movq 0x48(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x44c0b
cmpl $0x0, 0x60(%rbx)
je 0x44caf
leaq 0x48(%rbx), %rdi
callq 0x422ac
movq %rdx, %r14
leaq 0x58(%rbx), %rdi
movq (%rax), %r15
callq 0x41912
testq %r14, %r15
je 0x44c61
cmpq $0x0, 0x70(%rbx)
je 0x44cd0
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x426dc
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x409b8
movq %r14, %rdi
callq 0x3de32
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x44c66
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x3de32
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6afc5(%rip), %rdi # 0xafc4c
leaq 0x6b008(%rip), %rdx # 0xafc96
leaq 0x6bf42(%rip), %rcx # 0xb0bd7
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x23ed0
leaq 0x6bf43(%rip), %rcx # 0xb0beb
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x44cbb
leaq 0x6bf73(%rip), %rcx # 0xb0c29
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x6af8a(%rip), %rdi # 0xafc4c
leaq 0x6afcd(%rip), %rdx # 0xafc96
xorl %eax, %eax
callq 0x23ed0
leaq 0x6af75(%rip), %rdi # 0xafc4c
leaq 0x6afb8(%rip), %rdx # 0xafc96
leaq 0x6bf5c(%rip), %rcx # 0xb0c41
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x23ed0
jmp 0x44cf5
jmp 0x44cf5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3de32
movq %rbx, %rdi
callq 0x23fb0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+20h]
cmp rax, [rdi+30h]
jnz short loc_44B29
cmp dword ptr [rbx+38h], 0
jz loc_44C80
loc_44B29:
lea rdi, [rbx+20h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
test [rax], rdx
jz loc_44BC3
lea rdi, [rsp+58h+var_50]
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
test bpl, bpl
jnz short loc_44B74
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 5
pop rdx
lea rcx, [rsp+58h+var_50]
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)
test al, al
jz loc_44C61
loc_44B74:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_44BCD
mov rax, [rax-8]
test rax, rax
jz loc_44C61
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz short loc_44BF7
cmp ecx, 2
jnz loc_44CA1
mov rdi, [rax+8]
lea rsi, [rsp+58h+var_50]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; 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>>::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>>(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 rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_44C5D
loc_44BC3:
xor ebx, ebx
xor r14d, r14d
jmp loc_44C70
loc_44BCD:
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx]
jmp short loc_44C5D
loc_44BF7:
mov rax, [rbx+48h]
cmp rax, [rbx+58h]
jnz short loc_44C0B
cmp dword ptr [rbx+60h], 0
jz loc_44CAF
loc_44C0B:
lea rdi, [rbx+48h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov r14, rdx
lea rdi, [rbx+58h]; this
mov r15, [rax]
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
test r15, r14
jz short loc_44C61
cmp qword ptr [rbx+70h], 0
jz loc_44CD0
lea r14, [rsp+58h+var_40]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx+70h]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx+70h]
loc_44C5D:
mov bl, 1
jmp short loc_44C66
loc_44C61:
xor ebx, ebx
xor r14d, r14d
loc_44C66:
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_44C70:
mov eax, ebx
mov rdx, r14
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_44C80:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_44CA1:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_44CBB
loc_44CAF:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_44CBB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_44CD0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short loc_44CF5
jmp short $+2
loc_44CF5:
mov rbx, rax
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<decltype(nullptr)>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
_QWORD *v5; // rax
long long v6; // rdx
long long v7; // rax
unsigned __int8 *v8; // rax
int v9; // ecx
long long *v10; // rax
long long v11; // rdx
long long v12; // r14
long long v13; // r15
const char *v15; // rcx
long long v16; // rsi
long long v17; // rbx
_BYTE v18[16]; // [rsp+8h] [rbp-50h] BYREF
char v19[16]; // [rsp+18h] [rbp-40h] BYREF
char v20[48]; // [rsp+28h] [rbp-30h] BYREF
v4 = a1;
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
LABEL_23:
v15 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v16 = 7243LL;
LABEL_25:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
"GGML_ASSERT(%s) failed",
v15);
goto LABEL_26;
}
v5 = (_QWORD *)std::vector<bool>::back(a1 + 32);
if ( (v6 & *v5) != 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>::basic_json((long long)v18);
if ( a3
|| (unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
5) )
{
v7 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v7 )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v20,
(long long)v18);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v20);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v20);
goto LABEL_18;
}
v8 = *(unsigned __int8 **)(v7 - 8);
if ( v8 )
{
v9 = *v8;
if ( v9 != 1 )
{
if ( v9 == 2 )
{
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>>::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>>(
*((_QWORD *)v8 + 1),
(long long)v18);
LABEL_18:
LOBYTE(v4) = 1;
LABEL_20:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v18);
return v4;
}
goto LABEL_23;
}
if ( *(_QWORD *)(a1 + 72) == *(_QWORD *)(a1 + 88) && !*(_DWORD *)(a1 + 96) )
{
v15 = "!key_keep_stack.empty()";
v16 = 7255LL;
goto LABEL_25;
}
v10 = (long long *)std::vector<bool>::back(a1 + 72);
v12 = v11;
v13 = *v10;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 88));
if ( (v12 & v13) != 0 )
{
if ( *(_QWORD *)(a1 + 112) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v19,
(long long)v18);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)v19);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v19);
goto LABEL_18;
}
LABEL_26:
v17 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v18);
_Unwind_Resume(v17);
}
}
}
v4 = 0;
goto LABEL_20;
}
return 0;
}
| handle_value<decltype(nullptr)>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RDI + 0x30]
JNZ 0x00144b29
CMP dword ptr [RBX + 0x38],0x0
JZ 0x00144c80
LAB_00144b29:
LEA RDI,[RBX + 0x20]
CALL 0x001422ac
TEST qword ptr [RAX],RDX
JZ 0x00144bc3
LEA RDI,[RSP + 0x8]
XOR ESI,ESI
CALL 0x0013de46
TEST BPL,BPL
JNZ 0x00144b74
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_00144b5f:
PUSH 0x5
POP RDX
LEA RCX,[RSP + 0x8]
CALL 0x001422da
TEST AL,AL
JZ 0x00144c61
LAB_00144b74:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x00144bcd
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x00144c61
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x00144bf7
CMP ECX,0x2
JNZ 0x00144ca1
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00142710
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x00144c5d
LAB_00144bc3:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x00144c70
LAB_00144bcd:
LEA R14,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001426dc
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x001409b8
MOV RDI,R14
CALL 0x0013de32
MOV R14,qword ptr [RBX]
JMP 0x00144c5d
LAB_00144bf7:
MOV RAX,qword ptr [RBX + 0x48]
CMP RAX,qword ptr [RBX + 0x58]
JNZ 0x00144c0b
CMP dword ptr [RBX + 0x60],0x0
JZ 0x00144caf
LAB_00144c0b:
LEA RDI,[RBX + 0x48]
CALL 0x001422ac
LAB_00144c14:
MOV R14,RDX
LEA RDI,[RBX + 0x58]
MOV R15,qword ptr [RAX]
CALL 0x00141912
TEST R15,R14
JZ 0x00144c61
CMP qword ptr [RBX + 0x70],0x0
JZ 0x00144cd0
LEA R14,[RSP + 0x18]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x001426dc
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R14
CALL 0x001409b8
MOV RDI,R14
CALL 0x0013de32
MOV R14,qword ptr [RBX + 0x70]
LAB_00144c5d:
MOV BL,0x1
JMP 0x00144c66
LAB_00144c61:
XOR EBX,EBX
XOR R14D,R14D
LAB_00144c66:
LEA RDI,[RSP + 0x8]
CALL 0x0013de32
LAB_00144c70:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00144c80:
LEA RDI,[0x1afc4c]
LEA RDX,[0x1afc96]
LEA RCX,[0x1b0bd7]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00123ed0
LAB_00144ca1:
LEA RCX,[0x1b0beb]
MOV ESI,0x1c4b
JMP 0x00144cbb
LAB_00144caf:
LEA RCX,[0x1b0c29]
MOV ESI,0x1c57
LAB_00144cbb:
LEA RDI,[0x1afc4c]
LEA RDX,[0x1afc96]
XOR EAX,EAX
CALL 0x00123ed0
LAB_00144cd0:
LEA RDI,[0x1afc4c]
LEA RDX,[0x1afc96]
LEA RCX,[0x1b0c41]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00123ed0
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<decltype(nullptr)>(decltype(nullptr)&&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<decltype(nullptr)>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,_func_decltype_nullptr **param_1,bool param_2)
{
char cVar1;
char *pcVar2;
ulong uVar3;
int8 uVar4;
long lVar5;
int1 auVar6 [16];
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_50 [16];
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_40 [16];
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_30 [16];
if ((*(long *)(this + 0x20) == *(long *)(this + 0x30)) && (*(int *)(this + 0x38) == 0)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
auVar6 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((*auVar6._0_8_ & auVar6._8_8_) == 0) {
uVar3 = 0;
lVar5 = 0;
goto LAB_00144c70;
}
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((_func_decltype_nullptr *)local_50);
if (param_2) {
LAB_00144b74:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_30,local_50);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,local_30);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_30);
lVar5 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_00144c61;
if (*pcVar2 == '\x01') {
if ((*(long *)(this + 0x48) == *(long *)(this + 0x58)) && (*(int *)(this + 0x60) == 0)) {
pcVar2 = "!key_keep_stack.empty()";
uVar4 = 0x1c57;
goto LAB_00144cbb;
}
/* try { // try from 00144c0b to 00144c13 has its CatchHandler @ 00144cf3 */
auVar6 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
uVar3 = *auVar6._0_8_;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x58));
if ((uVar3 & auVar6._8_8_) == 0) goto LAB_00144c61;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 00144cd0 to 00144cf0 has its CatchHandler @ 00144cf1 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_40,local_50);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),local_40);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_40);
lVar5 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
pcVar2 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar4 = 0x1c4b;
LAB_00144cbb:
/* try { // try from 00144cbb to 00144ccf has its CatchHandler @ 00144cf5 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar4,"GGML_ASSERT(%s) failed",pcVar2);
}
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>>>
::
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>>
(*(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>>>
**)(pcVar2 + 8),local_50);
lVar5 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar3 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
/* try { // try from 00144b5f to 00144ba9 has its CatchHandler @ 00144cf5 */
cVar1 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,5,
local_50);
if (cVar1 != '\0') goto LAB_00144b74;
LAB_00144c61:
uVar3 = 0;
lVar5 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_50);
LAB_00144c70:
auVar6._0_8_ = uVar3 & 0xffffffff;
auVar6._8_8_ = lVar5;
return auVar6;
}
| |
31,253 | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<double&>(double&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x614a4
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x61337
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x6153e
movq %r14, %rdi
movl $0x1, %esi
callq 0x59184
testb %bpl, %bpl
jne 0x612e4
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x614c5
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x61478
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x61341
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x61478
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x6139b
cmpl $0x2, %ecx
jne 0x614ca
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5dd46
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x61474
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x61494
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59184
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x59184
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5b926
movq %r15, %rdi
xorl %esi, %esi
callq 0x59184
movq %r15, %rdi
callq 0x5e672
movq (%rbx), %r14
jmp 0x61474
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x614d8
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x6140d
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x61478
cmpq $0x0, 0x70(%rbx)
je 0x614f9
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x59184
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x59184
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x5b926
movq %r15, %rdi
xorl %esi, %esi
callq 0x59184
movq %r15, %rdi
callq 0x5e672
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x6147d
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x59184
movq %r15, %rdi
callq 0x5e672
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8a7fe(%rip), %rdi # 0xebca9
leaq 0x8a841(%rip), %rdx # 0xebcf3
leaq 0x8b76c(%rip), %rcx # 0xecc25
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x1aeb0
callq 0x1a300
leaq 0x8b768(%rip), %rcx # 0xecc39
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x614e4
leaq 0x8b798(%rip), %rcx # 0xecc77
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8a7be(%rip), %rdi # 0xebca9
leaq 0x8a801(%rip), %rdx # 0xebcf3
xorl %eax, %eax
callq 0x1aeb0
leaq 0x8a7a9(%rip), %rdi # 0xebca9
leaq 0x8a7ec(%rip), %rdx # 0xebcf3
leaq 0x8b781(%rip), %rcx # 0xecc8f
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x1aeb0
jmp 0x6151c
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x59184
movq %r14, %rdi
callq 0x5e672
movq %rbx, %rdi
callq 0x1afb0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRmEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_614A4
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r15
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_61337
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
mov rsi, [rsi]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_unsigned_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_612E4
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_614C5
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_61478
loc_612E4:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_61341
mov rax, [rax-8]
test rax, rax
jz loc_61478
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_6139B
cmp ecx, 2
jnz loc_614CA
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; 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>>::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>>(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 rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_61474
loc_61337:
xor ebx, ebx
xor r14d, r14d
jmp loc_61494
loc_61341:
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_61474
loc_6139B:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_614D8
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_6140D
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_6140D:
test rdx, rdx
jz short loc_61478
cmp qword ptr [rbx+70h], 0
jz loc_614F9
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_61474:
mov bl, 1
jmp short loc_6147D
loc_61478:
xor ebx, ebx
xor r14d, r14d
loc_6147D:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_61494:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_614A4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_614C5:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_614CA:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_614E4
loc_614D8:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_614E4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_614F9:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_6151C:
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<unsigned long &>(
long long a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rbx
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
v25 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
*a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v27);
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
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>>::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>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
return v4;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v21,
"GGML_ASSERT(%s) failed",
v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v26);
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v4 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<unsigned_long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x001614a4
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R15
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x00161337
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x0016153e
MOV RDI,R14
MOV ESI,0x1
CALL 0x00159184
TEST BPL,BPL
JNZ 0x001612e4
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x001614c5
LEA RDI,[RBX + 0x80]
LAB_001612c7:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x00161478
LAB_001612e4:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x00161341
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x00161478
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0016139b
CMP ECX,0x2
JNZ 0x001614ca
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0015dd46
LAB_0016131e:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x00161474
LAB_00161337:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x00161494
LAB_00161341:
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159184
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00159184
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0015b926
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159184
MOV RDI,R15
CALL 0x0015e672
MOV R14,qword ptr [RBX]
JMP 0x00161474
LAB_0016139b:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x001614d8
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0016140d
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0016140d:
TEST RDX,RDX
JZ 0x00161478
CMP qword ptr [RBX + 0x70],0x0
JZ 0x001614f9
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x00159184
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00159184
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x0015b926
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159184
MOV RDI,R15
CALL 0x0015e672
MOV R14,qword ptr [RBX + 0x70]
LAB_00161474:
MOV BL,0x1
JMP 0x0016147d
LAB_00161478:
XOR EBX,EBX
XOR R14D,R14D
LAB_0016147d:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00159184
MOV RDI,R15
CALL 0x0015e672
LAB_00161494:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001614a4:
LEA RDI,[0x1ebca9]
LEA RDX,[0x1ebcf3]
LEA RCX,[0x1ecc25]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x0011aeb0
LAB_001614c5:
CALL 0x0011a300
LAB_001614ca:
LEA RCX,[0x1ecc39]
MOV ESI,0x1c4b
JMP 0x001614e4
LAB_001614d8:
LEA RCX,[0x1ecc77]
MOV ESI,0x1c57
LAB_001614e4:
LEA RDI,[0x1ebca9]
LEA RDX,[0x1ebcf3]
XOR EAX,EAX
CALL 0x0011aeb0
LAB_001614f9:
LEA RDI,[0x1ebca9]
LEA RDX,[0x1ebcf3]
LEA RCX,[0x1ecc8f]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x0011aeb0
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<unsigned long&>(unsigned long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,ulong *param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_00161494;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_58,*param_1);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_001612e4:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_00161478;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_001614e4;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_00161478;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 001614f9 to 00161519 has its CatchHandler @ 0016151a */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
local_48 = local_58;
uStack_40 = uStack_50;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_001614e4:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
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>>>
::
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>>
(*(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>>>
**)(pcVar4 + 8),(basic_json *)&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 001614c5 to 001614f8 has its CatchHandler @ 0016151c */
std::__throw_bad_function_call();
}
/* try { // try from 001612c7 to 0016131d has its CatchHandler @ 0016151c */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_001612e4;
LAB_00161478:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_00161494:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
31,254 | void vec_binary_op_contiguous<&op_add(float, float), unsigned short, unsigned short, unsigned short>(long, unsigned short*, unsigned short const*, unsigned short const*) | ngxson[P]ggml-easy/ggml/src/ggml-cpu/binary-ops.cpp | static inline void vec_binary_op_contiguous(const int64_t n, dst_t * z, const src0_t * x, const src1_t * y) {
constexpr auto src0_to_f32 = type_conversion_table<src0_t>::to_f32;
constexpr auto src1_to_f32 = type_conversion_table<src1_t>::to_f32;
constexpr auto f32_to_dst = type_conversion_table<dst_t >::from_f32;
for (int i = 0; i < n; i++) {
z[i] = f32_to_dst(op(src0_to_f32(x[i]), src1_to_f32(y[i])));
}
} | O0 | cpp | void vec_binary_op_contiguous<&op_add(float, float), unsigned short, unsigned short, unsigned short>(long, unsigned short*, unsigned short const*, unsigned short const*):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
leaq -0xa44f(%rip), %rax # 0x5e020
movq %rax, 0x20(%rsp)
leaq -0xa88b(%rip), %rax # 0x5dbf0
movq %rax, 0x18(%rsp)
leaq -0xa897(%rip), %rax # 0x5dbf0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x40(%rsp), %rax
jge 0x68507
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, 0xa(%rsp)
movzwl 0xa(%rsp), %edi
callq 0x5e020
vmovss %xmm0, 0x4(%rsp)
movq 0x28(%rsp), %rax
movslq 0xc(%rsp), %rcx
vmovss (%rax,%rcx,4), %xmm0
callq 0x5dbf0
vmovaps %xmm0, %xmm1
vmovss 0x4(%rsp), %xmm0
callq 0x65390
callq 0x5dbf0
movq 0x38(%rsp), %rax
movslq 0xc(%rsp), %rcx
vmovss %xmm0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x68494
addq $0x48, %rsp
retq
nopl (%rax)
| _ZL24vec_binary_op_contiguousIXadL_ZL6op_divffEE11ggml_bf16_tffEvlPT2_PKT0_PKT1_:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_20], rcx
lea rax, _ZL11bf16_to_f3211ggml_bf16_t; bf16_to_f32(ggml_bf16_t)
mov [rsp+48h+var_28], rax
lea rax, _ZL10f32_to_f32f; f32_to_f32(float)
mov [rsp+48h+var_30], rax
lea rax, _ZL10f32_to_f32f; f32_to_f32(float)
mov [rsp+48h+var_38], rax
mov [rsp+48h+var_3C], 0
loc_68494:
movsxd rax, [rsp+48h+var_3C]
cmp rax, [rsp+48h+var_8]
jge short loc_68507
mov rax, [rsp+48h+var_18]
movsxd rcx, [rsp+48h+var_3C]
mov ax, [rax+rcx*2]
mov [rsp+48h+var_3E], ax
movzx edi, [rsp+48h+var_3E]
call _ZL11bf16_to_f3211ggml_bf16_t; bf16_to_f32(ggml_bf16_t)
vmovss [rsp+48h+var_44], xmm0
mov rax, [rsp+48h+var_20]
movsxd rcx, [rsp+48h+var_3C]
vmovss xmm0, dword ptr [rax+rcx*4]; float
call _ZL10f32_to_f32f; f32_to_f32(float)
vmovaps xmm1, xmm0; float
vmovss xmm0, [rsp+48h+var_44]; float
call _ZL6op_divff; op_div(float,float)
call _ZL10f32_to_f32f; f32_to_f32(float)
mov rax, [rsp+48h+var_10]
movsxd rcx, [rsp+48h+var_3C]
vmovss dword ptr [rax+rcx*4], xmm0
mov eax, [rsp+48h+var_3C]
add eax, 1
mov [rsp+48h+var_3C], eax
jmp short loc_68494
loc_68507:
add rsp, 48h
retn
| long long vec_binary_op_contiguous<&(op_div(float,float)),ggml_bf16_t,float,float>(
long long a1,
long long a2,
long long a3,
long long a4,
__m128 _XMM0)
{
long long result; // rax
__int128 v12; // xmm0
int i; // [rsp+Ch] [rbp-3Ch]
for ( i = 0; ; ++i )
{
result = i;
if ( i >= a1 )
break;
bf16_to_f32(*(_WORD *)(a3 + 2LL * i));
__asm { vmovss [rsp+48h+var_44], xmm0 }
_RAX = a4;
_RCX = i;
__asm { vmovss xmm0, dword ptr [rax+rcx*4]; float }
_XMM0 = f32_to_f32(_XMM0);
__asm
{
vmovaps xmm1, xmm0; float
vmovss xmm0, [rsp+48h+var_44]; float
}
v12 = op_div(_XMM0, _XMM1);
_XMM0 = (__m128)f32_to_f32((__m128)v12);
_RAX = a2;
_RCX = i;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
return result;
}
| vec_binary_op_contiguous<&(op_div(float,float)),ggml_bf16_t,float,float>:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x28],RCX
LEA RAX,[0x15e020]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x15dbf0]
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[0x15dbf0]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0xc],0x0
LAB_00168494:
MOVSXD RAX,dword ptr [RSP + 0xc]
CMP RAX,qword ptr [RSP + 0x40]
JGE 0x00168507
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV AX,word ptr [RAX + RCX*0x2]
MOV word ptr [RSP + 0xa],AX
MOVZX EDI,word ptr [RSP + 0xa]
CALL 0x0015e020
VMOVSS dword ptr [RSP + 0x4],XMM0
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0xc]
VMOVSS XMM0,dword ptr [RAX + RCX*0x4]
CALL 0x0015dbf0
VMOVAPS XMM1,XMM0
VMOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00165390
CALL 0x0015dbf0
MOV RAX,qword ptr [RSP + 0x38]
MOVSXD RCX,dword ptr [RSP + 0xc]
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00168494
LAB_00168507:
ADD RSP,0x48
RET
|
/* void vec_binary_op_contiguous<&(op_div(float, float)), ggml_bf16_t, float, float>(long, float*,
ggml_bf16_t const*, float const*) */
void vec_binary_op_contiguous<&(op_div(float,float)),ggml_bf16_t,float,float>
(long param_1,float *param_2,ggml_bf16_t *param_3,float *param_4)
{
float fVar1;
float fVar2;
int local_3c;
for (local_3c = 0; local_3c < param_1; local_3c = local_3c + 1) {
fVar1 = (float)bf16_to_f32(*(int2 *)(param_3 + (long)local_3c * 2));
fVar2 = (float)f32_to_f32(param_4[local_3c]);
fVar1 = (float)op_div(fVar1,fVar2);
fVar1 = (float)f32_to_f32(fVar1);
param_2[local_3c] = fVar1;
}
return;
}
| |
31,255 | ma_cmp_static_unique | eloqsql/storage/maria/ma_statrec.c | my_bool _ma_cmp_static_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
const uchar *record, MARIA_RECORD_POS pos)
{
DBUG_ENTER("_ma_cmp_static_unique");
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
pos, MYF(MY_NABP)))
DBUG_RETURN(1);
DBUG_RETURN(_ma_unique_comp(def, record, info->rec_buff,
def->null_are_equal));
} | O3 | c | ma_cmp_static_unique:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x598(%rdi)
movq (%rdi), %rax
movq 0x3a0(%rdi), %rsi
movq 0x398(%rax), %rdx
movl $0x4, %r8d
callq *0x6e0(%rax)
testq %rax, %rax
je 0x5b349
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3a0(%r15), %rdx
movsbl 0x3(%r14), %ecx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x424b1
| _ma_cmp_static_unique:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov dword ptr [rdi+598h], 1
mov rax, [rdi]
mov rsi, [rdi+3A0h]
mov rdx, [rax+398h]
mov r8d, 4
call qword ptr [rax+6E0h]
test rax, rax
jz short loc_5B349
mov al, 1
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5B349:
mov rdx, [r15+3A0h]
movsx ecx, byte ptr [r14+3]
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ma_unique_comp
| char ma_cmp_static_unique(long long a1, long long a2, long long a3, long long a4)
{
*(_DWORD *)(a1 + 1432) = 1;
if ( (*(long long ( **)(long long, _QWORD, _QWORD, long long, long long))(*(_QWORD *)a1 + 1760LL))(
a1,
*(_QWORD *)(a1 + 928),
*(_QWORD *)(*(_QWORD *)a1 + 920LL),
a4,
4LL) )
{
return 1;
}
else
{
return ma_unique_comp(a2, a3, *(_QWORD *)(a1 + 928), *(_BYTE *)(a2 + 3));
}
}
| _ma_cmp_static_unique:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV dword ptr [RDI + 0x598],0x1
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x3a0]
MOV RDX,qword ptr [RAX + 0x398]
MOV R8D,0x4
CALL qword ptr [RAX + 0x6e0]
TEST RAX,RAX
JZ 0x0015b349
MOV AL,0x1
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015b349:
MOV RDX,qword ptr [R15 + 0x3a0]
MOVSX ECX,byte ptr [R14 + 0x3]
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001424b1
|
int8 _ma_cmp_static_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
int8 uVar2;
*(int4 *)(param_1 + 0xb3) = 1;
lVar1 = (**(code **)(*param_1 + 0x6e0))
(param_1,param_1[0x74],*(int8 *)(*param_1 + 0x398),param_4,4);
if (lVar1 != 0) {
return 1;
}
uVar2 = _ma_unique_comp(param_2,param_3,param_1[0x74],(int)*(char *)(param_2 + 3));
return uVar2;
}
| |
31,256 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_object(unsigned long) | monkey531[P]llama/common/json.hpp | bool start_object(std::size_t len)
{
// check callback for object start
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
keep_stack.push_back(keep);
auto val = handle_value(BasicJsonType::value_t::object, true);
ref_stack.push_back(val.second);
// check object limit
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
}
return true;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::start_object(unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x80, %rdi
leaq 0x8(%r14), %rbx
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
shrq $0x3, %rsi
leaq 0xa8(%r14), %rcx
xorl %edx, %edx
callq 0x45566
leaq 0x20(%r14), %rdi
movzbl %al, %esi
callq 0x4480c
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x4558a
leaq 0x50(%rsp), %rsi
movb %al, -0x8(%rsi)
movq %rdx, (%rsi)
movq %rbx, %rdi
callq 0x45794
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
testq %rdi, %rdi
sete %al
cmpq $-0x1, %r15
sete %cl
orb %al, %cl
jne 0x44e06
callq 0x457b2
cmpq %r15, %rax
jb 0x44e13
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20380
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x45925
leaq 0x4ad09(%rip), %rsi # 0x8fb3b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x458c7
movq 0x10(%r14), %rax
movq -0x8(%rax), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x198, %esi # imm = 0x198
callq 0x457da
xorl %ebp, %ebp
leaq 0x89559(%rip), %rsi # 0xce3c0
leaq 0x33f8(%rip), %rdx # 0x48266
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20d98
jmp 0x44e8b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x20d98
testb %bpl, %bpl
jne 0x44e9f
jmp 0x44ea7
movq %rax, %r14
movq %rbx, %rdi
callq 0x20510
movq %r14, %rdi
callq 0x20bb0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12start_objectEm:
push rbp
push r15
push r14; char
push rbx; int
sub rsp, 58h
mov r15, rsi
mov r14, rdi
add rdi, 80h
lea rbx, [r14+8]
mov rsi, [r14+10h]
sub rsi, [r14+8]
shr rsi, 3
lea rcx, [r14+0A8h]
xor edx, edx
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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, [r14+20h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
lea rsi, [rsp+78h+var_70]
mov byte ptr [rsi], 1
push 1
pop rdx
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueINS1_7value_tEEESt4pairIbPSF_EOT_b; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t &&,bool)
lea rsi, [rsp+78h+var_28]
mov [rsi-8], al
mov [rsi], rdx
mov rdi, rbx
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE9push_backERKSE_; 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> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> * const&)
mov rax, [r14+10h]
mov rdi, [rax-8]
test rdi, rdi
setz al
cmp r15, 0FFFFFFFFFFFFFFFFh
setz cl
or cl, al
jnz short loc_44E06
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8max_sizeEv; 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>::max_size(void)
cmp rax, r15
jb short loc_44E13
loc_44E06:
mov al, 1
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_44E13:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+78h+var_50]; this
mov rsi, r15; unsigned __int64
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
lea rsi, aExcessiveObjec; "excessive object size: "
lea rdi, [rsp+78h+var_70]
lea rdx, [rsp+78h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA24_KcS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[24],std::string>(char const(&)[24],std::string &&)
mov rax, [r14+10h]
mov rcx, [rax-8]
mov bpl, 1
lea rdx, [rsp+78h+var_70]
mov rdi, rbx; this
mov esi, 198h; int
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+78h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_44E8B
mov r14, rax
mov bpl, 1
loc_44E8B:
lea rdi, [rsp+78h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_44E9F
jmp short loc_44EA7
mov r14, rax
loc_44E9F:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_44EA7:
mov rdi, r14
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::start_object(
long long a1,
unsigned long long a2)
{
unsigned __int8 v2; // al
long long v3; // rdx
nlohmann::json_abi_v3_11_3::detail::out_of_range *exception; // rbx
char v6; // [rsp+0h] [rbp-78h]
int v7[6]; // [rsp+8h] [rbp-70h] BYREF
char v8; // [rsp+20h] [rbp-58h]
int v9[6]; // [rsp+28h] [rbp-50h] BYREF
char v10; // [rsp+40h] [rbp-38h]
int v11; // [rsp+48h] [rbp-30h]
long long v12; // [rsp+50h] [rbp-28h]
int v13; // [rsp+58h] [rbp-20h]
char v14; // [rsp+60h] [rbp-18h]
v2 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
0LL,
a1 + 168);
std::vector<bool>::push_back(a1 + 32, v2);
LOBYTE(v7[0]) = 1;
LOBYTE(v11) = nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(
a1,
v7,
1LL);
v12 = v3;
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> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::push_back(a1 + 8);
if ( *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) != 0LL
&& a2 != -1LL
&& 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>::max_size() < a2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::to_string((std::__cxx11 *)v9, a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[24],std::string>(
v7,
"excessive object size: ",
v9);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
408,
v6,
v7[0],
v7[2],
v7[4],
v8,
v9[0],
v9[2],
v9[4],
v10,
v11,
v12,
v13,
v14);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return 1;
}
| start_object:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV R15,RSI
MOV R14,RDI
ADD RDI,0x80
LEA RBX,[R14 + 0x8]
MOV RSI,qword ptr [R14 + 0x10]
SUB RSI,qword ptr [R14 + 0x8]
SHR RSI,0x3
LEA RCX,[R14 + 0xa8]
XOR EDX,EDX
CALL 0x00145566
LEA RDI,[R14 + 0x20]
MOVZX ESI,AL
CALL 0x0014480c
LEA RSI,[RSP + 0x8]
MOV byte ptr [RSI],0x1
PUSH 0x1
POP RDX
MOV RDI,R14
CALL 0x0014558a
LEA RSI,[RSP + 0x50]
MOV byte ptr [RSI + -0x8],AL
MOV qword ptr [RSI],RDX
MOV RDI,RBX
CALL 0x00145794
MOV RAX,qword ptr [R14 + 0x10]
MOV RDI,qword ptr [RAX + -0x8]
TEST RDI,RDI
SETZ AL
CMP R15,-0x1
SETZ CL
OR CL,AL
JNZ 0x00144e06
CALL 0x001457b2
CMP RAX,R15
JC 0x00144e13
LAB_00144e06:
MOV AL,0x1
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00144e13:
PUSH 0x20
POP RDI
CALL 0x00120380
MOV RBX,RAX
LAB_00144e1e:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
CALL 0x00145925
LAB_00144e2b:
LEA RSI,[0x18fb3b]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
CALL 0x001458c7
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [RAX + -0x8]
MOV BPL,0x1
LAB_00144e4c:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x198
CALL 0x001457da
XOR EBP,EBP
LEA RSI,[0x1ce3c0]
LEA RDX,[0x148266]
MOV RDI,RBX
CALL 0x00120b30
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::start_object(unsigned long) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::start_object(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,ulong param_1)
{
bool bVar1;
ulong uVar2;
int8 uVar3;
basic_json *extraout_RDX;
detail local_70 [32];
__cxx11 local_50 [32];
int1 local_30;
basic_json *local_28;
bVar1 = (bool)std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,
0,this + 0xa8);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),bVar1);
local_70[0] = (detail)0x1;
local_30 = handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(this,local_70,true);
local_28 = extraout_RDX;
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::push_back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8),&local_28);
if (param_1 != 0xffffffffffffffff &&
*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(*(long *)(this + 0x10) + -8) !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)0x0) {
uVar2 = 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>
::max_size(*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(*(long *)(this + 0x10) + -8));
if (uVar2 < param_1) {
uVar3 = __cxa_allocate_exception(0x20);
/* try { // try from 00144e1e to 00144e2a has its CatchHandler @ 00144e9c */
std::__cxx11::to_string(local_50,param_1);
/* try { // try from 00144e2b to 00144e40 has its CatchHandler @ 00144e85 */
concat<std::__cxx11::string,char_const(&)[24],std::__cxx11::string>
(local_70,"excessive object size: ",(string *)local_50);
/* try { // try from 00144e4c to 00144e75 has its CatchHandler @ 00144e76 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0x198,local_70,*(int8 *)(*(long *)(this + 0x10) + -8));
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&out_of_range::typeinfo,exception::~exception);
}
}
return 1;
}
| |
31,257 | translog_lock | eloqsql/storage/maria/ma_loghandler.c | void translog_lock()
{
uint8 current_buffer;
DBUG_ENTER("translog_lock");
/*
Locking the loghandler mean locking current buffer, but it can change
during locking, so we should check it
*/
for (;;)
{
/*
log_descriptor.bc.buffer_no is only one byte so its reading is
an atomic operation
*/
current_buffer= log_descriptor.bc.buffer_no;
translog_buffer_lock(log_descriptor.buffers + current_buffer);
if (log_descriptor.bc.buffer_no == current_buffer)
break;
translog_buffer_unlock(log_descriptor.buffers + current_buffer);
}
DBUG_VOID_RETURN;
} | O0 | c | translog_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb 0xc69778(%rip), %al # 0xcaf3c6
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cltq
leaq 0x468ae2(%rip), %rdi # 0x4ae740
addq $0x2f8, %rdi # imm = 0x2F8
imulq $0x100120, %rax, %rax # imm = 0x100120
addq %rax, %rdi
callq 0x45cc0
movzbl 0xc6974b(%rip), %eax # 0xcaf3c6
movzbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x45c85
jmp 0x45caa
movzbl -0x1(%rbp), %eax
cltq
leaq 0x468aae(%rip), %rdi # 0x4ae740
addq $0x2f8, %rdi # imm = 0x2F8
imulq $0x100120, %rax, %rax # imm = 0x100120
addq %rax, %rdi
callq 0x45d00
jmp 0x45c48
jmp 0x45cac
jmp 0x45cae
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_lock:
push rbp
mov rbp, rsp
sub rsp, 10h
loc_45C48:
mov al, cs:byte_CAF3C6
mov [rbp+var_1], al
movzx eax, [rbp+var_1]
cdqe
lea rdi, log_descriptor
add rdi, 2F8h
imul rax, 100120h
add rdi, rax
call translog_buffer_lock
movzx eax, cs:byte_CAF3C6
movzx ecx, [rbp+var_1]
cmp eax, ecx
jnz short loc_45C85
jmp short loc_45CAA
loc_45C85:
movzx eax, [rbp+var_1]
cdqe
lea rdi, log_descriptor
add rdi, 2F8h
imul rax, 100120h
add rdi, rax
call translog_buffer_unlock
jmp short loc_45C48
loc_45CAA:
jmp short $+2
loc_45CAC:
jmp short $+2
loc_45CAE:
add rsp, 10h
pop rbp
retn
| long long translog_lock()
{
long long result; // rax
unsigned __int8 v1; // [rsp+Fh] [rbp-1h]
while ( 1 )
{
v1 = byte_CAF3C6;
translog_buffer_lock(&log_descriptor[131108 * (unsigned __int8)byte_CAF3C6 + 95]);
result = (unsigned __int8)byte_CAF3C6;
if ( (unsigned __int8)byte_CAF3C6 == v1 )
break;
translog_buffer_unlock(&log_descriptor[131108 * v1 + 95]);
}
return result;
}
| translog_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LAB_00145c48:
MOV AL,byte ptr [0x00daf3c6]
MOV byte ptr [RBP + -0x1],AL
MOVZX EAX,byte ptr [RBP + -0x1]
CDQE
LEA RDI,[0x5ae740]
ADD RDI,0x2f8
IMUL RAX,RAX,0x100120
ADD RDI,RAX
CALL 0x00145cc0
MOVZX EAX,byte ptr [0x00daf3c6]
MOVZX ECX,byte ptr [RBP + -0x1]
CMP EAX,ECX
JNZ 0x00145c85
JMP 0x00145caa
LAB_00145c85:
MOVZX EAX,byte ptr [RBP + -0x1]
CDQE
LEA RDI,[0x5ae740]
ADD RDI,0x2f8
IMUL RAX,RAX,0x100120
ADD RDI,RAX
CALL 0x00145d00
JMP 0x00145c48
LAB_00145caa:
JMP 0x00145cac
LAB_00145cac:
JMP 0x00145cae
LAB_00145cae:
ADD RSP,0x10
POP RBP
RET
|
void translog_lock(void)
{
byte bVar1;
while( true ) {
bVar1 = DAT_00daf3c6;
translog_buffer_lock(&DAT_005aea38 + (long)(int)(uint)DAT_00daf3c6 * 0x100120);
if (DAT_00daf3c6 == bVar1) break;
translog_buffer_unlock(&DAT_005aea38 + (long)(int)(uint)bVar1 * 0x100120);
}
return;
}
| |
31,258 | translog_lock | eloqsql/storage/maria/ma_loghandler.c | void translog_lock()
{
uint8 current_buffer;
DBUG_ENTER("translog_lock");
/*
Locking the loghandler mean locking current buffer, but it can change
during locking, so we should check it
*/
for (;;)
{
/*
log_descriptor.bc.buffer_no is only one byte so its reading is
an atomic operation
*/
current_buffer= log_descriptor.bc.buffer_no;
translog_buffer_lock(log_descriptor.buffers + current_buffer);
if (log_descriptor.bc.buffer_no == current_buffer)
break;
translog_buffer_unlock(log_descriptor.buffers + current_buffer);
}
DBUG_VOID_RETURN;
} | O3 | c | translog_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0xbe4190(%rip), %r15d # 0xc27836
leaq 0x3e3503(%rip), %r14 # 0x426bb0
imulq $0x100120, %r15, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x43733
cmpb %r15b, 0xbe4168(%rip) # 0xc27836
jne 0x436d9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36b338(%rip), %r15 # 0x3aea18
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x43728
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
callq 0x2a1f0
movzbl 0xbe4133(%rip), %r12d # 0xc27836
imulq $0x100120, %r12, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x43733
cmpb %r12b, 0xbe4112(%rip) # 0xc27836
jne 0x436e0
jmp 0x436d0
movq (%r15), %rax
callq *0x160(%rax)
jmp 0x436ec
| translog_lock:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
movzx r15d, byte ptr cs:xmmword_C27830+6
lea r14, log_descriptor
imul rax, r15, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_C27830+6, r15b
jnz short loc_436D9
loc_436D0:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_436D9:
lea r15, PSI_server
loc_436E0:
mov rdi, [rbx+1000D0h]
test rdi, rdi
jnz short loc_43728
loc_436EC:
add rbx, 100090h
mov rdi, rbx
call _pthread_mutex_unlock
movzx r12d, byte ptr cs:xmmword_C27830+6
imul rax, r12, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_C27830+6, r12b
jnz short loc_436E0
jmp short loc_436D0
loc_43728:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_436EC
| long long translog_lock()
{
char v0; // r15
long long *v1; // rbx
long long result; // rax
char v3; // r12
v0 = BYTE6(xmmword_C27830);
v1 = &log_descriptor[131108 * BYTE6(xmmword_C27830) + 95];
result = translog_buffer_lock(v1);
if ( BYTE6(xmmword_C27830) != v0 )
{
do
{
if ( v1[131098] )
PSI_server[44]();
pthread_mutex_unlock(v1 + 131090);
v3 = BYTE6(xmmword_C27830);
v1 = &log_descriptor[131108 * BYTE6(xmmword_C27830) + 95];
result = translog_buffer_lock(v1);
}
while ( BYTE6(xmmword_C27830) != v3 );
}
return result;
}
| translog_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOVZX R15D,byte ptr [0x00d27836]
LEA R14,[0x526bb0]
IMUL RAX,R15,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x00143733
CMP byte ptr [0x00d27836],R15B
JNZ 0x001436d9
LAB_001436d0:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001436d9:
LEA R15,[0x4aea18]
LAB_001436e0:
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x00143728
LAB_001436ec:
ADD RBX,0x100090
MOV RDI,RBX
CALL 0x0012a1f0
MOVZX R12D,byte ptr [0x00d27836]
IMUL RAX,R12,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x00143733
CMP byte ptr [0x00d27836],R12B
JNZ 0x001436e0
JMP 0x001436d0
LAB_00143728:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x001436ec
|
void translog_lock(void)
{
byte bVar1;
int *puVar2;
bVar1 = DAT_00d27836;
puVar2 = &DAT_00526ea8 + (ulong)DAT_00d27836 * 0x100120;
translog_buffer_lock(puVar2);
if (DAT_00d27836 != bVar1) {
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + (long)puVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock
((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + (long)puVar2));
bVar1 = DAT_00d27836;
puVar2 = &DAT_00526ea8 + (ulong)DAT_00d27836 * 0x100120;
translog_buffer_lock(puVar2);
} while (DAT_00d27836 != bVar1);
}
return;
}
| |
31,259 | my_aes_crypt | eloqsql/mysys_ssl/my_crypt.cc | int my_aes_crypt(enum my_aes_mode mode, int flags,
const uchar *src, uint slen, uchar *dst, uint *dlen,
const uchar *key, uint klen, const uchar *iv, uint ivlen)
{
void *ctx= alloca(MY_AES_CTX_SIZE);
int res1, res2;
uint d1= 0, d2;
if ((res1= my_aes_crypt_init(ctx, mode, flags, key, klen, iv, ivlen)))
return res1;
res1= my_aes_crypt_update(ctx, src, slen, dst, &d1);
res2= my_aes_crypt_finish(ctx, dst + d1, &d2);
if (res1 || res2)
ERR_remove_state(0); /* in case of failure clear error queue */
else
*dlen= d1 + d2;
return res1 ? res1 : res2;
} | O0 | cpp | my_aes_crypt:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x2b8(%rbp)
movl %esi, -0x2bc(%rbp)
movq %rdx, -0x2c8(%rbp)
movl %ecx, -0x2cc(%rbp)
movq %r8, -0x2d8(%rbp)
movq %r9, -0x2e0(%rbp)
leaq -0x2b0(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movl $0x0, -0x2f4(%rbp)
movq -0x2e8(%rbp), %rdi
movl -0x2b8(%rbp), %esi
movl -0x2bc(%rbp), %edx
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
movl 0x28(%rbp), %eax
movl %eax, (%rsp)
callq 0xd95a0
movl %eax, -0x2ec(%rbp)
cmpl $0x0, %eax
je 0xd979b
movl -0x2ec(%rbp), %eax
movl %eax, -0x2b4(%rbp)
jmp 0xd984e
movq -0x2e8(%rbp), %rdi
movq -0x2c8(%rbp), %rsi
movl -0x2cc(%rbp), %edx
movq -0x2d8(%rbp), %rcx
leaq -0x2f4(%rbp), %r8
callq 0xd9670
movl %eax, -0x2ec(%rbp)
movq -0x2e8(%rbp), %rdi
movq -0x2d8(%rbp), %rsi
movl -0x2f4(%rbp), %eax
addq %rax, %rsi
leaq -0x2f8(%rbp), %rdx
callq 0xd96b0
movl %eax, -0x2f0(%rbp)
cmpl $0x0, -0x2ec(%rbp)
jne 0xd9803
cmpl $0x0, -0x2f0(%rbp)
je 0xd980a
callq 0x2a760
jmp 0xd981f
movl -0x2f4(%rbp), %ecx
addl -0x2f8(%rbp), %ecx
movq -0x2e0(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x2ec(%rbp)
je 0xd9836
movl -0x2ec(%rbp), %eax
movl %eax, -0x2fc(%rbp)
jmp 0xd9842
movl -0x2f0(%rbp), %eax
movl %eax, -0x2fc(%rbp)
movl -0x2fc(%rbp), %eax
movl %eax, -0x2b4(%rbp)
movl -0x2b4(%rbp), %eax
movl %eax, -0x300(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xd987b
movl -0x300(%rbp), %eax
addq $0x310, %rsp # imm = 0x310
popq %rbp
retq
callq 0x2a250
| my_aes_crypt:
push rbp
mov rbp, rsp
sub rsp, 310h
mov eax, [rbp+arg_18]
mov rax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_2B8], edi
mov [rbp+var_2BC], esi
mov [rbp+var_2C8], rdx
mov [rbp+var_2CC], ecx
mov [rbp+var_2D8], r8
mov [rbp+var_2E0], r9
lea rax, [rbp+var_2B0]
mov [rbp+var_2E8], rax
mov [rbp+var_2F4], 0
mov rdi, [rbp+var_2E8]
mov esi, [rbp+var_2B8]
mov edx, [rbp+var_2BC]
mov rcx, [rbp+arg_0]
mov r8d, [rbp+arg_8]
mov r9, [rbp+arg_10]
mov eax, [rbp+arg_18]
mov [rsp+310h+var_310], eax
call my_aes_crypt_init
mov [rbp+var_2EC], eax
cmp eax, 0
jz short loc_D979B
mov eax, [rbp+var_2EC]
mov [rbp+var_2B4], eax
jmp loc_D984E
loc_D979B:
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2C8]
mov edx, [rbp+var_2CC]
mov rcx, [rbp+var_2D8]
lea r8, [rbp+var_2F4]
call my_aes_crypt_update
mov [rbp+var_2EC], eax
mov rdi, [rbp+var_2E8]
mov rsi, [rbp+var_2D8]
mov eax, [rbp+var_2F4]
add rsi, rax
lea rdx, [rbp+var_2F8]
call my_aes_crypt_finish
mov [rbp+var_2F0], eax
cmp [rbp+var_2EC], 0
jnz short loc_D9803
cmp [rbp+var_2F0], 0
jz short loc_D980A
loc_D9803:
call _ERR_clear_error
jmp short loc_D981F
loc_D980A:
mov ecx, [rbp+var_2F4]
add ecx, [rbp+var_2F8]
mov rax, [rbp+var_2E0]
mov [rax], ecx
loc_D981F:
cmp [rbp+var_2EC], 0
jz short loc_D9836
mov eax, [rbp+var_2EC]
mov [rbp+var_2FC], eax
jmp short loc_D9842
loc_D9836:
mov eax, [rbp+var_2F0]
mov [rbp+var_2FC], eax
loc_D9842:
mov eax, [rbp+var_2FC]
mov [rbp+var_2B4], eax
loc_D984E:
mov eax, [rbp+var_2B4]
mov [rbp+var_300], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_D987B
mov eax, [rbp+var_300]
add rsp, 310h
pop rbp
retn
loc_D987B:
call ___stack_chk_fail
| long long my_aes_crypt(
int a1,
int a2,
long long a3,
unsigned int a4,
long long a5,
_DWORD *a6,
long long a7,
unsigned int a8,
long long a9,
int a10)
{
int v12; // [rsp+18h] [rbp-2F8h] BYREF
unsigned int v13; // [rsp+1Ch] [rbp-2F4h] BYREF
unsigned int v14; // [rsp+20h] [rbp-2F0h]
unsigned int v15; // [rsp+24h] [rbp-2ECh]
_BYTE *v16; // [rsp+28h] [rbp-2E8h]
_DWORD *v17; // [rsp+30h] [rbp-2E0h]
long long v18; // [rsp+38h] [rbp-2D8h]
unsigned int v19; // [rsp+44h] [rbp-2CCh]
long long v20; // [rsp+48h] [rbp-2C8h]
int v21; // [rsp+54h] [rbp-2BCh]
int v22; // [rsp+58h] [rbp-2B8h]
_BYTE v24[680]; // [rsp+60h] [rbp-2B0h] BYREF
unsigned long long v25; // [rsp+308h] [rbp-8h]
v25 = __readfsqword(0x28u);
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = v24;
v13 = 0;
v15 = my_aes_crypt_init((MyCTX *)v24, a1, a2, a7, a8, a9, a10);
if ( v15 )
{
return v15;
}
else
{
v15 = my_aes_crypt_update((long long)v16, v20, v19, v18, (long long)&v13);
v14 = my_aes_crypt_finish((long long)v16, v13 + v18, (long long)&v12);
if ( v15 || v14 )
ERR_clear_error();
else
*v17 = v12 + v13;
if ( v15 )
return v15;
else
return v14;
}
}
| my_aes_crypt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x310
MOV EAX,dword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x2b8],EDI
MOV dword ptr [RBP + -0x2bc],ESI
MOV qword ptr [RBP + -0x2c8],RDX
MOV dword ptr [RBP + -0x2cc],ECX
MOV qword ptr [RBP + -0x2d8],R8
MOV qword ptr [RBP + -0x2e0],R9
LEA RAX,[RBP + -0x2b0]
MOV qword ptr [RBP + -0x2e8],RAX
MOV dword ptr [RBP + -0x2f4],0x0
MOV RDI,qword ptr [RBP + -0x2e8]
MOV ESI,dword ptr [RBP + -0x2b8]
MOV EDX,dword ptr [RBP + -0x2bc]
MOV RCX,qword ptr [RBP + 0x10]
MOV R8D,dword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x28]
MOV dword ptr [RSP],EAX
CALL 0x001d95a0
MOV dword ptr [RBP + -0x2ec],EAX
CMP EAX,0x0
JZ 0x001d979b
MOV EAX,dword ptr [RBP + -0x2ec]
MOV dword ptr [RBP + -0x2b4],EAX
JMP 0x001d984e
LAB_001d979b:
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2c8]
MOV EDX,dword ptr [RBP + -0x2cc]
MOV RCX,qword ptr [RBP + -0x2d8]
LEA R8,[RBP + -0x2f4]
CALL 0x001d9670
MOV dword ptr [RBP + -0x2ec],EAX
MOV RDI,qword ptr [RBP + -0x2e8]
MOV RSI,qword ptr [RBP + -0x2d8]
MOV EAX,dword ptr [RBP + -0x2f4]
ADD RSI,RAX
LEA RDX,[RBP + -0x2f8]
CALL 0x001d96b0
MOV dword ptr [RBP + -0x2f0],EAX
CMP dword ptr [RBP + -0x2ec],0x0
JNZ 0x001d9803
CMP dword ptr [RBP + -0x2f0],0x0
JZ 0x001d980a
LAB_001d9803:
CALL 0x0012a760
JMP 0x001d981f
LAB_001d980a:
MOV ECX,dword ptr [RBP + -0x2f4]
ADD ECX,dword ptr [RBP + -0x2f8]
MOV RAX,qword ptr [RBP + -0x2e0]
MOV dword ptr [RAX],ECX
LAB_001d981f:
CMP dword ptr [RBP + -0x2ec],0x0
JZ 0x001d9836
MOV EAX,dword ptr [RBP + -0x2ec]
MOV dword ptr [RBP + -0x2fc],EAX
JMP 0x001d9842
LAB_001d9836:
MOV EAX,dword ptr [RBP + -0x2f0]
MOV dword ptr [RBP + -0x2fc],EAX
LAB_001d9842:
MOV EAX,dword ptr [RBP + -0x2fc]
MOV dword ptr [RBP + -0x2b4],EAX
LAB_001d984e:
MOV EAX,dword ptr [RBP + -0x2b4]
MOV dword ptr [RBP + -0x300],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001d987b
MOV EAX,dword ptr [RBP + -0x300]
ADD RSP,0x310
POP RBP
RET
LAB_001d987b:
CALL 0x0012a250
|
int my_aes_crypt(int4 param_1,int4 param_2,int8 param_3,int4 param_4,
long param_5,int *param_6,int8 param_7,int4 param_8,int8 param_9,
int4 param_10)
{
long in_FS_OFFSET;
int local_304;
int local_300;
uint local_2fc;
int local_2f8;
int local_2f4;
int1 *local_2f0;
int *local_2e8;
long local_2e0;
int4 local_2d4;
int8 local_2d0;
int4 local_2c4;
int4 local_2c0;
int local_2bc;
int1 local_2b8 [680];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2f0 = local_2b8;
local_2fc = 0;
local_2e8 = param_6;
local_2e0 = param_5;
local_2d4 = param_4;
local_2d0 = param_3;
local_2c4 = param_2;
local_2c0 = param_1;
local_2f4 = my_aes_crypt_init(local_2f0,param_1,param_2,param_7,param_8,param_9,param_10);
local_2bc = local_2f4;
if (local_2f4 == 0) {
local_2f4 = my_aes_crypt_update(local_2f0,local_2d0,local_2d4,local_2e0,&local_2fc);
local_2f8 = my_aes_crypt_finish(local_2f0,local_2e0 + (ulong)local_2fc,&local_300);
if ((local_2f4 == 0) && (local_2f8 == 0)) {
*local_2e8 = local_2fc + local_300;
}
else {
ERR_clear_error();
}
if (local_2f4 == 0) {
local_304 = local_2f8;
}
else {
local_304 = local_2f4;
}
local_2bc = local_304;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_2bc;
}
| |
31,260 | my_aes_crypt | eloqsql/mysys_ssl/my_crypt.cc | int my_aes_crypt(enum my_aes_mode mode, int flags,
const uchar *src, uint slen, uchar *dst, uint *dlen,
const uchar *key, uint klen, const uchar *iv, uint ivlen)
{
void *ctx= alloca(MY_AES_CTX_SIZE);
int res1, res2;
uint d1= 0, d2;
if ((res1= my_aes_crypt_init(ctx, mode, flags, key, klen, iv, ivlen)))
return res1;
res1= my_aes_crypt_update(ctx, src, slen, dst, &d1);
res2= my_aes_crypt_finish(ctx, dst + d1, &d2);
if (res1 || res2)
ERR_remove_state(0); /* in case of failure clear error queue */
else
*dlen= d1 + d2;
return res1 ? res1 : res2;
} | O3 | cpp | my_aes_crypt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %edx
movl %edi, %esi
movq 0x10(%rbp), %rcx
movl 0x18(%rbp), %r8d
movq 0x20(%rbp), %r9
movl 0x28(%rbp), %eax
movq %fs:0x28, %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x2d4(%rbp)
movl %eax, (%rsp)
leaq -0x2d0(%rbp), %rdi
callq 0x926b0
movl %eax, %r15d
testl %eax, %eax
jne 0x92918
movq %rbx, -0x2e0(%rbp)
leaq -0x2d0(%rbp), %rbx
movq (%rbx), %rax
leaq -0x2d4(%rbp), %r15
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r14, %rcx
movq %r15, %r8
callq *0x18(%rax)
movl %eax, %r12d
movl (%r15), %esi
addq %r14, %rsi
movq (%rbx), %rax
leaq -0x2d8(%rbp), %rdx
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl %r15d, %eax
orl %r12d, %eax
je 0x928fc
callq 0x2a7b0
jmp 0x92911
movl -0x2d8(%rbp), %eax
addl -0x2d4(%rbp), %eax
movq -0x2e0(%rbp), %rcx
movl %eax, (%rcx)
testl %r12d, %r12d
cmovnel %r12d, %r15d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x9293c
movl %r15d, %eax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
| my_aes_crypt:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2C8h
mov rbx, r9
mov r14, r8
mov r12d, ecx
mov r13, rdx
mov edx, esi
mov esi, edi
mov rcx, [rbp+arg_0]
mov r8d, [rbp+arg_8]
mov r9, [rbp+arg_10]
mov eax, [rbp+arg_18]
mov rdi, fs:28h
mov [rbp+var_30], rdi
mov [rbp+var_2D4], 0
mov [rsp+2F0h+var_2F0], eax
lea rdi, [rbp+var_2D0]
call my_aes_crypt_init
mov r15d, eax
test eax, eax
jnz short loc_92918
mov [rbp+var_2E0], rbx
lea rbx, [rbp+var_2D0]
mov rax, [rbx]
lea r15, [rbp+var_2D4]
mov rdi, rbx
mov rsi, r13
mov edx, r12d
mov rcx, r14
mov r8, r15
call qword ptr [rax+18h]
mov r12d, eax
mov esi, [r15]
add rsi, r14
mov rax, [rbx]
lea rdx, [rbp+var_2D8]
mov rdi, rbx
call qword ptr [rax+20h]
mov r15d, eax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov eax, r15d
or eax, r12d
jz short loc_928FC
call _ERR_clear_error
jmp short loc_92911
loc_928FC:
mov eax, [rbp+var_2D8]
add eax, [rbp+var_2D4]
mov rcx, [rbp+var_2E0]
mov [rcx], eax
loc_92911:
test r12d, r12d
cmovnz r15d, r12d
loc_92918:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_9293C
mov eax, r15d
add rsp, 2C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9293C:
call ___stack_chk_fail
| long long my_aes_crypt(
int a1,
char a2,
long long a3,
unsigned int a4,
long long a5,
_DWORD *a6,
long long a7,
unsigned int a8,
long long a9)
{
unsigned int v13; // r15d
unsigned int v14; // r12d
int v16; // [rsp+18h] [rbp-2D8h] BYREF
unsigned int v17; // [rsp+1Ch] [rbp-2D4h] BYREF
_QWORD v18[90]; // [rsp+20h] [rbp-2D0h] BYREF
v18[84] = __readfsqword(0x28u);
v17 = 0;
v13 = my_aes_crypt_init(v18, a1, a2, a7, a8, a9);
if ( !v13 )
{
v14 = (*(long long ( **)(_QWORD *, long long, _QWORD, long long, unsigned int *))(v18[0] + 24LL))(
v18,
a3,
a4,
a5,
&v17);
v13 = (*(long long ( **)(_QWORD *, long long, int *))(v18[0] + 32LL))(v18, a5 + v17, &v16);
(*(void ( **)(_QWORD *))v18[0])(v18);
if ( v14 | v13 )
ERR_clear_error(v18);
else
*a6 = v17 + v16;
if ( v14 )
return v14;
}
return v13;
}
| my_aes_crypt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2c8
MOV RBX,R9
MOV R14,R8
MOV R12D,ECX
MOV R13,RDX
MOV EDX,ESI
MOV ESI,EDI
MOV RCX,qword ptr [RBP + 0x10]
MOV R8D,dword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x28]
MOV RDI,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RDI
MOV dword ptr [RBP + -0x2d4],0x0
MOV dword ptr [RSP],EAX
LEA RDI,[RBP + -0x2d0]
CALL 0x001926b0
MOV R15D,EAX
TEST EAX,EAX
JNZ 0x00192918
MOV qword ptr [RBP + -0x2e0],RBX
LEA RBX,[RBP + -0x2d0]
MOV RAX,qword ptr [RBX]
LEA R15,[RBP + -0x2d4]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,R12D
MOV RCX,R14
MOV R8,R15
CALL qword ptr [RAX + 0x18]
MOV R12D,EAX
MOV ESI,dword ptr [R15]
ADD RSI,R14
MOV RAX,qword ptr [RBX]
LEA RDX,[RBP + -0x2d8]
MOV RDI,RBX
CALL qword ptr [RAX + 0x20]
MOV R15D,EAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV EAX,R15D
OR EAX,R12D
JZ 0x001928fc
CALL 0x0012a7b0
JMP 0x00192911
LAB_001928fc:
MOV EAX,dword ptr [RBP + -0x2d8]
ADD EAX,dword ptr [RBP + -0x2d4]
MOV RCX,qword ptr [RBP + -0x2e0]
MOV dword ptr [RCX],EAX
LAB_00192911:
TEST R12D,R12D
CMOVNZ R15D,R12D
LAB_00192918:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0019293c
MOV EAX,R15D
ADD RSP,0x2c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019293c:
CALL 0x0012a240
|
int my_aes_crypt(int4 param_1,int4 param_2,int8 param_3,int4 param_4,
long param_5,int *param_6,int8 param_7,int4 param_8,int8 param_9,
int4 param_10)
{
int iVar1;
int iVar2;
long in_FS_OFFSET;
int local_2e0;
uint local_2dc;
int8 *local_2d8 [84];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_2dc = 0;
iVar1 = my_aes_crypt_init(local_2d8,param_1,param_2,param_7,param_8,param_9,param_10);
if (iVar1 == 0) {
iVar2 = (*(code *)local_2d8[0][3])(local_2d8,param_3,param_4,param_5,&local_2dc);
iVar1 = (*(code *)local_2d8[0][4])(local_2d8,(ulong)local_2dc + param_5,&local_2e0);
(*(code *)*local_2d8[0])(local_2d8);
if (iVar1 == 0 && iVar2 == 0) {
*param_6 = local_2e0 + local_2dc;
}
else {
ERR_clear_error();
}
if (iVar2 != 0) {
iVar1 = iVar2;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,261 | uf_space_prespace | eloqsql/storage/myisam/mi_packrec.c | static void uf_space_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill((uchar*) to,(end-to),' ');
else
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
} | O0 | c | uf_space_prespace:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbea27
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 0xbea4b
jmp 0xbea69
movq -0x10(%rbp), %rdi
callq 0xbd720
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbea69
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x2a2c0
jmp 0xbeb21
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbeaac
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%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 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x201c3c(%rip), %rcx # 0x2c06e0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbeabf
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbbed0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbeae1
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbeb21
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbeb1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0xbde30
jmp 0xbeb21
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| uf_space_prespace_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BEA27
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_BEA4B
jmp short loc_BEA69
loc_BEA27:
mov rdi, [rbp+var_10]
call fill_buffer_0
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_BEA69
loc_BEA4B:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
mov esi, 20h ; ' '
call _memset
jmp loc_BEB21
loc_BEA69:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BEAAC
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
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+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BEABF
loc_BEAAC:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BEABF:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BEAE1
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BEB21
loc_BEAE1:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BEB1F
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BEB1F:
jmp short $+2
loc_BEB21:
add rsp, 30h
pop rbp
retn
| long long uf_space_prespace_0(long long a1, int *a2, long long a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int v7; // eax
int v8; // ecx
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 32LL, &a4[-a3]);
}
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 32LL, &a4[-a3]);
LABEL_6:
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v7 = *a2;
v8 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v8;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v8);
}
if ( (unsigned long long)bits_0 + a3 <= (unsigned long long)a4 )
{
memset(a3, 32LL, bits_0);
result = bits_0 + a3;
if ( (_BYTE *)result != a4 )
return decode_bytes_0(a1, (long long)a2, (_BYTE *)(bits_0 + a3), a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_space_prespace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bea27
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 0x001bea4b
JMP 0x001bea69
LAB_001bea27:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bd720
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 0x001bea69
LAB_001bea4b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
MOV ESI,0x20
CALL 0x0012a2c0
JMP 0x001beb21
LAB_001bea69:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001beaac
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
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 + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3c06e0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001beabf
LAB_001beaac:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bbed0
MOV dword ptr [RBP + -0x28],EAX
LAB_001beabf:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001beae1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001beb21
LAB_001beae1:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001beb1f
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bde30
LAB_001beb1f:
JMP 0x001beb21
LAB_001beb21:
ADD RSP,0x30
POP RBP
RET
|
void uf_space_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
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 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
}
else {
memset(param_3,0x20,param_4 - (long)param_3);
}
return;
}
| |
31,262 | wt_thd_will_wait_for | eloqsql/mysys/waiting_threads.c | int wt_thd_will_wait_for(WT_THD *thd, WT_THD *blocker,
const WT_RESOURCE_ID *resid)
{
uint i;
WT_RESOURCE *rc;
DBUG_ENTER("wt_thd_will_wait_for");
DBUG_PRINT("wt", ("enter: thd=%s, blocker=%s, resid=%lu",
thd->name, blocker->name, (ulong)resid->value));
if (fix_thd_pins(thd))
DBUG_RETURN(WT_DEADLOCK);
if (thd->waiting_for == 0)
{
uint keylen;
const void *key;
/* XXX if (restype->make_key) key= restype->make_key(resid, &keylen); else */
{
key= resid;
keylen= sizeof_WT_RESOURCE_ID;
}
DBUG_PRINT("wt", ("first blocker"));
retry:
while ((rc= lf_hash_search(&reshash, thd->pins, key, keylen)) == 0)
{
DBUG_PRINT("wt", ("failed to find rc in hash, inserting"));
if (lf_hash_insert(&reshash, thd->pins, resid) == -1) /* if OOM */
DBUG_RETURN(WT_DEADLOCK);
/*
Two cases: either lf_hash_insert() failed - because another thread
has just inserted a resource with the same id - and we need to retry.
Or lf_hash_insert() succeeded, and then we need to repeat
lf_hash_search() to find a real address of the newly inserted element.
That is, we don't care what lf_hash_insert() has returned.
And we need to repeat the loop anyway.
*/
}
if (rc == MY_ERRPTR)
DBUG_RETURN(WT_DEADLOCK);
DBUG_PRINT("wt", ("found in hash rc=%p", rc));
rc_wrlock(rc);
if (rc->state != ACTIVE)
{
DBUG_PRINT("wt", ("but it's not active, retrying"));
/* Somebody has freed the element while we weren't looking */
rc_unlock(rc);
lf_hash_search_unpin(thd->pins);
goto retry;
}
lf_hash_search_unpin(thd->pins); /* the element cannot go away anymore */
thd->waiting_for= rc;
rc->waiter_count++;
thd->killed= 0;
}
else
{
DBUG_ASSERT(thd->waiting_for->id.type == resid->type);
DBUG_ASSERT(resid->type->compare(&thd->waiting_for->id, resid) == 0);
DBUG_PRINT("wt", ("adding another blocker"));
/*
we can safely access the resource here, it's in the hash as it has
non-zero waiter_count
*/
rc= thd->waiting_for;
rc_wrlock(rc);
DBUG_ASSERT(rc->waiter_count);
DBUG_ASSERT(rc->state == ACTIVE);
if (thd->killed)
{
stop_waiting_locked(thd);
DBUG_RETURN(WT_DEADLOCK);
}
}
/*
Another thread could be waiting on this resource for this very 'blocker'.
In this case we should not add it to the list for the second time.
*/
for (i= 0; i < rc->owners.elements; i++)
if (*dynamic_element(&rc->owners, i, WT_THD**) == blocker)
break;
if (i >= rc->owners.elements)
{
if (push_dynamic(&blocker->my_resources, (void*)&rc))
{
stop_waiting_locked(thd);
DBUG_RETURN(WT_DEADLOCK); /* deadlock and OOM use the same error code */
}
if (push_dynamic(&rc->owners, (void*)&blocker))
{
pop_dynamic(&blocker->my_resources);
stop_waiting_locked(thd);
DBUG_RETURN(WT_DEADLOCK);
}
}
rc_unlock(rc);
if (deadlock(thd, blocker, 1, *thd->deadlock_search_depth_short) != WT_OK)
{
stop_waiting(thd);
DBUG_RETURN(WT_DEADLOCK);
}
DBUG_RETURN(WT_OK);
} | O3 | c | wt_thd_will_wait_for:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, -0x38(%rbp)
cmpq $0x0, 0x30(%rdi)
je 0xa6da3
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0xa6c49
movq %r15, -0x30(%rbp)
leaq 0x18(%r15), %rdi
callq 0xa441d
cmpb $0x0, 0x60(%rbx)
jne 0xa6d11
jmp 0xa6cde
movq %r14, -0x40(%rbp)
leaq 0xb61e7c(%rip), %r13 # 0xc08ad0
movq 0x30(%rbx), %rsi
movq %r13, %rdi
movq %r12, %rdx
movl $0x10, %ecx
callq 0x2fc5f
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xa6cae
movq %rax, %r15
cmpq $0x1, %rax
je 0xa6d2e
movq %r15, -0x30(%rbp)
movq %r15, %r14
addq $0x18, %r14
movq %r14, %rdi
callq 0xa441d
cmpl $0x0, 0x14(%r15)
je 0xa6cc4
movq %r14, %rdi
callq 0xa44be
movq 0x30(%rbx), %rax
xorl %ecx, %ecx
xchgq %rcx, 0x10(%rax)
jmp 0xa6c54
movq 0x30(%rbx), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x2f400
cmpl $-0x1, %eax
jne 0xa6c54
jmp 0xa6d2e
movq 0x30(%rbx), %rax
xorl %ecx, %ecx
xchgq %rcx, 0x10(%rax)
movq %r15, 0x28(%rbx)
incl 0x10(%r15)
movb $0x0, 0x60(%rbx)
movq -0x40(%rbp), %r14
movl 0xe8(%r15), %eax
testq %rax, %rax
je 0xa6d01
movq 0xe0(%r15), %rcx
xorl %edx, %edx
cmpq %r14, (%rcx,%rdx,8)
je 0xa6d6d
incq %rdx
cmpq %rdx, %rax
jne 0xa6cf3
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x91b9e
testb %al, %al
je 0xa6d40
movq 0x28(%rbx), %rsi
decl 0x10(%rsi)
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
callq 0xa729d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xe0, %edi
addq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x91b9e
testb %al, %al
je 0xa6d69
movq -0x38(%rbp), %rdi
callq 0x91c93
movq %rbx, %rdi
callq 0xa6dc1
jmp 0xa6d28
movq -0x30(%rbp), %r15
addq $0x18, %r15
movq %r15, %rdi
callq 0xa44be
movq -0x38(%rbp), %rsi
movq 0x40(%rbx), %rax
movl (%rax), %ecx
movq %rbx, %rdi
movl $0x1, %edx
callq 0xa6dda
testl %eax, %eax
je 0xa6d9e
movq %rbx, %rdi
callq 0xa6f12
jmp 0xa6d28
xorl %r14d, %r14d
jmp 0xa6d2e
leaq 0xb61d4e(%rip), %rdi # 0xc08af8
callq 0x2f225
movq %rax, 0x30(%rbx)
testq %rax, %rax
jne 0xa6c24
jmp 0xa6d28
| wt_thd_will_wait_for:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov r14, rsi
mov rbx, rdi
mov [rbp+var_38], rsi
cmp qword ptr [rdi+30h], 0
jz loc_A6DA3
loc_A6C24:
mov r15, [rbx+28h]
test r15, r15
jz short loc_A6C49
mov [rbp+var_30], r15
lea rdi, [r15+18h]
call my_rw_wrlock
cmp byte ptr [rbx+60h], 0
jnz loc_A6D11
jmp loc_A6CDE
loc_A6C49:
mov [rbp+var_40], r14
lea r13, reshash
loc_A6C54:
mov rsi, [rbx+30h]
mov rdi, r13
mov rdx, r12
mov ecx, 10h
call lf_hash_search
mov r14d, 0FFFFFFFFh
test rax, rax
jz short loc_A6CAE
mov r15, rax
cmp rax, 1
jz loc_A6D2E
mov [rbp+var_30], r15
mov r14, r15
add r14, 18h
mov rdi, r14
call my_rw_wrlock
cmp dword ptr [r15+14h], 0
jz short loc_A6CC4
mov rdi, r14
call my_rw_unlock
mov rax, [rbx+30h]
xor ecx, ecx
xchg rcx, [rax+10h]
jmp short loc_A6C54
loc_A6CAE:
mov rsi, [rbx+30h]
mov rdi, r13
mov rdx, r12
call lf_hash_insert
cmp eax, 0FFFFFFFFh
jnz short loc_A6C54
jmp short loc_A6D2E
loc_A6CC4:
mov rax, [rbx+30h]
xor ecx, ecx
xchg rcx, [rax+10h]
mov [rbx+28h], r15
inc dword ptr [r15+10h]
mov byte ptr [rbx+60h], 0
mov r14, [rbp+var_40]
loc_A6CDE:
mov eax, [r15+0E8h]
test rax, rax
jz short loc_A6D01
mov rcx, [r15+0E0h]
xor edx, edx
loc_A6CF3:
cmp [rcx+rdx*8], r14
jz short loc_A6D6D
inc rdx
cmp rax, rdx
jnz short loc_A6CF3
loc_A6D01:
lea rsi, [rbp+var_30]
mov rdi, r14
call insert_dynamic
test al, al
jz short loc_A6D40
loc_A6D11:
mov rsi, [rbx+28h]
dec dword ptr [rsi+10h]
mov qword ptr [rbx+28h], 0
mov rdi, rbx
call unlock_lock_and_free_resource
loc_A6D28:
mov r14d, 0FFFFFFFFh
loc_A6D2E:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A6D40:
mov edi, 0E0h
add rdi, [rbp+var_30]
lea rsi, [rbp+var_38]
call insert_dynamic
test al, al
jz short loc_A6D69
mov rdi, [rbp+var_38]
call pop_dynamic
mov rdi, rbx
call stop_waiting_locked
jmp short loc_A6D28
loc_A6D69:
mov r15, [rbp+var_30]
loc_A6D6D:
add r15, 18h
mov rdi, r15
call my_rw_unlock
mov rsi, [rbp+var_38]
mov rax, [rbx+40h]
mov ecx, [rax]
mov rdi, rbx
mov edx, 1
call deadlock
test eax, eax
jz short loc_A6D9E
mov rdi, rbx
call stop_waiting
jmp short loc_A6D28
loc_A6D9E:
xor r14d, r14d
jmp short loc_A6D2E
loc_A6DA3:
lea rdi, unk_C08AF8
call lf_pinbox_get_pins
mov [rbx+30h], rax
test rax, rax
jnz loc_A6C24
jmp loc_A6D28
| long long wt_thd_will_wait_for(long long a1, long long a2, long long a3)
{
long long v4; // r14
long long v5; // r15
long long v6; // rax
unsigned int v7; // r14d
long long v8; // rdx
long long pins; // rax
long long v11; // [rsp+8h] [rbp-38h] BYREF
long long v12[6]; // [rsp+10h] [rbp-30h] BYREF
v4 = a2;
v11 = a2;
if ( !*(_QWORD *)(a1 + 48) )
{
pins = lf_pinbox_get_pins((long long)&unk_C08AF8);
*(_QWORD *)(a1 + 48) = pins;
if ( !pins )
return (unsigned int)-1;
}
v5 = *(_QWORD *)(a1 + 40);
if ( v5 )
{
v12[0] = *(_QWORD *)(a1 + 40);
my_rw_wrlock(v5 + 24);
if ( *(_BYTE *)(a1 + 96) )
goto LABEL_17;
}
else
{
while ( 1 )
{
while ( 1 )
{
v6 = lf_hash_search((long long)&reshash, *(volatile long long **)(a1 + 48), a3, 0x10u);
v7 = -1;
if ( v6 )
break;
if ( (unsigned int)lf_hash_insert((long long)&reshash, *(_QWORD *)(a1 + 48), a3) == -1 )
return v7;
}
v5 = v6;
if ( v6 == 1 )
return v7;
v12[0] = v6;
my_rw_wrlock(v6 + 24);
if ( !*(_DWORD *)(v5 + 20) )
break;
my_rw_unlock(v5 + 24);
_InterlockedExchange64((volatile long long *)(*(_QWORD *)(a1 + 48) + 16LL), 0LL);
}
_InterlockedExchange64((volatile long long *)(*(_QWORD *)(a1 + 48) + 16LL), 0LL);
*(_QWORD *)(a1 + 40) = v5;
++*(_DWORD *)(v5 + 16);
*(_BYTE *)(a1 + 96) = 0;
v4 = a2;
}
if ( !*(_DWORD *)(v5 + 232) )
{
LABEL_16:
if ( !(unsigned __int8)insert_dynamic(v4, (long long)v12) )
{
if ( (unsigned __int8)insert_dynamic(v12[0] + 224, (long long)&v11) )
{
pop_dynamic(v11);
stop_waiting_locked(a1);
return (unsigned int)-1;
}
v5 = v12[0];
goto LABEL_23;
}
LABEL_17:
--*(_DWORD *)(*(_QWORD *)(a1 + 40) + 16LL);
*(_QWORD *)(a1 + 40) = 0LL;
unlock_lock_and_free_resource(a1);
return (unsigned int)-1;
}
v8 = 0LL;
while ( *(_QWORD *)(*(_QWORD *)(v5 + 224) + 8 * v8) != v4 )
{
if ( *(_DWORD *)(v5 + 232) == ++v8 )
goto LABEL_16;
}
LABEL_23:
my_rw_unlock(v5 + 24);
if ( !(unsigned int)deadlock(a1, v11, 1LL, **(unsigned int **)(a1 + 64)) )
return 0;
stop_waiting(a1);
return (unsigned int)-1;
}
| wt_thd_will_wait_for:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RBP + -0x38],RSI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001a6da3
LAB_001a6c24:
MOV R15,qword ptr [RBX + 0x28]
TEST R15,R15
JZ 0x001a6c49
MOV qword ptr [RBP + -0x30],R15
LEA RDI,[R15 + 0x18]
CALL 0x001a441d
CMP byte ptr [RBX + 0x60],0x0
JNZ 0x001a6d11
JMP 0x001a6cde
LAB_001a6c49:
MOV qword ptr [RBP + -0x40],R14
LEA R13,[0xd08ad0]
LAB_001a6c54:
MOV RSI,qword ptr [RBX + 0x30]
MOV RDI,R13
MOV RDX,R12
MOV ECX,0x10
CALL 0x0012fc5f
MOV R14D,0xffffffff
TEST RAX,RAX
JZ 0x001a6cae
MOV R15,RAX
CMP RAX,0x1
JZ 0x001a6d2e
MOV qword ptr [RBP + -0x30],R15
MOV R14,R15
ADD R14,0x18
MOV RDI,R14
CALL 0x001a441d
CMP dword ptr [R15 + 0x14],0x0
JZ 0x001a6cc4
MOV RDI,R14
CALL 0x001a44be
MOV RAX,qword ptr [RBX + 0x30]
XOR ECX,ECX
XCHG qword ptr [RAX + 0x10],RCX
JMP 0x001a6c54
LAB_001a6cae:
MOV RSI,qword ptr [RBX + 0x30]
MOV RDI,R13
MOV RDX,R12
CALL 0x0012f400
CMP EAX,-0x1
JNZ 0x001a6c54
JMP 0x001a6d2e
LAB_001a6cc4:
MOV RAX,qword ptr [RBX + 0x30]
XOR ECX,ECX
XCHG qword ptr [RAX + 0x10],RCX
MOV qword ptr [RBX + 0x28],R15
INC dword ptr [R15 + 0x10]
MOV byte ptr [RBX + 0x60],0x0
MOV R14,qword ptr [RBP + -0x40]
LAB_001a6cde:
MOV EAX,dword ptr [R15 + 0xe8]
TEST RAX,RAX
JZ 0x001a6d01
MOV RCX,qword ptr [R15 + 0xe0]
XOR EDX,EDX
LAB_001a6cf3:
CMP qword ptr [RCX + RDX*0x8],R14
JZ 0x001a6d6d
INC RDX
CMP RAX,RDX
JNZ 0x001a6cf3
LAB_001a6d01:
LEA RSI,[RBP + -0x30]
MOV RDI,R14
CALL 0x00191b9e
TEST AL,AL
JZ 0x001a6d40
LAB_001a6d11:
MOV RSI,qword ptr [RBX + 0x28]
DEC dword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x28],0x0
MOV RDI,RBX
CALL 0x001a729d
LAB_001a6d28:
MOV R14D,0xffffffff
LAB_001a6d2e:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a6d40:
MOV EDI,0xe0
ADD RDI,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x38]
CALL 0x00191b9e
TEST AL,AL
JZ 0x001a6d69
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00191c93
MOV RDI,RBX
CALL 0x001a6dc1
JMP 0x001a6d28
LAB_001a6d69:
MOV R15,qword ptr [RBP + -0x30]
LAB_001a6d6d:
ADD R15,0x18
MOV RDI,R15
CALL 0x001a44be
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBX + 0x40]
MOV ECX,dword ptr [RAX]
MOV RDI,RBX
MOV EDX,0x1
CALL 0x001a6dda
TEST EAX,EAX
JZ 0x001a6d9e
MOV RDI,RBX
CALL 0x001a6f12
JMP 0x001a6d28
LAB_001a6d9e:
XOR R14D,R14D
JMP 0x001a6d2e
LAB_001a6da3:
LEA RDI,[0xd08af8]
CALL 0x0012f225
MOV qword ptr [RBX + 0x30],RAX
TEST RAX,RAX
JNZ 0x001a6c24
JMP 0x001a6d28
|
int8 wt_thd_will_wait_for(long param_1,long param_2,int8 param_3)
{
int *piVar1;
char cVar2;
int iVar3;
long lVar4;
ulong uVar5;
long local_40;
long local_38;
local_40 = param_2;
if (*(long *)(param_1 + 0x30) == 0) {
lVar4 = lf_pinbox_get_pins(0xd08af8);
*(long *)(param_1 + 0x30) = lVar4;
if (lVar4 == 0) {
return 0xffffffff;
}
}
lVar4 = *(long *)(param_1 + 0x28);
if (lVar4 == 0) {
while( true ) {
while (lVar4 = lf_hash_search(reshash,*(int8 *)(param_1 + 0x30),param_3), lVar4 == 0) {
iVar3 = lf_hash_insert(reshash,*(int8 *)(param_1 + 0x30),param_3);
if (iVar3 == -1) {
return 0xffffffff;
}
}
if (lVar4 == 1) {
return 0xffffffff;
}
local_38 = lVar4;
my_rw_wrlock(lVar4 + 0x18);
if (*(int *)(lVar4 + 0x14) == 0) break;
my_rw_unlock(lVar4 + 0x18);
LOCK();
*(int8 *)(*(long *)(param_1 + 0x30) + 0x10) = 0;
UNLOCK();
}
LOCK();
*(int8 *)(*(long *)(param_1 + 0x30) + 0x10) = 0;
UNLOCK();
*(long *)(param_1 + 0x28) = lVar4;
*(int *)(lVar4 + 0x10) = *(int *)(lVar4 + 0x10) + 1;
*(int1 *)(param_1 + 0x60) = 0;
}
else {
local_38 = lVar4;
my_rw_wrlock(lVar4 + 0x18);
if (*(char *)(param_1 + 0x60) != '\0') goto LAB_001a6d11;
}
if ((ulong)*(uint *)(lVar4 + 0xe8) != 0) {
uVar5 = 0;
do {
if (*(long *)(*(long *)(lVar4 + 0xe0) + uVar5 * 8) == param_2) goto LAB_001a6d6d;
uVar5 = uVar5 + 1;
} while (*(uint *)(lVar4 + 0xe8) != uVar5);
}
cVar2 = insert_dynamic(param_2,&local_38);
if (cVar2 == '\0') {
cVar2 = insert_dynamic(local_38 + 0xe0,&local_40);
lVar4 = local_38;
if (cVar2 != '\0') {
pop_dynamic(local_40);
stop_waiting_locked(param_1);
return 0xffffffff;
}
LAB_001a6d6d:
my_rw_unlock(lVar4 + 0x18);
iVar3 = deadlock(param_1,local_40,1,**(int4 **)(param_1 + 0x40));
if (iVar3 != 0) {
stop_waiting(param_1);
return 0xffffffff;
}
return 0;
}
LAB_001a6d11:
piVar1 = (int *)(*(long *)(param_1 + 0x28) + 0x10);
*piVar1 = *piVar1 + -1;
*(int8 *)(param_1 + 0x28) = 0;
unlock_lock_and_free_resource(param_1);
return 0xffffffff;
}
| |
31,263 | unlink_deleted_block | eloqsql/storage/myisam/mi_dynrec.c | static my_bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MI_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(mi_rrnd() or mi_scan(), then ensure that we skip over this block
when doing next mi_rrnd() or mi_scan().
*/
if (info->nextpos == block_info->filepos)
info->nextpos+=block_info->block_len;
DBUG_RETURN(0);
} | O3 | c | unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rsi), %rcx
movq (%rdi), %rax
cmpq 0x58(%rax), %rcx
jne 0x7db17
movq 0x40(%r14), %rcx
movq %rcx, 0x58(%rax)
movq 0x8(%rbx), %rax
decq 0x8(%rax)
movq 0x28(%r14), %rax
movq 0x8(%rbx), %rcx
subq %rax, 0x10(%rcx)
movq (%rbx), %rax
decq 0x50(%rax)
movq 0x178(%rbx), %rax
cmpq 0x38(%r14), %rax
jne 0x7db13
addq 0x28(%r14), %rax
movq %rax, 0x178(%rbx)
xorl %eax, %eax
jmp 0x7db69
leaq -0x70(%rbp), %rdi
movl $0x0, 0x50(%rdi)
movl 0x1c0(%rbx), %esi
movq 0x48(%r14), %rdx
callq 0x7d6d7
testb $0x4, %al
je 0x7db67
movq 0x40(%r14), %rax
leaq -0x6c(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x48(%r14), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
je 0x7db81
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x7dbd9
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rdx
cmpq $-0x1, %rdx
je 0x7dae0
movl 0x1c0(%rbx), %esi
leaq -0x70(%rbp), %rdi
callq 0x7d6d7
testb $0x4, %al
je 0x7db67
movq 0x48(%r14), %rax
leaq -0x64(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x40(%r14), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
jne 0x7db67
jmp 0x7dae0
callq 0x2a240
| unlink_deleted_block_0:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rcx, [rsi+38h]
mov rax, [rdi]
cmp rcx, [rax+58h]
jnz short loc_7DB17
mov rcx, [r14+40h]
mov [rax+58h], rcx
loc_7DAE0:
mov rax, [rbx+8]
dec qword ptr [rax+8]
mov rax, [r14+28h]
mov rcx, [rbx+8]
sub [rcx+10h], rax
mov rax, [rbx]
dec qword ptr [rax+50h]
mov rax, [rbx+178h]
cmp rax, [r14+38h]
jnz short loc_7DB13
add rax, [r14+28h]
mov [rbx+178h], rax
loc_7DB13:
xor eax, eax
jmp short loc_7DB69
loc_7DB17:
lea rdi, [rbp+var_70]
mov dword ptr [rdi+50h], 0
mov esi, [rbx+1C0h]
mov rdx, [r14+48h]
call _mi_get_block_info
test al, 4
jz short loc_7DB67
mov rax, [r14+40h]
lea rsi, [rbp+var_6C]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jz short loc_7DB81
loc_7DB67:
mov al, 1
loc_7DB69:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_7DBD9
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_7DB81:
mov rdx, [r14+40h]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_7DAE0
mov esi, [rbx+1C0h]
lea rdi, [rbp+var_70]
call _mi_get_block_info
test al, 4
jz short loc_7DB67
mov rax, [r14+48h]
lea rsi, [rbp+var_64]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jnz short loc_7DB67
jmp loc_7DAE0
loc_7DBD9:
call ___stack_chk_fail
| char unlink_deleted_block_0(_QWORD *a1, _QWORD *a2)
{
long long v2; // rax
long long v4; // rdx
_BYTE v5[4]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+4h] [rbp-6Ch] BYREF
unsigned long long v7[8]; // [rsp+Ch] [rbp-64h] BYREF
int v8; // [rsp+50h] [rbp-20h]
unsigned long long v9; // [rsp+58h] [rbp-18h]
v9 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 88LL) )
{
*(_QWORD *)(*a1 + 88LL) = a2[8];
}
else
{
v8 = 0;
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), a2[9]) & 4) == 0 )
return 1;
v6 = _byteswap_uint64(a2[8]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
&v6,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
v4 = a2[8];
if ( v4 != -1 )
{
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), v4) & 4) == 0 )
return 1;
v7[0] = _byteswap_uint64(a2[9]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
v7,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 80LL);
v2 = a1[47];
if ( v2 == a2[7] )
a1[47] = a2[5] + v2;
return 0;
}
| unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RDI]
CMP RCX,qword ptr [RAX + 0x58]
JNZ 0x0017db17
MOV RCX,qword ptr [R14 + 0x40]
MOV qword ptr [RAX + 0x58],RCX
LAB_0017dae0:
MOV RAX,qword ptr [RBX + 0x8]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x28]
MOV RCX,qword ptr [RBX + 0x8]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBX]
DEC qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBX + 0x178]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x0017db13
ADD RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RBX + 0x178],RAX
LAB_0017db13:
XOR EAX,EAX
JMP 0x0017db69
LAB_0017db17:
LEA RDI,[RBP + -0x70]
MOV dword ptr [RDI + 0x50],0x0
MOV ESI,dword ptr [RBX + 0x1c0]
MOV RDX,qword ptr [R14 + 0x48]
CALL 0x0017d6d7
TEST AL,0x4
JZ 0x0017db67
MOV RAX,qword ptr [R14 + 0x40]
LEA RSI,[RBP + -0x6c]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JZ 0x0017db81
LAB_0017db67:
MOV AL,0x1
LAB_0017db69:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0017dbd9
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_0017db81:
MOV RDX,qword ptr [R14 + 0x40]
CMP RDX,-0x1
JZ 0x0017dae0
MOV ESI,dword ptr [RBX + 0x1c0]
LEA RDI,[RBP + -0x70]
CALL 0x0017d6d7
TEST AL,0x4
JZ 0x0017db67
MOV RAX,qword ptr [R14 + 0x48]
LEA RSI,[RBP + -0x64]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JNZ 0x0017db67
JMP 0x0017dae0
LAB_0017dbd9:
CALL 0x0012a240
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
ulong uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int1 local_78 [4];
ulong local_74;
ulong local_6c [8];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 0x58)) {
*(int8 *)(*param_1 + 0x58) = *(int8 *)(param_2 + 0x40);
goto LAB_0017dae0;
}
local_28 = 0;
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38],*(int8 *)(param_2 + 0x48));
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x40);
local_74 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18
| (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 |
(uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_74,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar2 == 0) {
if (*(long *)(param_2 + 0x40) == -1) {
LAB_0017dae0:
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + -1;
if (param_1[0x2f] == *(long *)(param_2 + 0x38)) {
param_1[0x2f] = param_1[0x2f] + *(long *)(param_2 + 0x28);
}
uVar3 = 0;
goto LAB_0017db69;
}
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38]);
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x48);
local_6c[0] = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))
(param_1,local_6c,8,*(long *)(param_2 + 0x40) + 0xc,4);
if (lVar2 == 0) goto LAB_0017dae0;
}
}
}
uVar3 = 1;
LAB_0017db69:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
| |
31,264 | DepthAnything::preprocessSingle(cv::Mat const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&) | Depths-CPP/include/depth_anything.hpp | cv::Mat DepthAnything::preprocessSingle(const cv::Mat &image, std::vector<float> &blob, std::vector<int64_t> &inputTensorShape)
{
if (image.empty())
{
throw std::runtime_error("Input image is empty.");
}
cv::Size currentInputShape = inputImageShape;
if (isDynamicInputShape)
{
int rounded_w = DepthUtils::round_to_multiple(image.cols, 32);
int rounded_h = DepthUtils::round_to_multiple(image.rows, 32);
currentInputShape = cv::Size(rounded_w, rounded_h);
inputTensorShape = {1, 3, currentInputShape.height, currentInputShape.width};
}
cv::Mat resizedImage = DepthUtils::resize_no_padding(image, currentInputShape.width, currentInputShape.height);
cv::Mat floatImage;
resizedImage.convertTo(floatImage, CV_32FC3, 1.0f / 255.0f);
for (int c = 0; c < 3; ++c)
{
floatImage.forEach<cv::Vec3f>([c, this](cv::Vec3f &pixel, const int *) -> void
{ pixel[c] = (pixel[c] - mean[c]) / std[c]; });
}
std::vector<cv::Mat> chw;
cv::split(floatImage, chw);
for (auto &channel : chw)
{
blob.insert(blob.end(), (float *)channel.datastart, (float *)channel.dataend);
}
return resizedImage;
} | O0 | cpp | DepthAnything::preprocessSingle(cv::Mat const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&):
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %r8, 0x1b0(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x1c0(%rsp), %rdi
callq 0x1a260
testb $0x1, %al
jne 0x1b42c
jmp 0x1b48a
movl $0x10, %edi
callq 0x1a230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x13c9d(%rip), %rsi # 0x2f0e5
callq 0x1a060
jmp 0x1b44f
movq 0x20(%rsp), %rdi
movq 0x1eb5d(%rip), %rsi # 0x39fb8
movq 0x1eb96(%rip), %rdx # 0x39ff8
callq 0x1a3b0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
callq 0x1a2b0
jmp 0x1b882
movq 0x38(%rsp), %rsi
addq $0x1c, %rsi
leaq 0x19c(%rsp), %rdi
callq 0x20db0
movq 0x38(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x1b588
movq 0x1c0(%rsp), %rax
movl 0xc(%rax), %edi
movl $0x20, %esi
callq 0x20de0
movl %eax, 0x198(%rsp)
movq 0x1c0(%rsp), %rax
movl 0x8(%rax), %edi
movl $0x20, %esi
callq 0x20de0
movl %eax, 0x194(%rsp)
movl 0x198(%rsp), %esi
movl 0x194(%rsp), %edx
leaq 0x18c(%rsp), %rdi
callq 0x20b40
leaq 0x19c(%rsp), %rdi
leaq 0x18c(%rsp), %rsi
callq 0x20b60
movq $0x1, 0x158(%rsp)
movq $0x3, 0x160(%rsp)
movslq 0x1a0(%rsp), %rax
movq %rax, 0x168(%rsp)
movslq 0x19c(%rsp), %rax
movq %rax, 0x170(%rsp)
leaq 0x158(%rsp), %rax
movq %rax, 0x178(%rsp)
movq $0x4, 0x180(%rsp)
movq 0x1b0(%rsp), %rdi
movq 0x178(%rsp), %rsi
movq 0x180(%rsp), %rdx
callq 0x20e00
movq 0x28(%rsp), %rdi
movb $0x0, 0x157(%rsp)
movq 0x1c0(%rsp), %rsi
movl 0x19c(%rsp), %edx
movl 0x1a0(%rsp), %ecx
callq 0x20e60
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a070
movq 0x18(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x20f70
jmp 0x1b5d6
movq 0x28(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movl $0x15, %edx
vmovsd 0x13a18(%rip), %xmm0 # 0x2f008
vpxor %xmm1, %xmm1, %xmm1
callq 0x1a5d0
jmp 0x1b5fb
leaq 0xd8(%rsp), %rdi
callq 0x20fd0
movl $0x0, 0xd4(%rsp)
cmpl $0x3, 0xd4(%rsp)
jge 0x1b6a7
movq 0x38(%rsp), %rax
movl 0xd4(%rsp), %ecx
movl %ecx, 0xc0(%rsp)
movq %rax, 0xc8(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1b890
jmp 0x1b653
jmp 0x1b655
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x1b613
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x20fd0
jmp 0x1b852
leaq 0xa8(%rsp), %rdi
callq 0x20fe0
leaq 0x90(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0x20ff0
jmp 0x1b6cb
leaq 0x78(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x21030
jmp 0x1b6df
leaq 0x90(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1a4f0
jmp 0x1b6f3
leaq 0x78(%rsp), %rdi
callq 0x20fd0
leaq 0x90(%rsp), %rdi
callq 0x21070
leaq 0xa8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x21080
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x210b0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x210e0
testb $0x1, %al
jne 0x1b74d
jmp 0x1b817
leaq 0x68(%rsp), %rdi
callq 0x21120
movq %rax, 0x58(%rsp)
movq 0x1b8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x211e0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x21210
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq 0x50(%rsp), %rsi
callq 0x21130
movq %rax, 0x10(%rsp)
jmp 0x1b7a5
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x21250
jmp 0x1b735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b845
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0x1b808
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x20fd0
leaq 0x90(%rsp), %rdi
callq 0x21070
jmp 0x1b845
movb $0x1, 0x157(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x21270
leaq 0xf0(%rsp), %rdi
callq 0x1a090
testb $0x1, 0x157(%rsp)
jne 0x1b875
jmp 0x1b86b
leaq 0xa8(%rsp), %rdi
callq 0x21270
leaq 0xf0(%rsp), %rdi
callq 0x1a090
movq 0x28(%rsp), %rdi
callq 0x1a090
jmp 0x1b882
movq 0x28(%rsp), %rdi
callq 0x1a090
movq 0x30(%rsp), %rax
addq $0x1d8, %rsp # imm = 0x1D8
retq
movq 0x1a8(%rsp), %rdi
callq 0x1a3c0
nop
| _ZN13DepthAnything16preprocessSingleERKN2cv3MatERSt6vectorIfSaIfEERS4_IlSaIlEE:
sub rsp, 1D8h
mov [rsp+1D8h+var_1B0], rdi
mov rax, rdi
mov [rsp+1D8h+var_1A8], rax
mov [rsp+1D8h+var_8], rdi
mov [rsp+1D8h+var_10], rsi
mov [rsp+1D8h+var_18], rdx
mov [rsp+1D8h+var_20], rcx
mov [rsp+1D8h+var_28], r8
mov rax, [rsp+1D8h+var_10]
mov [rsp+1D8h+var_1A0], rax
mov rdi, [rsp+1D8h+var_18]; this
call __ZNK2cv3Mat5emptyEv; cv::Mat::empty(void)
test al, 1
jnz short loc_1B42C
jmp short loc_1B48A
loc_1B42C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+1D8h+var_1B8], rax
lea rsi, aInputImageIsEm; "Input image is empty."
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1B44F:
mov rdi, [rsp+1D8h+var_1B8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+1D8h+var_1B8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
call ___cxa_free_exception
jmp loc_1B882
loc_1B48A:
mov rsi, [rsp+1D8h+var_1A0]
add rsi, 1Ch
lea rdi, [rsp+1D8h+var_3C]
call _ZN2cv5Size_IiEC2ERKS1_; cv::Size_<int>::Size_(cv::Size_<int> const&)
mov rax, [rsp+1D8h+var_1A0]
test byte ptr [rax+18h], 1
jz loc_1B588
mov rax, [rsp+1D8h+var_18]
mov edi, [rax+0Ch]; this
mov esi, 20h ; ' '; int
call _ZN10DepthUtils17round_to_multipleEii; DepthUtils::round_to_multiple(int,int)
mov [rsp+1D8h+var_40], eax
mov rax, [rsp+1D8h+var_18]
mov edi, [rax+8]; this
mov esi, 20h ; ' '; int
call _ZN10DepthUtils17round_to_multipleEii; DepthUtils::round_to_multiple(int,int)
mov [rsp+1D8h+var_44], eax
mov esi, [rsp+1D8h+var_40]
mov edx, [rsp+1D8h+var_44]
lea rdi, [rsp+1D8h+var_4C]
call _ZN2cv5Size_IiEC2Eii; cv::Size_<int>::Size_(int,int)
lea rdi, [rsp+1D8h+var_3C]
lea rsi, [rsp+1D8h+var_4C]
call _ZN2cv5Size_IiEaSEOS1_; cv::Size_<int>::operator=(cv::Size_<int>&&)
mov [rsp+1D8h+var_80], 1
mov [rsp+1D8h+var_78], 3
movsxd rax, [rsp+1D8h+var_38]
mov [rsp+1D8h+var_70], rax
movsxd rax, [rsp+1D8h+var_3C]
mov [rsp+1D8h+var_68], rax
lea rax, [rsp+1D8h+var_80]
mov [rsp+1D8h+var_60], rax
mov [rsp+1D8h+var_58], 4
mov rdi, [rsp+1D8h+var_28]
mov rsi, [rsp+1D8h+var_60]
mov rdx, [rsp+1D8h+var_58]
call _ZNSt6vectorIlSaIlEEaSESt16initializer_listIlE; std::vector<long>::operator=(std::initializer_list<long>)
loc_1B588:
mov rdi, [rsp+1D8h+var_1B0]; this
mov [rsp+1D8h+var_81], 0
mov rsi, [rsp+1D8h+var_18]; cv::Mat *
mov edx, [rsp+1D8h+var_3C]; int
mov ecx, [rsp+1D8h+var_38]; int
call _ZN10DepthUtils17resize_no_paddingERKN2cv3MatEii; DepthUtils::resize_no_padding(cv::Mat const&,int,int)
lea rdi, [rsp+1D8h+var_E8]; this
mov [rsp+1D8h+var_1C0], rdi
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
mov rsi, [rsp+1D8h+var_1C0]; cv::Mat *
lea rdi, [rsp+1D8h+var_100]; this
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1B5D6:
mov rdi, [rsp+1D8h+var_1B0]
lea rsi, [rsp+1D8h+var_100]
mov edx, 15h
vmovsd xmm0, cs:qword_2F008
vpxor xmm1, xmm1, xmm1
call __ZNK2cv3Mat9convertToERKNS_12_OutputArrayEidd; cv::Mat::convertTo(cv::_OutputArray const&,int,double,double)
jmp short $+2
loc_1B5FB:
lea rdi, [rsp+1D8h+var_100]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
mov [rsp+1D8h+var_104], 0
loc_1B613:
cmp [rsp+1D8h+var_104], 3
jge loc_1B6A7
mov rax, [rsp+1D8h+var_1A0]
mov ecx, [rsp+1D8h+var_104]
mov [rsp+1D8h+var_118], ecx
mov [rsp+1D8h+var_110], rax
lea rdi, [rsp+1D8h+var_E8]
lea rsi, [rsp+1D8h+var_118]
call _ZN2cv3Mat7forEachINS_3VecIfLi3EEEZN13DepthAnything16preprocessSingleERKS0_RSt6vectorIfSaIfEERS7_IlSaIlEEE3$_0EEvRKT0_; cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessSingle(cv::Mat const&,std::vector<float> &,std::vector&<long,std::allocator<long>>)::$_0>(DepthAnything::preprocessSingle(cv::Mat const&,std::vector<float> &,std::vector&<long,std::allocator<long>>)::$_0 const&)
jmp short $+2
loc_1B653:
jmp short $+2
loc_1B655:
mov eax, [rsp+1D8h+var_104]
add eax, 1
mov [rsp+1D8h+var_104], eax
jmp short loc_1B613
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
jmp loc_1B852
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
lea rdi, [rsp+1D8h+var_100]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
jmp loc_1B852
loc_1B6A7:
lea rdi, [rsp+1D8h+var_130]
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
lea rdi, [rsp+1D8h+var_148]; this
lea rsi, [rsp+1D8h+var_E8]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1B6CB:
lea rdi, [rsp+1D8h+var_160]
lea rsi, [rsp+1D8h+var_130]
call _ZN2cv12_OutputArrayC2ERSt6vectorINS_3MatESaIS2_EE; cv::_OutputArray::_OutputArray(std::vector<cv::Mat> &)
jmp short $+2
loc_1B6DF:
lea rdi, [rsp+1D8h+var_148]
lea rsi, [rsp+1D8h+var_160]
call __ZN2cv5splitERKNS_11_InputArrayERKNS_12_OutputArrayE; cv::split(cv::_InputArray const&,cv::_OutputArray const&)
jmp short $+2
loc_1B6F3:
lea rdi, [rsp+1D8h+var_160]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+1D8h+var_148]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rax, [rsp+1D8h+var_130]
mov [rsp+1D8h+var_168], rax
mov rdi, [rsp+1D8h+var_168]
call _ZNSt6vectorIN2cv3MatESaIS1_EE5beginEv; std::vector<cv::Mat>::begin(void)
mov [rsp+1D8h+var_170], rax
mov rdi, [rsp+1D8h+var_168]
call _ZNSt6vectorIN2cv3MatESaIS1_EE3endEv; std::vector<cv::Mat>::end(void)
mov [rsp+1D8h+var_178], rax
loc_1B735:
lea rdi, [rsp+1D8h+var_170]
lea rsi, [rsp+1D8h+var_178]
call _ZN9__gnu_cxxneIPN2cv3MatESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&,__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&)
test al, 1
jnz short loc_1B74D
jmp loc_1B817
loc_1B74D:
lea rdi, [rsp+1D8h+var_170]
call _ZNK9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(void)
mov [rsp+1D8h+var_180], rax
mov rdi, [rsp+1D8h+var_20]
mov [rsp+1D8h+var_1D0], rdi
call _ZNSt6vectorIfSaIfEE3endEv; std::vector<float>::end(void)
mov [rsp+1D8h+var_190], rax
lea rdi, [rsp+1D8h+var_188]
lea rsi, [rsp+1D8h+var_190]
call _ZN9__gnu_cxx17__normal_iteratorIPKfSt6vectorIfSaIfEEEC2IPfEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameIS9_S8_EE7__valueES5_E6__typeEEE
mov rdi, [rsp+1D8h+var_1D0]
mov rax, [rsp+1D8h+var_180]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov rsi, [rsp+1D8h+var_188]
call _ZNSt6vectorIfSaIfEE6insertIPfvEEN9__gnu_cxx17__normal_iteratorIS3_S1_EENS5_IPKfS1_EET_SA_; std::vector<float>::insert<float *,void>(__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,float *,float *)
mov [rsp+1D8h+var_1C8], rax
jmp short $+2
loc_1B7A5:
mov rax, [rsp+1D8h+var_1C8]
mov [rsp+1D8h+var_198], rax
lea rdi, [rsp+1D8h+var_170]
call _ZN9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(void)
jmp loc_1B735
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
jmp short loc_1B845
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
jmp short loc_1B808
mov rcx, rax
mov eax, edx
mov [rsp+1D8h+var_30], rcx
mov [rsp+1D8h+var_34], eax
lea rdi, [rsp+1D8h+var_160]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1B808:
lea rdi, [rsp+1D8h+var_148]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp short loc_1B845
loc_1B817:
mov [rsp+1D8h+var_81], 1
lea rdi, [rsp+1D8h+var_130]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
lea rdi, [rsp+1D8h+var_E8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
test [rsp+1D8h+var_81], 1
jnz short loc_1B875
jmp short loc_1B86B
loc_1B845:
lea rdi, [rsp+1D8h+var_130]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1B852:
lea rdi, [rsp+1D8h+var_E8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
mov rdi, [rsp+1D8h+var_1B0]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_1B882
loc_1B86B:
mov rdi, [rsp+1D8h+var_1B0]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
loc_1B875:
mov rax, [rsp+1D8h+var_1A8]
add rsp, 1D8h
retn
loc_1B882:
mov rdi, [rsp+1D8h+var_30]
call __Unwind_Resume
| DepthUtils * DepthAnything::preprocessSingle(
DepthUtils *a1,
long long a2,
cv::Mat *a3,
long long a4,
long long a5,
double a6,
__m128 _XMM1)
{
int v7; // edx
int v8; // edx
const cv::_OutputArray *v11; // rdx
long long v13; // [rsp+8h] [rbp-1D0h]
std::runtime_error *exception; // [rsp+20h] [rbp-1B8h]
long long v15; // [rsp+48h] [rbp-190h] BYREF
long long v16; // [rsp+50h] [rbp-188h] BYREF
long long v17; // [rsp+58h] [rbp-180h]
long long v18; // [rsp+60h] [rbp-178h] BYREF
_QWORD v19[2]; // [rsp+68h] [rbp-170h] BYREF
_BYTE v20[24]; // [rsp+78h] [rbp-160h] BYREF
_BYTE v21[24]; // [rsp+90h] [rbp-148h] BYREF
_BYTE v22[24]; // [rsp+A8h] [rbp-130h] BYREF
int v23; // [rsp+C0h] [rbp-118h] BYREF
long long v24; // [rsp+C8h] [rbp-110h]
int i; // [rsp+D4h] [rbp-104h]
_BYTE v26[24]; // [rsp+D8h] [rbp-100h] BYREF
_BYTE v27[103]; // [rsp+F0h] [rbp-E8h] BYREF
char v28; // [rsp+157h] [rbp-81h]
_QWORD v29[6]; // [rsp+158h] [rbp-80h] BYREF
_BYTE v30[8]; // [rsp+18Ch] [rbp-4Ch] BYREF
unsigned int v31; // [rsp+194h] [rbp-44h]
unsigned int v32; // [rsp+198h] [rbp-40h]
int v33; // [rsp+19Ch] [rbp-3Ch] BYREF
int v34; // [rsp+1A0h] [rbp-38h]
long long v35; // [rsp+1B0h] [rbp-28h]
long long v36; // [rsp+1B8h] [rbp-20h]
cv::Mat *v37; // [rsp+1C0h] [rbp-18h]
long long v38; // [rsp+1C8h] [rbp-10h]
DepthUtils *v39; // [rsp+1D0h] [rbp-8h]
v39 = a1;
v38 = a2;
v37 = a3;
v36 = a4;
v35 = a5;
if ( (cv::Mat::empty(a3) & 1) != 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Input image is empty.");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
cv::Size_<int>::Size_(&v33, a2 + 28);
if ( (*(_BYTE *)(a2 + 24) & 1) != 0 )
{
v32 = DepthUtils::round_to_multiple((DepthUtils *)*((unsigned int *)v37 + 3), 32, v7);
v31 = DepthUtils::round_to_multiple((DepthUtils *)*((unsigned int *)v37 + 2), 32, v8);
cv::Size_<int>::Size_(v30, v32, v31);
cv::Size_<int>::operator=(&v33, v30);
v29[0] = 1LL;
v29[1] = 3LL;
v29[2] = v34;
v29[3] = v33;
v29[4] = v29;
v29[5] = 4LL;
std::vector<long>::operator=(v35, v29, 4LL);
}
v28 = 0;
DepthUtils::resize_no_padding(a1, v37, v33, v34);
cv::Mat::Mat((cv::Mat *)v27);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v26, (cv::Mat *)v27);
__asm
{
vmovsd xmm0, cs:qword_2F008
vpxor xmm1, xmm1, xmm1
}
cv::Mat::convertTo(a1, (const cv::_OutputArray *)v26, 21, *(double *)&_XMM0, *(double *)&_XMM1);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v26);
for ( i = 0; i < 3; ++i )
{
v23 = i;
v24 = a2;
cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessSingle(cv::Mat const&,std::vector<float> &,std::vector&<long,std::allocator<long>>)::$_0>(
v27,
&v23);
}
std::vector<cv::Mat>::vector(v22);
cv::_InputArray::_InputArray((cv::_InputArray *)v21, (const cv::Mat *)v27);
cv::_OutputArray::_OutputArray(v20, v22);
cv::split((cv *)v21, (const cv::_InputArray *)v20, v11);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v20);
cv::_InputArray::~_InputArray((cv::_InputArray *)v21);
v19[1] = v22;
v19[0] = std::vector<cv::Mat>::begin(v22);
v18 = std::vector<cv::Mat>::end(v22);
while ( (__gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(v19, &v18) & 1) != 0 )
{
v17 = __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(v19);
v13 = v36;
v15 = std::vector<float>::end();
__gnu_cxx::__normal_iterator<float const*,std::vector<float>>::__normal_iterator<float *>(&v16, &v15);
std::vector<float>::insert<float *,void>(v13, v16, *(_QWORD *)(v17 + 24), *(_QWORD *)(v17 + 32));
__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(v19);
}
v28 = 1;
std::vector<cv::Mat>::~vector(v22);
cv::Mat::~Mat((cv::Mat *)v27);
if ( (v28 & 1) == 0 )
cv::Mat::~Mat(a1);
return a1;
}
| preprocessSingle:
SUB RSP,0x1d8
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x1d0],RDI
MOV qword ptr [RSP + 0x1c8],RSI
MOV qword ptr [RSP + 0x1c0],RDX
MOV qword ptr [RSP + 0x1b8],RCX
MOV qword ptr [RSP + 0x1b0],R8
MOV RAX,qword ptr [RSP + 0x1c8]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x1c0]
CALL 0x0011a260
TEST AL,0x1
JNZ 0x0011b42c
JMP 0x0011b48a
LAB_0011b42c:
MOV EDI,0x10
CALL 0x0011a230
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
LAB_0011b441:
LEA RSI,[0x12f0e5]
CALL 0x0011a060
LAB_0011b44d:
JMP 0x0011b44f
LAB_0011b44f:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [0x00139fb8]
MOV RDX,qword ptr [0x00139ff8]
CALL 0x0011a3b0
LAB_0011b48a:
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x1c
LEA RDI,[RSP + 0x19c]
CALL 0x00120db0
MOV RAX,qword ptr [RSP + 0x38]
TEST byte ptr [RAX + 0x18],0x1
JZ 0x0011b588
MOV RAX,qword ptr [RSP + 0x1c0]
MOV EDI,dword ptr [RAX + 0xc]
MOV ESI,0x20
CALL 0x00120de0
MOV dword ptr [RSP + 0x198],EAX
MOV RAX,qword ptr [RSP + 0x1c0]
MOV EDI,dword ptr [RAX + 0x8]
MOV ESI,0x20
CALL 0x00120de0
MOV dword ptr [RSP + 0x194],EAX
MOV ESI,dword ptr [RSP + 0x198]
MOV EDX,dword ptr [RSP + 0x194]
LEA RDI,[RSP + 0x18c]
CALL 0x00120b40
LEA RDI,[RSP + 0x19c]
LEA RSI,[RSP + 0x18c]
CALL 0x00120b60
MOV qword ptr [RSP + 0x158],0x1
MOV qword ptr [RSP + 0x160],0x3
MOVSXD RAX,dword ptr [RSP + 0x1a0]
MOV qword ptr [RSP + 0x168],RAX
MOVSXD RAX,dword ptr [RSP + 0x19c]
MOV qword ptr [RSP + 0x170],RAX
LEA RAX,[RSP + 0x158]
MOV qword ptr [RSP + 0x178],RAX
MOV qword ptr [RSP + 0x180],0x4
MOV RDI,qword ptr [RSP + 0x1b0]
MOV RSI,qword ptr [RSP + 0x178]
MOV RDX,qword ptr [RSP + 0x180]
CALL 0x00120e00
LAB_0011b588:
MOV RDI,qword ptr [RSP + 0x28]
MOV byte ptr [RSP + 0x157],0x0
MOV RSI,qword ptr [RSP + 0x1c0]
MOV EDX,dword ptr [RSP + 0x19c]
MOV ECX,dword ptr [RSP + 0x1a0]
CALL 0x00120e60
LEA RDI,[RSP + 0xf0]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0011a070
MOV RSI,qword ptr [RSP + 0x18]
LAB_0011b5c7:
LEA RDI,[RSP + 0xd8]
CALL 0x00120f70
JMP 0x0011b5d6
LAB_0011b5d6:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0xd8]
MOV EDX,0x15
VMOVSD XMM0,qword ptr [0x0012f008]
VPXOR XMM1,XMM1,XMM1
CALL 0x0011a5d0
JMP 0x0011b5fb
LAB_0011b5fb:
LEA RDI,[RSP + 0xd8]
CALL 0x00120fd0
MOV dword ptr [RSP + 0xd4],0x0
LAB_0011b613:
CMP dword ptr [RSP + 0xd4],0x3
JGE 0x0011b6a7
MOV RAX,qword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0xd4]
MOV dword ptr [RSP + 0xc0],ECX
MOV qword ptr [RSP + 0xc8],RAX
LAB_0011b63c:
LEA RDI,[RSP + 0xf0]
LEA RSI,[RSP + 0xc0]
CALL 0x0011b890
JMP 0x0011b653
LAB_0011b653:
JMP 0x0011b655
LAB_0011b655:
MOV EAX,dword ptr [RSP + 0xd4]
ADD EAX,0x1
MOV dword ptr [RSP + 0xd4],EAX
JMP 0x0011b613
LAB_0011b6a7:
LEA RDI,[RSP + 0xa8]
CALL 0x00120fe0
LAB_0011b6b4:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0xf0]
CALL 0x00120ff0
JMP 0x0011b6cb
LAB_0011b6cb:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0xa8]
CALL 0x00121030
JMP 0x0011b6df
LAB_0011b6df:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x78]
CALL 0x0011a4f0
JMP 0x0011b6f3
LAB_0011b6f3:
LEA RDI,[RSP + 0x78]
CALL 0x00120fd0
LEA RDI,[RSP + 0x90]
CALL 0x00121070
LEA RAX,[RSP + 0xa8]
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00121080
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x001210b0
MOV qword ptr [RSP + 0x60],RAX
LAB_0011b735:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x60]
CALL 0x001210e0
TEST AL,0x1
JNZ 0x0011b74d
JMP 0x0011b817
LAB_0011b74d:
LEA RDI,[RSP + 0x68]
CALL 0x00121120
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x1b8]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001211e0
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x48]
CALL 0x00121210
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RSP + 0x50]
LAB_0011b799:
CALL 0x00121130
LAB_0011b79e:
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011b7a5
LAB_0011b7a5:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
LEA RDI,[RSP + 0x68]
CALL 0x00121250
JMP 0x0011b735
LAB_0011b817:
MOV byte ptr [RSP + 0x157],0x1
LEA RDI,[RSP + 0xa8]
CALL 0x00121270
LEA RDI,[RSP + 0xf0]
CALL 0x0011a090
TEST byte ptr [RSP + 0x157],0x1
JNZ 0x0011b875
JMP 0x0011b86b
LAB_0011b86b:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0011a090
LAB_0011b875:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x1d8
RET
|
/* DepthAnything::preprocessSingle(cv::Mat const&, std::vector<float, std::allocator<float> >&,
std::vector<long, std::allocator<long> >&) */
Mat * DepthAnything::preprocessSingle(Mat *param_1,vector *param_2,vector *param_3)
{
vector<float,std::allocator<float>> *pvVar1;
bool bVar2;
ulong uVar3;
runtime_error *this;
vector<float,std::allocator<float>> *in_RCX;
vector<long,std::allocator<long>> *in_R8;
int8 local_190;
int8 local_188;
long local_180;
int8 local_178;
int8 local_170;
vector<cv::Mat,std::allocator<cv::Mat>> *local_168;
_OutputArray local_160 [24];
_InputArray local_148 [24];
vector<cv::Mat,std::allocator<cv::Mat>> local_130 [24];
int local_118 [2];
vector *local_110;
int local_104;
_OutputArray local_100 [24];
Mat local_e8 [103];
byte local_81;
int8 local_80;
int8 local_78;
long local_70;
long local_68;
int8 *local_60;
int8 local_58;
Size_<int> local_4c [8];
int local_44;
int local_40;
int local_3c;
int local_38;
vector<long,std::allocator<long>> *local_28;
vector<float,std::allocator<float>> *local_20;
vector *local_18;
vector *local_10;
Mat *local_8;
local_28 = in_R8;
local_20 = in_RCX;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar3 = cv::Mat::empty();
if ((uVar3 & 1) == 0) {
cv::Size_<int>::Size_((Size_<int> *)&local_3c,(Size_ *)(param_2 + 0x1c));
if (((byte)param_2[0x18] & 1) != 0) {
local_40 = DepthUtils::round_to_multiple(*(int *)(local_18 + 0xc),0x20);
local_44 = DepthUtils::round_to_multiple(*(int *)(local_18 + 8),0x20);
cv::Size_<int>::Size_(local_4c,local_40,local_44);
cv::Size_<int>::operator=((Size_<int> *)&local_3c,(Size_ *)local_4c);
local_80 = 1;
local_78 = 3;
local_70 = (long)local_38;
local_68 = (long)local_3c;
local_60 = &local_80;
local_58 = 4;
std::vector<long,std::allocator<long>>::operator=(local_28,local_60,4);
}
local_81 = 0;
DepthUtils::resize_no_padding((DepthUtils *)param_1,(Mat *)local_18,local_3c,local_38);
cv::Mat::Mat(local_e8);
/* try { // try from 0011b5c7 to 0011b5d3 has its CatchHandler @ 0011b668 */
cv::_OutputArray::_OutputArray(local_100,local_e8);
/* try { // try from 0011b5d6 to 0011b5f8 has its CatchHandler @ 0011b681 */
cv::Mat::convertTo((_OutputArray *)param_1,(int)local_100,DAT_0012f008,0.0);
cv::_OutputArray::~_OutputArray(local_100);
for (local_104 = 0; local_104 < 3; local_104 = local_104 + 1) {
local_118[0] = local_104;
/* try { // try from 0011b63c to 0011b650 has its CatchHandler @ 0011b668 */
local_110 = param_2;
cv::Mat::
forEach<cv::Vec<float,3>,DepthAnything::preprocessSingle(cv::Mat_const&,std::vector<float,std::allocator<float>>&,std::vector<long,std::allocator<long>>&)::__0>
(local_e8,(__0 *)local_118);
}
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector(local_130);
/* try { // try from 0011b6b4 to 0011b6c8 has its CatchHandler @ 0011b7be */
cv::_InputArray::_InputArray(local_148,local_e8);
/* try { // try from 0011b6cb to 0011b6dc has its CatchHandler @ 0011b7d4 */
cv::_OutputArray::_OutputArray(local_160,(vector *)local_130);
/* try { // try from 0011b6df to 0011b6f0 has its CatchHandler @ 0011b7ea */
cv::split(local_148,local_160);
cv::_OutputArray::~_OutputArray(local_160);
cv::_InputArray::~_InputArray(local_148);
local_168 = local_130;
local_170 = std::vector<cv::Mat,std::allocator<cv::Mat>>::begin(local_168);
local_178 = std::vector<cv::Mat,std::allocator<cv::Mat>>::end(local_168);
while( true ) {
bVar2 = __gnu_cxx::operator!=((__normal_iterator *)&local_170,(__normal_iterator *)&local_178)
;
if (!bVar2) break;
local_180 = __gnu_cxx::
__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator*((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
*)&local_170);
pvVar1 = local_20;
local_190 = std::vector<float,std::allocator<float>>::end(local_20);
__gnu_cxx::__normal_iterator<float_const*,std::vector<float,std::allocator<float>>>::
__normal_iterator<float*>
((__normal_iterator<float_const*,std::vector<float,std::allocator<float>>> *)
&local_188,(__normal_iterator *)&local_190);
/* try { // try from 0011b799 to 0011b79d has its CatchHandler @ 0011b7be */
std::vector<float,std::allocator<float>>::insert<float*,void>
(pvVar1,local_188,*(int8 *)(local_180 + 0x18),
*(int8 *)(local_180 + 0x20));
__gnu_cxx::__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator++((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>> *)
&local_170);
}
local_81 = 1;
std::vector<cv::Mat,std::allocator<cv::Mat>>::~vector(local_130);
cv::Mat::~Mat(local_e8);
if ((local_81 & 1) == 0) {
cv::Mat::~Mat(param_1);
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0011b441 to 0011b44c has its CatchHandler @ 0011b467 */
std::runtime_error::runtime_error(this,"Input image is empty.");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00139fb8,PTR__runtime_error_00139ff8);
}
| |
31,265 | unlink_deleted_block | eloqsql/storage/myisam/mi_dynrec.c | static my_bool unlink_deleted_block(MI_INFO *info, MI_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MI_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_mi_get_block_info(&tmp,info->dfile,block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(mi_rrnd() or mi_scan(), then ensure that we skip over this block
when doing next mi_rrnd() or mi_scan().
*/
if (info->nextpos == block_info->filepos)
info->nextpos+=block_info->block_len;
DBUG_RETURN(0);
} | O3 | c | unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rsi), %rcx
movq (%rdi), %rax
cmpq 0x58(%rax), %rcx
jne 0x7972f
movq 0x40(%r14), %rcx
movq %rcx, 0x58(%rax)
movq 0x8(%rbx), %rax
decq 0x8(%rax)
movq 0x28(%r14), %rax
movq 0x8(%rbx), %rcx
subq %rax, 0x10(%rcx)
movq (%rbx), %rax
decq 0x50(%rax)
movq 0x178(%rbx), %rax
cmpq 0x38(%r14), %rax
jne 0x7972b
addq 0x28(%r14), %rax
movq %rax, 0x178(%rbx)
xorl %eax, %eax
jmp 0x79781
leaq -0x70(%rbp), %rdi
movl $0x0, 0x50(%rdi)
movl 0x1c0(%rbx), %esi
movq 0x48(%r14), %rdx
callq 0x792ef
testb $0x4, %al
je 0x7977f
movq 0x40(%r14), %rax
leaq -0x6c(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x48(%r14), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
je 0x79799
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x797f1
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rdx
cmpq $-0x1, %rdx
je 0x796f8
movl 0x1c0(%rbx), %esi
leaq -0x70(%rbp), %rdi
callq 0x792ef
testb $0x4, %al
je 0x7977f
movq 0x48(%r14), %rax
leaq -0x64(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x40(%r14), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x2e8(%rax)
testq %rax, %rax
jne 0x7977f
jmp 0x796f8
callq 0x29270
| unlink_deleted_block_0:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rcx, [rsi+38h]
mov rax, [rdi]
cmp rcx, [rax+58h]
jnz short loc_7972F
mov rcx, [r14+40h]
mov [rax+58h], rcx
loc_796F8:
mov rax, [rbx+8]
dec qword ptr [rax+8]
mov rax, [r14+28h]
mov rcx, [rbx+8]
sub [rcx+10h], rax
mov rax, [rbx]
dec qword ptr [rax+50h]
mov rax, [rbx+178h]
cmp rax, [r14+38h]
jnz short loc_7972B
add rax, [r14+28h]
mov [rbx+178h], rax
loc_7972B:
xor eax, eax
jmp short loc_79781
loc_7972F:
lea rdi, [rbp+var_70]
mov dword ptr [rdi+50h], 0
mov esi, [rbx+1C0h]
mov rdx, [r14+48h]
call _mi_get_block_info
test al, 4
jz short loc_7977F
mov rax, [r14+40h]
lea rsi, [rbp+var_6C]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jz short loc_79799
loc_7977F:
mov al, 1
loc_79781:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_797F1
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_79799:
mov rdx, [r14+40h]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_796F8
mov esi, [rbx+1C0h]
lea rdi, [rbp+var_70]
call _mi_get_block_info
test al, 4
jz short loc_7977F
mov rax, [r14+48h]
lea rsi, [rbp+var_64]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+2E8h]
test rax, rax
jnz short loc_7977F
jmp loc_796F8
loc_797F1:
call ___stack_chk_fail
| char unlink_deleted_block_0(_QWORD *a1, _QWORD *a2)
{
long long v2; // rax
long long v4; // rdx
_BYTE v5[4]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v6; // [rsp+4h] [rbp-6Ch] BYREF
unsigned long long v7[8]; // [rsp+Ch] [rbp-64h] BYREF
int v8; // [rsp+50h] [rbp-20h]
unsigned long long v9; // [rsp+58h] [rbp-18h]
v9 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 88LL) )
{
*(_QWORD *)(*a1 + 88LL) = a2[8];
}
else
{
v8 = 0;
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), a2[9]) & 4) == 0 )
return 1;
v6 = _byteswap_uint64(a2[8]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
&v6,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
v4 = a2[8];
if ( v4 != -1 )
{
if ( (mi_get_block_info((long long)v5, *((unsigned int *)a1 + 112), v4) & 4) == 0 )
return 1;
v7[0] = _byteswap_uint64(a2[9]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 744LL))(
a1,
v7,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 80LL);
v2 = a1[47];
if ( v2 == a2[7] )
a1[47] = a2[5] + v2;
return 0;
}
| unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RDI]
CMP RCX,qword ptr [RAX + 0x58]
JNZ 0x0017972f
MOV RCX,qword ptr [R14 + 0x40]
MOV qword ptr [RAX + 0x58],RCX
LAB_001796f8:
MOV RAX,qword ptr [RBX + 0x8]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x28]
MOV RCX,qword ptr [RBX + 0x8]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBX]
DEC qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBX + 0x178]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x0017972b
ADD RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RBX + 0x178],RAX
LAB_0017972b:
XOR EAX,EAX
JMP 0x00179781
LAB_0017972f:
LEA RDI,[RBP + -0x70]
MOV dword ptr [RDI + 0x50],0x0
MOV ESI,dword ptr [RBX + 0x1c0]
MOV RDX,qword ptr [R14 + 0x48]
CALL 0x001792ef
TEST AL,0x4
JZ 0x0017977f
MOV RAX,qword ptr [R14 + 0x40]
LEA RSI,[RBP + -0x6c]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JZ 0x00179799
LAB_0017977f:
MOV AL,0x1
LAB_00179781:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x001797f1
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_00179799:
MOV RDX,qword ptr [R14 + 0x40]
CMP RDX,-0x1
JZ 0x001796f8
MOV ESI,dword ptr [RBX + 0x1c0]
LEA RDI,[RBP + -0x70]
CALL 0x001792ef
TEST AL,0x4
JZ 0x0017977f
MOV RAX,qword ptr [R14 + 0x48]
LEA RSI,[RBP + -0x64]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JNZ 0x0017977f
JMP 0x001796f8
LAB_001797f1:
CALL 0x00129270
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
ulong uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int1 local_78 [4];
ulong local_74;
ulong local_6c [8];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 0x58)) {
*(int8 *)(*param_1 + 0x58) = *(int8 *)(param_2 + 0x40);
goto LAB_001796f8;
}
local_28 = 0;
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38],*(int8 *)(param_2 + 0x48));
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x40);
local_74 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18
| (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 |
(uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_74,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar2 == 0) {
if (*(long *)(param_2 + 0x40) == -1) {
LAB_001796f8:
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + -1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + -1;
if (param_1[0x2f] == *(long *)(param_2 + 0x38)) {
param_1[0x2f] = param_1[0x2f] + *(long *)(param_2 + 0x28);
}
uVar3 = 0;
goto LAB_00179781;
}
uVar1 = _mi_get_block_info(local_78,(int)param_1[0x38]);
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x48);
local_6c[0] = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x2e8))
(param_1,local_6c,8,*(long *)(param_2 + 0x40) + 0xc,4);
if (lVar2 == 0) goto LAB_001796f8;
}
}
}
uVar3 = 1;
LAB_00179781:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
| |
31,266 | ftxui::flex_grow(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/flex.cpp | Element flex_grow(Element child) {
return std::make_shared<Flex>(function_flex_grow, std::move(child));
} | O2 | cpp | ftxui::flex_grow(std::shared_ptr<ftxui::Node>):
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2b(%rip), %rsi # 0x1e802
movq %rsp, %rdi
callq 0x1e621
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x13452
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5ftxui9flex_growESt10shared_ptrINS_4NodeEE:
push rbx
sub rsp, 10h
mov rdx, rsi
mov rbx, rdi
lea rsi, _ZN5ftxui12_GLOBAL__N_118function_flex_growERNS_11RequirementE; ftxui::`anonymous namespace'::function_flex_grow(ftxui::Requirement &)
mov rdi, rsp
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_14FlexEJRFvRNS0_11RequirementEESt10shared_ptrINS0_4NodeEEEES7_IT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node> &&)
lea rdi, [rsp+18h+var_10]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _OWORD * ftxui::flex_grow(_OWORD *a1, __int128 *a2)
{
__int128 v2; // xmm0
__int128 v4; // [rsp+0h] [rbp-18h] BYREF
std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(
&v4,
(long long)ftxui::`anonymous namespace'::function_flex_grow,
a2);
v2 = v4;
*((_QWORD *)&v4 + 1) = 0LL;
*a1 = v2;
*(_QWORD *)&v4 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v4 + 1);
return a1;
}
| flex_grow:
PUSH RBX
SUB RSP,0x10
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[0x11e802]
MOV RDI,RSP
CALL 0x0011e621
LEA RDI,[RSP + 0x8]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* ftxui::flex_grow(std::shared_ptr<ftxui::Node>) */
int8 * ftxui::flex_grow(int8 *param_1)
{
int8 uVar1;
int8 local_18;
int8 uStack_10;
std::
make_shared<ftxui::(anonymous_namespace)::Flex,void(&)(ftxui::Requirement&),std::shared_ptr<ftxui::Node>>
((_func_void_Requirement_ptr *)&local_18,
(shared_ptr *)(anonymous_namespace)::function_flex_grow);
uVar1 = uStack_10;
uStack_10 = 0;
*param_1 = local_18;
param_1[1] = uVar1;
local_18 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_10);
return param_1;
}
| |
31,267 | my_utf16_uni | eloqsql/strings/ctype-ucs2.c | int
my_utf16_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
return my_mb_wc_utf16_quick(pwc, s, e);
} | O3 | c | my_utf16_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x4f398
movzbl (%rdx), %edi
movl %edi, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
cmpl $0xdc, %r9d
je 0x4f398
cmpl $0xd8, %r9d
jne 0x4f385
leaq 0x4(%rdx), %r9
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %r9
ja 0x4f398
movzbl (%r8), %ecx
movl %ecx, %r8d
andl $-0x4, %r8d
movl $0x0, %eax
cmpl $0xdc, %r8d
jne 0x4f398
shll $0x12, %edi
shll $0x8, %ecx
orl %edi, %ecx
movzbl 0x1(%rdx), %eax
shll $0xa, %eax
movzbl 0x3(%rdx), %edx
andl $0xc0300, %ecx # imm = 0xC0300
orl %edx, %ecx
addl %eax, %ecx
addl $0x10000, %ecx # imm = 0x10000
movl $0x4, %eax
jmp 0x4f393
shll $0x8, %edi
movzbl 0x1(%rdx), %ecx
orl %edi, %ecx
movl $0x2, %eax
movl %ecx, %ecx
movq %rcx, (%rsi)
popq %rbp
retq
| my_utf16_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja loc_4F398
movzx edi, byte ptr [rdx]
mov r9d, edi
and r9d, 0FFFFFFFCh
xor eax, eax
cmp r9d, 0DCh
jz short loc_4F398
cmp r9d, 0D8h
jnz short loc_4F385
lea r9, [rdx+4]
mov eax, 0FFFFFF98h
cmp r9, rcx
ja short loc_4F398
movzx ecx, byte ptr [r8]
mov r8d, ecx
and r8d, 0FFFFFFFCh
mov eax, 0
cmp r8d, 0DCh
jnz short loc_4F398
shl edi, 12h
shl ecx, 8
or ecx, edi
movzx eax, byte ptr [rdx+1]
shl eax, 0Ah
movzx edx, byte ptr [rdx+3]
and ecx, 0C0300h
or ecx, edx
add ecx, eax
add ecx, 10000h
mov eax, 4
jmp short loc_4F393
loc_4F385:
shl edi, 8
movzx ecx, byte ptr [rdx+1]
or ecx, edi
mov eax, 2
loc_4F393:
mov ecx, ecx
mov [rsi], rcx
loc_4F398:
pop rbp
retn
| long long my_utf16_uni(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
_BYTE *v4; // r8
long long result; // rax
int v6; // edi
int v7; // r9d
unsigned int v8; // ecx
v4 = a3 + 2;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = *a3;
v7 = v6 & 0xFC;
result = 0LL;
if ( v7 != 220 )
{
if ( v7 != 216 )
{
v8 = (v6 << 8) | a3[1];
result = 2LL;
goto LABEL_8;
}
result = 4294967192LL;
if ( (unsigned long long)(a3 + 4) <= a4 )
{
result = 0LL;
if ( (*v4 & 0xFC) == 0xDC )
{
v8 = (a3[1] << 10) + (a3[3] | ((v6 << 18) | ((unsigned __int8)*v4 << 8)) & 0xC0300) + 0x10000;
result = 4LL;
LABEL_8:
*a2 = v8;
}
}
}
}
return result;
}
| my_utf16_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0014f398
MOVZX EDI,byte ptr [RDX]
MOV R9D,EDI
AND R9D,0xfffffffc
XOR EAX,EAX
CMP R9D,0xdc
JZ 0x0014f398
CMP R9D,0xd8
JNZ 0x0014f385
LEA R9,[RDX + 0x4]
MOV EAX,0xffffff98
CMP R9,RCX
JA 0x0014f398
MOVZX ECX,byte ptr [R8]
MOV R8D,ECX
AND R8D,0xfffffffc
MOV EAX,0x0
CMP R8D,0xdc
JNZ 0x0014f398
SHL EDI,0x12
SHL ECX,0x8
OR ECX,EDI
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EAX,0xa
MOVZX EDX,byte ptr [RDX + 0x3]
AND ECX,0xc0300
OR ECX,EDX
ADD ECX,EAX
ADD ECX,0x10000
MOV EAX,0x4
JMP 0x0014f393
LAB_0014f385:
SHL EDI,0x8
MOVZX ECX,byte ptr [RDX + 0x1]
OR ECX,EDI
MOV EAX,0x2
LAB_0014f393:
MOV ECX,ECX
MOV qword ptr [RSI],RCX
LAB_0014f398:
POP RBP
RET
|
int8 my_utf16_uni(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
uVar3 = 0xffffff9a;
if (param_3 + 2 <= param_4) {
bVar1 = *param_3;
uVar3 = 0;
if ((bVar1 & 0xfc) != 0xdc) {
if ((bVar1 & 0xfc) == 0xd8) {
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
bVar2 = param_3[2];
if ((bVar2 & 0xfc) != 0xdc) {
return 0;
}
uVar4 = (((uint)bVar2 << 8 | (uint)bVar1 << 0x12) & 0xc0300 | (uint)param_3[3]) +
(uint)param_3[1] * 0x400 + 0x10000;
uVar3 = 4;
}
else {
uVar4 = (uint)CONCAT11(bVar1,param_3[1]);
uVar3 = 2;
}
*param_2 = (ulong)uVar4;
}
}
return uVar3;
}
| |
31,268 | inline_mysql_file_sync | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_sync(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File fd, myf flags)
{
int result= 0;
#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, fd, PSI_FILE_SYNC);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_sync(fd, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_sync(fd, flags);
return result;
} | O0 | c | inline_mysql_file_sync:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x212881(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x10, %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 0xada45
leaq 0x21283e(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5ac0
movl %eax, -0x24(%rbp)
leaq 0x21280f(%rip), %rax # 0x2c0238
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xada5a
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xf5ac0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_sync_5:
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
mov [rbp+var_24], 0
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 10h
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_ADA45
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_30]
xor ecx, ecx
mov esi, ecx
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_ADA5A
loc_ADA45:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_ADA5A:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_sync_5(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;
v7 = 0;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 16LL);
if ( v6 )
{
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v6, 0LL, v11, v10);
v7 = my_sync(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[67])(v6, 0LL);
}
else
{
return (unsigned int)my_sync(v9, v8);
}
return v7;
}
| inline_mysql_file_sync:
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
MOV dword ptr [RBP + -0x24],0x0
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x10
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 0x001ada45
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR ESI,ESI
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5ac0
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3c0238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x30]
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001ada5a
LAB_001ada45:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001f5ac0
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_001ada5a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_sync(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_2c = 0;
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,0x10);
if (local_38 == 0) {
local_c = my_sync(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x210))(local_38,0,local_18,local_1c);
local_2c = my_sync(local_20,local_28);
(**(code **)(PSI_server + 0x218))(local_38,0);
local_c = local_2c;
}
return local_c;
}
| |
31,269 | inline_mysql_file_sync | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_sync(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File fd, myf flags)
{
int result= 0;
#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, fd, PSI_FILE_SYNC);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_sync(fd, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_sync(fd, flags);
return result;
} | O3 | c | inline_mysql_file_sync:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %r12d
leaq 0x3469fe(%rip), %r13 # 0x386010
movq (%r13), %rax
leaq -0x70(%rbp), %rdi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x3f648
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa1444
movl %eax, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rax
leaq 0x9ad74(%rip), %rdx # 0xda3ca
movq %r15, %rdi
xorl %esi, %esi
movl %r12d, %ecx
callq *0x210(%rax)
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa1444
movl %eax, %ebx
movq (%r13), %rax
movq %r15, %rdi
xorl %esi, %esi
callq *0x218(%rax)
jmp 0x3f637
| inline_mysql_file_sync:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdx
mov r14d, esi
mov r12d, edi
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_70]
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz short loc_3F648
mov edi, r14d
mov rsi, rbx
call my_sync
mov ebx, eax
loc_3F637:
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F648:
mov r15, rax
mov rax, [r13+0]
lea rdx, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
xor esi, esi
mov ecx, r12d
call qword ptr [rax+210h]
mov edi, r14d
mov rsi, rbx
call my_sync
mov ebx, eax
mov rax, [r13+0]
mov rdi, r15
xor esi, esi
call qword ptr [rax+218h]
jmp short loc_3F637
| long long inline_mysql_file_sync(unsigned int a1, long long a2, long long a3)
{
long long v4; // rax
unsigned int v5; // ebx
long long v7; // r15
_BYTE v8[112]; // [rsp+0h] [rbp-70h] BYREF
v4 = ((long long ( *)(_BYTE *, long long, long long))PSI_server[43])(v8, a2, 16LL);
if ( v4 )
{
v7 = v4;
((void ( *)(long long, _QWORD, const char *, _QWORD))PSI_server[66])(
v4,
0LL,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c",
a1);
v5 = my_sync((unsigned int)a2, a3);
((void ( *)(long long, _QWORD))PSI_server[67])(v7, 0LL);
}
else
{
return (unsigned int)my_sync((unsigned int)a2, a3);
}
return v5;
}
| inline_mysql_file_sync:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDX
MOV R14D,ESI
MOV R12D,EDI
LEA R13,[0x486010]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x70]
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0013f648
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a1444
MOV EBX,EAX
LAB_0013f637:
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f648:
MOV R15,RAX
MOV RAX,qword ptr [R13]
LEA RDX,[0x1da3ca]
MOV RDI,R15
XOR ESI,ESI
MOV ECX,R12D
CALL qword ptr [RAX + 0x210]
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a1444
MOV EBX,EAX
MOV RAX,qword ptr [R13]
MOV RDI,R15
XOR ESI,ESI
CALL qword ptr [RAX + 0x218]
JMP 0x0013f637
|
int4 inline_mysql_file_sync(int4 param_1,ulong param_2,int8 param_3)
{
int4 uVar1;
long lVar2;
int1 local_78 [72];
lVar2 = (**(code **)(PSI_server + 0x158))(local_78,param_2,0x10);
if (lVar2 == 0) {
uVar1 = my_sync(param_2 & 0xffffffff,param_3);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar2,0,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c",param_1);
uVar1 = my_sync(param_2 & 0xffffffff,param_3);
(**(code **)(PSI_server + 0x218))(lVar2,0);
}
return uVar1;
}
| |
31,270 | minja::FilterNode::do_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 do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filter_value.is_callable()) {
throw std::runtime_error("Filter must be a callable: " + filter_value.dump());
}
std::string rendered_body = body->render(context);
ArgumentsValue filter_args = {{Value(rendered_body)}, {}};
auto result = filter_value.call(context, filter_args);
out << result.to_str();
} | O2 | cpp | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x77971
movq %rdi, %r15
cmpq $0x0, 0x30(%rdi)
je 0x7798d
movq %rdx, %r14
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0x62de2
cmpq $0x0, 0x30(%r12)
je 0x779bd
movq 0x30(%r15), %rsi
leaq 0xa0(%rsp), %rdi
movq %r14, %rdx
callq 0x764bc
leaq 0x50(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x66050
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rsp, %rcx
callq 0x6d548
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movups %xmm0, 0x18(%r15)
andq $0x0, 0x28(%r15)
leaq 0x50(%rsp), %rdi
callq 0x63072
leaq 0x50(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x6d804
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
callq 0x7055c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x237f0
movq %rsp, %rdi
callq 0x24218
leaq 0x50(%rsp), %rdi
callq 0x63072
leaq 0x20(%rsp), %rdi
callq 0x6d8e8
leaq 0xa0(%rsp), %rdi
callq 0x24218
leaq 0xc0(%rsp), %rdi
callq 0x63072
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x3d5b5(%rip), %rsi # 0xb4f38
movq %rax, %rdi
callq 0x23330
jmp 0x779a7
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x3d5b3(%rip), %rsi # 0xb4f52
movq %rax, %rdi
callq 0x23330
movq 0x86642(%rip), %rsi # 0xfdff0
movq 0x865a3(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f40
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %r14
leaq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
callq 0x63260
leaq 0x3d584(%rip), %rsi # 0xb4f6a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2730b
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x23e70
xorl %ebp, %ebp
movq 0x865e2(%rip), %rsi # 0xfdff0
movq 0x86543(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f40
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x24218
jmp 0x77a32
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x24218
testb %bpl, %bpl
jne 0x77a46
jmp 0x77aa9
movq %rax, %rbx
movq %r14, %rdi
callq 0x236b0
jmp 0x77aa9
jmp 0x77a52
movq %rax, %rbx
movq %r14, %rdi
callq 0x236b0
jmp 0x77ab6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x24218
jmp 0x77a6f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x63072
jmp 0x77a7e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6d8e8
jmp 0x77a9c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x63072
jmp 0x77a9c
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x24218
leaq 0xc0(%rsp), %rdi
callq 0x63072
movq %rbx, %rdi
callq 0x23fd0
movq %rax, %rbx
jmp 0x77aa9
nop
| _ZNK5minja10FilterNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_77971
mov r15, rdi
cmp qword ptr [rdi+30h], 0
jz loc_7798D
mov r14, rdx
lea r12, [rsp+138h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_779BD
mov rsi, [r15+30h]
lea rdi, [rsp+138h+var_98]
mov rdx, r14
call _ZNK5minja12TemplateNode6renderB5cxx11ERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_98]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
lea rdi, [rsp+138h+var_118]
lea rsi, [rsp+138h+var_E8]
push 1
pop rdx
mov rcx, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<minja::Value>::vector(std::initializer_list<minja::Value>,std::allocator<minja::Value> const&)
xorps xmm0, xmm0
lea r15, [rsp+138h+var_118]
movups xmmword ptr [r15+18h], xmm0
and qword ptr [r15+28h], 0
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_78]
mov rdx, r14
mov rcx, r15
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rdi, rsp; this
lea rsi, [rsp+138h+var_E8]; minja::Value *
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
mov rsi, rsp
mov rdi, rbx
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
lea rdi, [rsp+138h+var_118]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
lea rdi, [rsp+138h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+138h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_77971:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeFilt; "FilterNode.filter is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_779A7
loc_7798D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeBody; "FilterNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_779A7:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_779BD:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rdi, [rsp+138h+var_118]
lea rsi, [rsp+138h+var_78]
push 0FFFFFFFFFFFFFFFFh
pop rdx
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aFilterMustBeAC; "Filter must be a callable: "
lea rdi, [rsp+138h+var_E8]
lea rdx, [rsp+138h+var_118]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+138h+var_E8]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, [rsp+138h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_77A32
mov rbx, rax
mov bpl, 1
loc_77A32:
lea rdi, [rsp+138h+var_118]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_77A46
jmp short loc_77AA9
mov rbx, rax
loc_77A46:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_77AA9
jmp short $+2
loc_77A52:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_77AB6
mov rbx, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_77A6F
mov rbx, rax
loc_77A6F:
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_77A7E
mov rbx, rax
loc_77A7E:
lea rdi, [rsp+138h+var_118]; this
call _ZN5minja14ArgumentsValueD2Ev; minja::ArgumentsValue::~ArgumentsValue()
jmp short loc_77A9C
mov rbx, rax
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_77A9C
mov rbx, rax
loc_77A9C:
lea rdi, [rsp+138h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_77AA9:
lea rdi, [rsp+138h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_77AB6:
mov rdi, rbx
call __Unwind_Resume
mov rbx, rax
jmp short loc_77AA9
| void minja::FilterNode::do_render(long long a1, long long a2)
{
void (***v3)(void); // rsi
std::runtime_error *exception; // r14
void *v5; // r14
_BYTE v6[32]; // [rsp+0h] [rbp-138h] BYREF
_BYTE v7[24]; // [rsp+20h] [rbp-118h] BYREF
__int128 v8; // [rsp+38h] [rbp-100h]
long long v9; // [rsp+48h] [rbp-F0h]
_BYTE v10[80]; // [rsp+50h] [rbp-E8h] BYREF
_BYTE v11[32]; // [rsp+A0h] [rbp-98h] BYREF
_BYTE v12[48]; // [rsp+C0h] [rbp-78h] BYREF
long long v13; // [rsp+F0h] [rbp-48h]
v3 = *(void (****)(void))(a1 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.filter is null");
goto LABEL_7;
}
if ( !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.body is null");
LABEL_7:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v12, v3);
if ( !v13 )
{
v5 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v7, (long long)v12, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Filter must be a callable: ", (long long)v7);
std::runtime_error::runtime_error(v5, v10);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::TemplateNode::render[abi:cxx11]((long long)v11, *(long long ( ****)(_QWORD))(a1 + 48));
minja::Value::Value((long long)v10, (long long)v11);
std::vector<minja::Value>::vector((long long)v7, (long long)v10, 1LL);
v8 = 0LL;
v9 = 0LL;
minja::Value::~Value((minja::Value *)v10);
minja::Value::call((long long)v10, (long long)v12);
minja::Value::to_str[abi:cxx11]((std::__cxx11 *)v6, (minja::Value *)v10, 0.0);
std::operator<<<char>(a2, v6);
std::string::~string(v6);
minja::Value::~Value((minja::Value *)v10);
minja::ArgumentsValue::~ArgumentsValue((minja::ArgumentsValue *)v7);
std::string::~string(v11);
minja::Value::~Value((minja::Value *)v12);
}
| do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x00177971
MOV R15,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x0017798d
MOV R14,RDX
LEA R12,[RSP + 0xc0]
MOV RDI,R12
CALL 0x00162de2
CMP qword ptr [R12 + 0x30],0x0
JZ 0x001779bd
MOV RSI,qword ptr [R15 + 0x30]
LAB_001778a8:
LEA RDI,[RSP + 0xa0]
MOV RDX,R14
CALL 0x001764bc
LAB_001778b8:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xa0]
CALL 0x00166050
LAB_001778ca:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x50]
PUSH 0x1
POP RDX
MOV RCX,RSP
CALL 0x0016d548
XORPS XMM0,XMM0
LEA R15,[RSP + 0x20]
MOVUPS xmmword ptr [R15 + 0x18],XMM0
AND qword ptr [R15 + 0x28],0x0
LEA RDI,[RSP + 0x50]
CALL 0x00163072
LAB_001778fb:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xc0]
MOV RDX,R14
MOV RCX,R15
CALL 0x0016d804
LAB_00177913:
MOV RDI,RSP
LEA RSI,[RSP + 0x50]
CALL 0x0017055c
LAB_00177920:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x001237f0
LAB_0017792b:
MOV RDI,RSP
CALL 0x00124218
LEA RDI,[RSP + 0x50]
CALL 0x00163072
LEA RDI,[RSP + 0x20]
CALL 0x0016d8e8
LEA RDI,[RSP + 0xa0]
CALL 0x00124218
LEA RDI,[RSP + 0xc0]
CALL 0x00163072
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00177971:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_0017797c:
LEA RSI,[0x1b4f38]
MOV RDI,RAX
CALL 0x00123330
LAB_0017798b:
JMP 0x001779a7
LAB_0017798d:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_00177998:
LEA RSI,[0x1b4f52]
MOV RDI,RAX
CALL 0x00123330
LAB_001779a7:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f40
LAB_001779bd:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV R14,RAX
LAB_001779c8:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0xc0]
PUSH -0x1
POP RDX
XOR ECX,ECX
CALL 0x00163260
LAB_001779df:
LEA RSI,[0x1b4f6a]
LEA RDI,[RSP + 0x50]
LEA RDX,[RSP + 0x20]
CALL 0x0012730b
MOV BPL,0x1
LAB_001779f8:
LEA RSI,[RSP + 0x50]
MOV RDI,R14
CALL 0x00123e70
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f40
|
/* minja::FilterNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::FilterNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
runtime_error *prVar1;
string asStack_138 [32];
vector<minja::Value,std::allocator<minja::Value>> local_118 [24];
int8 local_100;
int8 uStack_f8;
int8 local_f0;
Value local_e8 [80];
TemplateNode local_98 [32];
Expression local_78 [48];
long local_48;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017797c to 0017798a has its CatchHandler @ 00177a52 */
std::runtime_error::runtime_error(prVar1,"FilterNode.filter is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 001778a8 to 001778b7 has its CatchHandler @ 00177abe */
TemplateNode::render_abi_cxx11_(local_98,*(shared_ptr **)(param_1 + 0x30));
/* try { // try from 001778b8 to 001778c9 has its CatchHandler @ 00177a99 */
Value::Value(local_e8,(string *)local_98);
/* try { // try from 001778ca to 001778de has its CatchHandler @ 00177a8a */
std::vector<minja::Value,std::allocator<minja::Value>>::vector
(local_118,local_e8,1,asStack_138);
local_100 = 0;
uStack_f8 = 0;
local_f0 = 0;
Value::~Value(local_e8);
/* try { // try from 001778fb to 00177912 has its CatchHandler @ 00177a7b */
Value::call(local_e8,(ArgumentsValue *)local_78);
/* try { // try from 00177913 to 0017791f has its CatchHandler @ 00177a6c */
Value::to_str_abi_cxx11_();
/* try { // try from 00177920 to 0017792a has its CatchHandler @ 00177a5f */
std::operator<<((ostream *)param_2,asStack_138);
std::__cxx11::string::~string(asStack_138);
Value::~Value(local_e8);
ArgumentsValue::~ArgumentsValue((ArgumentsValue *)local_118);
std::__cxx11::string::~string((string *)local_98);
Value::~Value((Value *)local_78);
return;
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001779c8 to 001779de has its CatchHandler @ 00177a43 */
Value::dump_abi_cxx11_((int)local_118,SUB81(local_78,0));
/* try { // try from 001779df to 001779f4 has its CatchHandler @ 00177a2c */
std::operator+((char *)local_e8,(string *)"Filter must be a callable: ");
/* try { // try from 001779f8 to 00177a1c has its CatchHandler @ 00177a1d */
std::runtime_error::runtime_error(prVar1,(string *)local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00177998 to 001779a6 has its CatchHandler @ 00177a50 */
std::runtime_error::runtime_error(prVar1,"FilterNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
| |
31,271 | minja::FilterNode::do_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 do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!filter) throw std::runtime_error("FilterNode.filter is null");
if (!body) throw std::runtime_error("FilterNode.body is null");
auto filter_value = filter->evaluate(context);
if (!filter_value.is_callable()) {
throw std::runtime_error("Filter must be a callable: " + filter_value.dump());
}
std::string rendered_body = body->render(context);
ArgumentsValue filter_args = {{Value(rendered_body)}, {}};
auto result = filter_value.call(context, filter_args);
out << result.to_str();
} | O3 | cpp | minja::FilterNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0xa0b07
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xa0b25
movq %rdx, %r15
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
callq 0x8618e
cmpq $0x0, 0x30(%r12)
je 0xa0b57
movq 0x30(%r14), %rsi
leaq 0xa0(%rsp), %rdi
movq %r15, %rdx
callq 0x9ef94
leaq 0x50(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x8a4de
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movl $0x1, %edx
callq 0x936a6
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x58a58
movq %r14, %rdi
callq 0x5ded4
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0xa0918
callq 0x6d8f8
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0xa0927
callq 0x6d8f8
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xa0936
callq 0x6d8f8
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xa096c
movq 0x8b641(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0957
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0961
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa096c
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %r14
leaq 0x50(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq %rsp, %rcx
movq %r15, %rdx
callq 0x93a88
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x96d80
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x1aa20
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa09c5
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58a58
movq %rbx, %rdi
callq 0x5ded4
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa09ed
callq 0x6d8f8
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0xa09fc
callq 0x6d8f8
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0xa0a0b
callq 0x6d8f8
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xa0a41
movq 0x8b56c(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0a2c
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0a36
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa0a41
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0x94dd0
movq %rsp, %rdi
callq 0x8dc62
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0a72
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x100(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x58a58
movq %rbx, %rdi
callq 0x5ded4
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa0a9a
callq 0x6d8f8
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0aac
callq 0x6d8f8
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0abe
callq 0x6d8f8
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0xa0af7
movq 0x8b4b6(%rip), %rax # 0x12bf88
cmpb $0x0, (%rax)
je 0xa0ae2
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa0aec
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa0af7
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a460
movq %rax, %r14
leaq 0x5042d(%rip), %rsi # 0xf0f48
movq %rax, %rdi
callq 0x1a330
jmp 0xa0b41
movl $0x10, %edi
callq 0x1a460
movq %rax, %r14
leaq 0x50429(%rip), %rsi # 0xf0f62
movq %rax, %rdi
callq 0x1a330
movq 0x8b4a8(%rip), %rsi # 0x12bff0
movq 0x8b411(%rip), %rdx # 0x12bf60
movq %r14, %rdi
callq 0x1af40
movl $0x10, %edi
callq 0x1a460
movq %rax, %r14
movq %rsp, %rdi
leaq 0xc0(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x867a2
leaq 0x503f8(%rip), %rsi # 0xf0f7a
leaq 0x50(%rsp), %rdi
movq %rsp, %rdx
callq 0x78e69
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x1ae50
xorl %ebp, %ebp
movq 0x8b448(%rip), %rsi # 0x12bff0
movq 0x8b3b1(%rip), %rdx # 0x12bf60
movq %r14, %rdi
callq 0x1af40
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0bd5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0bf0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0xa0c1d
jmp 0xa0cb8
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0c1d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xa0c1d
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a690
jmp 0xa0cb8
jmp 0xa0c2c
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a690
jmp 0xa0cc5
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0c5f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xa0c5f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x86480
jmp 0xa0c6e
movq %rax, %rbx
movq %r14, %rdi
callq 0x94dd0
movq %rsp, %rdi
callq 0x8dc62
jmp 0xa0c92
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x86480
jmp 0xa0c92
movq %rax, %rbx
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0cb8
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xa0cb8
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x86480
movq %rbx, %rdi
callq 0x1afd0
nop
| _ZNK5minja10FilterNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_A0B07
mov r14, rdi
cmp qword ptr [rdi+30h], 0
jz loc_A0B25
mov r15, rdx
lea r12, [rsp+138h+var_78]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
cmp qword ptr [r12+30h], 0
jz loc_A0B57
mov rsi, [r14+30h]
lea rdi, [rsp+138h+var_98]
mov rdx, r15
call _ZNK5minja12TemplateNode6renderB5cxx11ERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_98]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, rsp
lea rsi, [rsp+138h+var_E8]
lea rcx, [rsp+138h+var_108]
mov edx, 1
call _ZNSt6vectorIN5minja5ValueESaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<minja::Value>::vector(std::initializer_list<minja::Value>,std::allocator<minja::Value> const&)
xorps xmm0, xmm0
movups [rsp+138h+var_120], xmm0
mov [rsp+138h+var_110], 0
lea r14, [rsp+138h+var_A8]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_A0918
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0918:
mov rdi, [rsp+138h+var_C0]
test rdi, rdi
jz short loc_A0927
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0927:
mov rdi, [rsp+138h+var_D0]
test rdi, rdi
jz short loc_A0936
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0936:
mov rdi, [rsp+138h+var_E0]
test rdi, rdi
jz short loc_A096C
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0957
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0961
loc_A0957:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0961:
cmp eax, 1
jnz short loc_A096C
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A096C:
lea r14, [rsp+138h+var_120]
lea rdi, [rsp+138h+var_E8]
lea rsi, [rsp+138h+var_78]
mov rcx, rsp
mov rdx, r15
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_E8]
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
mov rsi, [rsp+138h+var_108]
mov rdx, [rsp+138h+var_100]
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A09C5
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A09C5:
lea rbx, [rsp+138h+var_A8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_A09ED
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A09ED:
mov rdi, [rsp+138h+var_C0]
test rdi, rdi
jz short loc_A09FC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A09FC:
mov rdi, [rsp+138h+var_D0]
test rdi, rdi
jz short loc_A0A0B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0A0B:
mov rdi, [rsp+138h+var_E0]
test rdi, rdi
jz short loc_A0A41
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0A2C
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0A36
loc_A0A2C:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0A36:
cmp eax, 1
jnz short loc_A0A41
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A0A41:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0A72
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0A72:
lea rbx, [rsp+138h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_A0A9A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0A9A:
mov rdi, [rsp+138h+var_50]
test rdi, rdi
jz short loc_A0AAC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0AAC:
mov rdi, [rsp+138h+var_60]
test rdi, rdi
jz short loc_A0ABE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A0ABE:
mov rdi, [rsp+138h+var_70]
test rdi, rdi
jz short loc_A0AF7
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_A0AE2
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A0AEC
loc_A0AE2:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A0AEC:
cmp eax, 1
jnz short loc_A0AF7
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A0AF7:
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A0B07:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeFilt; "FilterNode.filter is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_A0B41
loc_A0B25:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFilternodeBody; "FilterNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_A0B41:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_A0B57:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
lea rsi, [rsp+138h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aFilterMustBeAC; "Filter must be a callable: "
lea rdi, [rsp+138h+var_E8]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+138h+var_E8]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rax, [rsp+138h+var_D8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0BD5
mov rsi, [rsp+138h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0BD5:
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0BF0
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0BF0:
test bpl, bpl
jnz short loc_A0C1D
jmp loc_A0CB8
mov rbx, rax
lea rax, [rsp+138h+var_128]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0C1D
mov rsi, [rsp+138h+var_128]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0C1D
mov rbx, rax
loc_A0C1D:
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_A0CB8
jmp short $+2
loc_A0C2C:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_A0CC5
mov rbx, rax
lea rax, [rsp+138h+var_F8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0C5F
mov rsi, [rsp+138h+var_F8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0C5F
mov rbx, rax
loc_A0C5F:
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_A0C6E
mov rbx, rax
loc_A0C6E:
mov rdi, r14
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rsp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_A0C92
mov rbx, rax
lea rdi, [rsp+138h+var_E8]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_A0C92
mov rbx, rax
loc_A0C92:
lea rax, [rsp+138h+var_88]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0CB8
mov rsi, [rsp+138h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A0CB8
mov rbx, rax
loc_A0CB8:
lea rdi, [rsp+138h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_A0CC5:
mov rdi, rbx
call __Unwind_Resume
| long long minja::FilterNode::do_render(long long a1, long long a2)
{
void (***v3)(void); // rsi
long long v4; // rdi
signed __int32 v5; // eax
long long v6; // rdi
signed __int32 v7; // eax
long long result; // rax
long long v9; // rdi
std::runtime_error *exception; // r14
void *v11; // r14
_QWORD v12[2]; // [rsp+0h] [rbp-138h] BYREF
__int128 v13; // [rsp+18h] [rbp-120h] BYREF
long long v14; // [rsp+28h] [rbp-110h]
void *v15[2]; // [rsp+30h] [rbp-108h] BYREF
long long v16; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v17[8]; // [rsp+50h] [rbp-E8h] BYREF
long long v18; // [rsp+58h] [rbp-E0h]
volatile signed __int32 *v19; // [rsp+68h] [rbp-D0h]
volatile signed __int32 *v20; // [rsp+78h] [rbp-C0h]
volatile signed __int32 *v21; // [rsp+88h] [rbp-B0h]
char v22[16]; // [rsp+90h] [rbp-A8h] BYREF
void *v23[2]; // [rsp+A0h] [rbp-98h] BYREF
long long v24; // [rsp+B0h] [rbp-88h] BYREF
_BYTE v25[8]; // [rsp+C0h] [rbp-78h] BYREF
long long v26; // [rsp+C8h] [rbp-70h]
volatile signed __int32 *v27; // [rsp+D8h] [rbp-60h]
volatile signed __int32 *v28; // [rsp+E8h] [rbp-50h]
long long v29; // [rsp+F0h] [rbp-48h]
volatile signed __int32 *v30; // [rsp+F8h] [rbp-40h]
char v31[56]; // [rsp+100h] [rbp-38h] BYREF
v3 = *(void (****)(void))(a1 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.filter is null");
goto LABEL_47;
}
if ( !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterNode.body is null");
LABEL_47:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v25, v3);
if ( !v29 )
{
v11 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v12, (long long)v25, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v17, (long long)"Filter must be a callable: ", (long long)v12);
std::runtime_error::runtime_error(v11, v17);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::TemplateNode::render[abi:cxx11]((long long)v23, *(long long ( ****)(_QWORD))(a1 + 48));
minja::Value::Value((long long)v17, (long long)v23);
std::vector<minja::Value>::vector((long long)v12, (long long)v17, 1LL);
v13 = 0LL;
v14 = 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(v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
if ( v21 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v4 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
v5 = *(_DWORD *)(v18 + 12);
*(_DWORD *)(v18 + 12) = v5 - 1;
}
else
{
v5 = _InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( v5 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v4 + 24LL))(v4, 0LL);
}
minja::Value::call((long long)v17, (long long)v25);
minja::Value::to_str[abi:cxx11](v15, (long long)v17);
std::__ostream_insert<char,std::char_traits<char>>(a2, v15[0], v15[1]);
if ( v15[0] != &v16 )
operator delete(v15[0], v16 + 1);
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(v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
if ( v21 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v6 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
v7 = *(_DWORD *)(v18 + 12);
*(_DWORD *)(v18 + 12) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
std::vector<std::pair<std::string,minja::Value>>::~vector((char **)&v13);
std::vector<minja::Value>::~vector(v12);
if ( v23[0] != &v24 )
operator delete(v23[0], v24 + 1);
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(v31);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v31);
if ( v30 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
if ( v28 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v28);
if ( v27 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v27);
v9 = v26;
if ( v26 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v26 + 12);
*(_DWORD *)(v26 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v26 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)v9 + 24LL))(v9, 0LL);
}
return result;
}
| do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x001a0b07
MOV R14,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001a0b25
MOV R15,RDX
LEA R12,[RSP + 0xc0]
MOV RDI,R12
CALL 0x0018618e
CMP qword ptr [R12 + 0x30],0x0
JZ 0x001a0b57
MOV RSI,qword ptr [R14 + 0x30]
LAB_001a08a6:
LEA RDI,[RSP + 0xa0]
MOV RDX,R15
CALL 0x0019ef94
LAB_001a08b6:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xa0]
CALL 0x0018a4de
LAB_001a08c8:
MOV RDI,RSP
LEA RSI,[RSP + 0x50]
LEA RCX,[RSP + 0x30]
MOV EDX,0x1
CALL 0x001936a6
LAB_001a08df:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x28],0x0
LEA R14,[RSP + 0x90]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00158a58
MOV RDI,R14
CALL 0x0015ded4
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x001a0918
CALL 0x0016d8f8
LAB_001a0918:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x001a0927
CALL 0x0016d8f8
LAB_001a0927:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x001a0936
CALL 0x0016d8f8
LAB_001a0936:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x001a096c
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0957
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0961
LAB_001a0957:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0961:
CMP EAX,0x1
JNZ 0x001a096c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a096c:
LEA R14,[RSP + 0x18]
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0xc0]
MOV RCX,RSP
MOV RDX,R15
CALL 0x00193a88
LAB_001a0989:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x50]
CALL 0x00196d80
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LAB_001a09a2:
MOV RDI,RBX
CALL 0x0011aa20
LAB_001a09aa:
LEA RAX,[RSP + 0x40]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a09c5
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x0011a900
LAB_001a09c5:
LEA RBX,[RSP + 0x90]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158a58
MOV RDI,RBX
CALL 0x0015ded4
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x001a09ed
CALL 0x0016d8f8
LAB_001a09ed:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x001a09fc
CALL 0x0016d8f8
LAB_001a09fc:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x001a0a0b
CALL 0x0016d8f8
LAB_001a0a0b:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x001a0a41
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0a2c
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0a36
LAB_001a0a2c:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0a36:
CMP EAX,0x1
JNZ 0x001a0a41
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a0a41:
MOV RDI,R14
CALL 0x00194dd0
MOV RDI,RSP
CALL 0x0018dc62
LEA RAX,[RSP + 0xb0]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a0a72
MOV RSI,qword ptr [RSP + 0xb0]
INC RSI
CALL 0x0011a900
LAB_001a0a72:
LEA RBX,[RSP + 0x100]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00158a58
MOV RDI,RBX
CALL 0x0015ded4
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x001a0a9a
CALL 0x0016d8f8
LAB_001a0a9a:
MOV RDI,qword ptr [RSP + 0xe8]
TEST RDI,RDI
JZ 0x001a0aac
CALL 0x0016d8f8
LAB_001a0aac:
MOV RDI,qword ptr [RSP + 0xd8]
TEST RDI,RDI
JZ 0x001a0abe
CALL 0x0016d8f8
LAB_001a0abe:
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x001a0af7
MOV RAX,qword ptr [0x0022bf88]
CMP byte ptr [RAX],0x0
JZ 0x001a0ae2
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a0aec
LAB_001a0ae2:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a0aec:
CMP EAX,0x1
JNZ 0x001a0af7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a0af7:
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a0b07:
MOV EDI,0x10
CALL 0x0011a460
MOV R14,RAX
LAB_001a0b14:
LEA RSI,[0x1f0f48]
MOV RDI,RAX
CALL 0x0011a330
LAB_001a0b23:
JMP 0x001a0b41
LAB_001a0b25:
MOV EDI,0x10
CALL 0x0011a460
MOV R14,RAX
LAB_001a0b32:
LEA RSI,[0x1f0f62]
MOV RDI,RAX
CALL 0x0011a330
LAB_001a0b41:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,R14
CALL 0x0011af40
LAB_001a0b57:
MOV EDI,0x10
CALL 0x0011a460
MOV R14,RAX
LAB_001a0b64:
MOV RDI,RSP
LEA RSI,[RSP + 0xc0]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001867a2
LAB_001a0b7b:
LEA RSI,[0x1f0f7a]
LEA RDI,[RSP + 0x50]
MOV RDX,RSP
CALL 0x00178e69
MOV BPL,0x1
LAB_001a0b92:
LEA RSI,[RSP + 0x50]
MOV RDI,R14
CALL 0x0011ae50
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,R14
CALL 0x0011af40
|
/* minja::FilterNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::FilterNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
int iVar2;
runtime_error *prVar3;
vector<minja::Value,std::allocator<minja::Value>> avStack_138 [24];
int8 local_120;
int8 uStack_118;
int8 local_110;
long *local_108;
long local_100;
long local_f8 [2];
Value local_e8 [8];
long *local_e0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_d0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_c0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b0;
data local_a8 [16];
long *local_98 [2];
long local_88 [2];
Expression local_78 [8];
long *local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
long local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
data local_38 [16];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0b14 to 001a0b22 has its CatchHandler @ 001a0c2c */
std::runtime_error::runtime_error(prVar3,"FilterNode.filter is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate(local_78,*(shared_ptr **)(param_1 + 0x20));
if (local_48 != 0) {
/* try { // try from 001a08a6 to 001a08b5 has its CatchHandler @ 001a0cb5 */
TemplateNode::render_abi_cxx11_((TemplateNode *)local_98,*(shared_ptr **)(param_1 + 0x30));
/* try { // try from 001a08b6 to 001a08c7 has its CatchHandler @ 001a0c8f */
Value::Value(local_e8,(string *)local_98);
/* try { // try from 001a08c8 to 001a08de has its CatchHandler @ 001a0c80 */
std::vector<minja::Value,std::allocator<minja::Value>>::vector
(avStack_138,local_e8,1,&local_108);
local_120 = 0;
uStack_118 = 0;
local_110 = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_a8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_a8);
if (local_b0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b0);
}
if (local_c0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_c0);
}
if (local_d0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_d0);
}
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
/* try { // try from 001a096c to 001a0988 has its CatchHandler @ 001a0c6b */
Value::call((shared_ptr *)local_e8,(ArgumentsValue *)local_78);
/* try { // try from 001a0989 to 001a0997 has its CatchHandler @ 001a0c5c */
Value::to_str_abi_cxx11_();
/* try { // try from 001a09a2 to 001a09a9 has its CatchHandler @ 001a0c3c */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)param_2,(char *)local_108,local_100);
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_a8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_a8);
if (local_b0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b0);
}
if (local_c0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_c0);
}
if (local_d0 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_d0);
}
if (local_e0 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_e0 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_e0 + 0xc);
*(int *)((long)local_e0 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_e0 + 0x18))();
}
}
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)&local_120);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector(avStack_138);
if (local_98[0] != local_88) {
operator_delete(local_98[0],local_88[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_60);
}
if (local_70 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_70 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_70 + 0xc);
*(int *)((long)local_70 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_70 + 0x18))();
}
}
return;
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0b64 to 001a0b7a has its CatchHandler @ 001a0c1a */
Value::dump_abi_cxx11_((int)avStack_138,SUB81(local_78,0));
/* try { // try from 001a0b7b to 001a0b8e has its CatchHandler @ 001a0bfa */
std::operator+((char *)local_e8,(string *)"Filter must be a callable: ");
/* try { // try from 001a0b92 to 001a0bb6 has its CatchHandler @ 001a0bb7 */
std::runtime_error::runtime_error(prVar3,(string *)local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a0b32 to 001a0b40 has its CatchHandler @ 001a0c2a */
std::runtime_error::runtime_error(prVar3,"FilterNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
| |
31,272 | ma_reset_history | eloqsql/storage/maria/ma_state.c | void _ma_reset_history(MARIA_SHARE *share)
{
MARIA_STATE_HISTORY *history, *next;
DBUG_ENTER("_ma_reset_history");
share->state_history->trid= 0; /* Visibly by all */
share->state_history->state= share->state.state;
history= share->state_history->next;
share->state_history->next= 0;
for (; history; history= next)
{
next= history->next;
my_free(history);
}
DBUG_VOID_RETURN;
} | O0 | c | ma_reset_history:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x450(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x450(%rax), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movl $0x38, %edx
callq 0x2a090
movq -0x8(%rbp), %rax
movq 0x450(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x450(%rax), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x38209
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf4f60
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x381e4
jmp 0x3820b
jmp 0x3820d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_reset_history:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+450h]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov rdi, [rax+450h]
add rdi, 10h
mov rsi, [rbp+var_8]
add rsi, 18h
mov edx, 38h ; '8'
call _memcpy
mov rax, [rbp+var_8]
mov rax, [rax+450h]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+450h]
mov qword ptr [rax], 0
loc_381E4:
cmp [rbp+var_10], 0
jz short loc_38209
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
call my_free
mov rax, [rbp+var_18]
mov [rbp+var_10], rax
jmp short loc_381E4
loc_38209:
jmp short $+2
loc_3820B:
jmp short $+2
loc_3820D:
add rsp, 20h
pop rbp
retn
| _QWORD * ma_reset_history(long long a1)
{
_QWORD *result; // rax
_QWORD *v2; // [rsp+8h] [rbp-18h]
_QWORD *v3; // [rsp+10h] [rbp-10h]
*(_QWORD *)(*(_QWORD *)(a1 + 1104) + 8LL) = 0LL;
memcpy(*(_QWORD *)(a1 + 1104) + 16LL, a1 + 24, 56LL);
v3 = **(_QWORD ***)(a1 + 1104);
result = *(_QWORD **)(a1 + 1104);
*result = 0LL;
while ( v3 )
{
v2 = (_QWORD *)*v3;
my_free(v3);
result = v2;
v3 = v2;
}
return result;
}
| _ma_reset_history:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x450]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x450]
ADD RDI,0x10
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x18
MOV EDX,0x38
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x450]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x450]
MOV qword ptr [RAX],0x0
LAB_001381e4:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00138209
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001f4f60
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001381e4
LAB_00138209:
JMP 0x0013820b
LAB_0013820b:
JMP 0x0013820d
LAB_0013820d:
ADD RSP,0x20
POP RBP
RET
|
void _ma_reset_history(long param_1)
{
int8 *puVar1;
int8 local_18;
*(int8 *)(*(long *)(param_1 + 0x450) + 8) = 0;
memcpy((void *)(*(long *)(param_1 + 0x450) + 0x10),(void *)(param_1 + 0x18),0x38);
local_18 = (int8 *)**(int8 **)(param_1 + 0x450);
**(int8 **)(param_1 + 0x450) = 0;
while (local_18 != (int8 *)0x0) {
puVar1 = (int8 *)*local_18;
my_free(local_18);
local_18 = puVar1;
}
return;
}
| |
31,273 | LefDefParser::lefiPropType::setPropType(char const*, char) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiPropType.cpp | void
lefiPropType::setPropType(const char *name,
const char type)
{
int len;
if (numProperties_ == propertiesAllocated_)
bumpProps();
len = strlen(name) + 1;
propNames_[numProperties_] = (char*) malloc(len);
strcpy(propNames_[numProperties_], CASE(name));
propTypes_[numProperties_] = type;
numProperties_ += 1;
} | O0 | cpp | LefDefParser::lefiPropType::setPropType(char const*, char):
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x725ef
movq 0x8(%rsp), %rdi
callq 0x72670
movq 0x18(%rsp), %rdi
callq 0x20d0
addq $0x1, %rax
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rdi
callq 0x2310
movq 0x8(%rsp), %rcx
movq %rax, %rsi
movq 0x8(%rcx), %rax
movslq (%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x8(%rcx), %rax
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x3f780
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2250
movq 0x8(%rsp), %rax
movb 0x17(%rsp), %sil
movq 0x10(%rax), %rcx
movslq (%rax), %rdx
movb %sil, (%rcx,%rdx)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser12lefiPropType11setPropTypeEPKcc:
sub rsp, 28h
mov al, dl
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_11], al
mov rcx, [rsp+28h+var_8]
mov [rsp+28h+var_20], rcx
mov eax, [rcx]
cmp eax, [rcx+4]
jnz short loc_725EF
mov rdi, [rsp+28h+var_20]; this
call _ZN12LefDefParser12lefiPropType9bumpPropsEv; LefDefParser::lefiPropType::bumpProps(void)
loc_725EF:
mov rdi, [rsp+28h+var_10]
call _strlen
add rax, 1
mov [rsp+28h+var_18], eax
movsxd rdi, [rsp+28h+var_18]
call _malloc
mov rcx, [rsp+28h+var_20]
mov rsi, rax; char *
mov rax, [rcx+8]
movsxd rdx, dword ptr [rcx]
mov [rax+rdx*8], rsi
mov rax, [rcx+8]
movsxd rcx, dword ptr [rcx]
mov rax, [rax+rcx*8]
mov [rsp+28h+var_28], rax
mov rdi, [rsp+28h+var_10]; this
call _ZN12LefDefParser4CASEEPKc; LefDefParser::CASE(char const*)
mov rdi, [rsp+28h+var_28]
mov rsi, rax
call _strcpy
mov rax, [rsp+28h+var_20]
mov sil, [rsp+28h+var_11]
mov rcx, [rax+10h]
movsxd rdx, dword ptr [rax]
mov [rcx+rdx], sil
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
add rsp, 28h
retn
| LefDefParser::lefiPropType * LefDefParser::lefiPropType::setPropType(
LefDefParser::lefiPropType *this,
LefDefParser *a2,
char a3)
{
char *v3; // rax
LefDefParser *v4; // rax
LefDefParser::lefiPropType *result; // rax
long long v6; // [rsp+0h] [rbp-28h]
int v7; // [rsp+10h] [rbp-18h]
if ( *(_DWORD *)this == *((_DWORD *)this + 1) )
LefDefParser::lefiPropType::bumpProps(this);
v7 = strlen(a2) + 1;
v3 = (char *)malloc(v7);
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * *(int *)this) = v3;
v6 = *(_QWORD *)(*((_QWORD *)this + 1) + 8LL * *(int *)this);
v4 = LefDefParser::CASE(a2, v3);
strcpy(v6, v4);
result = this;
*(_BYTE *)(*((_QWORD *)this + 2) + (int)(*(_DWORD *)this)++) = a3;
return result;
}
| setPropType:
SUB RSP,0x28
MOV AL,DL
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV byte ptr [RSP + 0x17],AL
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RCX
MOV EAX,dword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x4]
JNZ 0x001725ef
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00172670
LAB_001725ef:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001020d0
ADD RAX,0x1
MOV dword ptr [RSP + 0x10],EAX
MOVSXD RDI,dword ptr [RSP + 0x10]
CALL 0x00102310
MOV RCX,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV RAX,qword ptr [RCX + 0x8]
MOVSXD RDX,dword ptr [RCX]
MOV qword ptr [RAX + RDX*0x8],RSI
MOV RAX,qword ptr [RCX + 0x8]
MOVSXD RCX,dword ptr [RCX]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0013f780
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x00102250
MOV RAX,qword ptr [RSP + 0x8]
MOV SIL,byte ptr [RSP + 0x17]
MOV RCX,qword ptr [RAX + 0x10]
MOVSXD RDX,dword ptr [RAX]
MOV byte ptr [RCX + RDX*0x1],SIL
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
ADD RSP,0x28
RET
|
/* LefDefParser::lefiPropType::setPropType(char const*, char) */
void __thiscall
LefDefParser::lefiPropType::setPropType(lefiPropType *this,char *param_1,char param_2)
{
char *__dest;
size_t sVar1;
void *pvVar2;
char *__src;
if (*(int *)this == *(int *)(this + 4)) {
bumpProps(this);
}
sVar1 = strlen(param_1);
pvVar2 = malloc((long)((int)sVar1 + 1));
*(void **)(*(long *)(this + 8) + (long)*(int *)this * 8) = pvVar2;
__dest = *(char **)(*(long *)(this + 8) + (long)*(int *)this * 8);
__src = (char *)CASE(param_1);
strcpy(__dest,__src);
*(char *)(*(long *)(this + 0x10) + (long)*(int *)this) = param_2;
*(int *)this = *(int *)this + 1;
return;
}
| |
31,274 | LefDefParser::lefiPropType::setPropType(char const*, char) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiPropType.cpp | void
lefiPropType::setPropType(const char *name,
const char type)
{
int len;
if (numProperties_ == propertiesAllocated_)
bumpProps();
len = strlen(name) + 1;
propNames_[numProperties_] = (char*) malloc(len);
strcpy(propNames_[numProperties_], CASE(name));
propTypes_[numProperties_] = type;
numProperties_ += 1;
} | O3 | cpp | LefDefParser::lefiPropType::setPropType(char const*, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %ebp
cmpl 0x4(%rdi), %ebp
jne 0x4999a
movq %r14, %rdi
callq 0x499e8
movl (%r14), %ebp
movq %r15, %rdi
callq 0x20d0
incl %eax
movslq %eax, %rdi
callq 0x2290
movq 0x8(%r14), %rcx
movslq %ebp, %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x8(%r14), %rax
movq (%rax,%rdx,8), %r12
movq %r15, %rdi
callq 0x27c0a
movq %r12, %rdi
movq %rax, %rsi
callq 0x21b0
movq 0x10(%r14), %rax
movslq (%r14), %rcx
movb %bl, (%rax,%rcx)
incl (%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN12LefDefParser12lefiPropType11setPropTypeEPKcc:
push rbp
push r15
push r14
push r12
push rbx
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov ebp, [rdi]
cmp ebp, [rdi+4]
jnz short loc_4999A
mov rdi, r14; this
call _ZN12LefDefParser12lefiPropType9bumpPropsEv; LefDefParser::lefiPropType::bumpProps(void)
mov ebp, [r14]
loc_4999A:
mov rdi, r15
call _strlen
inc eax
movsxd rdi, eax
call _malloc
mov rcx, [r14+8]
movsxd rdx, ebp
mov [rcx+rdx*8], rax
mov rax, [r14+8]
mov r12, [rax+rdx*8]
mov rdi, r15; this
call _ZN12LefDefParser4CASEEPKc; LefDefParser::CASE(char const*)
mov rdi, r12
mov rsi, rax
call _strcpy
mov rax, [r14+10h]
movsxd rcx, dword ptr [r14]
mov [rax+rcx], bl
inc dword ptr [r14]
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::lefiPropType::setPropType(LefDefParser::lefiPropType *this, LefDefParser *a2, char a3)
{
int v4; // ebp
int v5; // eax
long long v6; // r12
LefDefParser *v7; // rax
long long result; // rax
v4 = *(_DWORD *)this;
if ( *(_DWORD *)this == *((_DWORD *)this + 1) )
{
LefDefParser::lefiPropType::bumpProps(this);
v4 = *(_DWORD *)this;
}
v5 = strlen(a2);
*(_QWORD *)(*((_QWORD *)this + 1) + 8LL * v4) = malloc(v5 + 1);
v6 = *(_QWORD *)(*((_QWORD *)this + 1) + 8LL * v4);
v7 = LefDefParser::CASE(a2, (char *)a2);
strcpy(v6, v7);
result = *((_QWORD *)this + 2);
*(_BYTE *)(result + (int)(*(_DWORD *)this)++) = a3;
return result;
}
| setPropType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV EBP,dword ptr [RDI]
CMP EBP,dword ptr [RDI + 0x4]
JNZ 0x0014999a
MOV RDI,R14
CALL 0x001499e8
MOV EBP,dword ptr [R14]
LAB_0014999a:
MOV RDI,R15
CALL 0x001020d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00102290
MOV RCX,qword ptr [R14 + 0x8]
MOVSXD RDX,EBP
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV R12,qword ptr [RAX + RDX*0x8]
MOV RDI,R15
CALL 0x00127c0a
MOV RDI,R12
MOV RSI,RAX
CALL 0x001021b0
MOV RAX,qword ptr [R14 + 0x10]
MOVSXD RCX,dword ptr [R14]
MOV byte ptr [RAX + RCX*0x1],BL
INC dword ptr [R14]
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::lefiPropType::setPropType(char const*, char) */
void __thiscall
LefDefParser::lefiPropType::setPropType(lefiPropType *this,char *param_1,char param_2)
{
char *__dest;
size_t sVar1;
void *pvVar2;
char *__src;
int iVar3;
iVar3 = *(int *)this;
if (iVar3 == *(int *)(this + 4)) {
bumpProps(this);
iVar3 = *(int *)this;
}
sVar1 = strlen(param_1);
pvVar2 = malloc((long)((int)sVar1 + 1));
*(void **)(*(long *)(this + 8) + (long)iVar3 * 8) = pvVar2;
__dest = *(char **)(*(long *)(this + 8) + (long)iVar3 * 8);
__src = (char *)CASE(param_1);
strcpy(__dest,__src);
*(char *)(*(long *)(this + 0x10) + (long)*(int *)this) = param_2;
*(int *)this = *(int *)this + 1;
return;
}
| |
31,275 | get_store_length | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static size_t get_store_length(size_t length)
{
#define MAX_STORE_SIZE 9
unsigned char buffer[MAX_STORE_SIZE], *p;
/* We just store the length and subtract offset of our buffer
to determine the length */
p= mysql_net_store_length(buffer, length);
return p - buffer;
} | O0 | c | get_store_length:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x26570
movq -0x38(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x20869
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
callq 0x134b0
nop
| get_store_length:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_11]
mov [rbp+var_38], rdi
call mysql_net_store_length
mov rcx, [rbp+var_38]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_20869
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
loc_20869:
call ___stack_chk_fail
| long long get_store_length(long long a1)
{
_BYTE v2[9]; // [rsp+2Fh] [rbp-11h] BYREF
unsigned long long v3; // [rsp+38h] [rbp-8h]
v3 = __readfsqword(0x28u);
return mysql_net_store_length(v2, a1) - (_QWORD)v2;
}
| get_store_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x11]
MOV qword ptr [RBP + -0x38],RDI
CALL 0x00126570
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00120869
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
LAB_00120869:
CALL 0x001134b0
|
long get_store_length(int8 param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = mysql_net_store_length(local_19,param_1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar1 - (long)local_19;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,276 | mi_write_blob_record | eloqsql/storage/myisam/mi_dynrec.c | int _mi_write_blob_record(MI_INFO *info, const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
extra= (ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
MI_DYN_DELETE_BLOCK_HEADER+1);
reclength= (info->s->base.pack_reclength +
_mi_calc_total_blob_length(info,record)+ extra);
if (!(rec_buff=(uchar*) my_alloca(reclength)))
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(-1);
}
reclength2= _mi_rec_pack(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
record);
DBUG_PRINT("info",("reclength: %lu reclength2: %lu",
reclength, reclength2));
DBUG_ASSERT(reclength2 <= reclength);
error=write_dynamic_record(info,rec_buff+ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER),
reclength2);
my_afree(rec_buff);
return(error);
} | O3 | c | mi_write_blob_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x148(%rax), %r15
callq 0x318e8
leaq (%r15,%rax), %rsi
addq $0x5d, %rsi
xorl %edi, %edi
xorl %edx, %edx
callq 0x5d09d
testq %rax, %rax
je 0x318cf
movq %rax, %r15
movq %rax, %r12
addq $0x18, %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x30fae
movl %eax, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31320
movl %eax, %ebx
movq %r15, %rdi
callq 0x5d2ca
movl %ebx, %eax
jmp 0x318df
callq 0x5ed5e
movl $0x80, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _mi_write_blob_record:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
mov r15, [rax+148h]
call _mi_calc_total_blob_length
lea rsi, [r15+rax]
add rsi, 5Dh ; ']'
xor edi, edi
xor edx, edx
call my_malloc
test rax, rax
jz short loc_318CF
mov r15, rax
mov r12, rax
add r12, 18h
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _mi_rec_pack
mov edx, eax
mov rdi, rbx
mov rsi, r12
call write_dynamic_record
mov ebx, eax
mov rdi, r15
call my_free
mov eax, ebx
jmp short loc_318DF
loc_318CF:
call _my_thread_var
mov dword ptr [rax], 80h
mov eax, 0FFFFFFFFh
loc_318DF:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long mi_write_blob_record(_BYTE *a1, char *a2)
{
long long v3; // r15
const char *v4; // rsi
long long v5; // rax
long long v6; // r15
long long v7; // r12
unsigned int v8; // eax
unsigned int v9; // ebx
v3 = *(_QWORD *)(*(_QWORD *)a1 + 328LL);
v4 = (const char *)(v3 + mi_calc_total_blob_length() + 93);
v5 = my_malloc(0LL, v4);
if ( v5 )
{
v6 = v5;
v7 = v5 + 24;
v8 = mi_rec_pack((long long)a1, (_BYTE *)(v5 + 24), a2);
v9 = write_dynamic_record(a1, v7, v8);
my_free(v6);
return v9;
}
else
{
*(_DWORD *)my_thread_var(0LL, v4) = 128;
return 0xFFFFFFFFLL;
}
}
| _mi_write_blob_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV R15,qword ptr [RAX + 0x148]
CALL 0x001318e8
LEA RSI,[R15 + RAX*0x1]
ADD RSI,0x5d
XOR EDI,EDI
XOR EDX,EDX
CALL 0x0015d09d
TEST RAX,RAX
JZ 0x001318cf
MOV R15,RAX
MOV R12,RAX
ADD R12,0x18
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x00130fae
MOV EDX,EAX
MOV RDI,RBX
MOV RSI,R12
CALL 0x00131320
MOV EBX,EAX
MOV RDI,R15
CALL 0x0015d2ca
MOV EAX,EBX
JMP 0x001318df
LAB_001318cf:
CALL 0x0015ed5e
MOV dword ptr [RAX],0x80
MOV EAX,0xffffffff
LAB_001318df:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 _mi_write_blob_record(long *param_1,int8 param_2)
{
int4 uVar1;
long lVar2;
long lVar3;
int4 *puVar4;
lVar3 = *(long *)(*param_1 + 0x148);
lVar2 = _mi_calc_total_blob_length();
lVar3 = my_malloc(0,lVar3 + lVar2 + 0x5d,0);
if (lVar3 == 0) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x80;
uVar1 = 0xffffffff;
}
else {
uVar1 = _mi_rec_pack(param_1,lVar3 + 0x18,param_2);
uVar1 = write_dynamic_record(param_1,lVar3 + 0x18,uVar1);
my_free(lVar3);
}
return uVar1;
}
| |
31,277 | ma_calc_total_blob_length | eloqsql/storage/maria/ma_dynrec.c | ulong _ma_calc_total_blob_length(MARIA_HA *info, const uchar *record)
{
ulong length;
MARIA_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length= _ma_calc_blob_length(blob->pack_length,
record + blob->offset);
length+=blob->length;
}
return length;
} | O3 | c | ma_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl 0x3f0(%rax), %eax
testq %rax, %rax
je 0x466b4
movq 0x288(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %edi, %edi
leaq 0xa080c(%rip), %r8 # 0xe6e64
xorl %eax, %eax
movl 0x8(%rcx,%rdi), %r10d
decl %r10d
cmpl $0x3, %r10d
ja 0x4669e
movq (%rcx,%rdi), %r9
movslq (%r8,%r10,4), %r10
addq %r8, %r10
jmpq *%r10
movzbl (%rsi,%r9), %r9d
jmp 0x466a1
movzwl (%rsi,%r9), %r10d
movzbl 0x2(%rsi,%r9), %r9d
shll $0x10, %r9d
orq %r10, %r9
jmp 0x466a1
movl (%rsi,%r9), %r9d
jmp 0x466a1
movzwl (%rsi,%r9), %r9d
jmp 0x466a1
xorl %r9d, %r9d
movq %r9, 0x10(%rcx,%rdi)
addq %r9, %rax
addq $0x18, %rdi
cmpq %rdi, %rdx
jne 0x4665a
jmp 0x466b6
xorl %eax, %eax
popq %rbp
retq
| _ma_calc_total_blob_length:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov eax, [rax+3F0h]
test rax, rax
jz short loc_466B4
mov rcx, [rdi+288h]
shl rax, 3
lea rdx, [rax+rax*2]
xor edi, edi
lea r8, jpt_46673
xor eax, eax
loc_4665A:
mov r10d, [rcx+rdi+8]
dec r10d; switch 4 cases
cmp r10d, 3
ja short def_46673; jumptable 0000000000046673 default case
mov r9, [rcx+rdi]
movsxd r10, ds:(jpt_46673 - 0E6E64h)[r8+r10*4]
add r10, r8
jmp r10; switch jump
loc_46676:
movzx r9d, byte ptr [rsi+r9]; jumptable 0000000000046673 case 1
jmp short loc_466A1
loc_4667D:
movzx r10d, word ptr [rsi+r9]; jumptable 0000000000046673 case 3
movzx r9d, byte ptr [rsi+r9+2]
shl r9d, 10h
or r9, r10
jmp short loc_466A1
loc_46691:
mov r9d, [rsi+r9]; jumptable 0000000000046673 case 4
jmp short loc_466A1
loc_46697:
movzx r9d, word ptr [rsi+r9]; jumptable 0000000000046673 case 2
jmp short loc_466A1
def_46673:
xor r9d, r9d; jumptable 0000000000046673 default case
loc_466A1:
mov [rcx+rdi+10h], r9
add rax, r9
add rdi, 18h
cmp rdx, rdi
jnz short loc_4665A
jmp short loc_466B6
loc_466B4:
xor eax, eax
loc_466B6:
pop rbp
retn
| long long ma_calc_total_blob_length(_QWORD *a1, long long a2)
{
long long v2; // rcx
long long v3; // rdx
long long v4; // rdi
long long result; // rax
long long v6; // r9
unsigned long long v7; // r9
if ( !*(_DWORD *)(*a1 + 1008LL) )
return 0LL;
v2 = a1[81];
v3 = 24LL * *(unsigned int *)(*a1 + 1008LL);
v4 = 0LL;
result = 0LL;
do
{
v6 = *(_QWORD *)(v2 + v4);
switch ( *(_DWORD *)(v2 + v4 + 8) )
{
case 1:
v7 = *(unsigned __int8 *)(a2 + v6);
break;
case 2:
v7 = *(unsigned __int16 *)(a2 + v6);
break;
case 3:
v7 = *(unsigned __int16 *)(a2 + v6) | (unsigned long long)(*(unsigned __int8 *)(a2 + v6 + 2) << 16);
break;
case 4:
v7 = *(unsigned int *)(a2 + v6);
break;
default:
v7 = 0LL;
break;
}
*(_QWORD *)(v2 + v4 + 16) = v7;
result += v7;
v4 += 24LL;
}
while ( v3 != v4 );
return result;
}
| _ma_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x3f0]
TEST RAX,RAX
JZ 0x001466b4
MOV RCX,qword ptr [RDI + 0x288]
SHL RAX,0x3
LEA RDX,[RAX + RAX*0x2]
XOR EDI,EDI
LEA R8,[0x1e6e64]
XOR EAX,EAX
LAB_0014665a:
MOV R10D,dword ptr [RCX + RDI*0x1 + 0x8]
DEC R10D
CMP R10D,0x3
JA 0x0014669e
MOV R9,qword ptr [RCX + RDI*0x1]
MOVSXD R10,dword ptr [R8 + R10*0x4]
ADD R10,R8
switchD:
JMP R10
caseD_1:
MOVZX R9D,byte ptr [RSI + R9*0x1]
JMP 0x001466a1
caseD_3:
MOVZX R10D,word ptr [RSI + R9*0x1]
MOVZX R9D,byte ptr [RSI + R9*0x1 + 0x2]
SHL R9D,0x10
OR R9,R10
JMP 0x001466a1
caseD_4:
MOV R9D,dword ptr [RSI + R9*0x1]
JMP 0x001466a1
caseD_2:
MOVZX R9D,word ptr [RSI + R9*0x1]
JMP 0x001466a1
LAB_0014669e:
XOR R9D,R9D
LAB_001466a1:
MOV qword ptr [RCX + RDI*0x1 + 0x10],R9
ADD RAX,R9
ADD RDI,0x18
CMP RDX,RDI
JNZ 0x0014665a
JMP 0x001466b6
LAB_001466b4:
XOR EAX,EAX
LAB_001466b6:
POP RBP
RET
|
long _ma_calc_total_blob_length(long *param_1,long param_2)
{
uint uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
uVar1 = *(uint *)(*param_1 + 0x3f0);
if ((ulong)uVar1 == 0) {
lVar5 = 0;
}
else {
lVar3 = param_1[0x51];
lVar6 = 0;
lVar5 = 0;
do {
iVar2 = *(int *)(lVar3 + 8 + lVar6);
if (iVar2 - 1U < 4) {
lVar4 = *(long *)(lVar3 + lVar6);
switch(iVar2) {
case 1:
uVar7 = (ulong)*(byte *)(param_2 + lVar4);
break;
case 2:
uVar7 = (ulong)*(ushort *)(param_2 + lVar4);
break;
case 3:
uVar7 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + lVar4),
*(int2 *)(param_2 + lVar4));
break;
case 4:
uVar7 = (ulong)*(uint *)(param_2 + lVar4);
}
}
else {
uVar7 = 0;
}
*(ulong *)(lVar3 + 0x10 + lVar6) = uVar7;
lVar5 = lVar5 + uVar7;
lVar6 = lVar6 + 0x18;
} while ((ulong)uVar1 * 0x18 != lVar6);
}
return lVar5;
}
| |
31,278 | minja::SliceExpr::~SliceExpr() | monkey531[P]llama/common/minja.hpp | SliceExpr(const Location & location, std::shared_ptr<Expression> && s, std::shared_ptr<Expression> && e)
: Expression(location), start(std::move(s)), end(std::move(e)) {} | O1 | cpp | minja::SliceExpr::~SliceExpr():
pushq %rbx
movq %rdi, %rbx
leaq 0x78c5d(%rip), %rax # 0xed858
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x74c10
callq 0x42d00
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x74c1e
callq 0x42d00
leaq 0x78903(%rip), %rax # 0xed528
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x74c3b
popq %rbx
jmp 0x42d00
popq %rbx
retq
nop
| _ZN5minja9SliceExprD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja9SliceExprE; `vtable for'minja::SliceExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_74C10
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_74C10:
mov rdi, [rbx+28h]
test rdi, rdi
jz short loc_74C1E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_74C1E:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_74C3B
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_74C3B:
pop rbx
retn
| void minja::SliceExpr::~SliceExpr(minja::SliceExpr *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
*(_QWORD *)this = &`vtable for'minja::SliceExpr + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v4 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
}
| ~SliceExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1ed858]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00174c10
CALL 0x00142d00
LAB_00174c10:
MOV RDI,qword ptr [RBX + 0x28]
TEST RDI,RDI
JZ 0x00174c1e
CALL 0x00142d00
LAB_00174c1e:
LEA RAX,[0x1ed528]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00174c3b
POP RBX
JMP 0x00142d00
LAB_00174c3b:
POP RBX
RET
|
/* minja::SliceExpr::~SliceExpr() */
void __thiscall minja::SliceExpr::~SliceExpr(SliceExpr *this)
{
*(int ***)this = &PTR_do_evaluate_001ed868;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_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 + 0x38));
}
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_001ed538;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
return;
}
return;
}
| |
31,279 | ggml_argmax | monkey531[P]llama/ggml/src/ggml.c | struct ggml_tensor * ggml_argmax(
struct ggml_context * ctx,
struct ggml_tensor * a) {
GGML_ASSERT(ggml_is_matrix(a));
GGML_ASSERT(a->ne[0] <= INT32_MAX);
struct ggml_tensor * result = ggml_new_tensor_1d(ctx, GGML_TYPE_I32, a->ne[1]);
result->op = GGML_OP_ARGMAX;
result->src[0] = a;
return result;
} | O1 | c | ggml_argmax:
pushq %rbx
subq $0x10, %rsp
cmpq $0x1, 0x20(%rsi)
jne 0x1ab4c
movq %rsi, %rbx
cmpq $0x1, 0x28(%rsi)
jne 0x1ab4c
movl $0x80000000, %eax # imm = 0x80000000
cmpq %rax, 0x10(%rbx)
jge 0x1ab68
movq 0x18(%rbx), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1a, %esi
movl $0x1, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x19c80
movl $0x10, 0x50(%rax)
movq %rbx, 0x98(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x2fabc(%rip), %rdi # 0x4a60f
leaq 0x2faff(%rip), %rdx # 0x4a659
leaq 0x2fc1f(%rip), %rcx # 0x4a780
movl $0x8d7, %esi # imm = 0x8D7
jmp 0x1ab82
leaq 0x2faa0(%rip), %rdi # 0x4a60f
leaq 0x2fae3(%rip), %rdx # 0x4a659
leaq 0x2fc15(%rip), %rcx # 0x4a792
movl $0x8d8, %esi # imm = 0x8D8
xorl %eax, %eax
callq 0x17c70
| ggml_argmax:
push rbx
sub rsp, 10h
cmp qword ptr [rsi+20h], 1
jnz short loc_1AB4C
mov rbx, rsi
cmp qword ptr [rsi+28h], 1
jnz short loc_1AB4C
mov eax, 80000000h
cmp [rbx+10h], rax
jge short loc_1AB68
mov rax, [rbx+18h]
lea rcx, [rsp+18h+var_10]
mov [rcx], rax
mov esi, 1Ah
mov edx, 1
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov dword ptr [rax+50h], 10h
mov [rax+98h], rbx
add rsp, 10h
pop rbx
retn
loc_1AB4C:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsMatrixA; "ggml_is_matrix(a)"
mov esi, 8D7h
jmp short loc_1AB82
loc_1AB68:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aANe0Int32Max; "a->ne[0] <= INT32_MAX"
mov esi, 8D8h
loc_1AB82:
xor eax, eax
call _ggml_abort
| long long ggml_argmax(long long a1, long long *a2, long long a3, long long a4, int a5, int a6)
{
long long result; // rax
const char *v7; // rcx
int v8; // esi
long long v9; // [rsp+8h] [rbp-10h] BYREF
if ( a2[4] != 1 || a2[5] != 1 )
{
v7 = "ggml_is_matrix(a)";
v8 = 2263;
goto LABEL_7;
}
if ( a2[2] >= 0x80000000LL )
{
v7 = "a->ne[0] <= INT32_MAX";
v8 = 2264;
LABEL_7:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c",
v8,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v7,
a5,
a6);
}
v9 = a2[3];
result = ggml_new_tensor_impl(a1, 0x1Au, 1, &v9, 0LL, 0LL);
*(_DWORD *)(result + 80) = 16;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_argmax:
PUSH RBX
SUB RSP,0x10
CMP qword ptr [RSI + 0x20],0x1
JNZ 0x0011ab4c
MOV RBX,RSI
CMP qword ptr [RSI + 0x28],0x1
JNZ 0x0011ab4c
MOV EAX,0x80000000
CMP qword ptr [RBX + 0x10],RAX
JGE 0x0011ab68
MOV RAX,qword ptr [RBX + 0x18]
LEA RCX,[RSP + 0x8]
MOV qword ptr [RCX],RAX
MOV ESI,0x1a
MOV EDX,0x1
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00119c80
MOV dword ptr [RAX + 0x50],0x10
MOV qword ptr [RAX + 0x98],RBX
ADD RSP,0x10
POP RBX
RET
LAB_0011ab4c:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a659]
LEA RCX,[0x14a780]
MOV ESI,0x8d7
JMP 0x0011ab82
LAB_0011ab68:
LEA RDI,[0x14a60f]
LEA RDX,[0x14a659]
LEA RCX,[0x14a792]
MOV ESI,0x8d8
LAB_0011ab82:
XOR EAX,EAX
CALL 0x00117c70
|
void ggml_argmax(int8 param_1,long param_2)
{
long lVar1;
char *pcVar2;
int8 uVar3;
int8 local_10;
if ((*(long *)(param_2 + 0x20) == 1) && (*(long *)(param_2 + 0x28) == 1)) {
if (*(long *)(param_2 + 0x10) < 0x80000000) {
local_10 = *(int8 *)(param_2 + 0x18);
lVar1 = ggml_new_tensor_impl(param_1,0x1a,1,&local_10,0,0);
*(int4 *)(lVar1 + 0x50) = 0x10;
*(long *)(lVar1 + 0x98) = param_2;
return;
}
pcVar2 = "a->ne[0] <= INT32_MAX";
uVar3 = 0x8d8;
}
else {
pcVar2 = "ggml_is_matrix(a)";
uVar3 = 0x8d7;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml.c",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
31,280 | mul_sum_us8_pairs_float | 7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c | static inline __m256 mul_sum_us8_pairs_float(const __m256i ax, const __m256i sy) {
#if __AVXVNNI__
const __m256i zero = _mm256_setzero_si256();
const __m256i summed_pairs = _mm256_dpbusd_epi32(zero, ax, sy);
return _mm256_cvtepi32_ps(summed_pairs);
#else
// Perform multiplication and create 16-bit values
const __m256i dot = _mm256_maddubs_epi16(ax, sy);
return sum_i16_pairs_float(dot);
#endif
} | O0 | c | mul_sum_us8_pairs_float:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xc0, %rsp
vmovdqa %ymm0, 0x40(%rsp)
vmovdqa %ymm1, 0x20(%rsp)
vmovdqa 0x40(%rsp), %ymm1
vmovdqa 0x20(%rsp), %ymm0
vmovdqa %ymm1, 0x80(%rsp)
vmovdqa %ymm0, 0x60(%rsp)
vmovdqa 0x80(%rsp), %ymm0
vmovdqa 0x60(%rsp), %ymm1
vpmaddubsw %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, (%rsp)
vmovdqa (%rsp), %ymm0
callq 0x17c220
movq %rbp, %rsp
popq %rbp
retq
nop
| mul_sum_us8_pairs_float:
push rbp
mov rbp, rsp
and rsp, 0FFFFFFFFFFFFFFE0h
sub rsp, 0C0h
vmovdqa [rsp+0C0h+var_80], ymm0
vmovdqa [rsp+0C0h+var_A0], ymm1
vmovdqa ymm1, [rsp+0C0h+var_80]
vmovdqa ymm0, [rsp+0C0h+var_A0]
vmovdqa [rsp+0C0h+var_40], ymm1
vmovdqa [rsp+0C0h+var_60], ymm0
vmovdqa ymm0, [rsp+0C0h+var_40]
vmovdqa ymm1, [rsp+0C0h+var_60]
vpmaddubsw ymm0, ymm0, ymm1
vmovdqa [rsp+0C0h+var_C0], ymm0
vmovdqa ymm0, [rsp+0C0h+var_C0]
call sum_i16_pairs_float
mov rsp, rbp
pop rbp
retn
| long long mul_sum_us8_pairs_float(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
__m256 v15; // [rsp+0h] [rbp-C0h]
__m256 v16; // [rsp+20h] [rbp-A0h]
__m256 v17; // [rsp+40h] [rbp-80h]
__m256 v18; // [rsp+60h] [rbp-60h]
__asm
{
vmovdqa [rsp+0C0h+var_80], ymm0
vmovdqa [rsp+0C0h+var_A0], ymm1
vmovdqa ymm1, [rsp+0C0h+var_80]
vmovdqa ymm0, [rsp+0C0h+var_A0]
vmovdqa [rsp+0C0h+var_40], ymm1
vmovdqa [rsp+0C0h+var_60], ymm0
vmovdqa ymm0, [rsp+0C0h+var_40]
vmovdqa ymm1, [rsp+0C0h+var_60]
vpmaddubsw ymm0, ymm0, ymm1
vmovdqa [rsp+0C0h+var_C0], ymm0
vmovdqa ymm0, [rsp+0C0h+var_C0]
}
return sum_i16_pairs_float(
a1,
a2,
a3,
a4,
a5,
a6,
*(_QWORD *)v15.m256_f32,
*(_QWORD *)&v15.m256_f32[2],
*(_QWORD *)&v15.m256_f32[4],
*(_QWORD *)&v15.m256_f32[6],
*(_QWORD *)v16.m256_f32,
*(_QWORD *)&v16.m256_f32[2],
*(_QWORD *)&v16.m256_f32[4],
*(_QWORD *)&v16.m256_f32[6],
*(_QWORD *)v17.m256_f32,
*(_QWORD *)&v17.m256_f32[2],
*(_QWORD *)&v17.m256_f32[4],
*(_QWORD *)&v17.m256_f32[6],
*(_QWORD *)v18.m256_f32,
*(_QWORD *)&v18.m256_f32[2]);
}
| TensorStorage:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RDI
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0010b2b0
MOV RDI,qword ptr [RSP]
ADD RDI,0x20
MOV RSI,qword ptr [RSP + 0x8]
ADD RSI,0x20
MOV EDX,0x48
CALL 0x0010b600
ADD RSP,0x18
RET
|
/* TensorStorage::TensorStorage(TensorStorage const&) */
void __thiscall TensorStorage::TensorStorage(TensorStorage *this,TensorStorage *param_1)
{
std::__cxx11::string::string((string *)this,(string *)param_1);
memcpy(this + 0x20,param_1 + 0x20,0x48);
return;
}
| |
31,281 | minja::SetNode::SetNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | SetNode(const Location & location, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateNode(location), ns(ns), var_names(vns), value(std::move(v)) {} | O2 | cpp | minja::SetNode::SetNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %rbx
callq 0x730f8
leaq 0x875c1(%rip), %rax # 0xfd348
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x23c30
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x39c8c
andq $0x0, 0x60(%rbx)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x58(%rbx)
andq $0x0, (%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x241e8
jmp 0x75dd9
movq %rax, %r14
movq %rbx, %rdi
callq 0x77d72
movq %r14, %rdi
callq 0x23fb0
nop
| _ZN5minja7SetNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS9_SaIS9_EEOSt10shared_ptrINS_10ExpressionEE:
push r15
push r14
push r13
push r12
push rbx
mov r14, r8
mov r15, rcx
mov r13, rdx
mov rbx, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja7SetNodeE; `vtable for'minja::SetNode
add rax, 10h
mov [rbx], rax
lea r12, [rbx+20h]
mov rdi, r12
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rbx+40h]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
and qword ptr [rbx+60h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [rbx+58h], xmm0
and qword ptr [r14], 0
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_75DD9
mov r14, rax
loc_75DD9:
mov rdi, rbx; this
call _ZN5minja12TemplateNodeD2Ev; minja::TemplateNode::~TemplateNode()
mov rdi, r14
call __Unwind_Resume
| long long minja::SetNode::SetNode(long long a1, _QWORD *a2, long long a3, _QWORD *a4, __int128 *a5)
{
long long result; // rax
__int128 v8; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::SetNode + 2;
std::string::basic_string(a1 + 32);
result = std::vector<std::string>::vector((_QWORD *)(a1 + 64), a4);
*(_QWORD *)(a1 + 96) = 0LL;
v8 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 88) = v8;
*(_QWORD *)a5 = 0LL;
return result;
}
| SetNode:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,R8
MOV R15,RCX
MOV R13,RDX
MOV RBX,RDI
CALL 0x001730f8
LEA RAX,[0x1fd348]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA R12,[RBX + 0x20]
LAB_00175d92:
MOV RDI,R12
MOV RSI,R13
CALL 0x00123c30
LEA RDI,[RBX + 0x40]
LAB_00175da1:
MOV RSI,R15
CALL 0x00139c8c
LAB_00175da9:
AND qword ptr [RBX + 0x60],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
AND qword ptr [R14],0x0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::SetNode::SetNode(minja::Location const&, std::__cxx11::string const&,
std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::SetNode::SetNode
(SetNode *this,Location *param_1,string *param_2,vector *param_3,shared_ptr *param_4)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_001fd358;
/* try { // try from 00175d92 to 00175d9c has its CatchHandler @ 00175dd6 */
std::__cxx11::string::string((string *)(this + 0x20),param_2);
/* try { // try from 00175da1 to 00175da8 has its CatchHandler @ 00175dc9 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x40),
param_3);
*(int8 *)(this + 0x60) = 0;
uVar1 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x58) = *(int8 *)param_4;
*(int8 *)(this + 0x60) = uVar1;
*(int8 *)param_4 = 0;
return;
}
| |
31,282 | my_xml_leave | eloqsql/strings/xml.c | static int my_xml_leave(MY_XML_PARSER *p, const char *str, size_t slen)
{
char *e, *tag;
size_t glen;
char s[32];
char g[32];
int rc;
/* Find previous '/' or beginning */
for (e= p->attr.end; (e > p->attr.start) && (e[0] != '/') ; e--);
glen= (size_t) ((e[0] == '/') ? (p->attr.end - e - 1) : p->attr.end - e);
tag= e[0] == '/' ? e + 1 : e;
if (str && (slen != glen || memcmp(str, tag, slen)))
{
mstr(s,str,sizeof(s)-1,slen);
if (glen)
{
mstr(g, tag, sizeof(g)-1, glen);
sprintf(p->errstr,"'</%s>' unexpected ('</%s>' wanted)",s,g);
}
else
sprintf(p->errstr,"'</%s>' unexpected (END-OF-INPUT wanted)", s);
return MY_XML_ERROR;
}
if (p->flags & MY_XML_FLAG_RELATIVE_NAMES)
rc= p->leave_xml ? p->leave_xml(p, str, slen) : MY_XML_OK;
else
rc= (p->leave_xml ?
p->leave_xml(p, p->attr.start, p->attr.end - p->attr.start) :
MY_XML_OK);
*e='\0';
p->attr.end= e;
return rc;
} | O0 | c | my_xml_leave:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movq %rdx, -0x70(%rbp)
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rdx
xorl %eax, %eax
cmpq 0x118(%rdx), %rcx
movb %al, -0x8d(%rbp)
jbe 0x7a53f
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x8d(%rbp)
movb -0x8d(%rbp), %al
testb $0x1, %al
jne 0x7a54b
jmp 0x7a55b
jmp 0x7a54d
movq -0x78(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x7a513
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7a586
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x7a59f
movq -0x60(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x78(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x7a5ca
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x7a5d5
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x7a68d
movq -0x70(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x7a60e
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x24140
cmpl $0x0, %eax
je 0x7a68d
leaq -0x30(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x1f, %edx
callq 0x7ac40
cmpq $0x0, -0x88(%rbp)
je 0x7a667
leaq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rcx
movl $0x1f, %edx
callq 0x7ac40
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq 0x5815(%rip), %rsi # 0x7fe73
movb $0x0, %al
callq 0x240b0
jmp 0x7a681
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rdx
leaq 0x581d(%rip), %rsi # 0x7fe97
movb $0x0, %al
callq 0x240b0
movl $0x1, -0x54(%rbp)
jmp 0x7a762
movq -0x60(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7a6e2
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x7a6ca
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq *%rax
movl %eax, -0xa4(%rbp)
jmp 0x7a6d4
xorl %eax, %eax
movl %eax, -0xa4(%rbp)
jmp 0x7a6d4
movl -0xa4(%rbp), %eax
movl %eax, -0x8c(%rbp)
jmp 0x7a743
movq -0x60(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x7a72d
movq -0x60(%rbp), %rax
movq 0x158(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rsi
movq -0x60(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq -0x60(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movl %eax, -0xa8(%rbp)
jmp 0x7a737
xorl %eax, %eax
movl %eax, -0xa8(%rbp)
jmp 0x7a737
movl -0xa8(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x120(%rax)
movl -0x8c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0xac(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7a78c
movl -0xac(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
callq 0x242e0
nopw %cs:(%rax,%rax)
| my_xml_leave:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_70], rdx
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov [rbp+var_78], rax
loc_7A513:
mov rcx, [rbp+var_78]
mov rdx, [rbp+var_60]
xor eax, eax
cmp rcx, [rdx+118h]
mov [rbp+var_8D], al
jbe short loc_7A53F
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_8D], al
loc_7A53F:
mov al, [rbp+var_8D]
test al, 1
jnz short loc_7A54B
jmp short loc_7A55B
loc_7A54B:
jmp short $+2
loc_7A54D:
mov rax, [rbp+var_78]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rax
jmp short loc_7A513
loc_7A55B:
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_7A586
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
sub rax, 1
mov [rbp+var_98], rax
jmp short loc_7A59F
loc_7A586:
mov rax, [rbp+var_60]
mov rax, [rax+120h]
mov rcx, [rbp+var_78]
sub rax, rcx
mov [rbp+var_98], rax
loc_7A59F:
mov rax, [rbp+var_98]
mov [rbp+var_88], rax
mov rax, [rbp+var_78]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_7A5CA
mov rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
jmp short loc_7A5D5
loc_7A5CA:
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
loc_7A5D5:
mov rax, [rbp+var_A0]
mov [rbp+var_80], rax
cmp [rbp+var_68], 0
jz loc_7A68D
mov rax, [rbp+var_70]
cmp rax, [rbp+var_88]
jnz short loc_7A60E
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_70]
call _memcmp
cmp eax, 0
jz short loc_7A68D
loc_7A60E:
lea rdi, [rbp+var_30]
mov rsi, [rbp+var_68]
mov rcx, [rbp+var_70]
mov edx, 1Fh
call mstr_0
cmp [rbp+var_88], 0
jz short loc_7A667
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_80]
mov rcx, [rbp+var_88]
mov edx, 1Fh
call mstr_0
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_50]
lea rsi, aSUnexpectedSWa; "'</%s>' unexpected ('</%s>' wanted)"
mov al, 0
call _sprintf
jmp short loc_7A681
loc_7A667:
mov rdi, [rbp+var_60]
add rdi, 8
lea rdx, [rbp+var_30]
lea rsi, aSUnexpectedEnd; "'</%s>' unexpected (END-OF-INPUT wanted"...
mov al, 0
call _sprintf
loc_7A681:
mov [rbp+var_54], 1
jmp loc_7A762
loc_7A68D:
mov rax, [rbp+var_60]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_7A6E2
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_7A6CA
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_68]
mov rdx, [rbp+var_70]
call rax
mov [rbp+var_A4], eax
jmp short loc_7A6D4
loc_7A6CA:
xor eax, eax
mov [rbp+var_A4], eax
jmp short $+2
loc_7A6D4:
mov eax, [rbp+var_A4]
mov [rbp+var_8C], eax
jmp short loc_7A743
loc_7A6E2:
mov rax, [rbp+var_60]
cmp qword ptr [rax+158h], 0
jz short loc_7A72D
mov rax, [rbp+var_60]
mov rax, [rax+158h]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_60]
mov rsi, [rcx+118h]
mov rcx, [rbp+var_60]
mov rdx, [rcx+120h]
mov rcx, [rbp+var_60]
mov rcx, [rcx+118h]
sub rdx, rcx
call rax
mov [rbp+var_A8], eax
jmp short loc_7A737
loc_7A72D:
xor eax, eax
mov [rbp+var_A8], eax
jmp short $+2
loc_7A737:
mov eax, [rbp+var_A8]
mov [rbp+var_8C], eax
loc_7A743:
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
mov rcx, [rbp+var_78]
mov rax, [rbp+var_60]
mov [rax+120h], rcx
mov eax, [rbp+var_8C]
mov [rbp+var_54], eax
loc_7A762:
mov eax, [rbp+var_54]
mov [rbp+var_AC], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_7A78C
mov eax, [rbp+var_AC]
add rsp, 0B0h
pop rbp
retn
loc_7A78C:
call ___stack_chk_fail
| long long my_xml_leave(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-A8h]
unsigned int v5; // [rsp+Ch] [rbp-A4h]
_BYTE *v6; // [rsp+10h] [rbp-A0h]
long long v7; // [rsp+18h] [rbp-98h]
bool v8; // [rsp+23h] [rbp-8Dh]
unsigned int v9; // [rsp+24h] [rbp-8Ch]
_BYTE *i; // [rsp+38h] [rbp-78h]
char v13[32]; // [rsp+60h] [rbp-50h] BYREF
char v14[40]; // [rsp+80h] [rbp-30h] BYREF
unsigned long long v15; // [rsp+A8h] [rbp-8h]
v15 = __readfsqword(0x28u);
for ( i = *(_BYTE **)(a1 + 288); ; --i )
{
v8 = 0;
if ( (unsigned long long)i > *(_QWORD *)(a1 + 280) )
v8 = *i != 47;
if ( !v8 )
break;
}
if ( *i == 47 )
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i - 1LL;
else
v7 = *(_QWORD *)(a1 + 288) - (_QWORD)i;
if ( *i == 47 )
v6 = i + 1;
else
v6 = i;
if ( !a2 || a3 == v7 && !(unsigned int)memcmp(a2, v6, a3) )
{
if ( (*(_DWORD *)a1 & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 344) )
v5 = (*(long long ( **)(long long, long long, long long))(a1 + 344))(a1, a2, a3);
else
v5 = 0;
v9 = v5;
}
else
{
if ( *(_QWORD *)(a1 + 344) )
v4 = (*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 344))(
a1,
*(_QWORD *)(a1 + 280),
*(_QWORD *)(a1 + 288) - *(_QWORD *)(a1 + 280));
else
v4 = 0;
v9 = v4;
}
*i = 0;
*(_QWORD *)(a1 + 288) = i;
return v9;
}
else
{
mstr_0(v14, a2, 31LL, a3);
if ( v7 )
{
mstr_0(v13, v6, 31LL, v7);
sprintf(a1 + 8, "'</%s>' unexpected ('</%s>' wanted)", v14, v13);
}
else
{
sprintf(a1 + 8, "'</%s>' unexpected (END-OF-INPUT wanted)", v14);
}
return 1;
}
}
| my_xml_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RBP + -0x70],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x78],RAX
LAB_0017a513:
MOV RCX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RDX + 0x118]
MOV byte ptr [RBP + -0x8d],AL
JBE 0x0017a53f
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x8d],AL
LAB_0017a53f:
MOV AL,byte ptr [RBP + -0x8d]
TEST AL,0x1
JNZ 0x0017a54b
JMP 0x0017a55b
LAB_0017a54b:
JMP 0x0017a54d
LAB_0017a54d:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x78],RAX
JMP 0x0017a513
LAB_0017a55b:
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0017a586
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
SUB RAX,0x1
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0017a59f
LAB_0017a586:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x78]
SUB RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_0017a59f:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0017a5ca
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0017a5d5
LAB_0017a5ca:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
LAB_0017a5d5:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x80],RAX
CMP qword ptr [RBP + -0x68],0x0
JZ 0x0017a68d
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x88]
JNZ 0x0017a60e
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x00124140
CMP EAX,0x0
JZ 0x0017a68d
LAB_0017a60e:
LEA RDI,[RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x70]
MOV EDX,0x1f
CALL 0x0017ac40
CMP qword ptr [RBP + -0x88],0x0
JZ 0x0017a667
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
MOV EDX,0x1f
CALL 0x0017ac40
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x50]
LEA RSI,[0x17fe73]
MOV AL,0x0
CALL 0x001240b0
JMP 0x0017a681
LAB_0017a667:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
LEA RDX,[RBP + -0x30]
LEA RSI,[0x17fe97]
MOV AL,0x0
CALL 0x001240b0
LAB_0017a681:
MOV dword ptr [RBP + -0x54],0x1
JMP 0x0017a762
LAB_0017a68d:
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0017a6e2
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x0017a6ca
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
CALL RAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x0017a6d4
LAB_0017a6ca:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x0017a6d4
LAB_0017a6d4:
MOV EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x0017a743
LAB_0017a6e2:
MOV RAX,qword ptr [RBP + -0x60]
CMP qword ptr [RAX + 0x158],0x0
JZ 0x0017a72d
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x158]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RCX + 0x118]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RCX + 0x118]
SUB RDX,RCX
CALL RAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x0017a737
LAB_0017a72d:
XOR EAX,EAX
MOV dword ptr [RBP + -0xa8],EAX
JMP 0x0017a737
LAB_0017a737:
MOV EAX,dword ptr [RBP + -0xa8]
MOV dword ptr [RBP + -0x8c],EAX
LAB_0017a743:
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
MOV RCX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX + 0x120],RCX
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x54],EAX
LAB_0017a762:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0xac],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0017a78c
MOV EAX,dword ptr [RBP + -0xac]
ADD RSP,0xb0
POP RBP
RET
LAB_0017a78c:
CALL 0x001242e0
|
int4 my_xml_leave(uint *param_1,void *param_2,size_t param_3)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
int4 local_b0;
int4 local_ac;
char *local_a8;
size_t local_a0;
int4 local_94;
char *local_80;
int4 local_5c;
int1 local_58 [32];
int1 local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(char **)(param_1 + 0x48);
while( true ) {
bVar2 = false;
if (*(char **)(param_1 + 0x46) < local_80) {
bVar2 = *local_80 != '/';
}
if (!bVar2) break;
local_80 = local_80 + -1;
}
if (*local_80 == '/') {
local_a0 = (*(long *)(param_1 + 0x48) - (long)local_80) - 1;
}
else {
local_a0 = *(long *)(param_1 + 0x48) - (long)local_80;
}
if (*local_80 == '/') {
local_a8 = local_80 + 1;
}
else {
local_a8 = local_80;
}
if (param_2 == (void *)0x0) {
LAB_0017a68d:
if ((*param_1 & 1) == 0) {
if (*(long *)(param_1 + 0x56) == 0) {
local_b0 = 0;
}
else {
local_b0 = (**(code **)(param_1 + 0x56))
(param_1,*(int8 *)(param_1 + 0x46),
*(long *)(param_1 + 0x48) - *(long *)(param_1 + 0x46));
}
local_94 = local_b0;
}
else {
if (*(long *)(param_1 + 0x56) == 0) {
local_ac = 0;
}
else {
local_ac = (**(code **)(param_1 + 0x56))(param_1,param_2,param_3);
}
local_94 = local_ac;
}
*local_80 = '\0';
*(char **)(param_1 + 0x48) = local_80;
local_5c = local_94;
}
else {
if (param_3 == local_a0) {
iVar1 = memcmp(param_2,local_a8,param_3);
if (iVar1 == 0) goto LAB_0017a68d;
}
mstr(local_38,param_2,0x1f,param_3);
if (local_a0 == 0) {
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (END-OF-INPUT wanted)",local_38);
}
else {
mstr(local_58,local_a8,0x1f,local_a0);
sprintf((char *)(param_1 + 2),"\'</%s>\' unexpected (\'</%s>\' wanted)",local_38,local_58);
}
local_5c = 1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_5c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
31,283 | bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool) | monkey531[P]llama/common/json.hpp | bool operator!=(const_reference lhs, ScalarType rhs) noexcept
{
return lhs != basic_json(rhs);
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::operator!=<bool, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x3f872
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d7c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ef6b
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d7c0
movq %r14, %rdi
callq 0x4a3ae
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3neERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator!=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov ebx, eax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
| long long ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
unsigned __int8 a2)
{
long long result; // rax
_OWORD v3[2]; // [rsp+0h] [rbp-28h] BYREF
v3[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)v3,
a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
LOBYTE(result) = nlohmann::json_abi_v3_11_3::operator!=(a1, (unsigned __int8 *)v3, (__m128d)0LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)v3);
return (unsigned int)result;
}
| _ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
CALL 0x0013f872
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d7c0
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016ef6b
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d7c0
MOV RDI,R14
CALL 0x0014a3ae
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3neIbTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(basic_json *param_1)
{
int4 uVar1;
int8 local_28;
int8 uStack_20;
local_28 = 0;
uStack_20 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
uVar1 = nlohmann::json_abi_v3_11_3::operator!=(param_1,(basic_json *)&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_28);
return uVar1;
}
| |
31,284 | unlock_lock_and_free_resource | eloqsql/mysys/waiting_threads.c | static int unlock_lock_and_free_resource(WT_THD *thd, WT_RESOURCE *rc)
{
uint keylen;
const void *key;
DBUG_ENTER("unlock_lock_and_free_resource");
DBUG_ASSERT(rc->state == ACTIVE);
if (rc->owners.elements || rc->waiter_count)
{
DBUG_PRINT("wt", ("nothing to do, %u owners, %u waiters",
rc->owners.elements, rc->waiter_count));
rc_unlock(rc);
DBUG_RETURN(0);
}
if (fix_thd_pins(thd))
{
rc_unlock(rc);
DBUG_RETURN(1);
}
/* XXX if (rc->id.type->make_key) key= rc->id.type->make_key(&rc->id, &keylen); else */
{
key= &rc->id;
keylen= sizeof_WT_RESOURCE_ID;
}
/*
To free the element correctly we need to:
1. take its lock (already done).
2. set the state to FREE
3. release the lock
4. remove from the hash
*/
rc->state= FREE;
rc_unlock(rc);
DBUG_RETURN(lf_hash_delete(&reshash, thd->pins, key, keylen) == -1);
} | O3 | c | unlock_lock_and_free_resource:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0xe8(%rsi)
jne 0xa7276
cmpl $0x0, 0x10(%rbx)
je 0xa7289
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa44ea
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xa72c7
movl $0x1, 0x14(%rbx)
leaq 0x18(%rbx), %rdi
callq 0xa44ea
movq 0x30(%r14), %rsi
leaq 0xb61362(%rip), %rdi # 0xc08610
movq %rbx, %rdx
movl $0x10, %ecx
callq 0x2f711
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
jmp 0xa7284
leaq 0xb6136a(%rip), %rdi # 0xc08638
callq 0x2f205
movq %rax, 0x30(%r14)
testq %rax, %rax
jne 0xa7293
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa44ea
movl $0x1, %eax
jmp 0xa7284
| unlock_lock_and_free_resource:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
cmp dword ptr [rsi+0E8h], 0
jnz short loc_A7276
cmp dword ptr [rbx+10h], 0
jz short loc_A7289
loc_A7276:
add rbx, 18h
mov rdi, rbx
call my_rw_unlock
xor eax, eax
loc_A7284:
pop rbx
pop r14
pop rbp
retn
loc_A7289:
mov r14, rdi
cmp qword ptr [rdi+30h], 0
jz short loc_A72C7
loc_A7293:
mov dword ptr [rbx+14h], 1
lea rdi, [rbx+18h]
call my_rw_unlock
mov rsi, [r14+30h]
lea rdi, reshash
mov rdx, rbx
mov ecx, 10h
call lf_hash_delete
mov ecx, eax
xor eax, eax
cmp ecx, 0FFFFFFFFh
setz al
jmp short loc_A7284
loc_A72C7:
lea rdi, unk_C08638
call lf_pinbox_get_pins
mov [r14+30h], rax
test rax, rax
jnz short loc_A7293
add rbx, 18h
mov rdi, rbx
call my_rw_unlock
mov eax, 1
jmp short loc_A7284
| _BOOL8 unlock_lock_and_free_resource(long long a1, _DWORD *a2)
{
long long pins; // rax
if ( a2[58] || a2[4] )
{
my_rw_unlock((long long)(a2 + 6));
return 0LL;
}
else if ( *(_QWORD *)(a1 + 48)
|| (pins = lf_pinbox_get_pins((long long)&unk_C08638), (*(_QWORD *)(a1 + 48) = pins) != 0LL) )
{
a2[5] = 1;
my_rw_unlock((long long)(a2 + 6));
return (unsigned int)lf_hash_delete((long long)&reshash, *(volatile long long **)(a1 + 48), (long long)a2, 0x10u) == -1;
}
else
{
my_rw_unlock((long long)(a2 + 6));
return 1LL;
}
}
| unlock_lock_and_free_resource:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
CMP dword ptr [RSI + 0xe8],0x0
JNZ 0x001a7276
CMP dword ptr [RBX + 0x10],0x0
JZ 0x001a7289
LAB_001a7276:
ADD RBX,0x18
MOV RDI,RBX
CALL 0x001a44ea
XOR EAX,EAX
LAB_001a7284:
POP RBX
POP R14
POP RBP
RET
LAB_001a7289:
MOV R14,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001a72c7
LAB_001a7293:
MOV dword ptr [RBX + 0x14],0x1
LEA RDI,[RBX + 0x18]
CALL 0x001a44ea
MOV RSI,qword ptr [R14 + 0x30]
LEA RDI,[0xd08610]
MOV RDX,RBX
MOV ECX,0x10
CALL 0x0012f711
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,-0x1
SETZ AL
JMP 0x001a7284
LAB_001a72c7:
LEA RDI,[0xd08638]
CALL 0x0012f205
MOV qword ptr [R14 + 0x30],RAX
TEST RAX,RAX
JNZ 0x001a7293
ADD RBX,0x18
MOV RDI,RBX
CALL 0x001a44ea
MOV EAX,0x1
JMP 0x001a7284
|
bool unlock_lock_and_free_resource(long param_1,long param_2)
{
int iVar1;
long lVar2;
bool bVar3;
if ((*(int *)(param_2 + 0xe8) == 0) && (*(int *)(param_2 + 0x10) == 0)) {
if (*(long *)(param_1 + 0x30) == 0) {
lVar2 = lf_pinbox_get_pins(0xd08638);
*(long *)(param_1 + 0x30) = lVar2;
if (lVar2 == 0) {
my_rw_unlock(param_2 + 0x18);
return true;
}
}
*(int4 *)(param_2 + 0x14) = 1;
my_rw_unlock(param_2 + 0x18);
iVar1 = lf_hash_delete(reshash,*(int8 *)(param_1 + 0x30),param_2,0x10);
bVar3 = iVar1 == -1;
}
else {
my_rw_unlock(param_2 + 0x18);
bVar3 = false;
}
return bVar3;
}
| |
31,285 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map= cs->to_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_caseup_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x3837b
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x38365
popq %rbp
retq
| my_caseup_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_3837B
push rbp
mov rbp, rsp
mov rdx, [rdi+50h]
xor edi, edi
loc_38365:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_38365
pop rbp
locret_3837B:
retn
| long long my_caseup_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 80);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_caseup_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x0013837b
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x50]
XOR EDI,EDI
LAB_00138365:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x00138365
POP RBP
LAB_0013837b:
RET
|
void my_caseup_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x50);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
| |
31,286 | ggml_numa_init | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_numa_init(enum ggml_numa_strategy numa_flag) {
if (g_state.numa.n_nodes > 0) {
fprintf(stderr, "ggml_numa_init: NUMA already initialized\n");
return;
}
#if defined(__gnu_linux__)
struct stat st;
char path[256];
int rv;
// set numa scheme
g_state.numa.numa_strategy = numa_flag;
GGML_PRINT_DEBUG("numa strategy %u\n",g_state.numa.numa_strategy);
g_state.numa.cpuset = ggml_get_numa_affinity();
// enumerate nodes
while (g_state.numa.n_nodes < GGML_NUMA_MAX_NODES) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u", g_state.numa.n_nodes);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.n_nodes;
}
// enumerate CPUs
while (g_state.numa.total_cpus < GGML_NUMA_MAX_CPUS) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%u", g_state.numa.total_cpus);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.total_cpus;
}
GGML_PRINT_DEBUG("found %u numa nodes, %u CPUs\n", g_state.numa.n_nodes, g_state.numa.total_cpus);
// figure out which node we're on
uint current_cpu;
int getcpu_ret = 0;
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 33) || defined(__COSMOPOLITAN__)
getcpu_ret = getcpu(¤t_cpu, &g_state.numa.current_node);
#else
// old glibc doesn't have a wrapper for this call. Fall back on direct syscall
# if !defined(SYS_getcpu) && defined(SYS_get_cpu)
# define SYS_getcpu SYS_get_cpu // some older glibc versions use this name
# endif
getcpu_ret = syscall(SYS_getcpu, ¤t_cpu, &g_state.numa.current_node);
#endif
if (g_state.numa.n_nodes < 1 || g_state.numa.total_cpus < 1 || getcpu_ret != 0) {
g_state.numa.n_nodes = 0;
return;
}
GGML_PRINT_DEBUG("found our process on numa node %u, CPU %u\n", g_state.numa.current_node, current_cpu);
for (uint32_t n = 0; n < g_state.numa.n_nodes; ++n) {
struct ggml_numa_node * node = &g_state.numa.nodes[n];
GGML_PRINT_DEBUG("CPUs on node %u:", n);
node->n_cpus = 0;
for (uint32_t c = 0; c < g_state.numa.total_cpus; ++c) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u/cpu%u", n, c);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) == 0) {
node->cpus[node->n_cpus++] = c;
GGML_PRINT_DEBUG(" %u", c);
}
}
GGML_PRINT_DEBUG("\n");
}
if (ggml_is_numa()) {
FILE *fptr = fopen("/proc/sys/kernel/numa_balancing", "r");
if (fptr != NULL) {
char buf[42];
if (fgets(buf, sizeof(buf), fptr) && strncmp(buf, "0\n", sizeof(buf)) != 0) {
GGML_LOG_WARN("/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
}
fclose(fptr);
}
}
#else
UNUSED(numa_flag);
// TODO
#endif
} | O1 | c | ggml_numa_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
cmpl $0x0, 0x446d7(%rip) # 0x4d6d4
jne 0x92b9
movl %edi, 0x406a7(%rip) # 0x496b0
callq 0x8570
vxorps %xmm0, %xmm0, %xmm0
leaq 0xd0(%rsp), %rbx
vmovups %ymm0, (%rbx)
vmovups %ymm0, 0x20(%rbx)
vmovups %ymm0, 0x40(%rbx)
vmovups %ymm0, 0x60(%rbx)
movl $0x80, %esi
movq %rax, %rdi
movq %rbx, %rdx
vzeroupper
callq 0x8aa0
vmovups (%rbx), %ymm0
vmovups 0x20(%rbx), %ymm1
vmovups 0x40(%rbx), %ymm2
vmovups 0x60(%rbx), %ymm3
vmovups %ymm0, 0x44685(%rip) # 0x4d6e0
vmovups %ymm1, 0x4469d(%rip) # 0x4d700
vmovups %ymm2, 0x446b5(%rip) # 0x4d720
vmovups %ymm3, 0x446cd(%rip) # 0x4d740
movl 0x4465b(%rip), %ecx # 0x4d6d4
cmpl $0x7, %ecx
ja 0x90d6
leaq 0x2d61d(%rip), %rbx # 0x366a2
leaq 0xd0(%rsp), %r14
leaq 0x40(%rsp), %r15
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
vzeroupper
callq 0x8940
decl %eax
cmpl $0xff, %eax
jae 0x92e1
movq %r14, %rdi
movq %r15, %rsi
callq 0x8590
testl %eax, %eax
jne 0x90d6
movl 0x4460b(%rip), %ecx # 0x4d6d4
incl %ecx
movl %ecx, 0x44603(%rip) # 0x4d6d4
cmpl $0x8, %ecx
jb 0x9092
movl 0x445fc(%rip), %ecx # 0x4d6d8
cmpl $0x1ff, %ecx # imm = 0x1FF
ja 0x913f
leaq 0x2d673(%rip), %rbx # 0x3675e
leaq 0xd0(%rsp), %r14
leaq 0x40(%rsp), %r15
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
vzeroupper
callq 0x8940
decl %eax
cmpl $0xff, %eax
jae 0x92fd
movq %r14, %rdi
movq %r15, %rsi
callq 0x8590
testl %eax, %eax
jne 0x913f
movl 0x445a9(%rip), %ecx # 0x4d6d8
incl %ecx
movl %ecx, 0x445a1(%rip) # 0x4d6d8
cmpl $0x200, %ecx # imm = 0x200
jb 0x90f8
leaq 0x44596(%rip), %rsi # 0x4d6dc
leaq 0xc(%rsp), %rdi
vzeroupper
callq 0x8410
cmpl $0x0, 0x4457a(%rip) # 0x4d6d4
je 0x929d
cmpl $0x0, 0x44571(%rip) # 0x4d6d8
je 0x929d
testl %eax, %eax
jne 0x929d
cmpl $0x0, 0x44558(%rip) # 0x4d6d4
je 0x92a7
leaq 0x2d5f3(%rip), %rbx # 0x3677c
leaq 0xd0(%rsp), %r14
leaq 0x40(%rsp), %r15
xorl %r12d, %r12d
movq %r12, %rax
shlq $0xb, %rax
leaq (%rax,%r12,4), %rax
leaq 0x40505(%rip), %rcx # 0x496b0
movl $0x0, 0x804(%rcx,%rax)
cmpl $0x0, 0x4451b(%rip) # 0x4d6d8
je 0x9224
leaq 0x404ea(%rip), %rcx # 0x496b0
leaq (%rcx,%rax), %r13
addq $0x4, %r13
xorl %ebp, %ebp
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8940
decl %eax
cmpl $0xff, %eax
jae 0x92c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x8590
testl %eax, %eax
jne 0x921a
movl 0x800(%r13), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x800(%r13)
movl %ebp, (%r13,%rax,4)
incl %ebp
cmpl 0x444b6(%rip), %ebp # 0x4d6d8
jb 0x91d0
incq %r12
movl 0x444a7(%rip), %eax # 0x4d6d4
cmpq %rax, %r12
jb 0x9199
cmpl $0x1, %eax
jbe 0x92a7
leaq 0x2d560(%rip), %rdi # 0x367a2
leaq 0x2e8f9(%rip), %rsi # 0x37b42
callq 0x8710
testq %rax, %rax
je 0x92a7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movl $0x2a, %esi
movq %rax, %rdx
callq 0x88e0
testq %rax, %rax
je 0x9293
movl $0xa30, %eax # imm = 0xA30
xorl 0x10(%rsp), %eax
movzbl 0x12(%rsp), %ecx
orw %ax, %cx
je 0x9293
leaq 0x2d53e(%rip), %rsi # 0x367c5
movl $0x3, %edi
xorl %eax, %eax
callq 0x82d0
movq %rbx, %rdi
callq 0x8610
jmp 0x92a7
movl $0x0, 0x4442d(%rip) # 0x4d6d4
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x8c60
jmp 0x92a7
leaq 0x2d3fb(%rip), %rdi # 0x366c2
leaq 0x2d453(%rip), %rdx # 0x36721
leaq 0x2d463(%rip), %rcx # 0x36738
movl $0x92f, %esi # imm = 0x92F
xorl %eax, %eax
callq 0x89c0
leaq 0x2d3da(%rip), %rdi # 0x366c2
leaq 0x2d432(%rip), %rdx # 0x36721
leaq 0x2d442(%rip), %rcx # 0x36738
movl $0x906, %esi # imm = 0x906
jmp 0x92da
leaq 0x2d3be(%rip), %rdi # 0x366c2
leaq 0x2d416(%rip), %rdx # 0x36721
leaq 0x2d426(%rip), %rcx # 0x36738
movl $0x90e, %esi # imm = 0x90E
jmp 0x92da
| ggml_numa_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1D8h
cmp cs:dword_4D6D4, 0
jnz loc_92B9
mov cs:g_state, edi
call _pthread_self
vxorps xmm0, xmm0, xmm0
lea rbx, [rsp+208h+var_138]
vmovups ymmword ptr [rbx], ymm0
vmovups ymmword ptr [rbx+20h], ymm0
vmovups ymmword ptr [rbx+40h], ymm0
vmovups ymmword ptr [rbx+60h], ymm0
mov esi, 80h
mov rdi, rax
mov rdx, rbx
vzeroupper
call _pthread_getaffinity_np
vmovups ymm0, ymmword ptr [rbx]
vmovups ymm1, ymmword ptr [rbx+20h]
vmovups ymm2, ymmword ptr [rbx+40h]
vmovups ymm3, ymmword ptr [rbx+60h]
vmovups cs:ymmword_4D6E0, ymm0
vmovups cs:ymmword_4D700, ymm1
vmovups cs:ymmword_4D720, ymm2
vmovups cs:ymmword_4D740, ymm3
mov ecx, cs:dword_4D6D4
cmp ecx, 7
ja short loc_90D6
lea rbx, aSysDevicesSyst; "/sys/devices/system/node/node%u"
lea r14, [rsp+208h+var_138]
lea r15, [rsp+208h+var_1C8]
loc_9092:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
xor eax, eax
vzeroupper
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_92E1
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_90D6
mov ecx, cs:dword_4D6D4
inc ecx
mov cs:dword_4D6D4, ecx
cmp ecx, 8
jb short loc_9092
loc_90D6:
mov ecx, cs:dword_4D6D8
cmp ecx, 1FFh
ja short loc_913F
lea rbx, aSysDevicesSyst_0; "/sys/devices/system/cpu/cpu%u"
lea r14, [rsp+208h+var_138]
lea r15, [rsp+208h+var_1C8]
loc_90F8:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
xor eax, eax
vzeroupper
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_92FD
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_913F
mov ecx, cs:dword_4D6D8
inc ecx
mov cs:dword_4D6D8, ecx
cmp ecx, 200h
jb short loc_90F8
loc_913F:
lea rsi, dword_4D6DC
lea rdi, [rsp+208h+var_1FC]
vzeroupper
call _getcpu
cmp cs:dword_4D6D4, 0
jz loc_929D
cmp cs:dword_4D6D8, 0
jz loc_929D
test eax, eax
jnz loc_929D
cmp cs:dword_4D6D4, 0
jz loc_92A7
lea rbx, aSysDevicesSyst_1; "/sys/devices/system/node/node%u/cpu%u"
lea r14, [rsp+208h+var_138]
lea r15, [rsp+208h+var_1C8]
xor r12d, r12d
loc_9199:
mov rax, r12
shl rax, 0Bh
lea rax, [rax+r12*4]
lea rcx, g_state
mov dword ptr [rcx+rax+804h], 0
cmp cs:dword_4D6D8, 0
jz short loc_9224
lea rcx, g_state
lea r13, [rcx+rax]
add r13, 4
xor ebp, ebp
loc_91D0:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
mov ecx, r12d
mov r8d, ebp
xor eax, eax
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_92C0
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_921A
mov eax, [r13+800h]
lea ecx, [rax+1]
mov [r13+800h], ecx
mov [r13+rax*4+0], ebp
loc_921A:
inc ebp
cmp ebp, cs:dword_4D6D8
jb short loc_91D0
loc_9224:
inc r12
mov eax, cs:dword_4D6D4
cmp r12, rax
jb loc_9199
cmp eax, 1
jbe short loc_92A7
lea rdi, aProcSysKernelN; "/proc/sys/kernel/numa_balancing"
lea rsi, aGgmlNrowsDstNr+14h; "r"
call _fopen
test rax, rax
jz short loc_92A7
mov rbx, rax
lea rdi, [rsp+208h+var_1F8]
mov esi, 2Ah ; '*'
mov rdx, rax
call _fgets
test rax, rax
jz short loc_9293
mov eax, 0A30h
xor eax, [rsp+208h+var_1F8]
movzx ecx, byte ptr [rsp+208h+var_1F8+2]
or cx, ax
jz short loc_9293
lea rsi, aProcSysKernelN_0; "/proc/sys/kernel/numa_balancing is enab"...
mov edi, 3
xor eax, eax
call _ggml_log_internal
loc_9293:
mov rdi, rbx
call _fclose
jmp short loc_92A7
loc_929D:
mov cs:dword_4D6D4, 0
loc_92A7:
add rsp, 1D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_92B9:
call ggml_numa_init_cold_1
jmp short loc_92A7
loc_92C0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 92Fh
loc_92DA:
xor eax, eax
call _ggml_abort
loc_92E1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 906h
jmp short loc_92DA
loc_92FD:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 90Eh
jmp short loc_92DA
| long long ggml_numa_init(int a1, __m128 _XMM0)
{
long long v3; // rax
unsigned int v10; // ecx
unsigned int v11; // ecx
long long result; // rax
unsigned long long v13; // r12
int v14; // ebp
long long v15; // rax
long long v16; // rbx
long long i; // rsi
char v18[4]; // [rsp+Ch] [rbp-1FCh] BYREF
unsigned __int16 v19; // [rsp+10h] [rbp-1F8h] BYREF
unsigned __int8 v20; // [rsp+12h] [rbp-1F6h]
_BYTE v21[144]; // [rsp+40h] [rbp-1C8h] BYREF
_BYTE v22[312]; // [rsp+D0h] [rbp-138h] BYREF
if ( dword_4D6D4 )
return ggml_numa_init_cold_1();
g_state[0] = a1;
v3 = pthread_self();
__asm { vxorps xmm0, xmm0, xmm0 }
_RBX = v22;
__asm
{
vmovups ymmword ptr [rbx], ymm0
vmovups ymmword ptr [rbx+20h], ymm0
vmovups ymmword ptr [rbx+40h], ymm0
vmovups ymmword ptr [rbx+60h], ymm0
vzeroupper
}
pthread_getaffinity_np(v3, 128LL, v22, *(double *)&_XMM0);
__asm
{
vmovups ymm0, ymmword ptr [rbx]
vmovups ymm1, ymmword ptr [rbx+20h]
vmovups ymm2, ymmword ptr [rbx+40h]
vmovups ymm3, ymmword ptr [rbx+60h]
vmovups cs:ymmword_4D6E0, ymm0
vmovups cs:ymmword_4D700, ymm1
vmovups cs:ymmword_4D720, ymm2
vmovups cs:ymmword_4D740, ymm3
}
v10 = dword_4D6D4;
if ( (unsigned int)dword_4D6D4 <= 7 )
{
do
{
__asm { vzeroupper }
if ( (unsigned int)snprintf(v22, 256LL, "/sys/devices/system/node/node%u", v10) - 1 >= 0xFF )
goto LABEL_33;
if ( (unsigned int)stat(v22, v21) )
break;
v10 = dword_4D6D4 + 1;
dword_4D6D4 = v10;
}
while ( v10 < 8 );
}
v11 = dword_4D6D8;
if ( (unsigned int)dword_4D6D8 <= 0x1FF )
{
while ( 1 )
{
__asm { vzeroupper }
if ( (unsigned int)snprintf(v22, 256LL, "/sys/devices/system/cpu/cpu%u", v11) - 1 >= 0xFF )
break;
if ( !(unsigned int)stat(v22, v21) )
{
v11 = dword_4D6D8 + 1;
dword_4D6D8 = v11;
if ( v11 < 0x200 )
continue;
}
goto LABEL_10;
}
for ( i = 2318LL; ; i = 2310LL )
{
LABEL_32:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
i,
"GGML_ASSERT(%s) failed");
LABEL_33:
;
}
}
LABEL_10:
__asm { vzeroupper }
result = getcpu(v18, &dword_4D6DC);
if ( !dword_4D6D4 || !dword_4D6D8 || (_DWORD)result )
{
dword_4D6D4 = 0;
return result;
}
if ( !dword_4D6D4 )
return result;
v13 = 0LL;
do
{
g_state[513 * v13 + 513] = 0;
if ( dword_4D6D8 )
{
v14 = 0;
while ( (unsigned int)snprintf(v22, 256LL, "/sys/devices/system/node/node%u/cpu%u", v13, v14) - 1 < 0xFF )
{
if ( !(unsigned int)stat(v22, v21) )
{
v15 = (unsigned int)g_state[513 * v13 + 513];
g_state[513 * v13 + 513] = v15 + 1;
g_state[513 * v13 + 1 + v15] = v14;
}
if ( ++v14 >= (unsigned int)dword_4D6D8 )
goto LABEL_21;
}
i = 2351LL;
goto LABEL_32;
}
LABEL_21:
++v13;
result = (unsigned int)dword_4D6D4;
}
while ( v13 < (unsigned int)dword_4D6D4 );
if ( (unsigned int)dword_4D6D4 > 1 )
{
result = fopen("/proc/sys/kernel/numa_balancing", "r");
if ( result )
{
v16 = result;
if ( fgets(&v19, 42LL, result) )
{
if ( v19 ^ 0xA30 | v20 )
ggml_log_internal(
3LL,
"/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
}
return fclose(v16);
}
}
return result;
}
| ggml_numa_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1d8
CMP dword ptr [0x0014d6d4],0x0
JNZ 0x001092b9
MOV dword ptr [0x001496b0],EDI
CALL 0x00108570
VXORPS XMM0,XMM0,XMM0
LEA RBX,[RSP + 0xd0]
VMOVUPS ymmword ptr [RBX],YMM0
VMOVUPS ymmword ptr [RBX + 0x20],YMM0
VMOVUPS ymmword ptr [RBX + 0x40],YMM0
VMOVUPS ymmword ptr [RBX + 0x60],YMM0
MOV ESI,0x80
MOV RDI,RAX
MOV RDX,RBX
VZEROUPPER
CALL 0x00108aa0
VMOVUPS YMM0,ymmword ptr [RBX]
VMOVUPS YMM1,ymmword ptr [RBX + 0x20]
VMOVUPS YMM2,ymmword ptr [RBX + 0x40]
VMOVUPS YMM3,ymmword ptr [RBX + 0x60]
VMOVUPS ymmword ptr [0x0014d6e0],YMM0
VMOVUPS ymmword ptr [0x0014d700],YMM1
VMOVUPS ymmword ptr [0x0014d720],YMM2
VMOVUPS ymmword ptr [0x0014d740],YMM3
MOV ECX,dword ptr [0x0014d6d4]
CMP ECX,0x7
JA 0x001090d6
LEA RBX,[0x1366a2]
LEA R14,[RSP + 0xd0]
LEA R15,[RSP + 0x40]
LAB_00109092:
MOV ESI,0x100
MOV RDI,R14
MOV RDX,RBX
XOR EAX,EAX
VZEROUPPER
CALL 0x00108940
DEC EAX
CMP EAX,0xff
JNC 0x001092e1
MOV RDI,R14
MOV RSI,R15
CALL 0x00108590
TEST EAX,EAX
JNZ 0x001090d6
MOV ECX,dword ptr [0x0014d6d4]
INC ECX
MOV dword ptr [0x0014d6d4],ECX
CMP ECX,0x8
JC 0x00109092
LAB_001090d6:
MOV ECX,dword ptr [0x0014d6d8]
CMP ECX,0x1ff
JA 0x0010913f
LEA RBX,[0x13675e]
LEA R14,[RSP + 0xd0]
LEA R15,[RSP + 0x40]
LAB_001090f8:
MOV ESI,0x100
MOV RDI,R14
MOV RDX,RBX
XOR EAX,EAX
VZEROUPPER
CALL 0x00108940
DEC EAX
CMP EAX,0xff
JNC 0x001092fd
MOV RDI,R14
MOV RSI,R15
CALL 0x00108590
TEST EAX,EAX
JNZ 0x0010913f
MOV ECX,dword ptr [0x0014d6d8]
INC ECX
MOV dword ptr [0x0014d6d8],ECX
CMP ECX,0x200
JC 0x001090f8
LAB_0010913f:
LEA RSI,[0x14d6dc]
LEA RDI,[RSP + 0xc]
VZEROUPPER
CALL 0x00108410
CMP dword ptr [0x0014d6d4],0x0
JZ 0x0010929d
CMP dword ptr [0x0014d6d8],0x0
JZ 0x0010929d
TEST EAX,EAX
JNZ 0x0010929d
CMP dword ptr [0x0014d6d4],0x0
JZ 0x001092a7
LEA RBX,[0x13677c]
LEA R14,[RSP + 0xd0]
LEA R15,[RSP + 0x40]
XOR R12D,R12D
LAB_00109199:
MOV RAX,R12
SHL RAX,0xb
LEA RAX,[RAX + R12*0x4]
LEA RCX,[0x1496b0]
MOV dword ptr [RCX + RAX*0x1 + 0x804],0x0
CMP dword ptr [0x0014d6d8],0x0
JZ 0x00109224
LEA RCX,[0x1496b0]
LEA R13,[RCX + RAX*0x1]
ADD R13,0x4
XOR EBP,EBP
LAB_001091d0:
MOV ESI,0x100
MOV RDI,R14
MOV RDX,RBX
MOV ECX,R12D
MOV R8D,EBP
XOR EAX,EAX
CALL 0x00108940
DEC EAX
CMP EAX,0xff
JNC 0x001092c0
MOV RDI,R14
MOV RSI,R15
CALL 0x00108590
TEST EAX,EAX
JNZ 0x0010921a
MOV EAX,dword ptr [R13 + 0x800]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R13 + 0x800],ECX
MOV dword ptr [R13 + RAX*0x4],EBP
LAB_0010921a:
INC EBP
CMP EBP,dword ptr [0x0014d6d8]
JC 0x001091d0
LAB_00109224:
INC R12
MOV EAX,dword ptr [0x0014d6d4]
CMP R12,RAX
JC 0x00109199
CMP EAX,0x1
JBE 0x001092a7
LEA RDI,[0x1367a2]
LEA RSI,[0x137b42]
CALL 0x00108710
TEST RAX,RAX
JZ 0x001092a7
MOV RBX,RAX
LEA RDI,[RSP + 0x10]
MOV ESI,0x2a
MOV RDX,RAX
CALL 0x001088e0
TEST RAX,RAX
JZ 0x00109293
MOV EAX,0xa30
XOR EAX,dword ptr [RSP + 0x10]
MOVZX ECX,byte ptr [RSP + 0x12]
OR CX,AX
JZ 0x00109293
LEA RSI,[0x1367c5]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x001082d0
LAB_00109293:
MOV RDI,RBX
CALL 0x00108610
JMP 0x001092a7
LAB_0010929d:
MOV dword ptr [0x0014d6d4],0x0
LAB_001092a7:
ADD RSP,0x1d8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001092b9:
CALL 0x00108c60
JMP 0x001092a7
LAB_001092c0:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136738]
MOV ESI,0x92f
LAB_001092da:
XOR EAX,EAX
CALL 0x001089c0
LAB_001092e1:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136738]
MOV ESI,0x906
JMP 0x001092da
LAB_001092fd:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136738]
MOV ESI,0x90e
JMP 0x001092da
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_numa_init(int4 param_1)
{
int iVar1;
pthread_t __th;
FILE *__stream;
char *pcVar2;
uint uVar3;
ulong uVar4;
int8 uVar5;
ulong uVar6;
int1 local_1fc [4];
char local_1f8 [2];
char cStack_1f6;
stat local_1c8;
int1 local_138 [40];
__cpu_mask _Stack_110;
__cpu_mask _Stack_108;
__cpu_mask _Stack_100;
int1 local_f8 [32];
int1 local_d8 [32];
if (DAT_0014d6d4 == 0) {
g_state = param_1;
__th = pthread_self();
local_138._0_32_ = ZEXT1632(ZEXT816(0) << 0x40);
local_f8 = ZEXT1632(ZEXT816(0) << 0x40);
unique0x10000440 = local_138._0_32_;
local_d8 = local_f8;
pthread_getaffinity_np(__th,0x80,(cpu_set_t *)local_138);
_DAT_0014d6e0 = local_138._0_8_;
_Ram000000000014d6e8 = local_138._8_8_;
_Ram000000000014d6f0 = local_138._16_8_;
_Ram000000000014d6f8 = local_138._24_8_;
_DAT_0014d700 = local_138._32_8_;
_Ram000000000014d708 = _Stack_110;
_Ram000000000014d710 = _Stack_108;
_Ram000000000014d718 = _Stack_100;
_DAT_0014d720 = local_f8._0_8_;
_Ram000000000014d728 = local_f8._8_8_;
_Ram000000000014d730 = local_f8._16_8_;
_Ram000000000014d738 = local_f8._24_8_;
_DAT_0014d740 = local_d8._0_8_;
_Ram000000000014d748 = local_d8._8_8_;
_Ram000000000014d750 = local_d8._16_8_;
_Ram000000000014d758 = local_d8._24_8_;
if (DAT_0014d6d4 < 8) {
do {
iVar1 = snprintf(local_138,0x100,"/sys/devices/system/node/node%u");
if (0xfe < iVar1 - 1U) {
uVar5 = 0x906;
goto LAB_001092da;
}
iVar1 = stat(local_138,&local_1c8);
if (iVar1 != 0) break;
DAT_0014d6d4 = DAT_0014d6d4 + 1;
} while (DAT_0014d6d4 < 8);
}
if (DAT_0014d6d8 < 0x200) {
do {
iVar1 = snprintf(local_138,0x100,"/sys/devices/system/cpu/cpu%u");
if (0xfe < iVar1 - 1U) {
uVar5 = 0x90e;
LAB_001092da:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,uVar5,"GGML_ASSERT(%s) failed","rv > 0 && (unsigned)rv < sizeof(path)");
}
iVar1 = stat(local_138,&local_1c8);
if (iVar1 != 0) break;
DAT_0014d6d8 = DAT_0014d6d8 + 1;
} while (DAT_0014d6d8 < 0x200);
}
iVar1 = getcpu(local_1fc,&DAT_0014d6dc);
if (((DAT_0014d6d4 == 0) || (DAT_0014d6d8 == 0)) || (iVar1 != 0)) {
DAT_0014d6d4 = 0;
}
else if (DAT_0014d6d4 != 0) {
uVar6 = 0;
do {
(&DAT_00149eb4)[uVar6 * 0x201] = 0;
if (DAT_0014d6d8 != 0) {
uVar4 = 0;
do {
iVar1 = snprintf(local_138,0x100,"/sys/devices/system/node/node%u/cpu%u",
uVar6 & 0xffffffff,uVar4);
if (0xfe < iVar1 - 1U) {
uVar5 = 0x92f;
goto LAB_001092da;
}
iVar1 = stat(local_138,&local_1c8);
if (iVar1 == 0) {
uVar3 = (&DAT_00149eb4)[uVar6 * 0x201];
(&DAT_00149eb4)[uVar6 * 0x201] = uVar3 + 1;
(&DAT_001496b4)[uVar6 * 0x201 + (ulong)uVar3] = (int)uVar4;
}
uVar3 = (int)uVar4 + 1;
uVar4 = (ulong)uVar3;
} while (uVar3 < DAT_0014d6d8);
}
uVar6 = uVar6 + 1;
} while (uVar6 < DAT_0014d6d4);
if (1 < DAT_0014d6d4) {
__stream = fopen("/proc/sys/kernel/numa_balancing","r");
if (__stream != (FILE *)0x0) {
pcVar2 = fgets(local_1f8,0x2a,__stream);
if ((pcVar2 != (char *)0x0) && (cStack_1f6 != '\0' || (short)_local_1f8 != 0xa30)) {
ggml_log_internal(3,
"/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n"
);
}
fclose(__stream);
}
}
}
}
else {
ggml_numa_init_cold_1();
}
return;
}
| |
31,287 | ggml_numa_init | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_numa_init(enum ggml_numa_strategy numa_flag) {
if (g_state.numa.n_nodes > 0) {
fprintf(stderr, "ggml_numa_init: NUMA already initialized\n");
return;
}
#if defined(__gnu_linux__)
struct stat st;
char path[256];
int rv;
// set numa scheme
g_state.numa.numa_strategy = numa_flag;
GGML_PRINT_DEBUG("numa strategy %u\n",g_state.numa.numa_strategy);
g_state.numa.cpuset = ggml_get_numa_affinity();
// enumerate nodes
while (g_state.numa.n_nodes < GGML_NUMA_MAX_NODES) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u", g_state.numa.n_nodes);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.n_nodes;
}
// enumerate CPUs
while (g_state.numa.total_cpus < GGML_NUMA_MAX_CPUS) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%u", g_state.numa.total_cpus);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.total_cpus;
}
GGML_PRINT_DEBUG("found %u numa nodes, %u CPUs\n", g_state.numa.n_nodes, g_state.numa.total_cpus);
// figure out which node we're on
uint current_cpu;
int getcpu_ret = 0;
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 33) || defined(__COSMOPOLITAN__)
getcpu_ret = getcpu(¤t_cpu, &g_state.numa.current_node);
#else
// old glibc doesn't have a wrapper for this call. Fall back on direct syscall
# if !defined(SYS_getcpu) && defined(SYS_get_cpu)
# define SYS_getcpu SYS_get_cpu // some older glibc versions use this name
# endif
getcpu_ret = syscall(SYS_getcpu, ¤t_cpu, &g_state.numa.current_node);
#endif
if (g_state.numa.n_nodes < 1 || g_state.numa.total_cpus < 1 || getcpu_ret != 0) {
g_state.numa.n_nodes = 0;
return;
}
GGML_PRINT_DEBUG("found our process on numa node %u, CPU %u\n", g_state.numa.current_node, current_cpu);
for (uint32_t n = 0; n < g_state.numa.n_nodes; ++n) {
struct ggml_numa_node * node = &g_state.numa.nodes[n];
GGML_PRINT_DEBUG("CPUs on node %u:", n);
node->n_cpus = 0;
for (uint32_t c = 0; c < g_state.numa.total_cpus; ++c) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u/cpu%u", n, c);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) == 0) {
node->cpus[node->n_cpus++] = c;
GGML_PRINT_DEBUG(" %u", c);
}
}
GGML_PRINT_DEBUG("\n");
}
if (ggml_is_numa()) {
FILE *fptr = fopen("/proc/sys/kernel/numa_balancing", "r");
if (fptr != NULL) {
char buf[42];
if (fgets(buf, sizeof(buf), fptr) && strncmp(buf, "0\n", sizeof(buf)) != 0) {
GGML_LOG_WARN("/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
}
fclose(fptr);
}
}
#else
UNUSED(numa_flag);
// TODO
#endif
} | O2 | c | ggml_numa_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
cmpl $0x0, 0x41819(%rip) # 0x4a7a4
jne 0x921d
movl %edi, 0x3d7e9(%rip) # 0x46780
callq 0x8630
vxorps %xmm0, %xmm0, %xmm0
leaq 0xd0(%rsp), %rbx
vmovups %ymm0, (%rbx)
vmovups %ymm0, 0x20(%rbx)
vmovups %ymm0, 0x40(%rbx)
vmovups %ymm0, 0x60(%rbx)
movl $0x80, %esi
movq %rax, %rdi
movq %rbx, %rdx
vzeroupper
callq 0x8c00
vmovups (%rbx), %ymm0
vmovups 0x20(%rbx), %ymm1
vmovups 0x40(%rbx), %ymm2
vmovups 0x60(%rbx), %ymm3
vmovups %ymm0, 0x417c7(%rip) # 0x4a7b0
vmovups %ymm1, 0x417df(%rip) # 0x4a7d0
vmovups %ymm2, 0x417f7(%rip) # 0x4a7f0
vmovups %ymm3, 0x4180f(%rip) # 0x4a810
movl 0x4179d(%rip), %ecx # 0x4a7a4
leaq 0x2a72c(%rip), %r14 # 0x3373a
leaq 0x40(%rsp), %r15
cmpl $0x7, %ecx
ja 0x9059
movl $0x100, %esi # imm = 0x100
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
vzeroupper
callq 0x8a80
decl %eax
cmpl $0xff, %eax
jae 0x926b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8650
testl %eax, %eax
jne 0x9059
movl 0x41755(%rip), %ecx # 0x4a7a4
incl %ecx
movl %ecx, 0x4174d(%rip) # 0x4a7a4
jmp 0x9013
movl 0x41749(%rip), %ecx # 0x4a7a8
leaq 0x2a790(%rip), %rbx # 0x337f6
leaq 0xd0(%rsp), %r14
leaq 0x40(%rsp), %r15
cmpl $0x1ff, %ecx # imm = 0x1FF
ja 0x90bc
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
vzeroupper
callq 0x8a80
decl %eax
cmpl $0xff, %eax
jae 0x9287
movq %r14, %rdi
movq %r15, %rsi
callq 0x8650
testl %eax, %eax
jne 0x90bc
movl 0x416f6(%rip), %ecx # 0x4a7a8
incl %ecx
movl %ecx, 0x416ee(%rip) # 0x4a7a8
jmp 0x9073
leaq 0x416e9(%rip), %rsi # 0x4a7ac
leaq 0xc(%rsp), %rdi
vzeroupper
callq 0x84d0
movl 0x416ce(%rip), %edx # 0x4a7a4
testl %edx, %edx
je 0x919c
movl 0x416c4(%rip), %ecx # 0x4a7a8
testl %ecx, %ecx
je 0x919c
testl %eax, %eax
jne 0x919c
leaq 0x2a719(%rip), %rbx # 0x33814
leaq 0xd0(%rsp), %r14
leaq 0x40(%rsp), %r15
xorl %r12d, %r12d
movl %edx, %eax
cmpq %rax, %r12
jae 0x91a5
imulq $0x804, %r12, %rax # imm = 0x804
leaq 0x3d65c(%rip), %rdx # 0x46780
leaq (%rax,%rdx), %r13
addq $0x4, %r13
andl $0x0, 0x800(%r13)
xorl %ebp, %ebp
cmpl %ecx, %ebp
jae 0x918e
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x8a80
decl %eax
cmpl $0xff, %eax
jae 0x924a
movq %r14, %rdi
movq %r15, %rsi
callq 0x8650
testl %eax, %eax
jne 0x9184
movl 0x800(%r13), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x800(%r13)
movl %ebp, (%r13,%rax,4)
incl %ebp
movl 0x4161c(%rip), %ecx # 0x4a7a8
jmp 0x9136
incq %r12
movl 0x4160d(%rip), %edx # 0x4a7a4
jmp 0x910b
andl $0x0, 0x41601(%rip) # 0x4a7a4
jmp 0x920b
cmpl $0x1, %edx
jbe 0x920b
leaq 0x2a689(%rip), %rdi # 0x3383a
leaq 0x2ba29(%rip), %rsi # 0x34be1
callq 0x8800
testq %rax, %rax
je 0x920b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
pushq $0x2a
popq %rsi
movq %rax, %rdx
callq 0x8a20
testq %rax, %rax
je 0x9203
leaq 0x2a679(%rip), %rsi # 0x3385a
leaq 0x10(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x8740
testl %eax, %eax
je 0x9203
leaq 0x2a664(%rip), %rsi # 0x3385d
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x8340
movq %rbx, %rdi
callq 0x86f0
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3cd9c(%rip), %rax # 0x45fc0
movq (%rax), %rcx
leaq 0x2a4e2(%rip), %rdi # 0x33710
pushq $0x29
popq %rsi
pushq $0x1
popq %rdx
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8d50
leaq 0x2a509(%rip), %rdi # 0x3375a
leaq 0x2a561(%rip), %rdx # 0x337b9
leaq 0x2a571(%rip), %rcx # 0x337d0
movl $0x92f, %esi # imm = 0x92F
xorl %eax, %eax
callq 0x8b10
leaq 0x2a4e8(%rip), %rdi # 0x3375a
leaq 0x2a540(%rip), %rdx # 0x337b9
leaq 0x2a550(%rip), %rcx # 0x337d0
movl $0x906, %esi # imm = 0x906
jmp 0x9264
leaq 0x2a4cc(%rip), %rdi # 0x3375a
leaq 0x2a524(%rip), %rdx # 0x337b9
leaq 0x2a534(%rip), %rcx # 0x337d0
movl $0x90e, %esi # imm = 0x90E
jmp 0x9264
| ggml_numa_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1D8h
cmp cs:dword_4A7A4, 0
jnz loc_921D
mov cs:g_state, edi
call _pthread_self
vxorps xmm0, xmm0, xmm0
lea rbx, [rsp+208h+var_138]
vmovups ymmword ptr [rbx], ymm0
vmovups ymmword ptr [rbx+20h], ymm0
vmovups ymmword ptr [rbx+40h], ymm0
vmovups ymmword ptr [rbx+60h], ymm0
mov esi, 80h
mov rdi, rax
mov rdx, rbx
vzeroupper
call _pthread_getaffinity_np
vmovups ymm0, ymmword ptr [rbx]
vmovups ymm1, ymmword ptr [rbx+20h]
vmovups ymm2, ymmword ptr [rbx+40h]
vmovups ymm3, ymmword ptr [rbx+60h]
vmovups cs:ymmword_4A7B0, ymm0
vmovups cs:ymmword_4A7D0, ymm1
vmovups cs:ymmword_4A7F0, ymm2
vmovups cs:ymmword_4A810, ymm3
mov ecx, cs:dword_4A7A4
lea r14, aSysDevicesSyst; "/sys/devices/system/node/node%u"
lea r15, [rsp+208h+var_1C8]
loc_9013:
cmp ecx, 7
ja short loc_9059
mov esi, 100h
mov rdi, rbx
mov rdx, r14
xor eax, eax
vzeroupper
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_926B
mov rdi, rbx
mov rsi, r15
call _stat
test eax, eax
jnz short loc_9059
mov ecx, cs:dword_4A7A4
inc ecx
mov cs:dword_4A7A4, ecx
jmp short loc_9013
loc_9059:
mov ecx, cs:dword_4A7A8
lea rbx, aSysDevicesSyst_0; "/sys/devices/system/cpu/cpu%u"
lea r14, [rsp+208h+var_138]
lea r15, [rsp+208h+var_1C8]
loc_9073:
cmp ecx, 1FFh
ja short loc_90BC
mov esi, 100h
mov rdi, r14
mov rdx, rbx
xor eax, eax
vzeroupper
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_9287
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_90BC
mov ecx, cs:dword_4A7A8
inc ecx
mov cs:dword_4A7A8, ecx
jmp short loc_9073
loc_90BC:
lea rsi, dword_4A7AC
lea rdi, [rsp+208h+var_1FC]
vzeroupper
call _getcpu
mov edx, cs:dword_4A7A4
test edx, edx
jz loc_919C
mov ecx, cs:dword_4A7A8
test ecx, ecx
jz loc_919C
test eax, eax
jnz loc_919C
lea rbx, aSysDevicesSyst_1; "/sys/devices/system/node/node%u/cpu%u"
lea r14, [rsp+208h+var_138]
lea r15, [rsp+208h+var_1C8]
xor r12d, r12d
loc_910B:
mov eax, edx
cmp r12, rax
jnb loc_91A5
imul rax, r12, 804h
lea rdx, g_state
lea r13, [rax+rdx]
add r13, 4
and dword ptr [r13+800h], 0
xor ebp, ebp
loc_9136:
cmp ebp, ecx
jnb short loc_918E
mov esi, 100h
mov rdi, r14
mov rdx, rbx
mov ecx, r12d
mov r8d, ebp
xor eax, eax
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_924A
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_9184
mov eax, [r13+800h]
lea ecx, [rax+1]
mov [r13+800h], ecx
mov [r13+rax*4+0], ebp
loc_9184:
inc ebp
mov ecx, cs:dword_4A7A8
jmp short loc_9136
loc_918E:
inc r12
mov edx, cs:dword_4A7A4
jmp loc_910B
loc_919C:
and cs:dword_4A7A4, 0
jmp short loc_920B
loc_91A5:
cmp edx, 1
jbe short loc_920B
lea rdi, aProcSysKernelN; "/proc/sys/kernel/numa_balancing"
lea rsi, aGgmlNrowsDstNr+14h; "r"
call _fopen
test rax, rax
jz short loc_920B
mov rbx, rax
lea rdi, [rsp+208h+var_1F8]
push 2Ah ; '*'
pop rsi
mov rdx, rax
call _fgets
test rax, rax
jz short loc_9203
lea rsi, a0; "0\n"
lea rdi, [rsp+208h+var_1F8]
push 3
pop rdx
call _bcmp
test eax, eax
jz short loc_9203
lea rsi, aProcSysKernelN_0; "/proc/sys/kernel/numa_balancing is enab"...
push 3
pop rdi
xor eax, eax
call _ggml_log_internal
loc_9203:
mov rdi, rbx
call _fclose
loc_920B:
add rsp, 1D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_921D:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aGgmlNumaInitNu; "ggml_numa_init: NUMA already initialize"...
push 29h ; ')'
pop rsi
push 1
pop rdx
add rsp, 1D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _fwrite
loc_924A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 92Fh
loc_9264:
xor eax, eax
call _ggml_abort
loc_926B:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 906h
jmp short loc_9264
loc_9287:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov esi, 90Eh
jmp short loc_9264
| long long ggml_numa_init(int a1, __m128 _XMM0)
{
long long v3; // rax
unsigned int i; // ecx
unsigned int j; // ecx
long long result; // rax
unsigned int v13; // edx
unsigned int v14; // ecx
unsigned long long m; // r12
unsigned int n; // ebp
long long v17; // rax
long long v18; // rbx
long long k; // rsi
char v20[4]; // [rsp+Ch] [rbp-1FCh] BYREF
_BYTE v21[48]; // [rsp+10h] [rbp-1F8h] BYREF
_BYTE v22[144]; // [rsp+40h] [rbp-1C8h] BYREF
_BYTE v23[312]; // [rsp+D0h] [rbp-138h] BYREF
if ( dword_4A7A4 )
return fwrite("ggml_numa_init: NUMA already initialized\n", 41LL, 1LL, stderr);
g_state[0] = a1;
v3 = pthread_self();
__asm { vxorps xmm0, xmm0, xmm0 }
_RBX = v23;
__asm
{
vmovups ymmword ptr [rbx], ymm0
vmovups ymmword ptr [rbx+20h], ymm0
vmovups ymmword ptr [rbx+40h], ymm0
vmovups ymmword ptr [rbx+60h], ymm0
vzeroupper
}
pthread_getaffinity_np(v3, 128LL, v23, *(double *)&_XMM0);
__asm
{
vmovups ymm0, ymmword ptr [rbx]
vmovups ymm1, ymmword ptr [rbx+20h]
vmovups ymm2, ymmword ptr [rbx+40h]
vmovups ymm3, ymmword ptr [rbx+60h]
vmovups cs:ymmword_4A7B0, ymm0
vmovups cs:ymmword_4A7D0, ymm1
vmovups cs:ymmword_4A7F0, ymm2
vmovups cs:ymmword_4A810, ymm3
}
for ( i = dword_4A7A4; i <= 7; i = ++dword_4A7A4 )
{
__asm { vzeroupper }
if ( (unsigned int)snprintf(v23, 256LL, "/sys/devices/system/node/node%u", i) - 1 >= 0xFF )
goto LABEL_35;
if ( (unsigned int)stat(v23, v22) )
break;
}
for ( j = dword_4A7A8; j <= 0x1FF; j = ++dword_4A7A8 )
{
__asm { vzeroupper }
if ( (unsigned int)snprintf(v23, 256LL, "/sys/devices/system/cpu/cpu%u", j) - 1 >= 0xFF )
{
for ( k = 2318LL; ; k = 2310LL )
{
LABEL_34:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
k,
"GGML_ASSERT(%s) failed",
"rv > 0 && (unsigned)rv < sizeof(path)");
LABEL_35:
;
}
}
if ( (unsigned int)stat(v23, v22) )
break;
}
__asm { vzeroupper }
result = getcpu(v20, &dword_4A7AC);
v13 = dword_4A7A4;
if ( dword_4A7A4 && (v14 = dword_4A7A8) != 0 && !(_DWORD)result )
{
for ( m = 0LL; ; ++m )
{
result = v13;
if ( m >= v13 )
break;
g_state[513 * m + 513] = 0;
for ( n = 0; n < v14; ++n )
{
if ( (unsigned int)snprintf(v23, 256LL, "/sys/devices/system/node/node%u/cpu%u", m, n) - 1 >= 0xFF )
{
k = 2351LL;
goto LABEL_34;
}
if ( !(unsigned int)stat(v23, v22) )
{
v17 = (unsigned int)g_state[513 * m + 513];
g_state[513 * m + 513] = v17 + 1;
g_state[513 * m + 1 + v17] = n;
}
v14 = dword_4A7A8;
}
v13 = dword_4A7A4;
}
if ( v13 > 1 )
{
result = fopen("/proc/sys/kernel/numa_balancing", "r");
if ( result )
{
v18 = result;
if ( fgets(v21, 42LL, result) && (unsigned int)bcmp(v21, "0\n", 3LL) )
ggml_log_internal(
3LL,
"/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
return fclose(v18);
}
}
}
else
{
dword_4A7A4 = 0;
}
return result;
}
| ggml_numa_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1d8
CMP dword ptr [0x0014a7a4],0x0
JNZ 0x0010921d
MOV dword ptr [0x00146780],EDI
CALL 0x00108630
VXORPS XMM0,XMM0,XMM0
LEA RBX,[RSP + 0xd0]
VMOVUPS ymmword ptr [RBX],YMM0
VMOVUPS ymmword ptr [RBX + 0x20],YMM0
VMOVUPS ymmword ptr [RBX + 0x40],YMM0
VMOVUPS ymmword ptr [RBX + 0x60],YMM0
MOV ESI,0x80
MOV RDI,RAX
MOV RDX,RBX
VZEROUPPER
CALL 0x00108c00
VMOVUPS YMM0,ymmword ptr [RBX]
VMOVUPS YMM1,ymmword ptr [RBX + 0x20]
VMOVUPS YMM2,ymmword ptr [RBX + 0x40]
VMOVUPS YMM3,ymmword ptr [RBX + 0x60]
VMOVUPS ymmword ptr [0x0014a7b0],YMM0
VMOVUPS ymmword ptr [0x0014a7d0],YMM1
VMOVUPS ymmword ptr [0x0014a7f0],YMM2
VMOVUPS ymmword ptr [0x0014a810],YMM3
MOV ECX,dword ptr [0x0014a7a4]
LEA R14,[0x13373a]
LEA R15,[RSP + 0x40]
LAB_00109013:
CMP ECX,0x7
JA 0x00109059
MOV ESI,0x100
MOV RDI,RBX
MOV RDX,R14
XOR EAX,EAX
VZEROUPPER
CALL 0x00108a80
DEC EAX
CMP EAX,0xff
JNC 0x0010926b
MOV RDI,RBX
MOV RSI,R15
CALL 0x00108650
TEST EAX,EAX
JNZ 0x00109059
MOV ECX,dword ptr [0x0014a7a4]
INC ECX
MOV dword ptr [0x0014a7a4],ECX
JMP 0x00109013
LAB_00109059:
MOV ECX,dword ptr [0x0014a7a8]
LEA RBX,[0x1337f6]
LEA R14,[RSP + 0xd0]
LEA R15,[RSP + 0x40]
LAB_00109073:
CMP ECX,0x1ff
JA 0x001090bc
MOV ESI,0x100
MOV RDI,R14
MOV RDX,RBX
XOR EAX,EAX
VZEROUPPER
CALL 0x00108a80
DEC EAX
CMP EAX,0xff
JNC 0x00109287
MOV RDI,R14
MOV RSI,R15
CALL 0x00108650
TEST EAX,EAX
JNZ 0x001090bc
MOV ECX,dword ptr [0x0014a7a8]
INC ECX
MOV dword ptr [0x0014a7a8],ECX
JMP 0x00109073
LAB_001090bc:
LEA RSI,[0x14a7ac]
LEA RDI,[RSP + 0xc]
VZEROUPPER
CALL 0x001084d0
MOV EDX,dword ptr [0x0014a7a4]
TEST EDX,EDX
JZ 0x0010919c
MOV ECX,dword ptr [0x0014a7a8]
TEST ECX,ECX
JZ 0x0010919c
TEST EAX,EAX
JNZ 0x0010919c
LEA RBX,[0x133814]
LEA R14,[RSP + 0xd0]
LEA R15,[RSP + 0x40]
XOR R12D,R12D
LAB_0010910b:
MOV EAX,EDX
CMP R12,RAX
JNC 0x001091a5
IMUL RAX,R12,0x804
LEA RDX,[0x146780]
LEA R13,[RAX + RDX*0x1]
ADD R13,0x4
AND dword ptr [R13 + 0x800],0x0
XOR EBP,EBP
LAB_00109136:
CMP EBP,ECX
JNC 0x0010918e
MOV ESI,0x100
MOV RDI,R14
MOV RDX,RBX
MOV ECX,R12D
MOV R8D,EBP
XOR EAX,EAX
CALL 0x00108a80
DEC EAX
CMP EAX,0xff
JNC 0x0010924a
MOV RDI,R14
MOV RSI,R15
CALL 0x00108650
TEST EAX,EAX
JNZ 0x00109184
MOV EAX,dword ptr [R13 + 0x800]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R13 + 0x800],ECX
MOV dword ptr [R13 + RAX*0x4],EBP
LAB_00109184:
INC EBP
MOV ECX,dword ptr [0x0014a7a8]
JMP 0x00109136
LAB_0010918e:
INC R12
MOV EDX,dword ptr [0x0014a7a4]
JMP 0x0010910b
LAB_0010919c:
AND dword ptr [0x0014a7a4],0x0
JMP 0x0010920b
LAB_001091a5:
CMP EDX,0x1
JBE 0x0010920b
LEA RDI,[0x13383a]
LEA RSI,[0x134be1]
CALL 0x00108800
TEST RAX,RAX
JZ 0x0010920b
MOV RBX,RAX
LEA RDI,[RSP + 0x10]
PUSH 0x2a
POP RSI
MOV RDX,RAX
CALL 0x00108a20
TEST RAX,RAX
JZ 0x00109203
LEA RSI,[0x13385a]
LEA RDI,[RSP + 0x10]
PUSH 0x3
POP RDX
CALL 0x00108740
TEST EAX,EAX
JZ 0x00109203
LEA RSI,[0x13385d]
PUSH 0x3
POP RDI
XOR EAX,EAX
CALL 0x00108340
LAB_00109203:
MOV RDI,RBX
CALL 0x001086f0
LAB_0010920b:
ADD RSP,0x1d8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010921d:
MOV RAX,qword ptr [0x00145fc0]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x133710]
PUSH 0x29
POP RSI
PUSH 0x1
POP RDX
ADD RSP,0x1d8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00108d50
LAB_0010924a:
LEA RDI,[0x13375a]
LEA RDX,[0x1337b9]
LEA RCX,[0x1337d0]
MOV ESI,0x92f
LAB_00109264:
XOR EAX,EAX
CALL 0x00108b10
LAB_0010926b:
LEA RDI,[0x13375a]
LEA RDX,[0x1337b9]
LEA RCX,[0x1337d0]
MOV ESI,0x906
JMP 0x00109264
LAB_00109287:
LEA RDI,[0x13375a]
LEA RDX,[0x1337b9]
LEA RCX,[0x1337d0]
MOV ESI,0x90e
JMP 0x00109264
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_numa_init(int4 param_1)
{
int iVar1;
pthread_t __th;
long lVar2;
FILE *__stream;
char *pcVar3;
uint uVar4;
uint uVar5;
ulong uVar6;
int8 uVar7;
ulong uVar8;
int1 local_1fc [4];
char local_1f8 [48];
stat local_1c8;
int1 local_138 [40];
__cpu_mask _Stack_110;
__cpu_mask _Stack_108;
__cpu_mask _Stack_100;
int1 local_f8 [32];
int1 local_d8 [32];
if (DAT_0014a7a4 != 0) {
fwrite("ggml_numa_init: NUMA already initialized\n",0x29,1,*(FILE **)PTR_stderr_00145fc0);
return;
}
g_state = param_1;
__th = pthread_self();
local_138._0_32_ = ZEXT1632(ZEXT816(0) << 0x40);
local_f8 = ZEXT1632(ZEXT816(0) << 0x40);
unique0x1000042e = local_138._0_32_;
local_d8 = local_f8;
pthread_getaffinity_np(__th,0x80,(cpu_set_t *)local_138);
_DAT_0014a7b0 = local_138._0_8_;
_Ram000000000014a7b8 = local_138._8_8_;
_Ram000000000014a7c0 = local_138._16_8_;
_Ram000000000014a7c8 = local_138._24_8_;
_DAT_0014a7d0 = local_138._32_8_;
_Ram000000000014a7d8 = _Stack_110;
_Ram000000000014a7e0 = _Stack_108;
_Ram000000000014a7e8 = _Stack_100;
_DAT_0014a7f0 = local_f8._0_8_;
_Ram000000000014a7f8 = local_f8._8_8_;
_Ram000000000014a800 = local_f8._16_8_;
_Ram000000000014a808 = local_f8._24_8_;
_DAT_0014a810 = local_d8._0_8_;
_Ram000000000014a818 = local_d8._8_8_;
_Ram000000000014a820 = local_d8._16_8_;
_Ram000000000014a828 = local_d8._24_8_;
for (; DAT_0014a7a4 < 8; DAT_0014a7a4 = DAT_0014a7a4 + 1) {
iVar1 = snprintf((char *)local_138,0x100,"/sys/devices/system/node/node%u");
if (0xfe < iVar1 - 1U) {
uVar7 = 0x906;
goto LAB_00109264;
}
iVar1 = stat((char *)local_138,&local_1c8);
if (iVar1 != 0) break;
}
for (; DAT_0014a7a8 < 0x200; DAT_0014a7a8 = DAT_0014a7a8 + 1) {
iVar1 = snprintf(local_138,0x100,"/sys/devices/system/cpu/cpu%u");
if (0xfe < iVar1 - 1U) {
uVar7 = 0x90e;
LAB_00109264:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,uVar7,"GGML_ASSERT(%s) failed","rv > 0 && (unsigned)rv < sizeof(path)");
}
iVar1 = stat(local_138,&local_1c8);
if (iVar1 != 0) break;
}
iVar1 = getcpu(local_1fc,&DAT_0014a7ac);
if (((DAT_0014a7a4 == 0) || (DAT_0014a7a8 == 0)) || (iVar1 != 0)) {
DAT_0014a7a4 = 0;
return;
}
uVar8 = 0;
uVar4 = DAT_0014a7a8;
do {
if (DAT_0014a7a4 <= uVar8) {
if (DAT_0014a7a4 < 2) {
return;
}
__stream = fopen("/proc/sys/kernel/numa_balancing","r");
if (__stream == (FILE *)0x0) {
return;
}
pcVar3 = fgets(local_1f8,0x2a,__stream);
if ((pcVar3 != (char *)0x0) && (iVar1 = bcmp(local_1f8,&DAT_0013385a,3), iVar1 != 0)) {
ggml_log_internal(3,
"/proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n"
);
}
fclose(__stream);
return;
}
lVar2 = uVar8 * 0x804;
*(int4 *)(&DAT_00146f84 + lVar2) = 0;
uVar6 = 0;
while (uVar5 = (uint)uVar6, uVar5 < uVar4) {
iVar1 = snprintf(local_138,0x100,"/sys/devices/system/node/node%u/cpu%u",uVar8 & 0xffffffff,
uVar6);
if (0xfe < iVar1 - 1U) {
uVar7 = 0x92f;
goto LAB_00109264;
}
iVar1 = stat(local_138,&local_1c8);
if (iVar1 == 0) {
uVar4 = *(uint *)(&DAT_00146f84 + lVar2);
*(uint *)(&DAT_00146f84 + lVar2) = uVar4 + 1;
*(uint *)(&DAT_00146784 + (ulong)uVar4 * 4 + lVar2) = uVar5;
}
uVar4 = DAT_0014a7a8;
uVar6 = (ulong)(uVar5 + 1);
}
uVar8 = uVar8 + 1;
} while( true );
}
| |
31,288 | mysql_query_with_error_report | eloqsql/client/mysqldump.c | static int mysql_query_with_error_report(MYSQL *mysql_con, MYSQL_RES **res,
const char *query)
{
if (mysql_query(mysql_con, query) ||
(res && !((*res)= mysql_store_result(mysql_con))))
{
maybe_die(EX_MYSQLERR, "Couldn't execute '%s': %s (%d)",
query, mysql_error(mysql_con), mysql_errno(mysql_con));
return 1;
}
return 0;
} | O0 | c | mysql_query_with_error_report:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4fe70
cmpl $0x0, %eax
jne 0x39393
cmpq $0x0, -0x18(%rbp)
je 0x393d8
movq -0x10(%rbp), %rdi
callq 0x514c0
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x393d8
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x537f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x537c0
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl %eax, %r8d
movl $0x2, %edi
leaq 0x9ef8c(%rip), %rsi # 0xd8354
movb $0x0, %al
callq 0x3cbf0
movl $0x1, -0x4(%rbp)
jmp 0x393df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_query_with_error_report:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call mysql_query
cmp eax, 0
jnz short loc_39393
cmp [rbp+var_18], 0
jz short loc_393D8
mov rdi, [rbp+var_10]
call mysql_store_result
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz short loc_393D8
loc_39393:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8d, eax
mov edi, 2
lea rsi, aCouldnTExecute; "Couldn't execute '%s': %s (%d)"
mov al, 0
call maybe_die
mov [rbp+var_4], 1
jmp short loc_393DF
loc_393D8:
mov [rbp+var_4], 0
loc_393DF:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_query_with_error_report(long long a1, long long *a2, long long a3)
{
long long v3; // rax
int v4; // eax
int v5; // r9d
int v7; // [rsp+8h] [rbp-28h]
int v8; // [rsp+10h] [rbp-20h]
v8 = a3;
if ( (unsigned int)mysql_query(a1, a3) || a2 && (v3 = mysql_store_result(a1), (*a2 = v3) == 0) )
{
v7 = mysql_error(a1);
v4 = mysql_errno(a1);
maybe_die(2, (unsigned int)"Couldn't execute '%s': %s (%d)", v8, v7, v4, v5, v8);
return 1;
}
else
{
return 0;
}
}
| mysql_query_with_error_report:
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 RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0014fe70
CMP EAX,0x0
JNZ 0x00139393
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001393d8
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001514c0
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x001393d8
LAB_00139393:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001537f0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001537c0
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,EAX
MOV EDI,0x2
LEA RSI,[0x1d8354]
MOV AL,0x0
CALL 0x0013cbf0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001393df
LAB_001393d8:
MOV dword ptr [RBP + -0x4],0x0
LAB_001393df:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_query_with_error_report(int8 param_1,long *param_2,int8 param_3)
{
int iVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
int4 local_c;
iVar1 = mysql_query(param_1,param_3);
if (iVar1 == 0) {
if (param_2 != (long *)0x0) {
lVar3 = mysql_store_result(param_1);
*param_2 = lVar3;
if (lVar3 == 0) goto LAB_00139393;
}
local_c = 0;
}
else {
LAB_00139393:
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
maybe_die(2,"Couldn\'t execute \'%s\': %s (%d)",param_3,uVar4,uVar2);
local_c = 1;
}
return local_c;
}
| |
31,289 | test_backend(ggml_backend*, test_mode, char const*, char const*)::$_0::operator()(std::vector<std::unique_ptr<test_case, std::default_delete<test_case>>, std::allocator<std::unique_ptr<test_case, std::default_delete<test_case>>>>&, char const*) const | llama.cpp/tests/test-backend-ops.cpp | static bool test_backend(ggml_backend_t backend, test_mode mode, const char * op_name, const char * params_filter) {
auto filter_test_cases = [](std::vector<std::unique_ptr<test_case>> & test_cases, const char * params_filter) {
if (params_filter == nullptr) {
return;
}
std::regex params_filter_regex(params_filter);
for (auto it = test_cases.begin(); it != test_cases.end();) {
if (!std::regex_search((*it)->vars(), params_filter_regex)) {
it = test_cases.erase(it);
continue;
}
it++;
}
};
if (mode == MODE_TEST) {
auto test_cases = make_test_cases_eval();
filter_test_cases(test_cases, params_filter);
ggml_backend_t backend_cpu = ggml_backend_init_by_type(GGML_BACKEND_DEVICE_TYPE_CPU, NULL);
if (backend_cpu == NULL) {
printf(" Failed to initialize CPU backend\n");
return false;
}
size_t n_ok = 0;
for (auto & test : test_cases) {
if (test->eval(backend, backend_cpu, op_name)) {
n_ok++;
}
}
printf(" %zu/%zu tests passed\n", n_ok, test_cases.size());
ggml_backend_free(backend_cpu);
return n_ok == test_cases.size();
}
if (mode == MODE_GRAD) {
auto test_cases = make_test_cases_eval();
filter_test_cases(test_cases, params_filter);
size_t n_ok = 0;
for (auto & test : test_cases) {
if (test->eval_grad(backend, op_name)) {
n_ok++;
}
}
printf(" %zu/%zu tests passed\n", n_ok, test_cases.size());
return n_ok == test_cases.size();
}
if (mode == MODE_PERF) {
auto test_cases = make_test_cases_perf();
filter_test_cases(test_cases, params_filter);
for (auto & test : test_cases) {
test->eval_perf(backend, op_name);
}
return true;
}
GGML_ABORT("fatal error");
} | O3 | cpp | test_backend(ggml_backend*, test_mode, char const*, char const*)::$_0::operator()(std::vector<std::unique_ptr<test_case, std::default_delete<test_case>>, std::allocator<std::unique_ptr<test_case, std::default_delete<test_case>>>>&, char const*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rsi, %rsi
je 0x26791
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
movl $0x10, %edx
callq 0x5a208
movq (%rbx), %r14
cmpq 0x8(%rbx), %r14
je 0x2677d
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x58(%rsp), %r13
movq (%r14), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x0, (%rsp)
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x64c97
movl %eax, %ebp
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2673e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2675a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1c100
testb %bpl, %bpl
je 0x26765
addq $0x8, %r14
jmp 0x26773
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66d64
movq %rax, %r14
cmpq 0x8(%rbx), %r14
jne 0x266e7
leaq 0x70(%rsp), %rdi
callq 0x2c92a
leaq 0x60(%rsp), %rdi
callq 0x1cb90
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x267a2
movq %rax, %rbx
jmp 0x267dd
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x267c1
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1c100
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x267dd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1c100
leaq 0x70(%rsp), %rdi
callq 0x2c92a
leaq 0x60(%rsp), %rdi
callq 0x1cb90
movq %rbx, %rdi
callq 0x1c6d0
| _ZZL12test_backendP12ggml_backend9test_modePKcS3_ENK3$_0clERSt6vectorISt10unique_ptrI9test_caseSt14default_deleteIS7_EESaISA_EES3_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
test rsi, rsi
jz loc_26791
mov rbx, rdi
lea rdi, [rsp+0A8h+var_50]
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
mov r14, [rbx]
cmp r14, [rbx+8]
jz loc_2677D
lea r15, [rsp+0A8h+var_98]
lea r12, [rsp+0A8h+var_78]
lea r13, [rsp+0A8h+var_50]
loc_266E7:
mov rsi, [r14]
mov rax, [rsi]
mov rdi, r15
call qword ptr [rax+18h]
mov rdi, [rsp+0A8h+var_98]
mov rsi, [rsp+0A8h+var_90]
add rsi, rdi
xorps xmm0, xmm0
movaps [rsp+0A8h+var_68], xmm0
movaps xmmword ptr [rsp+0A8h+var_78], xmm0
mov [rsp+0A8h+var_A8], 0
mov rdx, r12
mov rcx, r13
xor r8d, r8d
xor r9d, r9d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
mov ebp, eax
mov rdi, [rsp+0A8h+var_78]; void *
test rdi, rdi
jz short loc_2673E
mov rsi, qword ptr [rsp+0A8h+var_68]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2673E:
mov rdi, [rsp+0A8h+var_98]; void *
lea rax, [rsp+0A8h+var_88]
cmp rdi, rax
jz short loc_2675A
mov rsi, [rsp+0A8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2675A:
test bpl, bpl
jz short loc_26765
add r14, 8
jmp short loc_26773
loc_26765:
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorISt10unique_ptrI9test_caseSt14default_deleteIS1_EESaIS4_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPS4_S6_EE; std::vector<std::unique_ptr<test_case>>::_M_erase(__gnu_cxx::__normal_iterator<std::unique_ptr<test_case>*,std::vector<std::unique_ptr<test_case>>>)
mov r14, rax
loc_26773:
cmp r14, [rbx+8]
jnz loc_266E7
loc_2677D:
lea rdi, [rsp+0A8h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0A8h+var_48]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
loc_26791:
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_267A2:
mov rbx, rax
jmp short loc_267DD
mov rbx, rax
mov rdi, [rsp+arg_28]; void *
test rdi, rdi
jz short loc_267C1
mov rsi, [rsp+arg_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_267C1:
mov rdi, [rsp+arg_8]; void *
lea rax, [rsp+arg_18]
cmp rdi, rax
jz short loc_267DD
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_267DD:
lea rdi, [rsp+arg_68]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+arg_58]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, rbx
call __Unwind_Resume
| void test_backend(ggml_backend *,test_mode,char const*,char const*)::$_0::operator()(
long long *a1,
long long a2)
{
long long v2; // r14
char v3; // bp
void *v4; // [rsp+10h] [rbp-98h] BYREF
long long v5; // [rsp+18h] [rbp-90h]
long long v6; // [rsp+20h] [rbp-88h] BYREF
void *v7[2]; // [rsp+30h] [rbp-78h] BYREF
__int128 v8; // [rsp+40h] [rbp-68h]
_BYTE v9[8]; // [rsp+58h] [rbp-50h] BYREF
_BYTE v10[16]; // [rsp+60h] [rbp-48h] BYREF
_BYTE v11[56]; // [rsp+70h] [rbp-38h] BYREF
if ( a2 )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v9, a2, 16LL);
v2 = *a1;
while ( v2 != a1[1] )
{
(*(void ( **)(void **))(**(_QWORD **)v2 + 24LL))(&v4);
v8 = 0LL;
*(_OWORD *)v7 = 0LL;
v3 = std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
(_DWORD)v4,
(int)v4 + (int)v5,
(unsigned int)v7,
(unsigned int)v9,
0,
0,
0);
if ( v7[0] )
operator delete(v7[0], v8 - (unsigned long long)v7[0]);
if ( v4 != &v6 )
operator delete(v4, v6 + 1);
if ( v3 )
v2 += 8LL;
else
v2 = std::vector<std::unique_ptr<test_case>>::_M_erase(a1, v2);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v11);
std::locale::~locale((std::locale *)v10);
}
}
| operator():
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
TEST RSI,RSI
JZ 0x00126791
MOV RBX,RDI
LEA RDI,[RSP + 0x58]
MOV EDX,0x10
CALL 0x0015a208
MOV R14,qword ptr [RBX]
CMP R14,qword ptr [RBX + 0x8]
JZ 0x0012677d
LEA R15,[RSP + 0x10]
LEA R12,[RSP + 0x30]
LEA R13,[RSP + 0x58]
LAB_001266e7:
MOV RSI,qword ptr [R14]
MOV RAX,qword ptr [RSI]
LAB_001266ed:
MOV RDI,R15
CALL qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LAB_0012670d:
MOV dword ptr [RSP],0x0
MOV RDX,R12
MOV RCX,R13
XOR R8D,R8D
XOR R9D,R9D
CALL 0x00164c97
MOV EBP,EAX
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0012673e
MOV RSI,qword ptr [RSP + 0x40]
SUB RSI,RDI
CALL 0x0011c100
LAB_0012673e:
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x0012675a
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011c100
LAB_0012675a:
TEST BPL,BPL
JZ 0x00126765
ADD R14,0x8
JMP 0x00126773
LAB_00126765:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00166d64
LAB_00126770:
MOV R14,RAX
LAB_00126773:
CMP R14,qword ptr [RBX + 0x8]
JNZ 0x001266e7
LAB_0012677d:
LEA RDI,[RSP + 0x70]
CALL 0x0012c92a
LEA RDI,[RSP + 0x60]
CALL 0x0011cb90
LAB_00126791:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* test_backend(ggml_backend*, test_mode, char const*, char
const*)::$_0::TEMPNAMEPLACEHOLDERVALUE(std::vector<std::unique_ptr<test_case,
std::default_delete<test_case> >, std::allocator<std::unique_ptr<test_case,
std::default_delete<test_case> > > >&, char const*) const */
void test_backend(ggml_backend*,test_mode,char_const*,char_const*)::$_0::operator()
(vector *param_1,char *param_2)
{
bool bVar1;
int8 *puVar2;
long *local_98;
long local_90;
long local_88 [2];
void *local_78;
int8 uStack_70;
long local_68;
int8 uStack_60;
basic_regex<char,std::__cxx11::regex_traits<char>> local_50 [8];
locale local_48 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_38 [8];
if (param_2 != (char *)0x0) {
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
(local_50,param_2,0x10);
puVar2 = *(int8 **)param_1;
if (puVar2 != *(int8 **)(param_1 + 8)) {
do {
/* try { // try from 001266ed to 001266f2 has its CatchHandler @ 001267a2 */
(**(code **)(*(long *)*puVar2 + 0x18))(&local_98);
local_68 = 0;
uStack_60 = 0;
local_78 = (void *)0x0;
uStack_70 = 0;
/* try { // try from 0012670d to 00126724 has its CatchHandler @ 001267a7 */
bVar1 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>>
(local_98,local_90 + (long)local_98,&local_78,local_50,0,0,0);
if (local_78 != (void *)0x0) {
operator_delete(local_78,local_68 - (long)local_78);
}
if (local_98 != local_88) {
operator_delete(local_98,local_88[0] + 1);
}
if (bVar1) {
puVar2 = puVar2 + 1;
}
else {
/* try { // try from 00126765 to 0012676f has its CatchHandler @ 001267a0 */
puVar2 = (int8 *)
std::
vector<std::unique_ptr<test_case,std::default_delete<test_case>>,std::allocator<std::unique_ptr<test_case,std::default_delete<test_case>>>>
::_M_erase((vector<std::unique_ptr<test_case,std::default_delete<test_case>>,std::allocator<std::unique_ptr<test_case,std::default_delete<test_case>>>>
*)param_1,puVar2);
}
} while (puVar2 != *(int8 **)(param_1 + 8));
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_38);
std::locale::~locale(local_48);
}
return;
}
| |
31,290 | MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int) | eloqsql/mysys_ssl/my_crypt.cc | virtual int init(const EVP_CIPHER *cipher, int encrypt, const uchar *key,
uint klen, const uchar *iv, uint ivlen)
{
compile_time_assert(MY_AES_CTX_SIZE >= sizeof(MyCTX));
if (unlikely(!cipher))
return MY_AES_BAD_KEYSIZE;
if (EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, encrypt) != 1)
return MY_AES_OPENSSL_ERROR;
DBUG_ASSERT(EVP_CIPHER_CTX_key_length(ctx) == (int)klen);
DBUG_ASSERT(EVP_CIPHER_CTX_iv_length(ctx) <= (int)ivlen);
return MY_AES_OK;
} | O3 | cpp | MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int):
testq %rsi, %rsi
je 0x2ff6f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
movq 0xc8(%rdi), %rdi
xorl %ebx, %ebx
xorl %edx, %edx
movq %r9, %r8
movl %eax, %r9d
callq 0x29730
cmpl $0x1, %eax
pushq $-0x65
popq %rax
cmovel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $-0x66
popq %rax
retq
nop
| _ZN5MyCTX4initEPK13evp_cipher_stiPKhjS4_j:
test rsi, rsi
jz short loc_2FF6F
push rbp
mov rbp, rsp
push rbx
push rax
mov eax, edx
mov rdi, [rdi+0C8h]
xor ebx, ebx
xor edx, edx
mov r8, r9
mov r9d, eax
call _EVP_CipherInit_ex
cmp eax, 1
push 0FFFFFFFFFFFFFF9Bh
pop rax
cmovz eax, ebx
add rsp, 8
pop rbx
pop rbp
retn
loc_2FF6F:
push 0FFFFFFFFFFFFFF9Ah
pop rax
retn
| long long MyCTX::init(long long a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
long long v6; // rax
bool v7; // zf
long long result; // rax
if ( !a2 )
return -102LL;
v7 = (unsigned int)EVP_CipherInit_ex(*(_QWORD *)(a1 + 200), a2, 0LL, a4, a6, a3, v6) == 1;
result = -101LL;
if ( v7 )
return 0LL;
return result;
}
| init:
TEST RSI,RSI
JZ 0x0012ff6f
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EAX,EDX
MOV RDI,qword ptr [RDI + 0xc8]
XOR EBX,EBX
XOR EDX,EDX
MOV R8,R9
MOV R9D,EAX
CALL 0x00129730
CMP EAX,0x1
PUSH -0x65
POP RAX
CMOVZ EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0012ff6f:
PUSH -0x66
POP RAX
RET
|
/* MyCTX::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*,
unsigned int) */
int8
MyCTX::init(evp_cipher_st *param_1,int param_2,uchar *param_3,uint param_4,uchar *param_5,
uint param_6)
{
int iVar1;
int8 uVar2;
int4 in_register_0000000c;
int4 in_register_00000034;
int4 in_register_0000008c;
if (CONCAT44(in_register_00000034,param_2) != 0) {
iVar1 = EVP_CipherInit_ex((EVP_CIPHER_CTX *)param_1[2].init,
(EVP_CIPHER *)CONCAT44(in_register_00000034,param_2),(ENGINE *)0x0,
(uchar *)CONCAT44(in_register_0000000c,param_4),
(uchar *)CONCAT44(in_register_0000008c,param_6),(int)param_3);
uVar2 = 0xffffff9b;
if (iVar1 == 1) {
uVar2 = 0;
}
return uVar2;
}
return 0xffffffffffffff9a;
}
| |
31,291 | my_hash_sort_8bit_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
/*
Remove trailing spaces. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *end= skip_trailing_space(key, len);
my_hash_sort_bin(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_8bit_bin:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0x422e0
movq %r9, %rdi
andq $-0x4, %rdi
cmpq %rsi, %rdi
jbe 0x422e0
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r9, %rax
movb -0x1(%r9), %r10b
cmpq %rdi, %r9
jbe 0x42340
leaq -0x1(%rax), %r9
cmpb $0x20, %r10b
je 0x422c8
jmp 0x422e3
movq %r9, %rax
movq %rax, %rdi
subq %rsi, %rdi
movq %rax, %rdx
movq %rdi, %r9
cmpq %rsi, %rax
jbe 0x42302
leaq -0x1(%rdx), %rax
leaq -0x1(%r9), %rdi
cmpb $0x20, -0x1(%rdx)
je 0x422e9
movq (%rcx), %rax
movq (%r8), %rdi
testq %r9, %r9
jle 0x42338
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x4230d
movq %rax, (%rcx)
movq %rdi, (%r8)
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdi, %rdx
setae %dil
orb %r9b, %dil
jne 0x422e3
movq %rax, %rdi
movq %rdi, %rax
cmpq %rdx, %rdi
jbe 0x422e3
leaq -0x4(%rax), %rdi
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x42357
jmp 0x422e3
| my_hash_sort_8bit_bin:
push rbp
mov rbp, rsp
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_422E0
mov rdi, r9
and rdi, 0FFFFFFFFFFFFFFFCh
cmp rdi, rsi
jbe short loc_422E0
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_422C8:
mov rax, r9
mov r10b, [r9-1]
cmp r9, rdi
jbe short loc_42340
lea r9, [rax-1]
cmp r10b, 20h ; ' '
jz short loc_422C8
jmp short loc_422E3
loc_422E0:
mov rax, r9
loc_422E3:
mov rdi, rax
sub rdi, rsi
loc_422E9:
mov rdx, rax
mov r9, rdi
cmp rax, rsi
jbe short loc_42302
lea rax, [rdx-1]
lea rdi, [r9-1]
cmp byte ptr [rdx-1], 20h ; ' '
jz short loc_422E9
loc_42302:
mov rax, [rcx]
mov rdi, [r8]
test r9, r9
jle short loc_42338
loc_4230D:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_4230D
loc_42338:
mov [rcx], rax
mov [r8], rdi
pop rbp
retn
loc_42340:
cmp r10b, 20h ; ' '
setnz r9b
cmp rdx, rdi
setnb dil
or dil, r9b
jnz short loc_422E3
mov rdi, rax
loc_42357:
mov rax, rdi
cmp rdi, rdx
jbe short loc_422E3
lea rdi, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_42357
jmp loc_422E3
| long long my_hash_sort_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdi
unsigned long long v7; // rdx
unsigned __int8 *v8; // rax
char v9; // r10
long long v10; // rdi
unsigned long long v11; // rdx
long long v12; // r9
long long result; // rax
long long v14; // rdi
unsigned long long v15; // rdi
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = &a2[a3];
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = (unsigned __int8 *)v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v15 = v5;
do
{
v8 = (unsigned __int8 *)v15;
if ( v15 <= v7 )
break;
v15 -= 4LL;
}
while ( *((_DWORD *)v8 - 1) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = (unsigned long long)v8;
v12 = v10;
if ( v8 <= a2 )
break;
--v8;
--v10;
}
while ( *(_BYTE *)(v11 - 1) == 32 );
result = *a4;
v14 = *a5;
if ( v12 > 0 )
{
do
{
result ^= (v14 + (result & 0x3F)) * *a2 + (result << 8);
v14 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v11 );
}
*a4 = result;
*a5 = v14;
return result;
}
| my_hash_sort_8bit_bin:
PUSH RBP
MOV RBP,RSP
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001422e0
MOV RDI,R9
AND RDI,-0x4
CMP RDI,RSI
JBE 0x001422e0
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001422c8:
MOV RAX,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDI
JBE 0x00142340
LEA R9,[RAX + -0x1]
CMP R10B,0x20
JZ 0x001422c8
JMP 0x001422e3
LAB_001422e0:
MOV RAX,R9
LAB_001422e3:
MOV RDI,RAX
SUB RDI,RSI
LAB_001422e9:
MOV RDX,RAX
MOV R9,RDI
CMP RAX,RSI
JBE 0x00142302
LEA RAX,[RDX + -0x1]
LEA RDI,[R9 + -0x1]
CMP byte ptr [RDX + -0x1],0x20
JZ 0x001422e9
LAB_00142302:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST R9,R9
JLE 0x00142338
LAB_0014230d:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x0014230d
LAB_00142338:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
POP RBP
RET
LAB_00142340:
CMP R10B,0x20
SETNZ R9B
CMP RDX,RDI
SETNC DIL
OR DIL,R9B
JNZ 0x001422e3
MOV RDI,RAX
LAB_00142357:
MOV RAX,RDI
CMP RDI,RDX
JBE 0x001422e3
LEA RDI,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x00142357
JMP 0x001422e3
|
void my_hash_sort_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
long lVar6;
pbVar2 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar2 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar2;
do {
pbVar2 = pbVar1;
if (pbVar2 <= pbVar4) {
pbVar1 = pbVar2;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar2[-1] == 0x20)
goto LAB_00142357;
break;
}
pbVar1 = pbVar2 + -1;
} while (pbVar2[-1] == 0x20);
}
goto LAB_001422e3;
while (pbVar1 = pbVar2 + -4, *(int *)(pbVar2 + -4) == 0x20202020) {
LAB_00142357:
pbVar2 = pbVar1;
if (pbVar2 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_001422e3:
lVar6 = (long)pbVar2 - (long)param_2;
do {
lVar5 = lVar6;
pbVar4 = pbVar2;
if (pbVar4 <= param_2) break;
pbVar2 = pbVar4 + -1;
lVar6 = lVar5 + -1;
} while (pbVar4[-1] == 0x20);
uVar3 = *param_4;
lVar6 = *param_5;
if (0 < lVar5) {
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar4);
}
*param_4 = uVar3;
*param_5 = lVar6;
return;
}
| |
31,292 | minja::ArgumentsValue::expectArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::pair<unsigned long, unsigned long> const&, std::pair<unsigned long, unsigned long> const&) | monkey531[P]llama/common/minja.hpp | void expectArgs(const std::string & method_name, const std::pair<size_t, size_t> & pos_count, const std::pair<size_t, size_t> & kw_count) {
if (args.size() < pos_count.first || args.size() > pos_count.second || kwargs.size() < kw_count.first || kwargs.size() > kw_count.second) {
std::ostringstream out;
out << method_name << " must have between " << pos_count.first << " and " << pos_count.second << " positional arguments and between " << kw_count.first << " and " << kw_count.second << " keyword arguments";
throw std::runtime_error(out.str());
}
} | O2 | cpp | minja::ArgumentsValue::expectArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::pair<unsigned long, unsigned long> const&, std::pair<unsigned long, unsigned long> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %rbx
movq %rdx, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rsi, %r15
pushq $0x50
popq %rcx
cqto
idivq %rcx
cmpq (%r14), %rax
jb 0x6ca53
cmpq 0x8(%r14), %rax
ja 0x6ca53
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
pushq $0x70
popq %rcx
cqto
idivq %rcx
cmpq (%rbx), %rax
jb 0x6ca53
cmpq 0x8(%rbx), %rax
ja 0x6ca53
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x23bc0
movq %r12, %rdi
movq %r15, %rsi
callq 0x237f0
leaq 0x47c70(%rip), %rsi # 0xb46e2
movq %rax, %rdi
callq 0x238c0
movq (%r14), %rsi
movq %rax, %rdi
callq 0x23640
leaq 0x47c6a(%rip), %rsi # 0xb46f6
movq %rax, %rdi
callq 0x238c0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x23640
leaq 0x47c55(%rip), %rsi # 0xb46fc
movq %rax, %rdi
callq 0x238c0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x23640
leaq 0x47c35(%rip), %rsi # 0xb46f6
movq %rax, %rdi
callq 0x238c0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x23640
leaq 0x47c43(%rip), %rsi # 0xb471f
movq %rax, %rdi
callq 0x238c0
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x23de0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e60
xorl %ebp, %ebp
movq 0x914d9(%rip), %rsi # 0xfdff0
movq 0x9143a(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23f30
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x24208
testb %bpl, %bpl
jne 0x6cb3d
jmp 0x6cb4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x236b0
jmp 0x6cb4a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x231f0
movq %r14, %rdi
callq 0x23fd0
| _ZN5minja14ArgumentsValue10expectArgsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt4pairImmESC_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 1A0h
mov rbx, rcx
mov r14, rdx
mov rax, [rdi+8]
sub rax, [rdi]
mov r15, rsi
push 50h ; 'P'
pop rcx
cqo
idiv rcx
cmp rax, [r14]
jb short loc_6CA53
cmp rax, [r14+8]
ja short loc_6CA53
mov rax, [rdi+20h]
sub rax, [rdi+18h]
push 70h ; 'p'
pop rcx
cqo
idiv rcx
cmp rax, [rbx]
jb short loc_6CA53
cmp rax, [rbx+8]
ja short loc_6CA53
add rsp, 1A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_6CA53:
lea r12, [rsp+1C8h+var_1A0]
mov rdi, r12
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rdi, r12
mov rsi, r15
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rsi, aMustHaveBetwee; " must have between "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aAnd; " and "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aPositionalArgu; " positional arguments and between "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [rbx]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aAnd; " and "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [rbx+8]
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aKeywordArgumen; " keyword arguments"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, [rsp+1C8h+var_198]
lea rdi, [rsp+1C8h+var_1C0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov bpl, 1
lea rsi, [rsp+1C8h+var_1C0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+1C8h+var_1C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6CB3D
jmp short loc_6CB4A
mov r14, rax
loc_6CB3D:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_6CB4A
mov r14, rax
loc_6CB4A:
lea rdi, [rsp+1C8h+var_1A0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, r14
call __Unwind_Resume
| unsigned long long minja::ArgumentsValue::expectArgs(
_QWORD *a1,
long long a2,
unsigned long long *a3,
unsigned long long *a4)
{
unsigned long long v6; // rax
unsigned long long result; // rax
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v11; // rax
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long v15; // rax
long long v16; // rax
void *exception; // rbx
_BYTE v18[32]; // [rsp+8h] [rbp-1C0h] BYREF
_BYTE v19[8]; // [rsp+28h] [rbp-1A0h] BYREF
_BYTE v20[408]; // [rsp+30h] [rbp-198h] BYREF
v6 = (a1[1] - *a1) / 80LL;
if ( v6 < *a3 || v6 > a3[1] || (result = (a1[4] - a1[3]) / 112LL, result < *a4) || result > a4[1] )
{
std::ostringstream::basic_ostringstream(v19);
v8 = std::operator<<<char>(v19, a2);
v9 = std::operator<<<std::char_traits<char>>(v8, " must have between ");
v10 = std::ostream::_M_insert<unsigned long>(v9, *a3);
v11 = std::operator<<<std::char_traits<char>>(v10, " and ");
v12 = std::ostream::_M_insert<unsigned long>(v11, a3[1]);
v13 = std::operator<<<std::char_traits<char>>(v12, " positional arguments and between ");
v14 = std::ostream::_M_insert<unsigned long>(v13, *a4);
v15 = std::operator<<<std::char_traits<char>>(v14, " and ");
v16 = std::ostream::_M_insert<unsigned long>(v15, a4[1]);
std::operator<<<std::char_traits<char>>(v16, " keyword arguments");
exception = __cxa_allocate_exception(0x10uLL);
std::stringbuf::str(v18, v20);
std::runtime_error::runtime_error(exception, v18);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| expectArgs:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1a0
MOV RBX,RCX
MOV R14,RDX
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
MOV R15,RSI
PUSH 0x50
POP RCX
CQO
IDIV RCX
CMP RAX,qword ptr [R14]
JC 0x0016ca53
CMP RAX,qword ptr [R14 + 0x8]
JA 0x0016ca53
MOV RAX,qword ptr [RDI + 0x20]
SUB RAX,qword ptr [RDI + 0x18]
PUSH 0x70
POP RCX
CQO
IDIV RCX
CMP RAX,qword ptr [RBX]
JC 0x0016ca53
CMP RAX,qword ptr [RBX + 0x8]
JA 0x0016ca53
ADD RSP,0x1a0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0016ca53:
LEA R12,[RSP + 0x28]
MOV RDI,R12
CALL 0x00123bc0
LAB_0016ca60:
MOV RDI,R12
MOV RSI,R15
CALL 0x001237f0
LEA RSI,[0x1b46e2]
MOV RDI,RAX
CALL 0x001238c0
MOV RSI,qword ptr [R14]
MOV RDI,RAX
CALL 0x00123640
LEA RSI,[0x1b46f6]
MOV RDI,RAX
CALL 0x001238c0
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,RAX
CALL 0x00123640
LEA RSI,[0x1b46fc]
MOV RDI,RAX
CALL 0x001238c0
MOV RSI,qword ptr [RBX]
MOV RDI,RAX
CALL 0x00123640
LEA RSI,[0x1b46f6]
MOV RDI,RAX
CALL 0x001238c0
MOV RSI,qword ptr [RBX + 0x8]
MOV RDI,RAX
CALL 0x00123640
LEA RSI,[0x1b471f]
MOV RDI,RAX
CALL 0x001238c0
LAB_0016cae4:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV RBX,RAX
LEA RSI,[RSP + 0x30]
LAB_0016caf4:
LEA RDI,[RSP + 0x8]
CALL 0x00123de0
MOV BPL,0x1
LAB_0016cb01:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00123e60
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123f30
|
/* minja::ArgumentsValue::expectArgs(std::__cxx11::string const&, std::pair<unsigned long, unsigned
long> const&, std::pair<unsigned long, unsigned long> const&) */
void __thiscall
minja::ArgumentsValue::expectArgs(ArgumentsValue *this,string *param_1,pair *param_2,pair *param_3)
{
ulong uVar1;
ostream *poVar2;
runtime_error *this_00;
string local_1c0 [32];
ostringstream local_1a0 [376];
uVar1 = (*(long *)(this + 8) - *(long *)this) / 0x50;
if ((*(ulong *)param_2 <= uVar1) && (uVar1 <= *(ulong *)(param_2 + 8))) {
uVar1 = (*(long *)(this + 0x20) - *(long *)(this + 0x18)) / 0x70;
if ((*(ulong *)param_3 <= uVar1) && (uVar1 <= *(ulong *)(param_3 + 8))) {
return;
}
}
std::__cxx11::ostringstream::ostringstream(local_1a0);
/* try { // try from 0016ca60 to 0016cae3 has its CatchHandler @ 0016cb47 */
poVar2 = std::operator<<((ostream *)local_1a0,param_1);
poVar2 = std::operator<<(poVar2," must have between ");
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
poVar2 = std::operator<<(poVar2," and ");
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
poVar2 = std::operator<<(poVar2," positional arguments and between ");
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
poVar2 = std::operator<<(poVar2," and ");
poVar2 = std::ostream::_M_insert<unsigned_long>((ulong)poVar2);
std::operator<<(poVar2," keyword arguments");
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016caf4 to 0016cafd has its CatchHandler @ 0016cb3a */
std::__cxx11::stringbuf::str();
/* try { // try from 0016cb01 to 0016cb25 has its CatchHandler @ 0016cb26 */
std::runtime_error::runtime_error(this_00,local_1c0);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
| |
31,293 | 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(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>&) | monkey531[P]llama/common/./json.hpp | reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(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>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xab56f
movb $0x2, (%r14)
callq 0x403ca
movq %rax, %rdi
movq %rax, 0x8(%r14)
jmp 0xab578
cmpl $0x2, %eax
jne 0xab595
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xab676
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24520
movq %rax, %rbx
movq %r14, %rdi
callq 0x45c5c
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x119b6(%rip), %rsi # 0xbcf6d
leaq 0x10(%rsp), %rdi
callq 0xab618
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x45b10
xorl %ebp, %ebp
leaq 0x53966(%rip), %rsi # 0xfef48
leaq -0x68ce7(%rip), %rdx # 0x42902
movq %rbx, %rdi
callq 0x25150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x25478
testb %bpl, %bpl
jne 0xab608
jmp 0xab610
movq %rax, %r14
movq %rbx, %rdi
callq 0x247a0
movq %r14, %rdi
callq 0x251e0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_AB56F
mov byte ptr [r14], 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJEEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>()
mov rdi, rax
mov [r14+8], rax
jmp short loc_AB578
loc_AB56F:
cmp eax, 2
jnz short loc_AB595
mov rdi, [r14+8]
loc_AB578:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; 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>>::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>&>(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 rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_AB595:
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, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_AB608
jmp short loc_AB610
mov r14, rax
loc_AB608:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AB610:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::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>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v6[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>();
*(_QWORD *)(a1 + 8) = v3;
}
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>>::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>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
| 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>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001ab56f
MOV byte ptr [R14],0x2
CALL 0x001403ca
MOV RDI,RAX
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001ab578
LAB_001ab56f:
CMP EAX,0x2
JNZ 0x001ab595
MOV RDI,qword ptr [R14 + 0x8]
LAB_001ab578:
MOV RSI,RBX
CALL 0x001ab676
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001ab595:
PUSH 0x20
POP RDI
CALL 0x00124520
MOV RBX,RAX
MOV RDI,R14
CALL 0x00145c5c
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001ab5b0:
LEA RSI,[0x1bcf6d]
LEA RDI,[RSP + 0x10]
CALL 0x001ab618
MOV BPL,0x1
LAB_001ab5c4:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x00145b10
XOR EBP,EBP
LEA RSI,[0x1fef48]
LEA RDX,[0x142902]
MOV RDI,RBX
CALL 0x00125150
|
/* 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>::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>&>(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 * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
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>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (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>>>
*)create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
();
*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001ab5b0 to 001ab5c0 has its CatchHandler @ 001ab605 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001ab5c4 to 001ab5f0 has its CatchHandler @ 001ab5f1 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
}
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>>>
::
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>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
| |
31,294 | 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(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>&) | monkey531[P]llama/common/./json.hpp | reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(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>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xe7610
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1b9f0
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
jmp 0xe7619
cmpl $0x2, %eax
jne 0xe7636
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xe7754
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b4f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x6195a
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x1191e(%rip), %rsi # 0xf8f78
leaq 0x10(%rsp), %rdi
callq 0xe76cc
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x61702
xorl %ebp, %ebp
leaq 0x448c3(%rip), %rsi # 0x12bf48
leaq -0x89a44(%rip), %rdx # 0x5dc48
movq %rbx, %rdi
callq 0x1c150
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe76b2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1ba20
testb %bpl, %bpl
jne 0xe76bc
jmp 0xe76c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b770
movq %r14, %rdi
callq 0x1c1e0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_E7610
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
jmp short loc_E7619
loc_E7610:
cmp eax, 2
jnz short loc_E7636
mov rdi, [r14+8]
loc_E7619:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; 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>>::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>&>(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 rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_E7636:
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, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E76B2
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E76B2:
test bpl, bpl
jnz short loc_E76BC
jmp short loc_E76C4
mov r14, rax
loc_E76BC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_E76C4:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::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>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = operator new(0x18uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v3;
}
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>>::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>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
| 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>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001e7610
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011b9f0
MOV RDI,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001e7619
LAB_001e7610:
CMP EAX,0x2
JNZ 0x001e7636
MOV RDI,qword ptr [R14 + 0x8]
LAB_001e7619:
MOV RSI,RBX
CALL 0x001e7754
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001e7636:
MOV EDI,0x20
CALL 0x0011b4f0
MOV RBX,RAX
MOV RDI,R14
CALL 0x0016195a
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001e7653:
LEA RSI,[0x1f8f78]
LEA RDI,[RSP + 0x10]
CALL 0x001e76cc
MOV BPL,0x1
LAB_001e7667:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x00161702
XOR EBP,EBP
LEA RSI,[0x22bf48]
LEA RDX,[0x15dc48]
MOV RDI,RBX
CALL 0x0011c150
|
/* 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>::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>&>(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 * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
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>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (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>>>
*)operator_new(0x18);
*(int8 *)this_00 = 0;
*(int8 *)(this_00 + 8) = 0;
*(int8 *)(this_00 + 0x10) = 0;
*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001e7653 to 001e7663 has its CatchHandler @ 001e76b9 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001e7667 to 001e7693 has its CatchHandler @ 001e7694 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
}
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>>>
::
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>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
| |
31,295 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | monkey531[P]llama/common/json.hpp | reference operator[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
return set_parent(result.first->second);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xaaf86
movb $0x1, (%r14)
movl $0x20, %edi
callq 0x1a870
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x56f38
cmpb $0x1, (%r14)
jne 0xaaff1
movq 0x8(%r14), %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x56f38
movq %r15, %rdi
movl $0x1, %esi
callq 0x56f38
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5dde4
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x56f38
movq %r14, %rdi
callq 0x5c724
addq $0x20, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
movq %r14, %rdi
callq 0x5d76e
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x46d7f(%rip), %rsi # 0xf1d94
movq %rsp, %rdi
callq 0xab0a0
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x5d516
xorl %ebp, %ebp
leaq 0x7eecc(%rip), %rsi # 0x129f08
leaq -0x51793(%rip), %rdx # 0x598b0
movq %rbx, %rdi
callq 0x1aea0
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x56f38
movq %rbx, %rdi
callq 0x5c724
jmp 0xab098
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xab08b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0xab08b
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xab098
movq %rbx, %rdi
callq 0x1a640
movq %r14, %rdi
callq 0x1af20
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_:
push rbp; char
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
cmp byte ptr [rdi], 0
jnz short loc_AAF86
mov byte ptr [r14], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_AAF86:
cmp byte ptr [r14], 1
jnz short loc_AAFF1
mov r14, [r14+8]
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rbx, 20h ; ' '
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_AAFF1:
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_28]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_AB098
mov r14, rax
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AB08B
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AB08B
mov r14, rax
mov bpl, 1
loc_AB08B:
test bpl, bpl
jz short loc_AB098
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AB098:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
long long *a2)
{
long long v2; // rax
_QWORD *v3; // r14
long long v4; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v7[9]; // [rsp+0h] [rbp-48h] BYREF
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
v2 = operator new(0x20uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v2;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
}
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v7[4] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
v7,
"cannot use operator[] with a string argument with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD **)(a1 + 8);
LOBYTE(v7[0]) = 0;
v7[1] = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v7);
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 *)v7);
v4 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
v3,
a2,
(long long)v7);
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 *)v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v7);
return v4 + 32;
}
| operator[]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
CMP byte ptr [RDI],0x0
JNZ 0x001aaf86
MOV byte ptr [R14],0x1
MOV EDI,0x20
CALL 0x0011a870
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x00156f38
LAB_001aaf86:
CMP byte ptr [R14],0x1
JNZ 0x001aaff1
MOV R14,qword ptr [R14 + 0x8]
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00156f38
MOV RDI,R15
MOV ESI,0x1
CALL 0x00156f38
LAB_001aafb9:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0015dde4
LAB_001aafc7:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00156f38
MOV RDI,R14
CALL 0x0015c724
ADD RBX,0x20
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001aaff1:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015d76e
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001ab00e:
LEA RSI,[0x1f1d94]
MOV RDI,RSP
CALL 0x001ab0a0
MOV BPL,0x1
LAB_001ab020:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x0015d516
XOR EBP,EBP
LEA RSI,[0x229f08]
LEA RDX,[0x1598b0]
MOV RDI,RBX
CALL 0x0011aea0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](std::__cxx11::string) */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,string *param_2)
{
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_00;
int8 *puVar1;
long lVar2;
int8 uVar3;
bool bVar4;
basic_json local_48 [8];
int8 local_40;
char *local_28;
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
puVar1 = (int8 *)operator_new(0x20);
*puVar1 = 0;
puVar1[1] = 0;
puVar1[2] = 0;
*(int8 **)(this + 8) = puVar1;
assert_invariant(SUB81(this,0));
}
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
this_00 = *(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
local_48[0] = (basic_json)0x0;
local_40 = 0;
bVar4 = SUB81(local_48,0);
assert_invariant(bVar4);
assert_invariant(bVar4);
/* try { // try from 001aafb9 to 001aafc6 has its CatchHandler @ 001ab04b */
lVar2 = ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace(this_00,param_2,local_48);
assert_invariant(bVar4);
data::~data((data *)local_48);
return lVar2 + 0x20;
}
uVar3 = __cxa_allocate_exception(0x20);
local_28 = (char *)type_name(this);
/* try { // try from 001ab00e to 001ab01c has its CatchHandler @ 001ab085 */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
((detail *)local_48,"cannot use operator[] with a string argument with ",&local_28);
/* try { // try from 001ab020 to 001ab04a has its CatchHandler @ 001ab065 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0x131,local_48,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
31,296 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | monkey531[P]llama/common/json.hpp | reference operator[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
return set_parent(result.first->second);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x7d833
movb $0x1, (%r14)
callq 0x3cbd4
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3cadc
movb (%r14), %al
cmpb $0x1, %al
jne 0x7d873
movq 0x8(%r14), %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3c616
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x42af2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3c602
addq $0x20, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x425be
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x364df(%rip), %rsi # 0xb3d74
movq %rsp, %rdi
callq 0x7d8fd
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x42472
xorl %ebp, %ebp
leaq 0x7c68c(%rip), %rsi # 0xf9f48
leaq -0x3e775(%rip), %rdx # 0x3f14e
movq %rbx, %rdi
callq 0x23e90
movq %rax, %r14
movq %rsp, %rdi
callq 0x3c602
jmp 0x7d8f5
movq %rax, %r14
movq %rsp, %rdi
callq 0x24158
testb %bpl, %bpl
jne 0x7d8ed
jmp 0x7d8f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x23660
movq %r14, %rdi
callq 0x23f10
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
mov al, [rdi]
test al, al
jnz short loc_7D833
mov byte ptr [r14], 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJEEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>>()
mov [r14+8], rax
push 1
pop rsi
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [r14]
loc_7D833:
cmp al, 1
jnz short loc_7D873
mov r14, [r14+8]
mov r15, rsp
mov rdi, r15
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
add rbx, 20h ; ' '
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7D873:
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_28]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_7D8F5
mov r14, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7D8ED
jmp short loc_7D8F5
mov r14, rax
loc_7D8ED:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7D8F5:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
_QWORD *a2)
{
char v2; // al
_QWORD **v3; // r14
long long v4; // rbx
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_QWORD v7[9]; // [rsp+0h] [rbp-48h] BYREF
v2 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
*(_QWORD *)(a1 + 8) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>>();
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);
v2 = *(_BYTE *)a1;
}
if ( v2 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7[4] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
v7,
"cannot use operator[] with a string argument with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
(long long)v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD ***)(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)v7);
v4 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
v3,
a2,
(long long)v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v7);
return v4 + 32;
}
| operator[]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x0017d833
MOV byte ptr [R14],0x1
CALL 0x0013cbd4
MOV qword ptr [R14 + 0x8],RAX
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0013cadc
MOV AL,byte ptr [R14]
LAB_0017d833:
CMP AL,0x1
JNZ 0x0017d873
MOV R14,qword ptr [R14 + 0x8]
MOV R15,RSP
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013c616
LAB_0017d848:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x00142af2
LAB_0017d856:
MOV RBX,RAX
MOV RDI,RSP
CALL 0x0013c602
ADD RBX,0x20
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0017d873:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x001425be
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0017d88e:
LEA RSI,[0x1b3d74]
MOV RDI,RSP
CALL 0x0017d8fd
MOV BPL,0x1
LAB_0017d8a0:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x00142472
XOR EBP,EBP
LEA RSI,[0x1f9f48]
LEA RDX,[0x13f14e]
MOV RDI,RBX
CALL 0x00123e90
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](std::__cxx11::string) */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,string *param_2)
{
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_00;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
ordered_map *poVar2;
long lVar3;
int8 uVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_48 [32];
char *local_28;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
poVar2 = create<nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
();
*(ordered_map **)(this + 8) = poVar2;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
this_00 = *(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
basic_json((_func_decltype_nullptr *)abStack_48);
/* try { // try from 0017d848 to 0017d855 has its CatchHandler @ 0017d8cb */
lVar3 = ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace(this_00,param_2,abStack_48);
~basic_json(abStack_48);
return lVar3 + 0x20;
}
uVar4 = __cxa_allocate_exception(0x20);
local_28 = (char *)type_name(this);
/* try { // try from 0017d88e to 0017d89c has its CatchHandler @ 0017d8ea */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
((detail *)abStack_48,"cannot use operator[] with a string argument with ",&local_28);
/* try { // try from 0017d8a0 to 0017d8ca has its CatchHandler @ 0017d8d8 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x131,abStack_48,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
31,297 | 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>>>::count(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&) const | monkey531[P]llama/common/json.hpp | size_type count(const key_type& key) const
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
} | 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>>>::count(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&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq %rcx, %r15
movq 0x8(%r14), %r12
cmpq %r12, %rcx
je 0x6f06c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68d34
leaq 0x60(%r15), %rcx
testb %al, %al
je 0x6f04d
xorl %eax, %eax
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZNK8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5countERSJ_:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rcx, [rdi]
loc_6F04D:
mov r15, rcx
mov r12, [r14+8]
cmp rcx, r12
jz short loc_6F06C
mov rdi, r15
mov rsi, rbx
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&)
lea rcx, [r15+60h]
test al, al
jz short loc_6F04D
loc_6F06C:
xor eax, eax
cmp r15, r12
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| _BOOL8 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>>>::count(
unsigned __int8 **a1,
unsigned __int8 *a2,
__m128d a3)
{
unsigned __int8 *v3; // rcx
unsigned __int8 *v4; // r15
unsigned __int8 *v5; // r12
char v6; // al
v3 = *a1;
do
{
v4 = v3;
v5 = a1[1];
if ( v3 == v5 )
break;
v6 = nlohmann::json_abi_v3_11_3::operator==(v3, a2, a3);
v3 = v4 + 96;
}
while ( !v6 );
return v4 != v5;
}
| count:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RCX,qword ptr [RDI]
LAB_0016f04d:
MOV R15,RCX
MOV R12,qword ptr [R14 + 0x8]
CMP RCX,R12
JZ 0x0016f06c
MOV RDI,R15
MOV RSI,RBX
CALL 0x00168d34
LEA RCX,[R15 + 0x60]
TEST AL,AL
JZ 0x0016f04d
LAB_0016f06c:
XOR EAX,EAX
CMP R15,R12
SETNZ AL
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> >
>::count(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&) const */
bool __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>>>
::count(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)
{
basic_json *pbVar1;
basic_json *pbVar2;
char cVar3;
basic_json *pbVar4;
pbVar2 = *(basic_json **)this;
do {
pbVar4 = pbVar2;
pbVar1 = *(basic_json **)(this + 8);
if (pbVar4 == pbVar1) break;
cVar3 = json_abi_v3_11_3::operator==(pbVar4,param_1);
pbVar2 = pbVar4 + 0x60;
} while (cVar3 == '\0');
return pbVar4 != pbVar1;
}
| |
31,298 | google::protobuf::compiler::CodeGenerator::GenerateAll(std::vector<google::protobuf::FileDescriptor const*, std::allocator<google::protobuf::FileDescriptor const*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::compiler::GeneratorContext*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/code_generator.cc | bool CodeGenerator::GenerateAll(const std::vector<const FileDescriptor*>& files,
const std::string& parameter,
GeneratorContext* generator_context,
std::string* error) const {
// Default implementation is just to call the per file method, and prefix any
// error string with the file to provide context.
bool succeeded = true;
for (int i = 0; i < files.size(); i++) {
const FileDescriptor* file = files[i];
succeeded = Generate(file, parameter, generator_context, error);
if (!succeeded && error && error->empty()) {
*error =
"Code generator returned false but provided no error "
"description.";
}
if (error && !error->empty()) {
*error = file->name() + ": " + *error;
break;
}
if (!succeeded) {
break;
}
}
return succeeded;
} | O0 | cpp | google::protobuf::compiler::CodeGenerator::GenerateAll(std::vector<google::protobuf::FileDescriptor const*, std::allocator<google::protobuf::FileDescriptor const*>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::compiler::GeneratorContext*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x1, 0x7f(%rsp)
movl $0x0, 0x78(%rsp)
movslq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
callq 0x28870
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x281fb
movq 0x98(%rsp), %rdi
movslq 0x78(%rsp), %rsi
callq 0x28890
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x80(%rsp), %r8
movq (%rdi), %rax
callq *0x10(%rax)
andb $0x1, %al
movb %al, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x28142
cmpq $0x0, 0x80(%rsp)
je 0x28142
movq 0x80(%rsp), %rdi
callq 0x212d0
testb $0x1, %al
jne 0x2812e
jmp 0x28142
movq 0x80(%rsp), %rdi
leaq 0x38008f(%rip), %rsi # 0x3a81cc
callq 0x21450
cmpq $0x0, 0x80(%rsp)
je 0x281e0
movq 0x80(%rsp), %rdi
callq 0x212d0
testb $0x1, %al
jne 0x281e0
movq 0x70(%rsp), %rdi
callq 0x28990
movq %rax, %rsi
leaq 0x3dd52b(%rip), %rdx # 0x4056a1
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x28900
movq 0x8(%rsp), %rsi
movq 0x80(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x288b0
jmp 0x2819e
movq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x215e0
leaq 0x50(%rsp), %rdi
callq 0x21cc8
leaq 0x30(%rsp), %rdi
callq 0x21cc8
jmp 0x281fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21cc8
jmp 0x28209
testb $0x1, 0x7f(%rsp)
jne 0x281e9
jmp 0x281fb
jmp 0x281eb
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x28099
movb 0x7f(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x21700
nopw %cs:(%rax,%rax)
| _ZNK6google8protobuf8compiler13CodeGenerator11GenerateAllERKSt6vectorIPKNS0_14FileDescriptorESaIS6_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS1_16GeneratorContextEPSG_:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_20], rcx
mov [rsp+0A8h+var_28], r8
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_90], rax; __int64
mov [rsp+0A8h+var_29], 1
mov [rsp+0A8h+var_30], 0
loc_28099:
movsxd rax, [rsp+0A8h+var_30]
mov qword ptr [rsp+0A8h+var_98], rax; int
mov rdi, [rsp+0A8h+var_10]
call _ZNKSt6vectorIPKN6google8protobuf14FileDescriptorESaIS4_EE4sizeEv; std::vector<google::protobuf::FileDescriptor const*>::size(void)
mov rcx, rax
mov rax, qword ptr [rsp+0A8h+var_98]
cmp rax, rcx
jnb loc_281FB
mov rdi, [rsp+0A8h+var_10]
movsxd rsi, [rsp+0A8h+var_30]
call _ZNKSt6vectorIPKN6google8protobuf14FileDescriptorESaIS4_EEixEm; std::vector<google::protobuf::FileDescriptor const*>::operator[](ulong)
mov rdi, [rsp+0A8h+var_90]
mov rax, [rax]
mov [rsp+0A8h+var_38], rax
mov rsi, [rsp+0A8h+var_38]
mov rdx, [rsp+0A8h+var_18]
mov rcx, [rsp+0A8h+var_20]
mov r8, [rsp+0A8h+var_28]
mov rax, [rdi]
call qword ptr [rax+10h]
and al, 1
mov [rsp+0A8h+var_29], al
test [rsp+0A8h+var_29], 1
jnz short loc_28142
cmp [rsp+0A8h+var_28], 0
jz short loc_28142
mov rdi, [rsp+0A8h+var_28]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_2812E
jmp short loc_28142
loc_2812E:
mov rdi, [rsp+0A8h+var_28]
lea rsi, aCodeGeneratorR; "Code generator returned false but provi"...
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
loc_28142:
cmp [rsp+0A8h+var_28], 0
jz loc_281E0
mov rdi, [rsp+0A8h+var_28]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_281E0
mov rdi, [rsp+0A8h+var_38]
call _ZNK6google8protobuf14FileDescriptor4nameB5cxx11Ev; google::protobuf::FileDescriptor::name(void)
mov rsi, rax; int
lea rdx, aField+0Fh; int
lea rdi, [rsp+0A8h+var_78]; int
mov [rsp+0A8h+var_A0], rdi; void *
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
mov rsi, [rsp+0A8h+var_A0]
mov rdx, [rsp+0A8h+var_28]
lea rdi, [rsp+0A8h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_2819E:
mov rdi, [rsp+0A8h+var_28]
lea rsi, [rsp+0A8h+var_58]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+0A8h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_281FB
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_28209
loc_281E0:
test [rsp+0A8h+var_29], 1
jnz short loc_281E9
jmp short loc_281FB
loc_281E9:
jmp short $+2
loc_281EB:
mov eax, [rsp+0A8h+var_30]
add eax, 1
mov [rsp+0A8h+var_30], eax
jmp loc_28099
loc_281FB:
mov al, [rsp+0A8h+var_29]
and al, 1
add rsp, 0A8h
retn
loc_28209:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| char google::protobuf::compiler::CodeGenerator::GenerateAll(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5)
{
int v5; // eax
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v10; // [rsp+0h] [rbp-A8h]
void *v11; // [rsp+8h] [rbp-A0h]
int v12[8]; // [rsp+30h] [rbp-78h] BYREF
_BYTE v13[32]; // [rsp+50h] [rbp-58h] BYREF
long long v14; // [rsp+70h] [rbp-38h]
int i; // [rsp+78h] [rbp-30h]
char v16; // [rsp+7Fh] [rbp-29h]
long long v17; // [rsp+80h] [rbp-28h]
long long v18; // [rsp+88h] [rbp-20h]
long long v19; // [rsp+90h] [rbp-18h]
long long v20; // [rsp+98h] [rbp-10h]
long long v21; // [rsp+A0h] [rbp-8h]
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v16 = 1;
for ( i = 0; i < (unsigned long long)std::vector<google::protobuf::FileDescriptor const*>::size(v20); ++i )
{
v14 = *(_QWORD *)std::vector<google::protobuf::FileDescriptor const*>::operator[](v20, i);
v16 = (*(long long ( **)(long long, long long, long long, long long, long long))(*(_QWORD *)a1 + 16LL))(
a1,
v14,
v19,
v18,
v17) & 1;
if ( !v16 && v17 && (std::string::empty(v17) & 1) != 0 )
std::string::operator=(v17, "Code generator returned false but provided no error description.");
if ( v17 && (std::string::empty(v17) & 1) == 0 )
{
v5 = google::protobuf::FileDescriptor::name[abi:cxx11](v14);
std::operator+<char>((int)v12, v5, (int)": ", v6, v7, v8, v10, v12, i, a1);
std::operator+<char>(v13, v11, v17);
std::string::operator=(v17, v13);
std::string::~string(v13);
std::string::~string(v12);
return v16 & 1;
}
if ( (v16 & 1) == 0 )
return v16 & 1;
}
return v16 & 1;
}
| GenerateAll:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x88],RCX
MOV qword ptr [RSP + 0x80],R8
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x18],RAX
MOV byte ptr [RSP + 0x7f],0x1
MOV dword ptr [RSP + 0x78],0x0
LAB_00128099:
MOVSXD RAX,dword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00128870
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JNC 0x001281fb
MOV RDI,qword ptr [RSP + 0x98]
MOVSXD RSI,dword ptr [RSP + 0x78]
CALL 0x00128890
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x70],RAX
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
AND AL,0x1
MOV byte ptr [RSP + 0x7f],AL
TEST byte ptr [RSP + 0x7f],0x1
JNZ 0x00128142
CMP qword ptr [RSP + 0x80],0x0
JZ 0x00128142
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x001212d0
TEST AL,0x1
JNZ 0x0012812e
JMP 0x00128142
LAB_0012812e:
MOV RDI,qword ptr [RSP + 0x80]
LEA RSI,[0x4a81cc]
CALL 0x00121450
LAB_00128142:
CMP qword ptr [RSP + 0x80],0x0
JZ 0x001281e0
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x001212d0
TEST AL,0x1
JNZ 0x001281e0
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00128990
MOV RSI,RAX
LEA RDX,[0x5056a1]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00128900
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x80]
LAB_00128192:
LEA RDI,[RSP + 0x50]
CALL 0x001288b0
LAB_0012819c:
JMP 0x0012819e
LAB_0012819e:
MOV RDI,qword ptr [RSP + 0x80]
LEA RSI,[RSP + 0x50]
CALL 0x001215e0
LEA RDI,[RSP + 0x50]
CALL 0x00121cc8
LEA RDI,[RSP + 0x30]
CALL 0x00121cc8
JMP 0x001281fb
LAB_001281e0:
TEST byte ptr [RSP + 0x7f],0x1
JNZ 0x001281e9
JMP 0x001281fb
LAB_001281e9:
JMP 0x001281eb
LAB_001281eb:
MOV EAX,dword ptr [RSP + 0x78]
ADD EAX,0x1
MOV dword ptr [RSP + 0x78],EAX
JMP 0x00128099
LAB_001281fb:
MOV AL,byte ptr [RSP + 0x7f]
AND AL,0x1
ADD RSP,0xa8
RET
|
/* google::protobuf::compiler::CodeGenerator::GenerateAll(std::vector<google::protobuf::FileDescriptor
const*, std::allocator<google::protobuf::FileDescriptor const*> > const&, std::__cxx11::string
const&, google::protobuf::compiler::GeneratorContext*, std::__cxx11::string*) const */
ulong __thiscall
google::protobuf::compiler::CodeGenerator::GenerateAll
(CodeGenerator *this,vector *param_1,string *param_2,GeneratorContext *param_3,
string *param_4)
{
ulong uVar1;
ulong uVar2;
int8 *puVar3;
char *pcVar4;
string local_78 [32];
string local_58 [32];
FileDescriptor *local_38;
int local_30;
byte local_29;
string *local_28;
GeneratorContext *local_20;
string *local_18;
vector<google::protobuf::FileDescriptor_const*,std::allocator<google::protobuf::FileDescriptor_const*>>
*local_10;
CodeGenerator *local_8;
local_29 = 1;
local_30 = 0;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = (vector<google::protobuf::FileDescriptor_const*,std::allocator<google::protobuf::FileDescriptor_const*>>
*)param_1;
local_8 = this;
do {
uVar1 = (ulong)local_30;
uVar2 = std::
vector<google::protobuf::FileDescriptor_const*,std::allocator<google::protobuf::FileDescriptor_const*>>
::size(local_10);
if (uVar2 <= uVar1) {
LAB_001281fb:
return CONCAT71((int7)(uVar1 >> 8),local_29) & 0xffffffffffffff01;
}
puVar3 = (int8 *)
std::
vector<google::protobuf::FileDescriptor_const*,std::allocator<google::protobuf::FileDescriptor_const*>>
::operator[](local_10,(long)local_30);
local_38 = (FileDescriptor *)*puVar3;
uVar1 = (**(code **)(*(long *)this + 0x10))(this,local_38,local_18,local_20,local_28);
uVar1 = uVar1 & 0xffffffffffffff01;
local_29 = (byte)uVar1;
if (((local_29 == 0) && (local_28 != (string *)0x0)) &&
(uVar1 = std::__cxx11::string::empty(), (uVar1 & 1) != 0)) {
uVar1 = std::__cxx11::string::operator=
(local_28,"Code generator returned false but provided no error description."
);
}
if ((local_28 != (string *)0x0) && (uVar1 = std::__cxx11::string::empty(), (uVar1 & 1) == 0)) {
pcVar4 = (char *)FileDescriptor::name_abi_cxx11_(local_38);
std::operator+(local_78,pcVar4);
/* try { // try from 00128192 to 0012819b has its CatchHandler @ 001281c6 */
std::operator+(local_58,local_78);
std::__cxx11::string::operator=(local_28,local_58);
std::__cxx11::string::~string(local_58);
uVar1 = std::__cxx11::string::~string(local_78);
goto LAB_001281fb;
}
if ((local_29 & 1) == 0) goto LAB_001281fb;
local_30 = local_30 + 1;
} while( true );
}
| |
31,299 | uf_endspace | eloqsql/storage/myisam/mi_packrec.c | static void uf_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
} | O3 | c | uf_endspace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x832f6
subl %ecx, %r13d
leaq 0x5e7b9(%rip), %rax # 0xe1a70
movl (%rax,%rcx,4), %r14d
andl (%r15), %r14d
movl %r13d, %ecx
shll %cl, %r14d
movq %rdi, -0x30(%rbp)
movq %r15, %rdi
movq %rdx, %r12
callq 0x823a5
movq -0x30(%rbp), %rdi
movq %r12, %rdx
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %r14d, %eax
jmp 0x8330f
movl (%r15), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r15)
shrl %cl, %eax
movl 0x1c(%rdi), %ecx
leaq 0x5e764(%rip), %rsi # 0xe1a70
andl (%rsi,%rcx,4), %eax
movl %eax, %r13d
leaq (%rdx,%r13), %rax
cmpq %rbx, %rax
jbe 0x83332
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
negq %r14
cmpq %rbx, %rax
je 0x83349
leaq (%rbx,%r14), %rcx
movq %r15, %rsi
callq 0x82c96
addq %r14, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
| uf_endspace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rsi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_832F6
sub r13d, ecx
lea rax, mask_0
mov r14d, [rax+rcx*4]
and r14d, [r15]
mov ecx, r13d
shl r14d, cl
mov [rbp+var_30], rdi
mov rdi, r15
mov r12, rdx
call fill_buffer_0
mov rdi, [rbp+var_30]
mov rdx, r12
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, r14d
jmp short loc_8330F
loc_832F6:
mov eax, [r15]
sub ecx, r13d
mov [r15+4], ecx
shr eax, cl
mov ecx, [rdi+1Ch]
lea rsi, mask_0
and eax, [rsi+rcx*4]
loc_8330F:
mov r13d, eax
lea rax, [rdx+r13]
cmp rax, rbx
jbe short loc_83332
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83332:
mov r14, r13
neg r14
cmp rax, rbx
jz short loc_83349
lea rcx, [rbx+r14]
mov rsi, r15
call decode_bytes_0
loc_83349:
add rbx, r14
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| unsigned long long uf_endspace_0(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
long long v5; // rcx
unsigned int v6; // r13d
int v7; // r13d
int v8; // r14d
_BYTE *v9; // r12
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // ecx
long long v13; // r13
unsigned long long result; // rax
v5 = a2[1];
v6 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v5 >= v6 )
{
v11 = *a2;
v12 = v5 - v6;
a2[1] = v12;
v10 = mask_0[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v7 = v6 - v5;
v8 = (*a2 & mask_0[v5]) << v7;
v9 = a3;
fill_buffer_0((long long)a2);
a3 = v9;
a2[1] = 32 - v7;
v10 = v8 + (*a2 >> -(char)v7);
}
v13 = v10;
result = (unsigned long long)&a3[v10];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes_0(a1, (long long)a2, a3, (_BYTE *)(a4 - v13));
return memset(a4 - v13, 32LL, v13);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_endspace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RSI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x001832f6
SUB R13D,ECX
LEA RAX,[0x1e1a70]
MOV R14D,dword ptr [RAX + RCX*0x4]
AND R14D,dword ptr [R15]
MOV ECX,R13D
SHL R14D,CL
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,R15
MOV R12,RDX
CALL 0x001823a5
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,R12
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,R14D
JMP 0x0018330f
LAB_001832f6:
MOV EAX,dword ptr [R15]
SUB ECX,R13D
MOV dword ptr [R15 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [RDI + 0x1c]
LEA RSI,[0x1e1a70]
AND EAX,dword ptr [RSI + RCX*0x4]
LAB_0018330f:
MOV R13D,EAX
LEA RAX,[RDX + R13*0x1]
CMP RAX,RBX
JBE 0x00183332
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183332:
MOV R14,R13
NEG R14
CMP RAX,RBX
JZ 0x00183349
LEA RCX,[RBX + R14*0x1]
MOV RSI,R15
CALL 0x00182c96
LAB_00183349:
ADD RBX,R14
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
ulong __n;
uVar4 = param_2[1];
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar4 < uVar1) {
uVar2 = (&mask)[uVar4];
uVar3 = *param_2;
bVar5 = (byte)(uVar1 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar4);
uVar4 = (*param_2 >> (-bVar5 & 0x1f)) + ((uVar2 & uVar3) << (bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar1;
uVar4 = *param_2 >> ((byte)(uVar4 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
__n = (ulong)uVar4;
if (param_4 < param_3 + __n) {
param_2[10] = 1;
return;
}
if (param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
memset((void *)(param_4 + -__n),0x20,__n);
return;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
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++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
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.