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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
43,300 | httplib::detail::BufferStream::~BufferStream() | hkr04[P]cpp-mcp/common/httplib.h | ~BufferStream() override = default; | O1 | c | httplib::detail::BufferStream::~BufferStream():
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x16cc2
movq (%rax), %rsi
incq %rsi
callq 0x8580
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x8580
| _ZN7httplib6detail12BufferStreamD0Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_16CC2
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16CC2:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void httplib::detail::BufferStream::~BufferStream(httplib::detail::BufferStream *this)
{
char *v2; // rdi
v2 = (char *)*((_QWORD *)this + 1);
if ( v2 != (char *)this + 24 )
operator delete(v2, *((_QWORD *)this + 3) + 1LL);
operator delete(this, 0x30uLL);
}
| ~BufferStream:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x00116cc2
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00108580
LAB_00116cc2:
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x00108580
|
/* httplib::detail::BufferStream::~BufferStream() */
void __thiscall httplib::detail::BufferStream::~BufferStream(BufferStream *this)
{
if (*(BufferStream **)(this + 8) != this + 0x18) {
operator_delete(*(BufferStream **)(this + 8),*(long *)(this + 0x18) + 1);
}
operator_delete(this,0x30);
return;
}
| |
43,301 | httplib::detail::BufferStream::~BufferStream() | hkr04[P]cpp-mcp/common/httplib.h | ~BufferStream() override = default; | O3 | c | httplib::detail::BufferStream::~BufferStream():
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x1671c
movq (%rax), %rsi
incq %rsi
callq 0x8580
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x8580
| _ZN7httplib6detail12BufferStreamD0Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+8]; void *
lea rax, [rbx+18h]
cmp rdi, rax
jz short loc_1671C
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1671C:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void httplib::detail::BufferStream::~BufferStream(httplib::detail::BufferStream *this)
{
char *v2; // rdi
v2 = (char *)*((_QWORD *)this + 1);
if ( v2 != (char *)this + 24 )
operator delete(v2, *((_QWORD *)this + 3) + 1LL);
operator delete(this, 0x30uLL);
}
| ~BufferStream:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RAX,[RBX + 0x18]
CMP RDI,RAX
JZ 0x0011671c
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00108580
LAB_0011671c:
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x00108580
|
/* httplib::detail::BufferStream::~BufferStream() */
void __thiscall httplib::detail::BufferStream::~BufferStream(BufferStream *this)
{
if (*(BufferStream **)(this + 8) != this + 0x18) {
operator_delete(*(BufferStream **)(this + 8),*(long *)(this + 0x18) + 1);
}
operator_delete(this,0x30);
return;
}
| |
43,302 | ft_init_nlq_search | eloqsql/storage/myisam/ft_nlq_search.c | FT_INFO *ft_init_nlq_search(MI_INFO *info, uint keynr, uchar *query,
uint query_len, uint flags, uchar *record)
{
TREE wtree;
ALL_IN_ONE aio;
FT_DOC *dptr;
FT_INFO *dlist=NULL;
my_off_t saved_lastpos=info->lastpos;
struct st_mysql_ftparser *parser;
MYSQL_FTPARSER_PARAM *ftparser_param;
DBUG_ENTER("ft_init_nlq_search");
/* black magic ON */
if ((int) (keynr = _mi_check_index(info,keynr)) < 0)
DBUG_RETURN(NULL);
if (_mi_readinfo(info,F_RDLCK,1))
DBUG_RETURN(NULL);
/* black magic OFF */
aio.info=info;
aio.keynr=keynr;
aio.charset=info->s->keyinfo[keynr].seg->charset;
aio.keybuff=info->lastkey+info->s->base.max_key_length;
parser= info->s->keyinfo[keynr].parser;
if (! (ftparser_param= ftparser_call_initializer(info, keynr, 0)))
goto err;
bzero(&wtree,sizeof(wtree));
init_tree(&aio.dtree,0,0,sizeof(FT_SUPERDOC),(qsort_cmp2)&FT_SUPERDOC_cmp,
NULL, NULL, MYF(0));
ft_parse_init(&wtree, aio.charset);
ftparser_param->flags= 0;
if (ft_parse(&wtree, query, query_len, parser, ftparser_param,
&wtree.mem_root))
goto err;
if (tree_walk(&wtree, (tree_walk_action)&walk_and_match, &aio,
left_root_right))
goto err;
if (flags & FT_EXPAND && ft_query_expansion_limit)
{
QUEUE best;
init_queue(&best,ft_query_expansion_limit,0,0, (queue_compare) &FT_DOC_cmp,
0, 0, 0);
tree_walk(&aio.dtree, (tree_walk_action) &walk_and_push,
&best, left_root_right);
while (best.elements)
{
my_off_t docid= ((FT_DOC *)queue_remove_top(&best))->dpos;
if (!(*info->read_record)(info,docid,record))
{
info->update|= HA_STATE_AKTIV;
ftparser_param->flags= MYSQL_FTFLAGS_NEED_COPY;
if (unlikely(_mi_ft_parse(&wtree, info, keynr, record, ftparser_param,
&wtree.mem_root)))
{
delete_queue(&best);
goto err;
}
}
}
delete_queue(&best);
reset_tree(&aio.dtree);
if (tree_walk(&wtree, (tree_walk_action)&walk_and_match, &aio,
left_root_right))
goto err;
}
/*
If ndocs == 0, this will not allocate RAM for FT_INFO.doc[],
so if ndocs == 0, FT_INFO.doc[] must not be accessed.
*/
dlist=(FT_INFO *)my_malloc(mi_key_memory_FT_INFO, sizeof(FT_INFO)+
sizeof(FT_DOC)*
(int)(aio.dtree.elements_in_tree-1),
MYF(0));
if (!dlist)
goto err;
dlist->please= (struct _ft_vft *) & _ft_vft_nlq;
dlist->ndocs=aio.dtree.elements_in_tree;
dlist->curdoc=-1;
dlist->info=aio.info;
dptr=dlist->doc;
tree_walk(&aio.dtree, (tree_walk_action) &walk_and_copy,
&dptr, left_root_right);
if (flags & FT_SORTED)
my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), (qsort2_cmp)&FT_DOC_cmp,
0);
err:
delete_tree(&aio.dtree, 0);
delete_tree(&wtree, 0);
info->lastpos=saved_lastpos;
DBUG_RETURN(dlist);
} | O0 | c | ft_init_nlq_search:
pushq %rbp
movq %rsp, %rbp
subq $0x5f0, %rsp # imm = 0x5F0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x590(%rbp)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x598(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbdfc0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0xa0231
jmp 0xa0224
movq $0x0, -0x8(%rbp)
jmp 0xa0660
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xb09f0
cmpl $0x0, %eax
je 0xa0255
jmp 0xa0248
movq $0x0, -0x8(%rbp)
jmp 0xa0660
movq -0x10(%rbp), %rax
movq %rax, -0x580(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x578(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x570(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x194(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x568(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, -0x5a0(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0xa21c0
movq %rax, -0x5a8(%rbp)
cmpq $0x0, %rax
jne 0xa02f4
jmp 0xa0623
leaq -0x2c8(%rbp), %rdi
xorl %esi, %esi
movl $0x298, %edx # imm = 0x298
callq 0x2a2a0
leaq -0x580(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %r9d
movl $0x20, %ecx
leaq 0x34d(%rip), %r8 # 0xa0670
movq %r9, %rsi
movq %r9, %rdx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x1004b0
movq -0x570(%rbp), %rsi
leaq -0x2c8(%rbp), %rdi
callq 0xa1e50
movq -0x5a8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movq -0x5a0(%rbp), %rcx
movq -0x5a8(%rbp), %r8
leaq -0x2c8(%rbp), %r9
addq $0x238, %r9 # imm = 0x238
leaq -0x2c8(%rbp), %rdi
callq 0xa1f00
cmpl $0x0, %eax
je 0xa0399
jmp 0xa0623
leaq -0x2c8(%rbp), %rdi
leaq 0x319(%rip), %rsi # 0xa06c0
leaq -0x580(%rbp), %rdx
xorl %ecx, %ecx
callq 0x101e20
cmpl $0x0, %eax
je 0xa03bf
jmp 0xa0623
movl -0x28(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa053b
leaq 0x22513b(%rip), %rax # 0x2c5510
cmpq $0x0, (%rax)
je 0xa053b
leaq 0x22512a(%rip), %rax # 0x2c5510
movq (%rax), %rax
movl %eax, %esi
leaq -0x5d8(%rbp), %rdi
xorl %ecx, %ecx
leaq 0xb05(%rip), %r8 # 0xa0f00
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xfd080
leaq -0x580(%rbp), %rdi
addq $0x20, %rdi
leaq 0xb48(%rip), %rsi # 0xa0f70
leaq -0x5d8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x101e20
cmpl $0x0, -0x5c8(%rbp)
je 0xa04f7
leaq -0x5d8(%rbp), %rdi
movl $0x1, %esi
callq 0xfd4a0
movq (%rax), %rax
movq %rax, -0x5e0(%rbp)
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x5e0(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xa04f2
movq -0x10(%rbp), %rax
movl 0x1d0(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1d0(%rax)
movq -0x5a8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x5a8(%rbp), %r8
leaq -0x2c8(%rbp), %r9
addq $0x238, %r9 # imm = 0x238
leaq -0x2c8(%rbp), %rdi
callq 0xa2690
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa04f0
leaq -0x5d8(%rbp), %rdi
callq 0xfd2b0
jmp 0xa0623
jmp 0xa04f2
jmp 0xa0436
leaq -0x5d8(%rbp), %rdi
callq 0xfd2b0
leaq -0x580(%rbp), %rdi
addq $0x20, %rdi
callq 0x100850
leaq -0x2c8(%rbp), %rdi
leaq 0x19f(%rip), %rsi # 0xa06c0
leaq -0x580(%rbp), %rdx
xorl %ecx, %ecx
callq 0x101e20
cmpl $0x0, %eax
je 0xa0539
jmp 0xa0623
jmp 0xa053b
leaq 0xbe0e3e(%rip), %rax # 0xc81380
movl (%rax), %edi
movl -0x354(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xf99f0
movq %rax, -0x590(%rbp)
cmpq $0x0, -0x590(%rbp)
jne 0xa0577
jmp 0xa0623
movq -0x590(%rbp), %rax
leaq 0x21afdb(%rip), %rcx # 0x2bb560
movq %rcx, (%rax)
movl -0x354(%rbp), %ecx
movq -0x590(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x590(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x580(%rbp), %rcx
movq -0x590(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x590(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x588(%rbp)
leaq -0x580(%rbp), %rdi
addq $0x20, %rdi
leaq 0xa24(%rip), %rsi # 0xa1000
leaq -0x588(%rbp), %rdx
xorl %ecx, %ecx
callq 0x101e20
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xa0621
movq -0x590(%rbp), %rdi
addq $0x18, %rdi
movq -0x590(%rbp), %rax
movslq 0x10(%rax), %rsi
movl $0x10, %edx
leaq 0x8e9(%rip), %rcx # 0xa0f00
xorl %eax, %eax
movl %eax, %r8d
callq 0xed0f0
jmp 0xa0623
leaq -0x580(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x1006b0
leaq -0x2c8(%rbp), %rdi
xorl %esi, %esi
callq 0x1006b0
movq -0x598(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x590(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x5f0, %rsp # imm = 0x5F0
popq %rbp
retq
nopl (%rax)
| ft_init_nlq_search:
push rbp
mov rbp, rsp
sub rsp, 5F0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_30], r9
mov [rbp+var_590], 0
mov rax, [rbp+var_10]
mov rax, [rax+170h]
mov [rbp+var_598], rax
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call _mi_check_index
mov [rbp+var_14], eax
cmp eax, 0
jge short loc_A0231
jmp short $+2
loc_A0224:
mov [rbp+var_8], 0
jmp loc_A0660
loc_A0231:
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 1
call _mi_readinfo
cmp eax, 0
jz short loc_A0255
jmp short $+2
loc_A0248:
mov [rbp+var_8], 0
jmp loc_A0660
loc_A0255:
mov rax, [rbp+var_10]
mov [rbp+var_580], rax
mov eax, [rbp+var_14]
mov [rbp+var_578], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+28h]
mov rax, [rax]
mov [rbp+var_570], rax
mov rax, [rbp+var_10]
mov rax, [rax+108h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov ecx, [rcx+194h]
add rax, rcx
mov [rbp+var_568], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+38h]
mov [rbp+var_5A0], rax
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
xor edx, edx
call ftparser_call_initializer
mov [rbp+var_5A8], rax
cmp rax, 0
jnz short loc_A02F4
jmp loc_A0623
loc_A02F4:
lea rdi, [rbp+var_2C8]
xor esi, esi
mov edx, 298h
call _memset
lea rdi, [rbp+var_580]
add rdi, 20h ; ' '
xor eax, eax
mov r9d, eax
mov ecx, 20h ; ' '
lea r8, FT_SUPERDOC_cmp
mov rsi, r9
mov rdx, r9
mov [rsp+5F0h+var_5F0], 0
mov [rsp+5F0h+var_5E8], 0
call init_tree
mov rsi, [rbp+var_570]
lea rdi, [rbp+var_2C8]
call ft_parse_init
mov rax, [rbp+var_5A8]
mov dword ptr [rax+34h], 0
mov rsi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_5A0]
mov r8, [rbp+var_5A8]
lea r9, [rbp+var_2C8]
add r9, 238h
lea rdi, [rbp+var_2C8]
call ft_parse
cmp eax, 0
jz short loc_A0399
jmp loc_A0623
loc_A0399:
lea rdi, [rbp+var_2C8]
lea rsi, walk_and_match
lea rdx, [rbp+var_580]
xor ecx, ecx
call tree_walk
cmp eax, 0
jz short loc_A03BF
jmp loc_A0623
loc_A03BF:
mov eax, [rbp+var_28]
and eax, 4
cmp eax, 0
jz loc_A053B
lea rax, ft_query_expansion_limit
cmp qword ptr [rax], 0
jz loc_A053B
lea rax, ft_query_expansion_limit
mov rax, [rax]
mov esi, eax
lea rdi, [rbp+var_5D8]
xor ecx, ecx
lea r8, FT_DOC_cmp
xor eax, eax
mov r9d, eax
mov edx, ecx
mov dword ptr [rsp+5F0h+var_5F0], 0
mov dword ptr [rsp+5F0h+var_5E8], 0
call init_queue
lea rdi, [rbp+var_580]
add rdi, 20h ; ' '
lea rsi, walk_and_push
lea rdx, [rbp+var_5D8]
xor ecx, ecx
call tree_walk
loc_A0436:
cmp [rbp+var_5C8], 0
jz loc_A04F7
lea rdi, [rbp+var_5D8]
mov esi, 1
call queue_remove
mov rax, [rax]
mov [rbp+var_5E0], rax
mov rax, [rbp+var_10]
mov rax, [rax+140h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_5E0]
mov rdx, [rbp+var_30]
call rax
cmp eax, 0
jnz short loc_A04F2
mov rax, [rbp+var_10]
mov ecx, [rax+1D0h]
or ecx, 2
mov [rax+1D0h], ecx
mov rax, [rbp+var_5A8]
mov dword ptr [rax+34h], 1
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_30]
mov r8, [rbp+var_5A8]
lea r9, [rbp+var_2C8]
add r9, 238h
lea rdi, [rbp+var_2C8]
call _mi_ft_parse
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_A04F0
lea rdi, [rbp+var_5D8]
call delete_queue
jmp loc_A0623
loc_A04F0:
jmp short $+2
loc_A04F2:
jmp loc_A0436
loc_A04F7:
lea rdi, [rbp+var_5D8]
call delete_queue
lea rdi, [rbp+var_580]
add rdi, 20h ; ' '
call reset_tree
lea rdi, [rbp+var_2C8]
lea rsi, walk_and_match
lea rdx, [rbp+var_580]
xor ecx, ecx
call tree_walk
cmp eax, 0
jz short loc_A0539
jmp loc_A0623
loc_A0539:
jmp short $+2
loc_A053B:
lea rax, mi_key_memory_FT_INFO
mov edi, [rax]
mov eax, [rbp+var_354]
sub eax, 1
movsxd rsi, eax
shl rsi, 4
add rsi, 28h ; '('
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_590], rax
cmp [rbp+var_590], 0
jnz short loc_A0577
jmp loc_A0623
loc_A0577:
mov rax, [rbp+var_590]
lea rcx, _ft_vft_nlq
mov [rax], rcx
mov ecx, [rbp+var_354]
mov rax, [rbp+var_590]
mov [rax+10h], ecx
mov rax, [rbp+var_590]
mov dword ptr [rax+14h], 0FFFFFFFFh
mov rcx, [rbp+var_580]
mov rax, [rbp+var_590]
mov [rax+8], rcx
mov rax, [rbp+var_590]
add rax, 18h
mov [rbp+var_588], rax
lea rdi, [rbp+var_580]
add rdi, 20h ; ' '
lea rsi, walk_and_copy_0
lea rdx, [rbp+var_588]
xor ecx, ecx
call tree_walk
mov eax, [rbp+var_28]
and eax, 2
cmp eax, 0
jz short loc_A0621
mov rdi, [rbp+var_590]
add rdi, 18h
mov rax, [rbp+var_590]
movsxd rsi, dword ptr [rax+10h]
mov edx, 10h
lea rcx, FT_DOC_cmp
xor eax, eax
mov r8d, eax
call my_qsort2
loc_A0621:
jmp short $+2
loc_A0623:
lea rdi, [rbp+var_580]
add rdi, 20h ; ' '
xor esi, esi
call delete_tree
lea rdi, [rbp+var_2C8]
xor esi, esi
call delete_tree
mov rcx, [rbp+var_598]
mov rax, [rbp+var_10]
mov [rax+170h], rcx
mov rax, [rbp+var_590]
mov [rbp+var_8], rax
loc_A0660:
mov rax, [rbp+var_8]
add rsp, 5F0h
pop rbp
retn
| long long ft_init_nlq_search(long long a1, unsigned int a2, long long a3, unsigned int a4, int a5, long long a6)
{
_QWORD *v6; // rax
_BYTE v8[16]; // [rsp+18h] [rbp-5D8h] BYREF
int v9; // [rsp+28h] [rbp-5C8h]
long long v10; // [rsp+48h] [rbp-5A8h]
long long v11; // [rsp+50h] [rbp-5A0h]
long long v12; // [rsp+58h] [rbp-598h]
long long v13; // [rsp+60h] [rbp-590h]
long long v14; // [rsp+68h] [rbp-588h] BYREF
long long v15; // [rsp+70h] [rbp-580h] BYREF
unsigned int v16; // [rsp+78h] [rbp-578h]
long long v17; // [rsp+80h] [rbp-570h]
long long v18; // [rsp+88h] [rbp-568h]
_BYTE v19[524]; // [rsp+90h] [rbp-560h] BYREF
int v20; // [rsp+29Ch] [rbp-354h]
_BYTE v21[568]; // [rsp+328h] [rbp-2C8h] BYREF
_BYTE v22[96]; // [rsp+560h] [rbp-90h] BYREF
long long v23; // [rsp+5C0h] [rbp-30h]
int v24; // [rsp+5C8h] [rbp-28h]
unsigned int v25; // [rsp+5CCh] [rbp-24h]
long long v26; // [rsp+5D0h] [rbp-20h]
unsigned int v27; // [rsp+5DCh] [rbp-14h]
long long v28; // [rsp+5E0h] [rbp-10h]
v28 = a1;
v27 = a2;
v26 = a3;
v25 = a4;
v24 = a5;
v23 = a6;
v13 = 0LL;
v12 = *(_QWORD *)(a1 + 368);
v27 = mi_check_index(a1, a2);
if ( (v27 & 0x80000000) != 0 )
return 0LL;
if ( (unsigned int)mi_readinfo(v28, 0LL, 1LL) )
return 0LL;
v15 = v28;
v16 = v27;
v17 = **(_QWORD **)(112LL * v27 + *(_QWORD *)(*(_QWORD *)v28 + 536LL) + 40);
v18 = *(unsigned int *)(*(_QWORD *)v28 + 404LL) + *(_QWORD *)(v28 + 264);
v11 = *(_QWORD *)(112LL * v27 + *(_QWORD *)(*(_QWORD *)v28 + 536LL) + 56);
v10 = ftparser_call_initializer(v28, v27, 0LL);
if ( v10 )
{
memset(v21, 0LL, 664LL);
init_tree((unsigned int)v19, 0, 0, 32, (unsigned int)FT_SUPERDOC_cmp, 0, 0LL, 0LL);
ft_parse_init(v21, v17);
*(_DWORD *)(v10 + 52) = 0;
if ( !(unsigned int)ft_parse(v21, v26, v25, v11, v10, v22)
&& !(unsigned int)tree_walk(v21, walk_and_match, &v15, 0LL) )
{
if ( (v24 & 4) == 0 || !*(_QWORD *)&ft_query_expansion_limit )
goto LABEL_17;
init_queue((unsigned int)v8, ft_query_expansion_limit, 0, 0, (unsigned int)FT_DOC_cmp, 0, 0, 0);
tree_walk(v19, walk_and_push, v8, 0LL);
while ( v9 )
{
v6 = (_QWORD *)queue_remove(v8, 1LL);
if ( !(*(unsigned int ( **)(long long, _QWORD, long long))(v28 + 320))(v28, *v6, v23) )
{
*(_DWORD *)(v28 + 464) |= 2u;
*(_DWORD *)(v10 + 52) = 1;
if ( (unsigned int)mi_ft_parse(v21, v28, v27, v23, v10, v22) )
{
delete_queue(v8);
goto LABEL_20;
}
}
}
delete_queue(v8);
reset_tree(v19);
if ( !(unsigned int)tree_walk(v21, walk_and_match, &v15, 0LL) )
{
LABEL_17:
v13 = my_malloc(mi_key_memory_FT_INFO, 16LL * (v20 - 1) + 40, 0LL);
if ( v13 )
{
*(_QWORD *)v13 = ft_vft_nlq;
*(_DWORD *)(v13 + 16) = v20;
*(_DWORD *)(v13 + 20) = -1;
*(_QWORD *)(v13 + 8) = v15;
v14 = v13 + 24;
tree_walk(v19, walk_and_copy_0, &v14, 0LL);
if ( (v24 & 2) != 0 )
my_qsort2(v13 + 24, *(int *)(v13 + 16), 16LL, FT_DOC_cmp, 0LL);
}
}
}
}
LABEL_20:
delete_tree(v19, 0LL);
delete_tree(v21, 0LL);
*(_QWORD *)(v28 + 368) = v12;
return v13;
}
| ft_init_nlq_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x5f0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV qword ptr [RBP + -0x30],R9
MOV qword ptr [RBP + -0x590],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x170]
MOV qword ptr [RBP + -0x598],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001bdfc0
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JGE 0x001a0231
JMP 0x001a0224
LAB_001a0224:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a0660
LAB_001a0231:
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x1
CALL 0x001b09f0
CMP EAX,0x0
JZ 0x001a0255
JMP 0x001a0248
LAB_001a0248:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a0660
LAB_001a0255:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x580],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x578],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x570],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x108]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x194]
ADD RAX,RCX
MOV qword ptr [RBP + -0x568],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x5a0],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
XOR EDX,EDX
CALL 0x001a21c0
MOV qword ptr [RBP + -0x5a8],RAX
CMP RAX,0x0
JNZ 0x001a02f4
JMP 0x001a0623
LAB_001a02f4:
LEA RDI,[RBP + -0x2c8]
XOR ESI,ESI
MOV EDX,0x298
CALL 0x0012a2a0
LEA RDI,[RBP + -0x580]
ADD RDI,0x20
XOR EAX,EAX
MOV R9D,EAX
MOV ECX,0x20
LEA R8,[0x1a0670]
MOV RSI,R9
MOV RDX,R9
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
CALL 0x002004b0
MOV RSI,qword ptr [RBP + -0x570]
LEA RDI,[RBP + -0x2c8]
CALL 0x001a1e50
MOV RAX,qword ptr [RBP + -0x5a8]
MOV dword ptr [RAX + 0x34],0x0
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x5a0]
MOV R8,qword ptr [RBP + -0x5a8]
LEA R9,[RBP + -0x2c8]
ADD R9,0x238
LEA RDI,[RBP + -0x2c8]
CALL 0x001a1f00
CMP EAX,0x0
JZ 0x001a0399
JMP 0x001a0623
LAB_001a0399:
LEA RDI,[RBP + -0x2c8]
LEA RSI,[0x1a06c0]
LEA RDX,[RBP + -0x580]
XOR ECX,ECX
CALL 0x00201e20
CMP EAX,0x0
JZ 0x001a03bf
JMP 0x001a0623
LAB_001a03bf:
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001a053b
LEA RAX,[0x3c5510]
CMP qword ptr [RAX],0x0
JZ 0x001a053b
LEA RAX,[0x3c5510]
MOV RAX,qword ptr [RAX]
MOV ESI,EAX
LEA RDI,[RBP + -0x5d8]
XOR ECX,ECX
LEA R8,[0x1a0f00]
XOR EAX,EAX
MOV R9D,EAX
MOV EDX,ECX
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x001fd080
LEA RDI,[RBP + -0x580]
ADD RDI,0x20
LEA RSI,[0x1a0f70]
LEA RDX,[RBP + -0x5d8]
XOR ECX,ECX
CALL 0x00201e20
LAB_001a0436:
CMP dword ptr [RBP + -0x5c8],0x0
JZ 0x001a04f7
LEA RDI,[RBP + -0x5d8]
MOV ESI,0x1
CALL 0x001fd4a0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x5e0],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x140]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x5e0]
MOV RDX,qword ptr [RBP + -0x30]
CALL RAX
CMP EAX,0x0
JNZ 0x001a04f2
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x1d0]
OR ECX,0x2
MOV dword ptr [RAX + 0x1d0],ECX
MOV RAX,qword ptr [RBP + -0x5a8]
MOV dword ptr [RAX + 0x34],0x1
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x5a8]
LEA R9,[RBP + -0x2c8]
ADD R9,0x238
LEA RDI,[RBP + -0x2c8]
CALL 0x001a2690
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001a04f0
LEA RDI,[RBP + -0x5d8]
CALL 0x001fd2b0
JMP 0x001a0623
LAB_001a04f0:
JMP 0x001a04f2
LAB_001a04f2:
JMP 0x001a0436
LAB_001a04f7:
LEA RDI,[RBP + -0x5d8]
CALL 0x001fd2b0
LEA RDI,[RBP + -0x580]
ADD RDI,0x20
CALL 0x00200850
LEA RDI,[RBP + -0x2c8]
LEA RSI,[0x1a06c0]
LEA RDX,[RBP + -0x580]
XOR ECX,ECX
CALL 0x00201e20
CMP EAX,0x0
JZ 0x001a0539
JMP 0x001a0623
LAB_001a0539:
JMP 0x001a053b
LAB_001a053b:
LEA RAX,[0xd81380]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x354]
SUB EAX,0x1
MOVSXD RSI,EAX
SHL RSI,0x4
ADD RSI,0x28
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f99f0
MOV qword ptr [RBP + -0x590],RAX
CMP qword ptr [RBP + -0x590],0x0
JNZ 0x001a0577
JMP 0x001a0623
LAB_001a0577:
MOV RAX,qword ptr [RBP + -0x590]
LEA RCX,[0x3bb560]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x354]
MOV RAX,qword ptr [RBP + -0x590]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x590]
MOV dword ptr [RAX + 0x14],0xffffffff
MOV RCX,qword ptr [RBP + -0x580]
MOV RAX,qword ptr [RBP + -0x590]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x590]
ADD RAX,0x18
MOV qword ptr [RBP + -0x588],RAX
LEA RDI,[RBP + -0x580]
ADD RDI,0x20
LEA RSI,[0x1a1000]
LEA RDX,[RBP + -0x588]
XOR ECX,ECX
CALL 0x00201e20
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001a0621
MOV RDI,qword ptr [RBP + -0x590]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x590]
MOVSXD RSI,dword ptr [RAX + 0x10]
MOV EDX,0x10
LEA RCX,[0x1a0f00]
XOR EAX,EAX
MOV R8D,EAX
CALL 0x001ed0f0
LAB_001a0621:
JMP 0x001a0623
LAB_001a0623:
LEA RDI,[RBP + -0x580]
ADD RDI,0x20
XOR ESI,ESI
CALL 0x002006b0
LEA RDI,[RBP + -0x2c8]
XOR ESI,ESI
CALL 0x002006b0
MOV RCX,qword ptr [RBP + -0x598]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x170],RCX
MOV RAX,qword ptr [RBP + -0x590]
MOV qword ptr [RBP + -0x8],RAX
LAB_001a0660:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x5f0
POP RBP
RET
|
int8 *
ft_init_nlq_search(long *param_1,int4 param_2,int8 param_3,int4 param_4,
uint param_5,int8 param_6)
{
int iVar1;
int8 *puVar2;
ulong uVar3;
ulong uVar4;
int1 local_5e0 [16];
int local_5d0;
long local_5b0;
int8 local_5a8;
long local_5a0;
int8 *local_598;
int8 *local_590;
long *local_588;
uint local_580;
int8 local_578;
long local_570;
int1 auStack_568 [524];
int local_35c;
int1 local_2d0 [568];
int1 auStack_98 [96];
int8 local_38;
uint local_30;
int4 local_2c;
int8 local_28;
uint local_1c;
long *local_18;
int8 *local_10;
local_598 = (int8 *)0x0;
local_5a0 = param_1[0x2e];
local_38 = param_6;
local_30 = param_5;
local_2c = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
local_1c = _mi_check_index(param_1,param_2);
if ((int)local_1c < 0) {
local_10 = (int8 *)0x0;
}
else {
iVar1 = _mi_readinfo(local_18,0,1);
if (iVar1 == 0) {
local_588 = local_18;
local_580 = local_1c;
local_578 = **(int8 **)(*(long *)(*local_18 + 0x218) + (ulong)local_1c * 0x70 + 0x28);
local_570 = local_18[0x21] + (ulong)*(uint *)(*local_18 + 0x194);
local_5a8 = *(int8 *)(*(long *)(*local_18 + 0x218) + (ulong)local_1c * 0x70 + 0x38);
local_5b0 = ftparser_call_initializer(local_18,local_1c,0);
if (local_5b0 != 0) {
memset(local_2d0,0,0x298);
uVar3 = 0;
uVar4 = 0;
init_tree(auStack_568,0,0,0x20,FT_SUPERDOC_cmp,0,0,0);
ft_parse_init(local_2d0,local_578);
*(int4 *)(local_5b0 + 0x34) = 0;
iVar1 = ft_parse(local_2d0,local_28,local_2c,local_5a8,local_5b0,auStack_98);
if ((iVar1 == 0) && (iVar1 = tree_walk(local_2d0,walk_and_match,&local_588,0), iVar1 == 0))
{
if (((local_30 & 4) == 0) || (ft_query_expansion_limit == 0)) {
LAB_001a053b:
local_598 = (int8 *)
my_malloc(mi_key_memory_FT_INFO,(long)(local_35c + -1) * 0x10 + 0x28,0);
if (local_598 != (int8 *)0x0) {
*local_598 = _ft_vft_nlq;
*(int *)(local_598 + 2) = local_35c;
*(int4 *)((long)local_598 + 0x14) = 0xffffffff;
local_598[1] = local_588;
local_590 = local_598 + 3;
tree_walk(auStack_568,walk_and_copy,&local_590,0);
if ((local_30 & 2) != 0) {
my_qsort2(local_598 + 3,(long)*(int *)(local_598 + 2),0x10,FT_DOC_cmp,0);
}
}
}
else {
init_queue(local_5e0,ft_query_expansion_limit & 0xffffffff,0,0,FT_DOC_cmp,0,
uVar3 & 0xffffffff00000000,uVar4 & 0xffffffff00000000);
tree_walk(auStack_568,walk_and_push,local_5e0,0);
do {
do {
if (local_5d0 == 0) {
delete_queue(local_5e0);
reset_tree(auStack_568);
iVar1 = tree_walk(local_2d0,walk_and_match,&local_588,0);
if (iVar1 == 0) goto LAB_001a053b;
goto LAB_001a0623;
}
puVar2 = (int8 *)queue_remove(local_5e0,1);
iVar1 = (*(code *)local_18[0x28])(local_18,*puVar2,local_38);
} while (iVar1 != 0);
*(uint *)(local_18 + 0x3a) = *(uint *)(local_18 + 0x3a) | 2;
*(int4 *)(local_5b0 + 0x34) = 1;
iVar1 = _mi_ft_parse(local_2d0,local_18,local_1c,local_38,local_5b0,auStack_98);
} while (iVar1 == 0);
delete_queue(local_5e0);
}
}
}
LAB_001a0623:
delete_tree(auStack_568,0);
delete_tree(local_2d0,0);
local_18[0x2e] = local_5a0;
local_10 = local_598;
}
else {
local_10 = (int8 *)0x0;
}
}
return local_10;
}
| |
43,303 | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&) | monkey531[P]llama/common/minja.hpp | static Value simple_function(const std::string & fn_name, const std::vector<std::string> & params, const std::function<Value(const std::shared_ptr<Context> &, Value & args)> & fn) {
std::map<std::string, size_t> named_positions;
for (size_t i = 0, n = params.size(); i < n; i++) named_positions[params[i]] = i;
return Value::callable([=](const std::shared_ptr<Context> & context, ArgumentsValue & args) -> Value {
auto args_obj = Value::object();
std::vector<bool> provided_args(params.size());
for (size_t i = 0, n = args.args.size(); i < n; i++) {
auto & arg = args.args[i];
if (i < params.size()) {
args_obj.set(params[i], arg);
provided_args[i] = true;
} else {
throw std::runtime_error("Too many positional params for " + fn_name);
}
}
for (auto & [name, value] : args.kwargs) {
auto named_pos_it = named_positions.find(name);
if (named_pos_it == named_positions.end()) {
throw std::runtime_error("Unknown argument " + name + " for function " + fn_name);
}
provided_args[named_pos_it->second] = true;
args_obj.set(name, value);
}
return fn(context, args_obj);
});
} | O1 | cpp | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0xc0(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x8(%rdx), %rbp
subq (%rdx), %rbp
je 0x78430
sarq $0x5, %rbp
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %ebx, %ebx
leaq 0xb8(%rsp), %r13
xorl %r12d, %r12d
movq (%r15), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0xad0c6
movq %r12, (%rax)
incq %r12
addq $0x20, %rbx
cmpq %r12, %rbp
jne 0x78413
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x548e4
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x224fa
leaq 0x68(%rsp), %r14
leaq 0xb8(%rsp), %rsi
movq %r14, %rdi
callq 0xad520
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0xad142
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x88, %edi
callq 0x1b8a0
movq %rax, %r12
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x548e4
leaq 0x18(%r12), %rdi
leaq 0x28(%r12), %rbp
movq %rbp, 0x18(%r12)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq %rsi, %rdx
callq 0x224fa
leaq 0x40(%r12), %rax
movq 0x78(%rsp), %rcx
testq %rcx, %rcx
je 0x7851b
leaq 0x70(%rsp), %rdx
movl (%rdx), %esi
movl %esi, 0x40(%r12)
movq %rcx, 0x48(%r12)
movups 0x10(%rdx), %xmm0
movups %xmm0, 0x50(%r12)
movq %rax, 0x8(%rcx)
leaq 0x90(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x60(%r12)
movq $0x0, -0x18(%rax)
movq %rdx, -0x10(%rax)
movq %rdx, -0x8(%rax)
jmp 0x7853c
movl $0x0, 0x40(%r12)
movq $0x0, 0x48(%r12)
movq %rax, 0x50(%r12)
movq %rax, 0x58(%r12)
leaq 0x60(%r12), %rax
movq $0x0, (%rax)
leaq 0x68(%r12), %rdi
movq %r15, %rsi
callq 0xad142
movq %rsp, %rsi
movq %r12, (%rsi)
leaq 0x1d5(%rip), %rax # 0x78732
movq %rax, 0x18(%rsi)
leaq 0x858(%rip), %rax # 0x78dc0
movq %rax, 0x10(%rsi)
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x96b1c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x78590
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa8(%rsp), %rax
testq %rax, %rax
je 0x785aa
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xad782
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x785c9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8c0
leaq 0x30(%rsp), %rdi
callq 0x22074
leaq 0xb8(%rsp), %rdi
callq 0xad782
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x78689
jmp 0x78689
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7867d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7867d
jmp 0x78689
movq %rax, %rbx
movq %r12, %rdi
addq $0x38, %rdi
callq 0xad782
movq 0x18(%r12), %rdi
cmpq %rbp, %rdi
je 0x78647
movq (%rbp), %rsi
incq %rsi
callq 0x1b8c0
jmp 0x78647
movq %rax, %rbx
movq %r12, %rdi
callq 0x22074
jmp 0x78654
movq %rax, %rbx
movl $0x88, %esi
movq %r12, %rdi
callq 0x1b8c0
jmp 0x78666
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7867d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x30(%rsp), %rdi
callq 0x786e4
jmp 0x786ce
movq %rax, %rdi
callq 0x21597
movq %rax, %rbx
movq %r14, %rdi
callq 0xad782
jmp 0x786a1
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x786bd
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8c0
jmp 0x786bd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x22074
jmp 0x786ce
jmp 0x786cb
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xad782
movq %rbx, %rdi
callq 0x1bf90
nop
| _ZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_F0], rcx
mov r15, rdx
mov r14, rsi
mov [rsp+118h+var_F8], rdi
lea rax, [rsp+118h+var_58]
mov dword ptr [rax], 0
xor ecx, ecx
mov [rax+8], rcx
mov [rax+10h], rax
mov [rax+18h], rax
mov [rax+20h], rcx
mov rbp, [rdx+8]
sub rbp, [rdx]
jz short loc_78430
sar rbp, 5
cmp rbp, 1
adc rbp, 0
xor ebx, ebx
lea r13, [rsp+118h+var_60]
xor r12d, r12d
loc_78413:
mov rsi, [r15]
add rsi, rbx
mov rdi, r13
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmSt4lessIS5_ESaISt4pairIKS5_mEEEixERS9_; std::map<std::string,ulong>::operator[](std::string const&)
mov [rax], r12
inc r12
add rbx, 20h ; ' '
cmp rbp, r12
jnz short loc_78413
loc_78430:
lea rdi, [rsp+118h+var_E8]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [rsp+118h+var_D0]
lea r13, [rsp+118h+var_C0]
mov [r13-10h], r13
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r14, [rsp+118h+var_B0]
lea rsi, [rsp+118h+var_60]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EEC2ERKSE_; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>> const&)
lea r15, [rsp+118h+var_80]
mov rdi, r15
mov rsi, [rsp+118h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
xorps xmm0, xmm0
movaps [rsp+118h+var_108], xmm0
movaps [rsp+118h+var_118], xmm0
mov edi, 88h; unsigned __int64
call __Znwm; operator new(ulong)
mov r12, rax
lea rsi, [rsp+118h+var_E8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [r12+18h]
lea rbp, [r12+28h]
mov [r12+18h], rbp
mov rsi, [rsp+118h+var_D0]
mov rdx, [rsp+118h+var_C8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, [r12+40h]
mov rcx, [rsp+118h+var_A0]
test rcx, rcx
jz short loc_7851B
lea rdx, [rsp+118h+var_A8]
mov esi, [rdx]
mov [r12+40h], esi
mov [r12+48h], rcx
movups xmm0, xmmword ptr [rdx+10h]
movups xmmword ptr [r12+50h], xmm0
mov [rcx+8], rax
lea rax, [rsp+118h+var_88]
mov rcx, [rax]
mov [r12+60h], rcx
mov qword ptr [rax-18h], 0
mov [rax-10h], rdx
mov [rax-8], rdx
jmp short loc_7853C
loc_7851B:
mov dword ptr [r12+40h], 0
mov qword ptr [r12+48h], 0
mov [r12+50h], rax
mov [r12+58h], rax
lea rax, [r12+60h]
loc_7853C:
mov qword ptr [rax], 0
lea rdi, [r12+68h]
mov rsi, r15
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
mov rsi, rsp
mov [rsi], r12
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E9_M_invokeERKSt9_Any_dataS6_S8_; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke(std::_Any_data const&,std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
mov rbx, [rsp+118h+var_F8]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_78590
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_78590:
mov rax, [rsp+118h+var_70]
test rax, rax
jz short loc_785AA
mov rdi, r15
mov rsi, r15
mov edx, 3
call rax
loc_785AA:
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_785C9
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_785C9:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp loc_78689
jmp loc_78689
mov rbx, rax
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_7867D
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_7867D
jmp short loc_78689
mov rbx, rax
mov rdi, r12
add rdi, 38h ; '8'
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [r12+18h]; void *
cmp rdi, rbp
jz short loc_78647
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_78647
mov rbx, rax
loc_78647:
mov rdi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_78654
mov rbx, rax
loc_78654:
mov esi, 88h; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_78666
mov rbx, rax
loc_78666:
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_7867D
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_7867D:
lea rdi, [rsp+118h+var_E8]
call _ZZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EEEN3$_0D2Ev; minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0()
jmp short loc_786CE
loc_78689:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
jmp short loc_786A1
mov rbx, rax
loc_786A1:
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_786BD
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_786BD
mov rbx, rax
loc_786BD:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_786CE
jmp short $+2
loc_786CB:
mov rbx, rax
loc_786CE:
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long minja::simple_function(long long a1, long long a2, _QWORD *a3, long long a4)
{
long long v5; // rbp
long long v6; // rbp
long long v7; // rbx
long long v8; // r12
long long v9; // r12
long long v10; // rax
long long v11; // rcx
long long *v12; // rax
long long v13; // rbx
int v14; // edx
int v15; // ecx
int v16; // r8d
int v17; // r9d
__int128 v19; // [rsp+0h] [rbp-118h] BYREF
__int128 v20; // [rsp+10h] [rbp-108h]
long long v21; // [rsp+20h] [rbp-F8h]
long long v22; // [rsp+28h] [rbp-F0h]
_QWORD v23[3]; // [rsp+30h] [rbp-E8h] BYREF
void *v24[2]; // [rsp+48h] [rbp-D0h] BYREF
_QWORD v25[2]; // [rsp+58h] [rbp-C0h] BYREF
_BYTE v26[8]; // [rsp+68h] [rbp-B0h] BYREF
int v27; // [rsp+70h] [rbp-A8h] BYREF
long long v28; // [rsp+78h] [rbp-A0h]
__int128 v29; // [rsp+80h] [rbp-98h]
long long v30; // [rsp+90h] [rbp-88h] BYREF
_BYTE v31[16]; // [rsp+98h] [rbp-80h] BYREF
void ( *v32)(_BYTE *, _BYTE *, long long); // [rsp+A8h] [rbp-70h]
_BYTE v33[8]; // [rsp+B8h] [rbp-60h] BYREF
int v34; // [rsp+C0h] [rbp-58h] BYREF
long long v35; // [rsp+C8h] [rbp-50h]
int *v36; // [rsp+D0h] [rbp-48h]
int *v37; // [rsp+D8h] [rbp-40h]
long long v38; // [rsp+E0h] [rbp-38h]
v22 = a4;
v21 = a1;
v34 = 0;
v35 = 0LL;
v36 = &v34;
v37 = &v34;
v38 = 0LL;
v5 = a3[1] - *a3;
if ( v5 )
{
v6 = (v5 >> 5 == 0) + (v5 >> 5);
v7 = 0LL;
v8 = 0LL;
do
{
*(_QWORD *)std::map<std::string,unsigned long>::operator[](v33, v7 + *a3) = v8++;
v7 += 32LL;
}
while ( v6 != v8 );
}
std::vector<std::string>::vector((long long)v23, a3);
v24[0] = v25;
std::string::_M_construct<char *>(v24, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::_Rb_tree(
v26,
v33);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v31, v22);
v20 = 0LL;
v19 = 0LL;
v9 = operator new(0x88uLL);
std::vector<std::string>::vector(v9, v23);
*(_QWORD *)(v9 + 24) = v9 + 40;
std::string::_M_construct<char *>((_QWORD *)(v9 + 24), (_BYTE *)v24[0], (long long)v24[0] + (unsigned long long)v24[1]);
v10 = v9 + 64;
v11 = v28;
if ( v28 )
{
*(_DWORD *)(v9 + 64) = v27;
*(_QWORD *)(v9 + 72) = v11;
*(_OWORD *)(v9 + 80) = v29;
*(_QWORD *)(v11 + 8) = v10;
v12 = &v30;
*(_QWORD *)(v9 + 96) = v30;
v28 = 0LL;
*(_QWORD *)&v29 = &v27;
*((_QWORD *)&v29 + 1) = &v27;
}
else
{
*(_DWORD *)(v9 + 64) = 0;
*(_QWORD *)(v9 + 72) = 0LL;
*(_QWORD *)(v9 + 80) = v10;
*(_QWORD *)(v9 + 88) = v10;
v12 = (long long *)(v9 + 96);
}
*v12 = 0LL;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v9 + 104, v31);
*((_QWORD *)&v20 + 1) = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke;
*(_QWORD *)&v20 = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager;
v13 = v21;
minja::Value::callable(v21, (unsigned int)&v19, v14, v15, v16, v17, v9, *((long long *)&v19 + 1));
if ( (_QWORD)v20 )
((void ( *)(__int128 *, __int128 *, long long))v20)(&v19, &v19, 3LL);
if ( v32 )
v32(v31, v31, 3LL);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v26);
if ( v24[0] != v25 )
operator delete(v24[0], v25[0] + 1LL);
std::vector<std::string>::~vector(v23);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v33);
return v13;
}
| simple_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x28],RCX
MOV R15,RDX
MOV R14,RSI
MOV qword ptr [RSP + 0x20],RDI
LEA RAX,[RSP + 0xc0]
MOV dword ptr [RAX],0x0
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
MOV qword ptr [RAX + 0x20],RCX
MOV RBP,qword ptr [RDX + 0x8]
SUB RBP,qword ptr [RDX]
JZ 0x00178430
SAR RBP,0x5
CMP RBP,0x1
ADC RBP,0x0
XOR EBX,EBX
LEA R13,[RSP + 0xb8]
XOR R12D,R12D
LAB_00178413:
MOV RSI,qword ptr [R15]
ADD RSI,RBX
LAB_00178419:
MOV RDI,R13
CALL 0x001ad0c6
MOV qword ptr [RAX],R12
INC R12
ADD RBX,0x20
CMP RBP,R12
JNZ 0x00178413
LAB_00178430:
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x001548e4
LEA RDI,[RSP + 0x48]
LEA R13,[RSP + 0x58]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LAB_00178455:
CALL 0x001224fa
LEA R14,[RSP + 0x68]
LAB_0017845f:
LEA RSI,[RSP + 0xb8]
MOV RDI,R14
CALL 0x001ad520
LEA R15,[RSP + 0x98]
LAB_00178477:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001ad142
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_00178490:
MOV EDI,0x88
CALL 0x0011b8a0
LAB_0017849a:
MOV R12,RAX
LEA RSI,[RSP + 0x30]
MOV RDI,RAX
CALL 0x001548e4
LEA RDI,[R12 + 0x18]
LEA RBP,[R12 + 0x28]
MOV qword ptr [R12 + 0x18],RBP
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RDX,RSI
LAB_001784c6:
CALL 0x001224fa
LEA RAX,[R12 + 0x40]
MOV RCX,qword ptr [RSP + 0x78]
TEST RCX,RCX
JZ 0x0017851b
LEA RDX,[RSP + 0x70]
MOV ESI,dword ptr [RDX]
MOV dword ptr [R12 + 0x40],ESI
MOV qword ptr [R12 + 0x48],RCX
MOVUPS XMM0,xmmword ptr [RDX + 0x10]
MOVUPS xmmword ptr [R12 + 0x50],XMM0
MOV qword ptr [RCX + 0x8],RAX
LEA RAX,[RSP + 0x90]
MOV RCX,qword ptr [RAX]
MOV qword ptr [R12 + 0x60],RCX
MOV qword ptr [RAX + -0x18],0x0
MOV qword ptr [RAX + -0x10],RDX
MOV qword ptr [RAX + -0x8],RDX
JMP 0x0017853c
LAB_0017851b:
MOV dword ptr [R12 + 0x40],0x0
MOV qword ptr [R12 + 0x48],0x0
MOV qword ptr [R12 + 0x50],RAX
MOV qword ptr [R12 + 0x58],RAX
LEA RAX,[R12 + 0x60]
LAB_0017853c:
MOV qword ptr [RAX],0x0
LEA RDI,[R12 + 0x68]
LAB_00178548:
MOV RSI,R15
CALL 0x001ad142
MOV RSI,RSP
MOV qword ptr [RSI],R12
LEA RAX,[0x178732]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x178dc0]
MOV qword ptr [RSI + 0x10],RAX
LAB_0017856c:
MOV RBX,qword ptr [RSP + 0x20]
MOV RDI,RBX
CALL 0x00196b1c
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x00178590
LAB_00178583:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00178590:
MOV RAX,qword ptr [RSP + 0xa8]
TEST RAX,RAX
JZ 0x001785aa
LAB_0017859d:
MOV RDI,R15
MOV RSI,R15
MOV EDX,0x3
CALL RAX
LAB_001785aa:
MOV RDI,R14
CALL 0x001ad782
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R13
JZ 0x001785c9
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011b8c0
LAB_001785c9:
LEA RDI,[RSP + 0x30]
CALL 0x00122074
LEA RDI,[RSP + 0xb8]
CALL 0x001ad782
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::simple_function(std::__cxx11::string const&, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&, std::function<minja::Value
(std::shared_ptr<minja::Context> const&, minja::Value&)> const&) */
Value * __thiscall
minja::simple_function(minja *this,string *param_1,vector *param_2,function *param_3)
{
minja *pmVar1;
long *plVar2;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this_00;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar3;
long lVar4;
long lVar5;
long lVar6;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_118;
int8 uStack_110;
code *local_108;
code *pcStack_100;
minja *local_f8;
function *local_f0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_e8 [24];
long *local_d0;
long local_c8;
long local_c0 [2];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_b0 [8];
int4 local_a8 [2];
long local_a0;
int4 *local_98;
int4 *puStack_90;
int8 local_88;
function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> local_80 [16];
code *local_70;
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_60 [8];
int4 local_58 [2];
int8 local_50;
int4 *local_48;
int4 *local_40;
int8 local_38;
local_48 = local_58;
local_58[0] = 0;
local_50 = 0;
local_38 = 0;
local_f8 = this;
local_f0 = param_3;
local_40 = local_48;
if (*(long *)(param_2 + 8) - *(long *)param_2 != 0) {
lVar5 = *(long *)(param_2 + 8) - *(long *)param_2 >> 5;
lVar4 = 0;
lVar6 = 0;
do {
/* try { // try from 00178419 to 00178420 has its CatchHandler @ 001786cb */
plVar2 = (long *)std::
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::operator[](local_60,(string *)(*(long *)param_2 + lVar4));
*plVar2 = lVar6;
lVar6 = lVar6 + 1;
lVar4 = lVar4 + 0x20;
} while (lVar5 + (ulong)(lVar5 == 0) != lVar6);
}
/* try { // try from 00178430 to 0017843c has its CatchHandler @ 001786c9 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_e8,param_2);
local_d0 = local_c0;
/* try { // try from 00178455 to 00178459 has its CatchHandler @ 001786ba */
std::__cxx11::string::_M_construct<char*>
(&local_d0,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 0017845f to 0017846e has its CatchHandler @ 0017869e */
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::_Rb_tree(local_b0,(_Rb_tree *)local_60);
/* try { // try from 00178477 to 00178483 has its CatchHandler @ 00178691 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
(local_80,local_f0);
local_108 = (code *)0x0;
pcStack_100 = (code *)0x0;
local_118 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)0x0;
uStack_110 = 0;
/* try { // try from 00178490 to 00178499 has its CatchHandler @ 00178663 */
this_00 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)operator_new(0x88);
/* try { // try from 0017849a to 001784a9 has its CatchHandler @ 00178651 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(this_00,(vector *)local_e8);
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x18) =
this_00 + 0x28;
/* try { // try from 001784c6 to 001784ca has its CatchHandler @ 00178644 */
std::__cxx11::string::_M_construct<char*>(this_00 + 0x18,local_d0,local_c8 + (long)local_d0);
pvVar3 = this_00 + 0x40;
if (local_a0 == 0) {
*(int4 *)(this_00 + 0x40) = 0;
*(int8 *)(this_00 + 0x48) = 0;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x50) = pvVar3
;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x58) = pvVar3
;
pvVar3 = this_00 + 0x60;
}
else {
*(int4 *)(this_00 + 0x40) = local_a8[0];
*(long *)(this_00 + 0x48) = local_a0;
*(int4 **)(this_00 + 0x50) = local_98;
*(int4 **)(this_00 + 0x58) = puStack_90;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(local_a0 + 8) = pvVar3;
pvVar3 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_88;
*(int8 *)(this_00 + 0x60) = local_88;
local_a0 = 0;
local_98 = local_a8;
puStack_90 = local_a8;
}
*(int8 *)pvVar3 = 0;
/* try { // try from 00178548 to 0017854f has its CatchHandler @ 0017861d */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> *)
(this_00 + 0x68),local_80);
pmVar1 = local_f8;
pcStack_100 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_invoke;
local_108 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_manager;
local_118 = this_00;
/* try { // try from 0017856c to 00178578 has its CatchHandler @ 001785ff */
Value::callable((Value *)local_f8,(function *)&local_118);
if (local_108 != (code *)0x0) {
/* try { // try from 00178583 to 0017858f has its CatchHandler @ 001785fa */
(*local_108)(&local_118,&local_118,3);
}
if (local_70 != (code *)0x0) {
/* try { // try from 0017859d to 001785a9 has its CatchHandler @ 001785f5 */
(*local_70)(local_80,local_80,3);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_b0);
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_e8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
*)local_60);
return (Value *)pmVar1;
}
| |
43,304 | ma_get_host_list | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void ma_get_host_list(char *host_list, struct st_host *host_info, int default_port)
{
char *token, *start, *save;
int host_nr= 0;
start= host_list;
while ((token= strtok_r(start, ",", &save)))
{
char *p;
/* ipv6 hostname */
if ((p= strchr(token, ']')))
{
host_info[host_nr].host= token + 1;
*p++= 0;
token= p;
}
else
host_info[host_nr].host= token;
/* check if port was specified */
if ((p= strchr(token, ':')))
{
*p++= 0;
host_info[host_nr].port= atoi(p);
}
else
host_info[host_nr].port= default_port;
host_nr++;
start= NULL;
}
return;
} | O0 | c | ma_get_host_list:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2f2c8(%rip), %rsi # 0x4bca5
leaq -0x30(%rbp), %rdx
callq 0x13780
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1cacc
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1ca42
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ca58
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1caa1
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x136b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x1cab6
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x1c9d2
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_get_host_list:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_34], 0
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
loc_1C9D2:
mov rdi, [rbp+var_28]
lea rsi, asc_4BCA5; ","
lea rdx, [rbp+var_30]
call _strtok_r
mov [rbp+var_20], rax
cmp rax, 0
jz loc_1CACC
mov rdi, [rbp+var_20]
mov esi, 5Dh ; ']'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_1CA42
mov rcx, [rbp+var_20]
add rcx, 1
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
jmp short loc_1CA58
loc_1CA42:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_1CA58:
mov rdi, [rbp+var_20]
mov esi, 3Ah ; ':'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_1CAA1
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rdi, [rbp+var_40]
call _atoi
mov ecx, eax
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short loc_1CAB6
loc_1CAA1:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
loc_1CAB6:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
mov [rbp+var_28], 0
jmp loc_1C9D2
loc_1CACC:
add rsp, 40h
pop rbp
retn
| long long ma_get_host_list(long long a1, long long a2, int a3)
{
long long result; // rax
int v4; // eax
_BYTE *v5; // [rsp+0h] [rbp-40h]
_BYTE *v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+Ch] [rbp-34h]
_BYTE v8[8]; // [rsp+10h] [rbp-30h] BYREF
long long i; // [rsp+18h] [rbp-28h]
_BYTE *v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+2Ch] [rbp-14h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v7 = 0;
for ( i = a1; ; i = 0LL )
{
result = strtok_r(i, ",", v8);
v10 = (_BYTE *)result;
if ( !result )
break;
v5 = (_BYTE *)strchr(v10, 93LL);
if ( v5 )
{
*(_QWORD *)(16LL * v7 + v12) = v10 + 1;
*v5 = 0;
v10 = v5 + 1;
}
else
{
*(_QWORD *)(16LL * v7 + v12) = v10;
}
v6 = (_BYTE *)strchr(v10, 58LL);
if ( v6 )
{
*v6 = 0;
v4 = atoi(v6 + 1);
*(_DWORD *)(16LL * v7 + v12 + 8) = v4;
}
else
{
*(_DWORD *)(16LL * v7 + v12 + 8) = v11;
}
++v7;
}
return result;
}
| ma_get_host_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_0011c9d2:
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x14bca5]
LEA RDX,[RBP + -0x30]
CALL 0x00113780
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0011cacc
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x5d
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x0011ca42
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0011ca58
LAB_0011ca42:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_0011ca58:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x3a
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x0011caa1
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001136b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x0011cab6
LAB_0011caa1:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
LAB_0011cab6:
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV qword ptr [RBP + -0x28],0x0
JMP 0x0011c9d2
LAB_0011cacc:
ADD RSP,0x40
POP RBP
RET
|
void ma_get_host_list(char *param_1,long param_2,int4 param_3)
{
int iVar1;
char *pcVar2;
int local_3c;
char *local_38;
char *local_30;
char *local_28;
int4 local_1c;
long local_18;
char *local_10;
local_3c = 0;
local_30 = param_1;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
local_28 = strtok_r(local_30,",",&local_38);
if (local_28 == (char *)0x0) break;
pcVar2 = strchr(local_28,0x5d);
if (pcVar2 == (char *)0x0) {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28;
}
else {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28 + 1;
local_28 = pcVar2 + 1;
*pcVar2 = '\0';
}
pcVar2 = strchr(local_28,0x3a);
if (pcVar2 == (char *)0x0) {
*(int4 *)(local_18 + (long)local_3c * 0x10 + 8) = local_1c;
}
else {
*pcVar2 = '\0';
iVar1 = atoi(pcVar2 + 1);
*(int *)(local_18 + (long)local_3c * 0x10 + 8) = iVar1;
}
local_3c = local_3c + 1;
local_30 = (char *)0x0;
}
return;
}
| |
43,305 | mysql_once_init | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static int mysql_once_init()
#else
static void mysql_once_init()
#endif
{
ma_init(); /* Will init threads */
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name(MARIADB_DEFAULT_CHARSET, 0);
if (mysql_client_plugin_init())
{
#ifdef _WIN32
return 1;
#else
return;
#endif
}
if (!mysql_port)
{
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
struct servent *serv_ptr;
#endif
char *env;
mysql_port = MARIADB_PORT;
#if !__has_feature(memory_sanitizer) /* work around MSAN deficiency */
if ((serv_ptr = getservbyname("mysql", "tcp")))
mysql_port = (uint)ntohs((ushort)serv_ptr->s_port);
#endif
if ((env = getenv("MYSQL_TCP_PORT")))
mysql_port =(uint)atoi(env);
}
if (!mysql_unix_port)
{
char *env;
#ifdef _WIN32
mysql_unix_port = (char*)MARIADB_NAMEDPIPE;
#else
mysql_unix_port = (char*)MARIADB_UNIX_ADDR;
#endif
if ((env = getenv("MYSQL_UNIX_PORT")) ||
(env = getenv("MARIADB_UNIX_PORT")))
mysql_unix_port = env;
} | O3 | c | mysql_once_init:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x1e928
callq 0x32b9c
xorl %eax, %eax
callq 0x32322
leaq 0x18802(%rip), %rdi # 0x35c8c
xorl %esi, %esi
callq 0x322b6
xorl %eax, %eax
callq 0x27938
testl %eax, %eax
jne 0x1d55e
leaq 0x2da89(%rip), %rbx # 0x4af30
cmpl $0x0, (%rbx)
jne 0x1d4f2
movl $0xcea, (%rbx) # imm = 0xCEA
leaq 0x1aeff(%rip), %rdi # 0x383b8
leaq 0x189b7(%rip), %rsi # 0x35e77
callq 0x13080
testq %rax, %rax
je 0x1d4d7
movzwl 0x10(%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%rbx)
leaq 0x1899d(%rip), %rdi # 0x35e7b
callq 0x13590
testq %rax, %rax
je 0x1d4f2
movq %rax, %rdi
callq 0x136f0
movl %eax, (%rbx)
leaq 0x2da3f(%rip), %rbx # 0x4af38
cmpq $0x0, (%rbx)
jne 0x1d52e
leaq 0x18984(%rip), %rax # 0x35e8a
movq %rax, (%rbx)
leaq 0x1898a(%rip), %rdi # 0x35e9a
callq 0x13590
testq %rax, %rax
jne 0x1d52b
leaq 0x18989(%rip), %rdi # 0x35eaa
callq 0x13590
testq %rax, %rax
je 0x1d52e
movq %rax, (%rbx)
leaq 0x2da2b(%rip), %rax # 0x4af60
cmpb $0x0, (%rax)
jne 0x1d53f
callq 0x23ce2
xorl %edi, %edi
xorl %esi, %esi
callq 0x28408
movl $0x1, %esi
movl $0xd, %edi
callq 0x13560
movb $0x1, 0x2d9e6(%rip) # 0x4af44
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
| mysql_once_init:
push rbp
mov rbp, rsp
push rbx
push rax
call ma_init
call init_client_errs
xor eax, eax
call get_default_configuration_dirs
lea rdi, aUtf8mb4; "utf8mb4"
xor esi, esi
call set_default_charset_by_name
xor eax, eax
call mysql_client_plugin_init
test eax, eax
jnz loc_1D55E
lea rbx, mysql_port
cmp dword ptr [rbx], 0
jnz short loc_1D4F2
mov dword ptr [rbx], 0CEAh
lea rdi, aEtcMysql+5; "mysql"
lea rsi, aTcp; "tcp"
call _getservbyname
test rax, rax
jz short loc_1D4D7
movzx eax, word ptr [rax+10h]
rol ax, 8
movzx eax, ax
mov [rbx], eax
loc_1D4D7:
lea rdi, aMysqlTcpPort; "MYSQL_TCP_PORT"
call _getenv
test rax, rax
jz short loc_1D4F2
mov rdi, rax
call _atoi
mov [rbx], eax
loc_1D4F2:
lea rbx, mysql_unix_port
cmp qword ptr [rbx], 0
jnz short loc_1D52E
lea rax, aTmpMysqlSock; "/tmp/mysql.sock"
mov [rbx], rax
lea rdi, aMysqlUnixPort; "MYSQL_UNIX_PORT"
call _getenv
test rax, rax
jnz short loc_1D52B
lea rdi, aMariadbUnixPor; "MARIADB_UNIX_PORT"
call _getenv
test rax, rax
jz short loc_1D52E
loc_1D52B:
mov [rbx], rax
loc_1D52E:
lea rax, mysql_ps_subsystem_initialized
cmp byte ptr [rax], 0
jnz short loc_1D53F
call mysql_init_ps_subsystem
loc_1D53F:
xor edi, edi
xor esi, esi
call ma_tls_start
mov esi, 1
mov edi, 0Dh
call _signal
mov cs:mysql_client_init, 1
loc_1D55E:
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_once_init(long long a1)
{
long long result; // rax
long long v2; // rax
long long v3; // rax
long long v4; // rax
ma_init(a1);
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4", 0LL);
result = mysql_client_plugin_init();
if ( !(_DWORD)result )
{
if ( !mysql_port )
{
mysql_port = 3306;
v2 = getservbyname("mysql", "tcp");
if ( v2 )
mysql_port = (unsigned __int16)__ROL2__(*(_WORD *)(v2 + 16), 8);
v3 = getenv("MYSQL_TCP_PORT");
if ( v3 )
mysql_port = atoi(v3);
}
if ( !mysql_unix_port )
{
mysql_unix_port = "/tmp/mysql.sock";
v4 = getenv("MYSQL_UNIX_PORT");
if ( v4 || (v4 = getenv("MARIADB_UNIX_PORT")) != 0 )
mysql_unix_port = v4;
}
if ( !mysql_ps_subsystem_initialized )
mysql_init_ps_subsystem();
ma_tls_start(0LL, 0LL);
result = signal(13LL, 1LL);
mysql_client_init = 1;
}
return result;
}
| mysql_once_init:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CALL 0x0011e928
CALL 0x00132b9c
XOR EAX,EAX
CALL 0x00132322
LEA RDI,[0x135c8c]
XOR ESI,ESI
CALL 0x001322b6
XOR EAX,EAX
CALL 0x00127938
TEST EAX,EAX
JNZ 0x0011d55e
LEA RBX,[0x14af30]
CMP dword ptr [RBX],0x0
JNZ 0x0011d4f2
MOV dword ptr [RBX],0xcea
LEA RDI,[0x1383b8]
LEA RSI,[0x135e77]
CALL 0x00113080
TEST RAX,RAX
JZ 0x0011d4d7
MOVZX EAX,word ptr [RAX + 0x10]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBX],EAX
LAB_0011d4d7:
LEA RDI,[0x135e7b]
CALL 0x00113590
TEST RAX,RAX
JZ 0x0011d4f2
MOV RDI,RAX
CALL 0x001136f0
MOV dword ptr [RBX],EAX
LAB_0011d4f2:
LEA RBX,[0x14af38]
CMP qword ptr [RBX],0x0
JNZ 0x0011d52e
LEA RAX,[0x135e8a]
MOV qword ptr [RBX],RAX
LEA RDI,[0x135e9a]
CALL 0x00113590
TEST RAX,RAX
JNZ 0x0011d52b
LEA RDI,[0x135eaa]
CALL 0x00113590
TEST RAX,RAX
JZ 0x0011d52e
LAB_0011d52b:
MOV qword ptr [RBX],RAX
LAB_0011d52e:
LEA RAX,[0x14af60]
CMP byte ptr [RAX],0x0
JNZ 0x0011d53f
CALL 0x00123ce2
LAB_0011d53f:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00128408
MOV ESI,0x1
MOV EDI,0xd
CALL 0x00113560
MOV byte ptr [0x0014af44],0x1
LAB_0011d55e:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_once_init(void)
{
ushort uVar1;
int iVar2;
servent *psVar3;
char *pcVar4;
ma_init();
init_client_errs();
get_default_configuration_dirs();
set_default_charset_by_name("utf8mb4",0);
iVar2 = mysql_client_plugin_init();
if (iVar2 == 0) {
if (mysql_port == 0) {
mysql_port = 0xcea;
psVar3 = getservbyname("mysql","tcp");
if (psVar3 != (servent *)0x0) {
uVar1 = (ushort)psVar3->s_port;
mysql_port = (uint)(ushort)(uVar1 << 8 | uVar1 >> 8);
}
pcVar4 = getenv("MYSQL_TCP_PORT");
if (pcVar4 != (char *)0x0) {
mysql_port = atoi(pcVar4);
}
}
if (mysql_unix_port == (char *)0x0) {
mysql_unix_port = "/tmp/mysql.sock";
pcVar4 = getenv("MYSQL_UNIX_PORT");
if ((pcVar4 != (char *)0x0) || (pcVar4 = getenv("MARIADB_UNIX_PORT"), pcVar4 != (char *)0x0))
{
mysql_unix_port = pcVar4;
}
}
if (mysql_ps_subsystem_initialized == '\0') {
mysql_init_ps_subsystem();
}
ma_tls_start(0,0);
signal(0xd,(__sighandler_t)0x1);
mysql_client_init = 1;
return;
}
return;
}
| |
43,306 | dict_index_get_if_in_cache_low(unsigned long) | eloqsql/storage/innobase/dict/dict0dict.cc | dict_index_t*
dict_index_get_if_in_cache_low(
/*===========================*/
index_id_t index_id) /*!< in: index id */
{
ut_ad(dict_sys.frozen());
for (dict_table_t *table= UT_LIST_GET_FIRST(dict_sys.table_LRU);
table; table= UT_LIST_GET_NEXT(table_LRU, table))
if (dict_index_t *index= dict_table_find_index_on_id(table, index_id))
return index;
for (dict_table_t *table = UT_LIST_GET_FIRST(dict_sys.table_non_LRU);
table; table= UT_LIST_GET_NEXT(table_LRU, table))
if (dict_index_t *index= dict_table_find_index_on_id(table, index_id))
return index;
return nullptr;
} | O0 | cpp | dict_index_get_if_in_cache_low(unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x1039c7e
movq 0xb3c4eb(%rip), %rax # 0x1b76170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1039cc5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1034080
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1039cb2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1039d14
jmp 0x1039cb4
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1039c89
movq 0xb3c4c4(%rip), %rax # 0x1b76190
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1039d0c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1034080
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1039cf9
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1039d14
jmp 0x1039cfb
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1039cd0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| _Z30dict_index_get_if_in_cache_lowm:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
jmp short $+2
loc_1039C7E:
mov rax, cs:qword_1B76170
mov [rbp+var_18], rax
loc_1039C89:
cmp [rbp+var_18], 0
jz short loc_1039CC5
mov rdi, [rbp+var_18]; dict_table_t *
mov rsi, [rbp+var_10]; unsigned __int64
call _Z27dict_table_find_index_on_idPK12dict_table_tm; dict_table_find_index_on_id(dict_table_t const*,ulong)
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_1039CB2
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_1039D14
loc_1039CB2:
jmp short $+2
loc_1039CB4:
mov rax, [rbp+var_18]
mov rax, [rax+118h]
mov [rbp+var_18], rax
jmp short loc_1039C89
loc_1039CC5:
mov rax, cs:qword_1B76190
mov [rbp+var_28], rax
loc_1039CD0:
cmp [rbp+var_28], 0
jz short loc_1039D0C
mov rdi, [rbp+var_28]; dict_table_t *
mov rsi, [rbp+var_10]; unsigned __int64
call _Z27dict_table_find_index_on_idPK12dict_table_tm; dict_table_find_index_on_id(dict_table_t const*,ulong)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_1039CF9
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_1039D14
loc_1039CF9:
jmp short $+2
loc_1039CFB:
mov rax, [rbp+var_28]
mov rax, [rax+118h]
mov [rbp+var_28], rax
jmp short loc_1039CD0
loc_1039D0C:
mov [rbp+var_8], 0
loc_1039D14:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| _QWORD * dict_index_get_if_in_cache_low(long long a1)
{
_QWORD *v2; // [rsp+0h] [rbp-30h]
dict_table_t *j; // [rsp+8h] [rbp-28h]
_QWORD *index_on_id; // [rsp+10h] [rbp-20h]
dict_table_t *i; // [rsp+18h] [rbp-18h]
for ( i = (dict_table_t *)qword_1B76170; i; i = (dict_table_t *)*((_QWORD *)i + 35) )
{
index_on_id = dict_table_find_index_on_id(i, a1);
if ( index_on_id )
return index_on_id;
}
for ( j = (dict_table_t *)qword_1B76190; j; j = (dict_table_t *)*((_QWORD *)j + 35) )
{
v2 = dict_table_find_index_on_id(j, a1);
if ( v2 )
return v2;
}
return 0LL;
}
| my_sha224_result:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x01039990
ADD RSP,0x10
POP RBP
RET
|
void my_sha224_result(SHA256state_st *param_1,uchar *param_2)
{
sha_result(param_1,param_2);
return;
}
| |
43,307 | u64toa_reverse | bluesky950520[P]quickjs/tests/test_conv.c | size_t u64toa_reverse(char buf[minimum_length(21)], uint64_t n)
{
if (likely(n < 0x100000000))
return u32toa_reverse(buf, n);
char *end;
size_t len = 0;
while (n >= 10) {
uint32_t quo = n % 10;
n /= 10;
buf[len++] = (char)('0' + quo);
}
buf[len++] = (char)('0' + n);
buf[len] = '\0';
for (end = buf + len - 1; buf < end;) {
char c = *buf;
*buf++ = *end;
*end-- = c;
}
return len;
} | O0 | c | u64toa_reverse:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, 0x20(%rsp)
setb %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x3d0c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
callq 0x3bc0
movq %rax, 0x30(%rsp)
jmp 0x3e03
movq $0x0, 0x10(%rsp)
cmpq $0xa, 0x20(%rsp)
jb 0x3d6a
movq 0x20(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x20(%rsp)
movl 0xc(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x3d15
movq 0x20(%rsp), %rax
addq $0x30, %rax
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movb %dl, (%rax,%rcx)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x28(%rsp), %rax
addq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x3df9
movq 0x28(%rsp), %rax
movb (%rax), %al
movb %al, 0xb(%rsp)
movq 0x18(%rsp), %rax
movb (%rax), %cl
movq 0x28(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x28(%rsp)
movb %cl, (%rax)
movb 0xb(%rsp), %cl
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x18(%rsp)
movb %cl, (%rax)
jmp 0x3daf
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
| u64toa_reverse:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rax, 100000000h
cmp [rsp+38h+var_18], rax
setb al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_3D0C
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_18]
mov esi, eax
call u32toa_reverse
mov [rsp+38h+var_8], rax
jmp loc_3E03
loc_3D0C:
mov [rsp+38h+var_28], 0
loc_3D15:
cmp [rsp+38h+var_18], 0Ah
jb short loc_3D6A
mov rax, [rsp+38h+var_18]
mov ecx, 0Ah
xor edx, edx
div rcx
mov eax, edx
mov [rsp+38h+var_2C], eax
mov rax, [rsp+38h+var_18]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rsp+38h+var_18], rax
mov eax, [rsp+38h+var_2C]
add eax, 30h ; '0'
mov dl, al
mov rax, [rsp+38h+var_10]
mov rcx, [rsp+38h+var_28]
mov rsi, rcx
add rsi, 1
mov [rsp+38h+var_28], rsi
mov [rax+rcx], dl
jmp short loc_3D15
loc_3D6A:
mov rax, [rsp+38h+var_18]
add rax, 30h ; '0'
mov dl, al
mov rax, [rsp+38h+var_10]
mov rcx, [rsp+38h+var_28]
mov rsi, rcx
add rsi, 1
mov [rsp+38h+var_28], rsi
mov [rax+rcx], dl
mov rax, [rsp+38h+var_10]
mov rcx, [rsp+38h+var_28]
mov byte ptr [rax+rcx], 0
mov rax, [rsp+38h+var_10]
add rax, [rsp+38h+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+38h+var_20], rax
loc_3DAF:
mov rax, [rsp+38h+var_10]
cmp rax, [rsp+38h+var_20]
jnb short loc_3DF9
mov rax, [rsp+38h+var_10]
mov al, [rax]
mov [rsp+38h+var_2D], al
mov rax, [rsp+38h+var_20]
mov cl, [rax]
mov rax, [rsp+38h+var_10]
mov rdx, rax
add rdx, 1
mov [rsp+38h+var_10], rdx
mov [rax], cl
mov cl, [rsp+38h+var_2D]
mov rax, [rsp+38h+var_20]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+38h+var_20], rdx
mov [rax], cl
jmp short loc_3DAF
loc_3DF9:
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_8], rax
loc_3E03:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long u64toa_reverse(char *a1, unsigned long long a2)
{
long long v2; // rcx
long long v3; // rcx
char *v4; // rax
char *v5; // rax
char v7; // [rsp+Bh] [rbp-2Dh]
int v8; // [rsp+Ch] [rbp-2Ch]
long long v9; // [rsp+10h] [rbp-28h]
long long v10; // [rsp+10h] [rbp-28h]
char *i; // [rsp+18h] [rbp-20h]
unsigned long long v12; // [rsp+20h] [rbp-18h]
char *v13; // [rsp+28h] [rbp-10h]
v13 = a1;
v12 = a2;
if ( a2 < 0x100000000LL )
return u32toa_reverse(a1, a2);
v9 = 0LL;
while ( v12 >= 0xA )
{
v8 = v12 % 0xA;
v12 /= 0xAuLL;
v2 = v9++;
a1[v2] = v8 + 48;
}
v3 = v9;
v10 = v9 + 1;
a1[v3] = v12 + 48;
a1[v10] = 0;
for ( i = &a1[v10 - 1]; v13 < i; --i )
{
v7 = *v13;
v4 = v13++;
*v4 = *i;
v5 = i;
*v5 = v7;
}
return v10;
}
| u64toa_reverse:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,0x100000000
CMP qword ptr [RSP + 0x20],RAX
SETC AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00103d0c
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV ESI,EAX
CALL 0x00103bc0
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00103e03
LAB_00103d0c:
MOV qword ptr [RSP + 0x10],0x0
LAB_00103d15:
CMP qword ptr [RSP + 0x20],0xa
JC 0x00103d6a
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x20],RAX
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RSP + 0x10],RSI
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x00103d15
LAB_00103d6a:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RSP + 0x10],RSI
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,qword ptr [RSP + 0x10]
ADD RAX,-0x1
MOV qword ptr [RSP + 0x18],RAX
LAB_00103daf:
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RSP + 0x18]
JNC 0x00103df9
MOV RAX,qword ptr [RSP + 0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0xb],AL
MOV RAX,qword ptr [RSP + 0x18]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RSP + 0x28],RDX
MOV byte ptr [RAX],CL
MOV CL,byte ptr [RSP + 0xb]
MOV RAX,qword ptr [RSP + 0x18]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x00103daf
LAB_00103df9:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
LAB_00103e03:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
long u64toa_reverse(int1 *param_1,ulong param_2)
{
int1 uVar1;
int1 auVar2 [16];
long local_28;
int1 *local_20;
ulong local_18;
int1 *local_10;
long local_8;
if (param_2 < 0x100000000) {
local_8 = u32toa_reverse(param_1,param_2 & 0xffffffff);
}
else {
local_28 = 0;
local_18 = param_2;
while (9 < local_18) {
auVar2._8_8_ = 0;
auVar2._0_8_ = local_18;
local_18 = local_18 / 10;
param_1[local_28] = SUB161(auVar2 % ZEXT816(10),0) + '0';
local_28 = local_28 + 1;
}
local_8 = local_28 + 1;
param_1[local_28] = (char)local_18 + '0';
param_1[local_8] = 0;
local_20 = param_1 + local_8;
local_10 = param_1;
while (local_20 = local_20 + -1, local_10 < local_20) {
uVar1 = *local_10;
*local_10 = *local_20;
*local_20 = uVar1;
local_10 = local_10 + 1;
}
}
return local_8;
}
| |
43,308 | common_chat_format_single[abi:cxx11](minja::chat_template const&, std::vector<common_chat_msg, std::allocator<common_chat_msg>> const&, common_chat_msg const&, bool, bool) | monkey531[P]llama/common/common.cpp | std::string common_chat_format_single(
const common_chat_template & tmpl,
const std::vector<common_chat_msg> & past_msg,
const common_chat_msg & new_msg,
bool add_ass,
bool use_jinja) {
std::ostringstream ss;
auto fmt_past_msg = past_msg.empty() ? "" : common_chat_apply_template(tmpl, past_msg, false, use_jinja);
std::vector<common_chat_msg> chat_new(past_msg);
// if the past_msg ends with a newline, we must preserve it in the formatted version
if (add_ass && !fmt_past_msg.empty() && fmt_past_msg.back() == '\n') {
ss << "\n";
};
// format chat with new_msg
chat_new.push_back(new_msg);
auto fmt_new_msg = common_chat_apply_template(tmpl, chat_new, add_ass, use_jinja);
// get the diff part
ss << fmt_new_msg.substr(fmt_past_msg.size(), fmt_new_msg.size() - fmt_past_msg.size());
return ss.str();
} | O3 | cpp | common_chat_format_single[abi:cxx11](minja::chat_template const&, std::vector<common_chat_msg, std::allocator<common_chat_msg>> const&, common_chat_msg const&, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1ab90
movq (%r13), %rax
movzbl %r15b, %r15d
cmpq 0x8(%r13), %rax
je 0x77123
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x7697c
jmp 0x77140
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x6f29a(%rip), %rdx # 0xe63cd
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x22402
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x7f018
testb %bpl, %bpl
je 0x77181
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x77181
movq 0x8(%rsp), %rcx
cmpb $0xa, -0x1(%rcx,%rax)
jne 0x77181
leaq 0x6f25d(%rip), %rsi # 0xe63cc
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x1aa00
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x7f0b0
movzbl %bpl, %ecx
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
movl %r15d, %r8d
callq 0x7697c
movq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rsi
movq 0x8(%rsi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x1a930
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x1aa00
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x771f4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1adb0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7721f
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x48(%rsp), %rdi
callq 0x7f0dc
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77244
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0xb4d2d(%rip), %rsi # 0x12bf78
leaq 0x80(%rsp), %rdi
callq 0x1a4b0
leaq 0xf0(%rsp), %rdi
callq 0x1a2c0
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7727c
movq %rax, %rbx
jmp 0x772f2
jmp 0x772a3
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x772a6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x772a6
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x772cd
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0x772cd
jmp 0x772ca
movq %rax, %rbx
jmp 0x772d7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7f0dc
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x772f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0xb4c7f(%rip), %rsi # 0x12bf78
leaq 0x80(%rsp), %rdi
callq 0x1a4b0
leaq 0xf0(%rsp), %rdi
callq 0x1a2c0
movq %rbx, %rdi
callq 0x1af90
| _Z25common_chat_format_singleB5cxx11RKN5minja13chat_templateERKSt6vectorI15common_chat_msgSaIS4_EERKS4_bb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1F8h
mov r15d, r9d
mov ebp, r8d
mov r12, rcx
mov r13, rdx
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [r13+0]
movzx r15d, r15b
cmp rax, [r13+8]
jz short loc_77123
lea rdi, [rsp+228h+var_220]
mov rsi, r14
mov rdx, r13
xor ecx, ecx
mov r8d, r15d
call _Z26common_chat_apply_templateB5cxx11RKN5minja13chat_templateERKSt6vectorI15common_chat_msgSaIS4_EEbb; common_chat_apply_template(minja::chat_template const&,std::vector<common_chat_msg> const&,bool,bool)
jmp short loc_77140
loc_77123:
lea rax, [rsp+228h+var_210]
mov [rax-10h], rax
lea rdx, aCosineSimilari+1Bh; ""
lea rdi, [rsp+228h+var_220]
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_77140:
lea rdi, [rsp+228h+var_1E0]
mov rsi, r13
call _ZNSt6vectorI15common_chat_msgSaIS0_EEC2ERKS2_; std::vector<common_chat_msg>::vector(std::vector<common_chat_msg> const&)
test bpl, bpl
jz short loc_77181
mov rax, [rsp+228h+var_218]
test rax, rax
jz short loc_77181
mov rcx, [rsp+228h+var_220]
cmp byte ptr [rcx+rax-1], 0Ah
jnz short loc_77181
lea rsi, aCosineSimilari+1Ah; "\n"
lea rdi, [rsp+228h+var_1A8]
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_77181:
lea rdi, [rsp+228h+var_1E0]
mov rsi, r12
call _ZNSt6vectorI15common_chat_msgSaIS0_EE9push_backERKS0_; std::vector<common_chat_msg>::push_back(common_chat_msg const&)
movzx ecx, bpl
lea rdi, [rsp+228h+var_1C8]
lea rdx, [rsp+228h+var_1E0]
mov rsi, r14
mov r8d, r15d
call _Z26common_chat_apply_templateB5cxx11RKN5minja13chat_templateERKSt6vectorI15common_chat_msgSaIS4_EEbb; common_chat_apply_template(minja::chat_template const&,std::vector<common_chat_msg> const&,bool,bool)
mov rdx, [rsp+228h+var_218]
lea rsi, [rsp+228h+var_1C8]
mov rcx, [rsi+8]
sub rcx, rdx
lea rdi, [rsp+228h+var_200]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rsi, [rsp+228h+var_200]
mov rdx, [rsp+228h+var_1F8]
lea rdi, [rsp+228h+var_1A8]
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+228h+var_1F0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_771F4
mov rsi, [rsp+228h+var_1F0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_771F4:
lea rsi, [rsp+228h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rax, [rsp+228h+var_1B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7721F
mov rsi, [rsp+228h+var_1B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7721F:
lea rdi, [rsp+228h+var_1E0]
call _ZNSt6vectorI15common_chat_msgSaIS0_EED2Ev; std::vector<common_chat_msg>::~vector()
lea rax, [rsp+228h+var_210]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_77244
mov rsi, [rsp+228h+var_210]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_77244:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+228h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_7727C:
mov rbx, rax
jmp short loc_772F2
jmp short loc_772A3
mov rbx, rax
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_772A6
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_772A6
loc_772A3:
mov rbx, rax
loc_772A6:
lea rax, [rsp+arg_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_772CD
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_772CD
jmp short loc_772CA
mov rbx, rax
jmp short loc_772D7
loc_772CA:
mov rbx, rax
loc_772CD:
lea rdi, [rsp+arg_40]
call _ZNSt6vectorI15common_chat_msgSaIS0_EED2Ev; std::vector<common_chat_msg>::~vector()
loc_772D7:
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_772F2
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_772F2:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_78]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_E8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long common_chat_format_single[abi:cxx11](
long long a1,
common_chat_inputs *a2,
long long *a3,
long long a4,
unsigned __int8 a5,
unsigned __int8 a6)
{
char *v11; // [rsp+8h] [rbp-220h] BYREF
long long v12; // [rsp+10h] [rbp-218h]
_QWORD v13[2]; // [rsp+18h] [rbp-210h] BYREF
void *v14[2]; // [rsp+28h] [rbp-200h] BYREF
long long v15; // [rsp+38h] [rbp-1F0h] BYREF
long long v16[3]; // [rsp+48h] [rbp-1E0h] BYREF
void *v17[2]; // [rsp+60h] [rbp-1C8h] BYREF
long long v18; // [rsp+70h] [rbp-1B8h] BYREF
_BYTE v19[8]; // [rsp+80h] [rbp-1A8h] BYREF
_BYTE v20[104]; // [rsp+88h] [rbp-1A0h] BYREF
_BYTE v21[312]; // [rsp+F0h] [rbp-138h] BYREF
std::ostringstream::basic_ostringstream(v19);
if ( *a3 == a3[1] )
{
v11 = (char *)v13;
std::string::_M_construct<char const*>((long long)&v11, "", (long long)"");
}
else
{
common_chat_apply_template[abi:cxx11](&v11, a2, a3, 0, a6);
}
std::vector<common_chat_msg>::vector(v16, a3);
if ( a5 && v12 && v11[v12 - 1] == 10 )
std::__ostream_insert<char,std::char_traits<char>>(v19, "\n", 1LL);
std::vector<common_chat_msg>::push_back(v16, a4);
common_chat_apply_template[abi:cxx11](v17, a2, v16, a5, a6);
std::string::substr(v14, v17, v12, (char *)v17[1] - v12);
std::__ostream_insert<char,std::char_traits<char>>(v19, v14[0], v14[1]);
if ( v14[0] != &v15 )
operator delete(v14[0], v15 + 1);
std::stringbuf::str(a1, v20);
if ( v17[0] != &v18 )
operator delete(v17[0], v18 + 1);
std::vector<common_chat_msg>::~vector(v16);
if ( v11 != (char *)v13 )
operator delete(v11, v13[0] + 1LL);
std::ostringstream::~ostringstream(v19, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v21);
return a1;
}
| common_chat_format_single[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f8
MOV R15D,R9D
MOV EBP,R8D
MOV R12,RCX
MOV R13,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x80]
CALL 0x0011ab90
MOV RAX,qword ptr [R13]
MOVZX R15D,R15B
CMP RAX,qword ptr [R13 + 0x8]
JZ 0x00177123
LAB_0017710c:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,R13
XOR ECX,ECX
MOV R8D,R15D
CALL 0x0017697c
JMP 0x00177140
LAB_00177123:
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
LAB_0017712c:
LEA RDX,[0x1e63cd]
LEA RDI,[RSP + 0x8]
MOV RSI,RDX
CALL 0x00122402
LAB_00177140:
LEA RDI,[RSP + 0x48]
MOV RSI,R13
CALL 0x0017f018
TEST BPL,BPL
JZ 0x00177181
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x00177181
MOV RCX,qword ptr [RSP + 0x8]
CMP byte ptr [RCX + RAX*0x1 + -0x1],0xa
JNZ 0x00177181
LAB_00177168:
LEA RSI,[0x1e63cc]
LEA RDI,[RSP + 0x80]
MOV EDX,0x1
CALL 0x0011aa00
LAB_00177181:
LEA RDI,[RSP + 0x48]
MOV RSI,R12
CALL 0x0017f0b0
LAB_0017718e:
MOVZX ECX,BPL
LEA RDI,[RSP + 0x60]
LEA RDX,[RSP + 0x48]
MOV RSI,R14
MOV R8D,R15D
CALL 0x0017697c
MOV RDX,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x60]
MOV RCX,qword ptr [RSI + 0x8]
SUB RCX,RDX
LAB_001771b8:
LEA RDI,[RSP + 0x28]
CALL 0x0011a930
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
LAB_001771cc:
LEA RDI,[RSP + 0x80]
CALL 0x0011aa00
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001771f4
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8e0
LAB_001771f4:
LEA RSI,[RSP + 0x88]
LAB_001771fc:
MOV RDI,RBX
CALL 0x0011adb0
LAB_00177204:
LEA RAX,[RSP + 0x70]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017721f
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011a8e0
LAB_0017721f:
LEA RDI,[RSP + 0x48]
CALL 0x0017f0dc
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00177244
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a8e0
LAB_00177244:
MOV RSI,qword ptr [0x0022bf78]
LEA RDI,[RSP + 0x80]
CALL 0x0011a4b0
LEA RDI,[RSP + 0xf0]
CALL 0x0011a2c0
MOV RAX,RBX
ADD RSP,0x1f8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* common_chat_format_single[abi:cxx11](minja::chat_template const&, std::vector<common_chat_msg,
std::allocator<common_chat_msg> > const&, common_chat_msg const&, bool, bool) */
chat_template *
common_chat_format_single_abi_cxx11_
(chat_template *param_1,vector *param_2,common_chat_msg *param_3,bool param_4,bool param_5
)
{
int7 in_register_00000009;
long *local_220;
long local_218;
long local_210 [2];
long *local_200;
long local_1f8;
long local_1f0 [2];
vector<common_chat_msg,std::allocator<common_chat_msg>> local_1e0 [24];
long *local_1c8 [2];
long local_1b8 [2];
ostringstream local_1a8 [112];
ios_base local_138 [264];
std::__cxx11::ostringstream::ostringstream(local_1a8);
if (*(long *)param_3 == *(long *)(param_3 + 8)) {
local_220 = local_210;
/* try { // try from 0017712c to 0017713f has its CatchHandler @ 0017727a */
std::__cxx11::string::_M_construct<char_const*>(&local_220,"");
}
else {
/* try { // try from 0017710c to 00177120 has its CatchHandler @ 0017727c */
common_chat_apply_template_abi_cxx11_
((chat_template *)&local_220,param_2,SUB81(param_3,0),false);
}
/* try { // try from 00177140 to 0017714c has its CatchHandler @ 001772c5 */
std::vector<common_chat_msg,std::allocator<common_chat_msg>>::vector(local_1e0,(vector *)param_3);
if (((param_5) && (local_218 != 0)) && (*(char *)((long)local_220 + local_218 + -1) == '\n')) {
/* try { // try from 00177168 to 0017718d has its CatchHandler @ 001772ca */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_1a8,"\n",1);
}
std::vector<common_chat_msg,std::allocator<common_chat_msg>>::push_back
(local_1e0,(common_chat_msg *)CONCAT71(in_register_00000009,param_4));
/* try { // try from 0017718e to 001771a6 has its CatchHandler @ 001772c3 */
common_chat_apply_template_abi_cxx11_
((chat_template *)local_1c8,param_2,SUB81(local_1e0,0),param_5);
/* try { // try from 001771b8 to 001771c1 has its CatchHandler @ 001772a3 */
std::__cxx11::string::substr((ulong)&local_200,(ulong)local_1c8);
/* try { // try from 001771cc to 001771d8 has its CatchHandler @ 00177283 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,(char *)local_200,local_1f8);
if (local_200 != local_1f0) {
operator_delete(local_200,local_1f0[0] + 1);
}
/* try { // try from 001771fc to 00177203 has its CatchHandler @ 00177281 */
std::__cxx11::stringbuf::str();
if (local_1c8[0] != local_1b8) {
operator_delete(local_1c8[0],local_1b8[0] + 1);
}
std::vector<common_chat_msg,std::allocator<common_chat_msg>>::~vector(local_1e0);
if (local_220 != local_210) {
operator_delete(local_220,local_210[0] + 1);
}
std::__cxx11::ostringstream::~ostringstream(local_1a8);
std::ios_base::~ios_base(local_138);
return param_1;
}
| |
43,309 | mariadb_get_infov | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *arg, ...)
{
va_list ap;
va_start(ap, arg);
switch(value) {
case MARIADB_MAX_ALLOWED_PACKET:
*((size_t *)arg)= (size_t)max_allowed_packet;
break;
case MARIADB_NET_BUFFER_LENGTH:
*((size_t *)arg)= (size_t)net_buffer_length;
break;
case MARIADB_CONNECTION_ERROR_ID:
if (!mysql)
goto error;
*((unsigned int *)arg)= mysql->net.last_errno;
break;
case MARIADB_CONNECTION_ERROR:
if (!mysql)
goto error;
*((char **)arg)= mysql->net.last_error;
break;
case MARIADB_CONNECTION_SQLSTATE:
if (!mysql)
goto error;
*((char **)arg)= mysql->net.sqlstate;
break;
case MARIADB_CONNECTION_TLS_VERSION:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((char **)arg)= (char *)ma_pvio_tls_get_protocol_version(mysql->net.pvio->ctls);
else
#endif
goto error;
break;
case MARIADB_CONNECTION_TLS_VERSION_ID:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((unsigned int *)arg)= ma_pvio_tls_get_protocol_version_id(mysql->net.pvio->ctls);
else
#endif
goto error;
break;
case MARIADB_TLS_LIBRARY:
#ifdef HAVE_TLS
*((const char **)arg)= tls_library_version;
#else
*((const char **)arg)= "Off";
#endif
break;
case MARIADB_CLIENT_VERSION:
*((const char **)arg)= MARIADB_CLIENT_VERSION_STR;
break;
case MARIADB_CLIENT_VERSION_ID:
*((size_t *)arg)= MARIADB_VERSION_ID;
break;
case MARIADB_CONNECTION_SERVER_VERSION:
if (mysql)
*((char **)arg)= mysql->server_version;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_TYPE:
if (mysql)
*((const char **)arg)= mariadb_connection(mysql) ? "MariaDB" : "MySQL";
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_VERSION_ID:
if (mysql)
*((size_t *)arg)= mariadb_server_version_id(mysql);
else
goto error;
break;
case MARIADB_CONNECTION_PROTOCOL_VERSION_ID:
if (mysql)
*((unsigned int *)arg)= mysql->protocol_version;
else
goto error;
break;
case MARIADB_CONNECTION_MARIADB_CHARSET_INFO:
if (mysql)
mariadb_get_charset_info(mysql, (MY_CHARSET_INFO *)arg);
else
goto error;
break;
case MARIADB_CONNECTION_SOCKET:
if (mysql)
*((my_socket *)arg)= mariadb_get_socket(mysql);
else
goto error;
break;
case MARIADB_CONNECTION_TYPE:
if (mysql && mysql->net.pvio)
*((int *)arg)= (int)mysql->net.pvio->type;
else
goto error;
break;
case MARIADB_CONNECTION_ASYNC_TIMEOUT_MS:
if (mysql && mysql->options.extension && mysql->options.extension->async_context)
*((unsigned int *)arg)= mysql->options.extension->async_context->timeout_value;
break;
case MARIADB_CONNECTION_ASYNC_TIMEOUT:
if (mysql && mysql->options.extension && mysql->options.extension->async_context)
{
unsigned int timeout= mysql->options.extension->async_context->timeout_value;
if (timeout > UINT_MAX - 999)
*((unsigned int *)arg)= (timeout - 1)/1000 + 1;
else
*((unsigned int *)arg)= (timeout+999)/1000;
}
break;
case MARIADB_CHARSET_NAME:
{
char *name;
name= va_arg(ap, char *);
if (name)
*((MARIADB_CHARSET_INFO **)arg)= (MARIADB_CHARSET_INFO *)mysql_find_charset_name(name);
else
goto error;
}
break;
case MARIADB_CHARSET_ID:
{
unsigned int nr;
nr= va_arg(ap, unsigned int);
*((MARIADB_CHARSET_INFO **)arg)= (MARIADB_CHARSET_INFO *)mysql_find_charset_nr(nr);
}
break;
case MARIADB_CONNECTION_SSL_CIPHER:
#ifdef HAVE_TLS
if (mysql && mysql->net.pvio && mysql->net.pvio->ctls)
*((char **)arg)= (char *)ma_pvio_tls_cipher(mysql->net.pvio->ctls);
else
#endif
*((char **)arg)= NULL;
break;
case MARIADB_CLIENT_ERRORS:
*((char ***)arg)= (char **)client_errors;
break;
case MARIADB_CONNECTION_INFO:
if (mysql)
*((char **)arg)= (char *)mysql->info;
else
goto error;
break;
case MARIADB_CONNECTION_PVIO_TYPE:
if (mysql && mysql->net.pvio)
*((unsigned int *)arg)= (unsigned int)mysql->net.pvio->type;
else
goto error;
break;
case MARIADB_CONNECTION_SCHEMA:
if (mysql)
*((char **)arg)= mysql->db;
else
goto error;
break;
case MARIADB_CONNECTION_USER:
if (mysql)
*((char **)arg)= mysql->user;
else
goto error;
break;
case MARIADB_CONNECTION_PORT:
if (mysql)
*((unsigned int *)arg)= mysql->port;
else
goto error;
break;
case MARIADB_CONNECTION_UNIX_SOCKET:
if (mysql)
*((char **)arg)= mysql->unix_socket;
else
goto error;
break;
case MARIADB_CONNECTION_HOST:
if (mysql)
*((char **)arg)= mysql->host;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_STATUS:
if (mysql)
*((unsigned int *)arg)= mysql->server_status;
else
goto error;
break;
case MARIADB_CONNECTION_SERVER_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->server_capabilities;
else
goto error;
break;
case MARIADB_CONNECTION_EXTENDED_SERVER_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->extension->mariadb_server_capabilities;
else
goto error;
break;
case MARIADB_CONNECTION_CLIENT_CAPABILITIES:
if (mysql)
*((unsigned long *)arg)= mysql->client_flag;
else
goto error;
break;
case MARIADB_CONNECTION_BYTES_READ:
*((size_t *)arg)= mysql->net.pvio->bytes_read;
break;
case MARIADB_CONNECTION_BYTES_SENT:
*((size_t *)arg)= mysql->net.pvio->bytes_sent;
break;
default:
va_end(ap);
return(-1);
}
va_end(ap);
return(0);
error:
va_end(ap);
return(-1);
} | O3 | c | mariadb_get_infov:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
leaq -0xd0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x41da2
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, -0x20(%rbp)
movb $-0x1, %al
cmpl $0x23, %esi
ja 0x42155
movl %esi, %ecx
leaq 0x5a3e8(%rip), %rdx # 0x9c1b8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testq %rdi, %rdi
je 0x42155
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x42155
movl 0x20(%rcx), %eax
jmp 0x420f2
movq (%rdi), %rax
movq 0x68(%rax), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2b8(%rdi), %rax
jmp 0x42150
movq (%rdi), %rax
movq 0x60(%rax), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2d0(%rdi), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2e8(%rdi), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x368(%rdi), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2e0(%rdi), %rax
jmp 0x42150
movq $0x18902, (%rbx) # imm = 0x18902
jmp 0x42153
testq %rdi, %rdi
je 0x42155
movl 0x360(%rdi), %eax
jmp 0x420f2
testq %rdi, %rdi
je 0x42155
movl 0x90(%rdi), %eax
jmp 0x420f2
leaq 0x2f9dce(%rip), %rax # 0x33bc80
jmp 0x42150
testq %rdi, %rdi
je 0x42155
callq 0x3adb3
testb %al, %al
leaq 0x533b6(%rip), %rax # 0x95284
leaq 0x5281d(%rip), %rcx # 0x946f2
cmoveq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x42153
leaq 0x533a2(%rip), %rax # 0x9528a
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq %rbx, %rsi
callq 0x41b44
jmp 0x42153
movl -0x20(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x42122
movq %rcx, %rax
addq -0x10(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x20(%rbp)
jmp 0x4212e
movl -0x20(%rbp), %edx
cmpq $0x28, %rdx
ja 0x42137
movq %rdx, %rcx
addq -0x10(%rbp), %rcx
addl $0x8, %edx
movl %edx, -0x20(%rbp)
jmp 0x42143
testq %rdi, %rdi
je 0x42155
movq 0x370(%rdi), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2d0(%rdi), %rdi
callq 0x41249
jmp 0x42150
testq %rdi, %rdi
je 0x42119
movq (%rdi), %rax
testq %rax, %rax
je 0x42119
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x42119
callq 0x42f1a
jmp 0x42150
testq %rdi, %rdi
je 0x42153
movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x42153
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x42153
movl 0x10(%rax), %eax
cmpl $0xfffffc19, %eax # imm = 0xFFFFFC19
jb 0x4215f
decl %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
incl %eax
jmp 0x4216f
leaq 0x3c0ff5(%rip), %rax # 0x402fe0
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movl 0x378(%rdi), %eax
jmp 0x420f2
testq %rdi, %rdi
je 0x42153
movq 0x480(%rdi), %rax
testq %rax, %rax
je 0x42153
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x42153
movl 0x10(%rax), %eax
jmp 0x420f2
testq %rdi, %rdi
je 0x42155
callq 0x41cf6
jmp 0x420f2
testq %rdi, %rdi
je 0x42155
movq 0x2b0(%rdi), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
addq $0x97, %rdi
jmp 0x420d2
testq %rdi, %rdi
je 0x42155
movl 0x380(%rdi), %eax
jmp 0x420f2
testq %rdi, %rdi
je 0x42155
movq 0x4f0(%rdi), %rax
movq 0x70(%rax), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x42155
movq 0x38(%rcx), %rdi
testq %rdi, %rdi
je 0x42155
callq 0x42f38
jmp 0x42150
testq %rdi, %rdi
je 0x42155
addq $0x297, %rdi # imm = 0x297
movq %rdi, (%rbx)
jmp 0x42153
testq %rdi, %rdi
je 0x42155
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x42155
movq 0x38(%rcx), %rdi
testq %rdi, %rdi
je 0x42155
callq 0x42f2e
movl %eax, (%rbx)
jmp 0x42153
leaq 0x2f9b2b(%rip), %rax # 0x33bc28
jmp 0x42106
leaq 0x2f9b3a(%rip), %rax # 0x33bc40
movq (%rax), %rax
jmp 0x42150
testq %rdi, %rdi
je 0x42155
movq 0x2c8(%rdi), %rax
jmp 0x42150
movq $0x0, (%rbx)
jmp 0x42153
movq -0x18(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movl (%rax), %edi
callq 0x55666
jmp 0x42150
movq -0x18(%rbp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x18(%rbp)
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x42155
callq 0x556ea
movq %rax, (%rbx)
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
addl $0x3e7, %eax # imm = 0x3E7
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movl %eax, (%rbx)
jmp 0x42153
| mariadb_get_infov:
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
mov rbx, rdx
lea rdx, [rbp+var_D0]
mov [rdx+18h], rcx
mov [rdx+20h], r8
mov [rdx+28h], r9
test al, al
jz short loc_41DA2
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_41DA2:
mov [rbp+var_10], rdx
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov rax, 3000000018h
mov [rbp+var_20], rax
mov al, 0FFh
cmp esi, 23h; switch 36 cases
ja def_41DD7; jumptable 0000000000041DD7 default case
mov ecx, esi
lea rdx, jpt_41DD7
movsxd rcx, ds:(jpt_41DD7 - 9C1B8h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_41DD9:
test rdi, rdi; jumptable 0000000000041DD7 cases 14,25
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rcx, [rdi]
test rcx, rcx
jz def_41DD7; jumptable 0000000000041DD7 default case
mov eax, [rcx+20h]
jmp loc_420F2
loc_41DF6:
mov rax, [rdi]; jumptable 0000000000041DD7 case 35
mov rax, [rax+68h]
jmp loc_42150
loc_41E02:
test rdi, rdi; jumptable 0000000000041DD7 case 27
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2B8h]
jmp loc_42150
loc_41E17:
mov rax, [rdi]; jumptable 0000000000041DD7 case 34
mov rax, [rax+60h]
jmp loc_42150
loc_41E23:
test rdi, rdi; jumptable 0000000000041DD7 case 17
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2D0h]
jmp loc_42150
loc_41E38:
test rdi, rdi; jumptable 0000000000041DD7 case 15
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2E8h]
jmp loc_42150
loc_41E4D:
test rdi, rdi; jumptable 0000000000041DD7 case 33
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+368h]
jmp loc_42150
loc_41E62:
test rdi, rdi; jumptable 0000000000041DD7 case 11
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2E0h]
jmp loc_42150
loc_41E77:
mov qword ptr [rbx], 18902h; jumptable 0000000000041DD7 case 4
jmp loc_42153
loc_41E83:
test rdi, rdi; jumptable 0000000000041DD7 case 12
jz def_41DD7; jumptable 0000000000041DD7 default case
mov eax, [rdi+360h]
jmp loc_420F2
loc_41E97:
test rdi, rdi; jumptable 0000000000041DD7 case 9
jz def_41DD7; jumptable 0000000000041DD7 default case
mov eax, [rdi+90h]
jmp loc_420F2
loc_41EAB:
lea rax, client_errors; jumptable 0000000000041DD7 case 2
jmp loc_42150
loc_41EB7:
test rdi, rdi; jumptable 0000000000041DD7 case 16
jz def_41DD7; jumptable 0000000000041DD7 default case
call mariadb_connection
test al, al
lea rax, aMysql; "MySQL"
lea rcx, a10610Mariadb+8; "MariaDB"
cmovz rcx, rax
mov [rbx], rcx
jmp loc_42153
loc_41EE1:
lea rax, a10610; jumptable 0000000000041DD7 case 3
jmp loc_42150
loc_41EED:
test rdi, rdi; jumptable 0000000000041DD7 case 7
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rsi, rbx
call mariadb_get_charset_info
jmp loc_42153
loc_41F03:
mov ecx, dword ptr [rbp+var_20]; jumptable 0000000000041DD7 case 0
cmp rcx, 28h ; '('
ja loc_42122
mov rax, rcx
add rax, [rbp+var_10]
add ecx, 8
mov dword ptr [rbp+var_20], ecx
jmp loc_4212E
loc_41F22:
mov edx, dword ptr [rbp+var_20]; jumptable 0000000000041DD7 case 1
cmp rdx, 28h ; '('
ja loc_42137
mov rcx, rdx
add rcx, [rbp+var_10]
add edx, 8
mov dword ptr [rbp+var_20], edx
jmp loc_42143
loc_41F41:
test rdi, rdi; jumptable 0000000000041DD7 case 31
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+370h]
jmp loc_42150
loc_41F56:
test rdi, rdi; jumptable 0000000000041DD7 case 18
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rdi, [rdi+2D0h]
call mariadb_server_version_id
jmp loc_42150
loc_41F70:
test rdi, rdi; jumptable 0000000000041DD7 case 21
jz loc_42119
mov rax, [rdi]
test rax, rax
jz loc_42119
mov rdi, [rax+38h]
test rdi, rdi
jz loc_42119
call ma_pvio_tls_cipher
jmp loc_42150
loc_41F9C:
test rdi, rdi; jumptable 0000000000041DD7 case 5
jz loc_42153
mov rax, [rdi+480h]
test rax, rax
jz loc_42153
mov rax, [rax+28h]
test rax, rax
jz loc_42153
mov eax, [rax+10h]
cmp eax, 0FFFFFC19h
jb loc_4215F
dec eax
imul rax, 10624DD3h
shr rax, 26h
inc eax
jmp loc_4216F
loc_41FE4:
lea rax, tls_library_version; jumptable 0000000000041DD7 case 22
jmp loc_42150
loc_41FF0:
test rdi, rdi; jumptable 0000000000041DD7 case 13
jz def_41DD7; jumptable 0000000000041DD7 default case
mov eax, [rdi+378h]
jmp loc_420F2
loc_42004:
test rdi, rdi; jumptable 0000000000041DD7 case 6
jz loc_42153
mov rax, [rdi+480h]
test rax, rax
jz loc_42153
mov rax, [rax+28h]
test rax, rax
jz loc_42153
mov eax, [rax+10h]
jmp loc_420F2
loc_42032:
test rdi, rdi; jumptable 0000000000041DD7 case 19
jz def_41DD7; jumptable 0000000000041DD7 default case
call mariadb_get_socket
jmp loc_420F2
loc_42045:
test rdi, rdi; jumptable 0000000000041DD7 case 10
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2B0h]
jmp loc_42150
loc_4205A:
test rdi, rdi; jumptable 0000000000041DD7 case 8
jz def_41DD7; jumptable 0000000000041DD7 default case
add rdi, 97h
jmp short loc_420D2
loc_4206C:
test rdi, rdi; jumptable 0000000000041DD7 case 30
jz def_41DD7; jumptable 0000000000041DD7 default case
mov eax, [rdi+380h]
jmp short loc_420F2
loc_4207D:
test rdi, rdi; jumptable 0000000000041DD7 case 32
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+4F0h]
mov rax, [rax+70h]
jmp loc_42150
loc_42096:
test rdi, rdi; jumptable 0000000000041DD7 case 23
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rcx, [rdi]
test rcx, rcx
jz def_41DD7; jumptable 0000000000041DD7 default case
mov rdi, [rcx+38h]
test rdi, rdi
jz def_41DD7; jumptable 0000000000041DD7 default case
call ma_pvio_tls_get_protocol_version
jmp loc_42150
loc_420C2:
test rdi, rdi; jumptable 0000000000041DD7 case 20
jz def_41DD7; jumptable 0000000000041DD7 default case
add rdi, 297h
loc_420D2:
mov [rbx], rdi
jmp short loc_42153
loc_420D7:
test rdi, rdi; jumptable 0000000000041DD7 case 24
jz short def_41DD7; jumptable 0000000000041DD7 default case
mov rcx, [rdi]
test rcx, rcx
jz short def_41DD7; jumptable 0000000000041DD7 default case
mov rdi, [rcx+38h]
test rdi, rdi
jz short def_41DD7; jumptable 0000000000041DD7 default case
call ma_pvio_tls_get_protocol_version_id
loc_420F2:
mov [rbx], eax
jmp short loc_42153
loc_420F6:
lea rax, max_allowed_packet; jumptable 0000000000041DD7 case 28
jmp short loc_42106
loc_420FF:
lea rax, net_buffer_length; jumptable 0000000000041DD7 case 29
loc_42106:
mov rax, [rax]
jmp short loc_42150
loc_4210B:
test rdi, rdi; jumptable 0000000000041DD7 case 26
jz short def_41DD7; jumptable 0000000000041DD7 default case
mov rax, [rdi+2C8h]
jmp short loc_42150
loc_42119:
mov qword ptr [rbx], 0
jmp short loc_42153
loc_42122:
mov rax, [rbp+var_18]
lea rcx, [rax+8]
mov [rbp+var_18], rcx
loc_4212E:
mov edi, [rax]
call mysql_find_charset_nr
jmp short loc_42150
loc_42137:
mov rcx, [rbp+var_18]
lea rdx, [rcx+8]
mov [rbp+var_18], rdx
loc_42143:
mov rdi, [rcx]
test rdi, rdi
jz short def_41DD7; jumptable 0000000000041DD7 default case
call mysql_find_charset_name
loc_42150:
mov [rbx], rax
loc_42153:
xor eax, eax
def_41DD7:
add rsp, 0C8h; jumptable 0000000000041DD7 default case
pop rbx
pop rbp
retn
loc_4215F:
add eax, 3E7h
imul rax, 10624DD3h
shr rax, 26h
loc_4216F:
mov [rbx], eax
jmp short loc_42153
| long long mariadb_get_infov(
long long a1,
int a2,
_QWORD *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
long long result; // rax
int socket; // eax
const char *charset_nr; // rax
bool v19; // al
char *v20; // rcx
char *v21; // rax
char *v22; // rcx
long long v23; // rax
long long v24; // rax
unsigned int v25; // eax
unsigned int v26; // eax
long long v27; // rax
long long v28; // rax
long long v29; // rdi
const char **v30; // rax
char v31; // [rsp+0h] [rbp-D0h] BYREF
long long v32; // [rsp+18h] [rbp-B8h]
long long v33; // [rsp+20h] [rbp-B0h]
long long v34; // [rsp+28h] [rbp-A8h]
__m128 v35; // [rsp+30h] [rbp-A0h]
__m128 v36; // [rsp+40h] [rbp-90h]
__m128 v37; // [rsp+50h] [rbp-80h]
__m128 v38; // [rsp+60h] [rbp-70h]
__m128 v39; // [rsp+70h] [rbp-60h]
__m128 v40; // [rsp+80h] [rbp-50h]
__m128 v41; // [rsp+90h] [rbp-40h]
__m128 v42; // [rsp+A0h] [rbp-30h]
long long v43; // [rsp+B0h] [rbp-20h]
char *v44; // [rsp+B8h] [rbp-18h]
char *v45; // [rsp+C0h] [rbp-10h]
v35 = a7;
v36 = a8;
v37 = a9;
v38 = a10;
v39 = a11;
v40 = a12;
v41 = a13;
v42 = a14;
v32 = a4;
v33 = a5;
v34 = a6;
v45 = &v31;
v44 = &a15;
result = 0x30000000FFLL;
v43 = 0x3000000018LL;
switch ( a2 )
{
case 0:
if ( (unsigned int)v43 > 0x28uLL )
{
v21 = v44;
v44 += 8;
}
else
{
v21 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
charset_nr = (const char *)mysql_find_charset_nr(*(unsigned int *)v21);
goto LABEL_87;
case 1:
if ( (unsigned int)v43 > 0x28uLL )
{
v22 = v44;
v44 += 8;
}
else
{
v22 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
if ( !*(_QWORD *)v22 )
return result;
charset_nr = (const char *)mysql_find_charset_name(*(_QWORD *)v22);
goto LABEL_87;
case 2:
charset_nr = (const char *)client_errors;
goto LABEL_87;
case 3:
charset_nr = "10.6.10";
goto LABEL_87;
case 4:
*a3 = 100610LL;
return 0LL;
case 5:
if ( a1 )
{
v23 = *(_QWORD *)(a1 + 1152);
if ( v23 )
{
v24 = *(_QWORD *)(v23 + 40);
if ( v24 )
{
v25 = *(_DWORD *)(v24 + 16);
if ( v25 < 0xFFFFFC19 )
v26 = (v25 + 999) / 0x3E8;
else
v26 = (v25 - 1) / 0x3E8 + 1;
*(_DWORD *)a3 = v26;
}
}
}
return 0LL;
case 6:
if ( !a1 )
return 0LL;
v27 = *(_QWORD *)(a1 + 1152);
if ( !v27 )
return 0LL;
v28 = *(_QWORD *)(v27 + 40);
if ( !v28 )
return 0LL;
socket = *(_DWORD *)(v28 + 16);
goto LABEL_75;
case 7:
if ( !a1 )
return result;
mariadb_get_charset_info(a1, (long long)a3);
return 0LL;
case 8:
if ( !a1 )
return result;
v29 = a1 + 151;
goto LABEL_70;
case 9:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 144);
goto LABEL_75;
case 10:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 688);
goto LABEL_87;
case 11:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 736);
goto LABEL_87;
case 12:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 864);
goto LABEL_75;
case 13:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 888);
goto LABEL_75;
case 14:
case 25:
if ( !a1 || !*(_QWORD *)a1 )
return result;
socket = *(_DWORD *)(*(_QWORD *)a1 + 32LL);
goto LABEL_75;
case 15:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 744);
goto LABEL_87;
case 16:
if ( !a1 )
return result;
v19 = mariadb_connection(a1);
v20 = "MariaDB";
if ( !v19 )
v20 = "MySQL";
*a3 = v20;
return 0LL;
case 17:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 720);
goto LABEL_87;
case 18:
if ( !a1 )
return result;
charset_nr = (const char *)mariadb_server_version_id(*(_QWORD *)(a1 + 720));
goto LABEL_87;
case 19:
if ( !a1 )
return result;
socket = mariadb_get_socket((long long *)a1);
goto LABEL_75;
case 20:
if ( !a1 )
return result;
v29 = a1 + 663;
LABEL_70:
*a3 = v29;
return 0LL;
case 21:
if ( a1 && *(_QWORD *)a1 && *(_QWORD *)(*(_QWORD *)a1 + 56LL) )
{
charset_nr = (const char *)ma_pvio_tls_cipher();
LABEL_87:
*a3 = charset_nr;
}
else
{
*a3 = 0LL;
}
return 0LL;
case 22:
charset_nr = (const char *)&tls_library_version;
goto LABEL_87;
case 23:
if ( !a1 || !*(_QWORD *)a1 || !*(_QWORD *)(*(_QWORD *)a1 + 56LL) )
return result;
charset_nr = (const char *)ma_pvio_tls_get_protocol_version();
goto LABEL_87;
case 24:
if ( !a1 || !*(_QWORD *)a1 || !*(_QWORD *)(*(_QWORD *)a1 + 56LL) )
return result;
socket = ma_pvio_tls_get_protocol_version_id();
goto LABEL_75;
case 26:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 712);
goto LABEL_87;
case 27:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 696);
goto LABEL_87;
case 28:
v30 = (const char **)&max_allowed_packet;
goto LABEL_78;
case 29:
v30 = (const char **)&net_buffer_length;
LABEL_78:
charset_nr = *v30;
goto LABEL_87;
case 30:
if ( !a1 )
return result;
socket = *(_DWORD *)(a1 + 896);
LABEL_75:
*(_DWORD *)a3 = socket;
return 0LL;
case 31:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 880);
goto LABEL_87;
case 32:
if ( !a1 )
return result;
charset_nr = *(const char **)(*(_QWORD *)(a1 + 1264) + 112LL);
goto LABEL_87;
case 33:
if ( !a1 )
return result;
charset_nr = *(const char **)(a1 + 872);
goto LABEL_87;
case 34:
charset_nr = *(const char **)(*(_QWORD *)a1 + 96LL);
goto LABEL_87;
case 35:
charset_nr = *(const char **)(*(_QWORD *)a1 + 104LL);
goto LABEL_87;
default:
return result;
}
}
| mariadb_get_infov:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
MOV RBX,RDX
LEA RDX,[RBP + -0xd0]
MOV qword ptr [RDX + 0x18],RCX
MOV qword ptr [RDX + 0x20],R8
MOV qword ptr [RDX + 0x28],R9
TEST AL,AL
JZ 0x00141da2
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_00141da2:
MOV qword ptr [RBP + -0x10],RDX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,0x3000000018
MOV qword ptr [RBP + -0x20],RAX
MOV AL,0xff
CMP ESI,0x23
JA 0x00142155
MOV ECX,ESI
LEA RDX,[0x19c1b8]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_e:
TEST RDI,RDI
JZ 0x00142155
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x00142155
MOV EAX,dword ptr [RCX + 0x20]
JMP 0x001420f2
caseD_23:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x68]
JMP 0x00142150
caseD_1b:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2b8]
JMP 0x00142150
caseD_22:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x60]
JMP 0x00142150
caseD_11:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2d0]
JMP 0x00142150
caseD_f:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2e8]
JMP 0x00142150
caseD_21:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x368]
JMP 0x00142150
caseD_b:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2e0]
JMP 0x00142150
caseD_4:
MOV qword ptr [RBX],0x18902
JMP 0x00142153
caseD_c:
TEST RDI,RDI
JZ 0x00142155
MOV EAX,dword ptr [RDI + 0x360]
JMP 0x001420f2
caseD_9:
TEST RDI,RDI
JZ 0x00142155
MOV EAX,dword ptr [RDI + 0x90]
JMP 0x001420f2
caseD_2:
LEA RAX,[0x43bc80]
JMP 0x00142150
caseD_10:
TEST RDI,RDI
JZ 0x00142155
CALL 0x0013adb3
TEST AL,AL
LEA RAX,[0x195284]
LEA RCX,[0x1946f2]
CMOVZ RCX,RAX
MOV qword ptr [RBX],RCX
JMP 0x00142153
caseD_3:
LEA RAX,[0x19528a]
JMP 0x00142150
caseD_7:
TEST RDI,RDI
JZ 0x00142155
MOV RSI,RBX
CALL 0x00141b44
JMP 0x00142153
caseD_0:
MOV ECX,dword ptr [RBP + -0x20]
CMP RCX,0x28
JA 0x00142122
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x10]
ADD ECX,0x8
MOV dword ptr [RBP + -0x20],ECX
JMP 0x0014212e
caseD_1:
MOV EDX,dword ptr [RBP + -0x20]
CMP RDX,0x28
JA 0x00142137
MOV RCX,RDX
ADD RCX,qword ptr [RBP + -0x10]
ADD EDX,0x8
MOV dword ptr [RBP + -0x20],EDX
JMP 0x00142143
caseD_1f:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x370]
JMP 0x00142150
caseD_12:
TEST RDI,RDI
JZ 0x00142155
MOV RDI,qword ptr [RDI + 0x2d0]
CALL 0x00141249
JMP 0x00142150
caseD_15:
TEST RDI,RDI
JZ 0x00142119
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00142119
MOV RDI,qword ptr [RAX + 0x38]
TEST RDI,RDI
JZ 0x00142119
CALL 0x00142f1a
JMP 0x00142150
caseD_5:
TEST RDI,RDI
JZ 0x00142153
MOV RAX,qword ptr [RDI + 0x480]
TEST RAX,RAX
JZ 0x00142153
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x00142153
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,0xfffffc19
JC 0x0014215f
DEC EAX
IMUL RAX,RAX,0x10624dd3
SHR RAX,0x26
INC EAX
JMP 0x0014216f
caseD_16:
LEA RAX,[0x502fe0]
JMP 0x00142150
caseD_d:
TEST RDI,RDI
JZ 0x00142155
MOV EAX,dword ptr [RDI + 0x378]
JMP 0x001420f2
caseD_6:
TEST RDI,RDI
JZ 0x00142153
MOV RAX,qword ptr [RDI + 0x480]
TEST RAX,RAX
JZ 0x00142153
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x00142153
MOV EAX,dword ptr [RAX + 0x10]
JMP 0x001420f2
caseD_13:
TEST RDI,RDI
JZ 0x00142155
CALL 0x00141cf6
JMP 0x001420f2
caseD_a:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2b0]
JMP 0x00142150
caseD_8:
TEST RDI,RDI
JZ 0x00142155
ADD RDI,0x97
JMP 0x001420d2
caseD_1e:
TEST RDI,RDI
JZ 0x00142155
MOV EAX,dword ptr [RDI + 0x380]
JMP 0x001420f2
caseD_20:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x4f0]
MOV RAX,qword ptr [RAX + 0x70]
JMP 0x00142150
caseD_17:
TEST RDI,RDI
JZ 0x00142155
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x00142155
MOV RDI,qword ptr [RCX + 0x38]
TEST RDI,RDI
JZ 0x00142155
CALL 0x00142f38
JMP 0x00142150
caseD_14:
TEST RDI,RDI
JZ 0x00142155
ADD RDI,0x297
LAB_001420d2:
MOV qword ptr [RBX],RDI
JMP 0x00142153
caseD_18:
TEST RDI,RDI
JZ 0x00142155
MOV RCX,qword ptr [RDI]
TEST RCX,RCX
JZ 0x00142155
MOV RDI,qword ptr [RCX + 0x38]
TEST RDI,RDI
JZ 0x00142155
CALL 0x00142f2e
LAB_001420f2:
MOV dword ptr [RBX],EAX
JMP 0x00142153
caseD_1c:
LEA RAX,[0x43bc28]
JMP 0x00142106
caseD_1d:
LEA RAX,[0x43bc40]
LAB_00142106:
MOV RAX,qword ptr [RAX]
JMP 0x00142150
caseD_1a:
TEST RDI,RDI
JZ 0x00142155
MOV RAX,qword ptr [RDI + 0x2c8]
JMP 0x00142150
LAB_00142119:
MOV qword ptr [RBX],0x0
JMP 0x00142153
LAB_00142122:
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x18],RCX
LAB_0014212e:
MOV EDI,dword ptr [RAX]
CALL 0x00155666
JMP 0x00142150
LAB_00142137:
MOV RCX,qword ptr [RBP + -0x18]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RBP + -0x18],RDX
LAB_00142143:
MOV RDI,qword ptr [RCX]
TEST RDI,RDI
JZ 0x00142155
CALL 0x001556ea
LAB_00142150:
MOV qword ptr [RBX],RAX
LAB_00142153:
XOR EAX,EAX
default:
ADD RSP,0xc8
POP RBX
POP RBP
RET
LAB_0014215f:
ADD EAX,0x3e7
IMUL RAX,RAX,0x10624dd3
SHR RAX,0x26
LAB_0014216f:
MOV dword ptr [RBX],EAX
JMP 0x00142153
|
/* WARNING: Removing unreachable block (ram,0x00142122) */
/* WARNING: Removing unreachable block (ram,0x00142137) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xffffffffffffff40 : 0x0014212e */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8
mariadb_get_infov(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int4 param_10,uint *param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int4 uVar1;
char in_AL;
char cVar2;
uint uVar3;
int8 uVar4;
int1 *puVar5;
long *plVar6;
char *pcVar7;
long lVar8;
int1 local_d8 [24];
long local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000018;
uVar4 = 0x30000000ff;
local_b8 = param_13;
local_b0 = param_14;
switch(param_10) {
case 0:
local_28 = 0x3000000020;
uVar1 = (int4)local_c0;
local_c0 = param_12;
puVar5 = (int1 *)mysql_find_charset_nr(uVar1);
break;
case 1:
local_28 = 0x3000000020;
if (local_c0 == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)mysql_find_charset_name();
break;
case 2:
puVar5 = (int1 *)&client_errors;
break;
case 3:
puVar5 = "10.6.10";
break;
case 4:
param_11[0] = 0x18902;
param_11[1] = 0;
goto LAB_00142153;
case 5:
if (((param_9 != (long *)0x0) && (param_9[0x90] != 0)) &&
(lVar8 = *(long *)(param_9[0x90] + 0x28), lVar8 != 0)) {
uVar3 = *(uint *)(lVar8 + 0x10);
if (uVar3 < 0xfffffc19) {
uVar3 = (uVar3 + 999) / 1000;
}
else {
uVar3 = (uVar3 - 1) / 1000 + 1;
}
*param_11 = uVar3;
}
goto LAB_00142153;
case 6:
if (((param_9 != (long *)0x0) && (param_9[0x90] != 0)) &&
(lVar8 = *(long *)(param_9[0x90] + 0x28), lVar8 != 0)) {
uVar3 = *(uint *)(lVar8 + 0x10);
goto LAB_001420f2;
}
goto LAB_00142153;
case 7:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
mariadb_get_charset_info(param_9,param_11);
goto LAB_00142153;
case 8:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
lVar8 = (long)param_9 + 0x97;
goto LAB_001420d2;
case 9:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x12);
goto LAB_001420f2;
case 10:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x56];
break;
case 0xb:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5c];
break;
case 0xc:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x6c);
goto LAB_001420f2;
case 0xd:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x6f);
goto LAB_001420f2;
case 0xe:
case 0x19:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(*param_9 + 0x20);
goto LAB_001420f2;
case 0xf:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5d];
break;
case 0x10:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
cVar2 = mariadb_connection();
pcVar7 = "MariaDB";
if (cVar2 == '\0') {
pcVar7 = "MySQL";
}
*(char **)param_11 = pcVar7;
goto LAB_00142153;
case 0x11:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x5a];
break;
case 0x12:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)mariadb_server_version_id(param_9[0x5a]);
break;
case 0x13:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
local_c0 = param_12;
uVar3 = mariadb_get_socket();
goto LAB_001420f2;
case 0x14:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
lVar8 = (long)param_9 + 0x297;
LAB_001420d2:
*(long *)param_11 = lVar8;
goto LAB_00142153;
case 0x15:
if (((param_9 != (long *)0x0) && (*param_9 != 0)) && (*(long *)(*param_9 + 0x38) != 0)) {
local_c0 = param_12;
puVar5 = (int1 *)ma_pvio_tls_cipher();
break;
}
param_11[0] = 0;
param_11[1] = 0;
goto LAB_00142153;
case 0x16:
puVar5 = tls_library_version;
break;
case 0x17:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
if (*(long *)(*param_9 + 0x38) == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
puVar5 = (int1 *)ma_pvio_tls_get_protocol_version();
break;
case 0x18:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
if (*param_9 == 0) {
return 0x30000000ff;
}
if (*(long *)(*param_9 + 0x38) == 0) {
return 0x30000000ff;
}
local_c0 = param_12;
uVar3 = ma_pvio_tls_get_protocol_version_id();
goto LAB_001420f2;
case 0x1a:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x59];
break;
case 0x1b:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x57];
break;
case 0x1c:
plVar6 = &max_allowed_packet;
goto LAB_00142106;
case 0x1d:
plVar6 = &net_buffer_length;
LAB_00142106:
puVar5 = (int1 *)*plVar6;
break;
case 0x1e:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
uVar3 = *(uint *)(param_9 + 0x70);
LAB_001420f2:
*param_11 = uVar3;
goto LAB_00142153;
case 0x1f:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x6e];
break;
case 0x20:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = *(int1 **)(param_9[0x9e] + 0x70);
break;
case 0x21:
if (param_9 == (long *)0x0) {
return 0x30000000ff;
}
puVar5 = (int1 *)param_9[0x6d];
break;
case 0x22:
puVar5 = *(int1 **)(*param_9 + 0x60);
break;
case 0x23:
puVar5 = *(int1 **)(*param_9 + 0x68);
break;
default:
goto switchD_00141dd7_default;
}
*(int1 **)param_11 = puVar5;
LAB_00142153:
uVar4 = 0;
switchD_00141dd7_default:
return uVar4;
}
| |
43,310 | OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(OpenSubdiv::v3_6_0::Tmr::EndCapType) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/../tmr/../tmr/nodeBase.h | constexpr int
NodeBase::loopIrregularPatchSize(EndCapType type) {
switch (type) {
case EndCapType::ENDCAP_BILINEAR_BASIS: return 3;
case EndCapType::ENDCAP_BSPLINE_BASIS: return 12;
case EndCapType::ENDCAP_GREGORY_BASIS: return 18;
case EndCapType::ENDCAP_NONE: return 0;
}
return 0;
} | O0 | c | OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(OpenSubdiv::v3_6_0::Tmr::EndCapType):
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x1ce7e1
movq -0x10(%rbp), %rax
leaq 0x2e5fc(%rip), %rcx # 0x1fcdb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x1ce7e8
movl $0xc, -0x4(%rbp)
jmp 0x1ce7e8
movl $0x12, -0x4(%rbp)
jmp 0x1ce7e8
movl $0x0, -0x4(%rbp)
jmp 0x1ce7e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| _ZN10OpenSubdiv6v3_6_03Tmr8NodeBase22loopIrregularPatchSizeENS1_10EndCapTypeE:
push rbp
mov rbp, rsp
mov ax, di
mov [rbp+var_6], ax
movzx eax, [rbp+var_6]
mov [rbp+var_10], rax
sub rax, 3; switch 4 cases
ja short def_1CE7BB; jumptable 00000000001CE7BB default case
mov rax, [rbp+var_10]
lea rcx, jpt_1CE7BB
movsxd rax, ds:(jpt_1CE7BB - 1FCDB0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1CE7BD:
mov [rbp+var_4], 3; jumptable 00000000001CE7BB case 1
jmp short loc_1CE7E8
loc_1CE7C6:
mov [rbp+var_4], 0Ch; jumptable 00000000001CE7BB case 2
jmp short loc_1CE7E8
loc_1CE7CF:
mov [rbp+var_4], 12h; jumptable 00000000001CE7BB case 3
jmp short loc_1CE7E8
loc_1CE7D8:
mov [rbp+var_4], 0; jumptable 00000000001CE7BB case 0
jmp short loc_1CE7E8
def_1CE7BB:
mov [rbp+var_4], 0; jumptable 00000000001CE7BB default case
loc_1CE7E8:
mov eax, [rbp+var_4]
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(__int16 a1)
{
unsigned int v2; // [rsp+Ch] [rbp-4h]
switch ( a1 )
{
case 0:
v2 = 0;
break;
case 1:
v2 = 3;
break;
case 2:
v2 = 12;
break;
case 3:
v2 = 18;
break;
default:
v2 = 0;
break;
}
return v2;
}
| |||
43,311 | OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(OpenSubdiv::v3_6_0::Tmr::EndCapType) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/../tmr/../tmr/nodeBase.h | constexpr int
NodeBase::loopIrregularPatchSize(EndCapType type) {
switch (type) {
case EndCapType::ENDCAP_BILINEAR_BASIS: return 3;
case EndCapType::ENDCAP_BSPLINE_BASIS: return 12;
case EndCapType::ENDCAP_GREGORY_BASIS: return 18;
case EndCapType::ENDCAP_NONE: return 0;
}
return 0;
} | O2 | c | OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(OpenSubdiv::v3_6_0::Tmr::EndCapType):
xorl %eax, %eax
cmpw $0x3, %di
ja 0xb243f
movzwl %di, %eax
leaq 0x1c7f0(%rip), %rcx # 0xcec2c
movl (%rcx,%rax,4), %eax
retq
| _ZN10OpenSubdiv6v3_6_03Tmr8NodeBase22loopIrregularPatchSizeENS1_10EndCapTypeE:
xor eax, eax
cmp di, 3
ja short locret_B243F
movzx eax, di
lea rcx, unk_CEC2C
mov eax, [rcx+rax*4]
locret_B243F:
retn
| long long OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(unsigned __int16 a1)
{
long long result; // rax
result = 0LL;
if ( a1 <= 3u )
return dword_CEC2C[a1];
return result;
}
| loopIrregularPatchSize:
XOR EAX,EAX
CMP DI,0x3
JA 0x001b243f
MOVZX EAX,DI
LEA RCX,[0x1cec2c]
MOV EAX,dword ptr [RCX + RAX*0x4]
LAB_001b243f:
RET
|
/* OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(OpenSubdiv::v3_6_0::Tmr::EndCapType) */
int4 OpenSubdiv::v3_6_0::Tmr::NodeBase::loopIrregularPatchSize(ushort param_1)
{
int4 uVar1;
uVar1 = 0;
if (param_1 < 4) {
uVar1 = *(int4 *)(&DAT_001cec2c + (ulong)param_1 * 4);
}
return uVar1;
}
| |
43,312 | dequantize_row_q8_0 | llama.cpp/ggml/src/ggml-quants.c | void dequantize_row_q8_0(const block_q8_0 * GGML_RESTRICT x, float * GGML_RESTRICT y, int64_t k) {
static const int qk = QK8_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int j = 0; j < qk; ++j) {
y[i*qk + j] = x[i].qs[j]*d;
}
}
} | O3 | c | dequantize_row_q8_0:
leaq 0x1f(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
sarq $0x5, %rax
testl %eax, %eax
jle 0x2cc8e
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x2(%rdi), %rcx
xorl %edx, %edx
movq 0x3d36f(%rip), %r8 # 0x69fa8
movq %rdx, %r9
shlq $0x5, %r9
leaq (%r9,%rdx,2), %r9
movzwl (%rdi,%r9), %r9d
movss (%r8,%r9,4), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
xorl %r9d, %r9d
movd (%rcx,%r9), %xmm1
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3]
psrad $0x18, %xmm1
cvtdq2ps %xmm1, %xmm1
mulps %xmm0, %xmm1
movups %xmm1, (%rsi,%r9,4)
addq $0x4, %r9
cmpq $0x20, %r9
jne 0x2cc56
incq %rdx
addq $0x22, %rcx
subq $-0x80, %rsi
cmpq %rax, %rdx
jne 0x2cc39
retq
| dequantize_row_q8_0:
lea rax, [rdx+1Fh]
test rdx, rdx
cmovns rax, rdx
sar rax, 5
test eax, eax
jle short locret_2CC8E
and eax, 7FFFFFFFh
lea rcx, [rdi+2]
xor edx, edx
mov r8, cs:ggml_table_f32_f16_ptr
loc_2CC39:
mov r9, rdx
shl r9, 5
lea r9, [r9+rdx*2]
movzx r9d, word ptr [rdi+r9]
movss xmm0, dword ptr [r8+r9*4]
shufps xmm0, xmm0, 0
xor r9d, r9d
loc_2CC56:
movd xmm1, dword ptr [rcx+r9]
punpcklbw xmm1, xmm1
punpcklwd xmm1, xmm1
psrad xmm1, 18h
cvtdq2ps xmm1, xmm1
mulps xmm1, xmm0
movups xmmword ptr [rsi+r9*4], xmm1
add r9, 4
cmp r9, 20h ; ' '
jnz short loc_2CC56
inc rdx
add rcx, 22h ; '"'
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rdx, rax
jnz short loc_2CC39
locret_2CC8E:
retn
| long long dequantize_row_q8_0(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rcx
long long v5; // rdx
__m128 v6; // xmm0
__m128 v7; // xmm0
long long i; // r9
__m128i v9; // xmm1
__m128i v10; // xmm1
result = a3 / 32;
if ( (int)(a3 / 32) > 0 )
{
result = (a3 / 32) & 0x7FFFFFFF;
v4 = a1 + 2;
v5 = 0LL;
do
{
v6 = (__m128)LODWORD(ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 34 * v5)]);
v7 = _mm_shuffle_ps(v6, v6, 0);
for ( i = 0LL; i != 32; i += 4LL )
{
v9 = _mm_cvtsi32_si128(*(_DWORD *)(v4 + i));
v10 = _mm_unpacklo_epi8(v9, v9);
*(__m128 *)(a2 + 4 * i) = _mm_mul_ps(_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(v10, v10), 0x18u)), v7);
}
++v5;
v4 += 34LL;
a2 += 128LL;
}
while ( v5 != result );
}
return result;
}
| dequantize_row_q8_0:
LEA RAX,[RDX + 0x1f]
TEST RDX,RDX
CMOVNS RAX,RDX
SAR RAX,0x5
TEST EAX,EAX
JLE 0x0012cc8e
AND EAX,0x7fffffff
LEA RCX,[RDI + 0x2]
XOR EDX,EDX
MOV R8,qword ptr [0x00169fa8]
LAB_0012cc39:
MOV R9,RDX
SHL R9,0x5
LEA R9,[R9 + RDX*0x2]
MOVZX R9D,word ptr [RDI + R9*0x1]
MOVSS XMM0,dword ptr [R8 + R9*0x4]
SHUFPS XMM0,XMM0,0x0
XOR R9D,R9D
LAB_0012cc56:
MOVD XMM1,dword ptr [RCX + R9*0x1]
PUNPCKLBW XMM1,XMM1
PUNPCKLWD XMM1,XMM1
PSRAD XMM1,0x18
CVTDQ2PS XMM1,XMM1
MULPS XMM1,XMM0
MOVUPS xmmword ptr [RSI + R9*0x4],XMM1
ADD R9,0x4
CMP R9,0x20
JNZ 0x0012cc56
INC RDX
ADD RCX,0x22
SUB RSI,-0x80
CMP RDX,RAX
JNZ 0x0012cc39
LAB_0012cc8e:
RET
|
void dequantize_row_q8_0(long param_1,long param_2,long param_3)
{
float *pfVar1;
float fVar2;
int4 uVar3;
int8 uVar4;
ulong uVar5;
int6 uVar6;
int1 auVar7 [12];
int *puVar8;
uint uVar9;
long lVar10;
ulong uVar11;
long lVar12;
short sVar13;
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
int1 uVar17;
int2 uVar18;
puVar8 = PTR_ggml_table_f32_f16_00169fa8;
lVar10 = param_3 + 0x1f;
if (-1 < param_3) {
lVar10 = param_3;
}
uVar9 = (uint)(lVar10 >> 5);
if (0 < (int)uVar9) {
lVar10 = param_1 + 2;
uVar11 = 0;
do {
fVar2 = *(float *)(puVar8 + (ulong)*(ushort *)(param_1 + uVar11 * 0x22) * 4);
lVar12 = 0;
do {
uVar3 = *(int4 *)(lVar10 + lVar12);
uVar17 = (int1)((uint)uVar3 >> 0x18);
uVar18 = CONCAT11(uVar17,uVar17);
uVar17 = (int1)((uint)uVar3 >> 0x10);
uVar4 = CONCAT35(CONCAT21(uVar18,uVar17),CONCAT14(uVar17,uVar3));
uVar17 = (int1)((uint)uVar3 >> 8);
uVar6 = CONCAT51(CONCAT41((int)((ulong)uVar4 >> 0x20),uVar17),uVar17);
sVar13 = CONCAT11((char)uVar3,(char)uVar3);
uVar5 = CONCAT62(uVar6,sVar13);
auVar16._8_4_ = 0;
auVar16._0_8_ = uVar5;
auVar16._12_2_ = uVar18;
auVar16._14_2_ = uVar18;
uVar18 = (int2)((ulong)uVar4 >> 0x20);
auVar15._12_4_ = auVar16._12_4_;
auVar15._8_2_ = 0;
auVar15._0_8_ = uVar5;
auVar15._10_2_ = uVar18;
auVar14._10_6_ = auVar15._10_6_;
auVar14._8_2_ = uVar18;
auVar14._0_8_ = uVar5;
uVar18 = (int2)uVar6;
auVar7._4_8_ = auVar14._8_8_;
auVar7._2_2_ = uVar18;
auVar7._0_2_ = uVar18;
pfVar1 = (float *)(param_2 + lVar12 * 4);
*pfVar1 = (float)((int)sVar13 >> 8) * fVar2;
pfVar1[1] = (float)(auVar7._0_4_ >> 0x18) * fVar2;
pfVar1[2] = (float)(auVar14._8_4_ >> 0x18) * fVar2;
pfVar1[3] = (float)(auVar15._12_4_ >> 0x18) * fVar2;
lVar12 = lVar12 + 4;
} while (lVar12 != 0x20);
uVar11 = uVar11 + 1;
lVar10 = lVar10 + 0x22;
param_2 = param_2 + 0x80;
} while (uVar11 != (uVar9 & 0x7fffffff));
}
return;
}
| |
43,313 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(OpenSubdiv::v3_6_0::Bfr::FaceTopology const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | bool
SurfaceFactory::faceHasLimitNeighborhood(FaceTopology const & topology) const {
assert(_testNeighborhoodForLimit);
MultiVertexTag tag = topology.GetTag();
if ((_rejectSmoothBoundariesForLimit && tag.HasNonSharpBoundary()) ||
(_rejectIrregularFacesForLimit && tag.HasIrregularFaceSizes())) {
return false;
}
return true;
} | O0 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(OpenSubdiv::v3_6_0::Bfr::FaceTopology const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb 0x28(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1b64ba
jmp 0x1b64d9
leaq 0x4465c(%rip), %rdi # 0x1fab1d
leaq 0x4466f(%rip), %rsi # 0x1fab37
movl $0x101, %edx # imm = 0x101
leaq 0x446c3(%rip), %rcx # 0x1fab97
callq 0xc9440
movq -0x18(%rbp), %rsi
leaq -0x1a(%rbp), %rdi
callq 0xd2fb0
movq -0x38(%rbp), %rax
movb 0x28(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1b6511
leaq -0x1a(%rbp), %rdi
callq 0xc9900
movb %al, -0x39(%rbp)
jmp 0x1b6508
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1b653c
jmp 0x1b6511
movq -0x38(%rbp), %rax
movb 0x28(%rax), %al
shrb $0x4, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1b6560
leaq -0x1a(%rbp), %rdi
callq 0xd1440
movb %al, -0x3a(%rbp)
jmp 0x1b6533
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x1b653c
jmp 0x1b6560
movb $0x0, -0x1(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x1b656b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xc5170
jmp 0x1b657f
movb $0x1, -0x1(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0xc5170
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xd58b0
nopl (%rax,%rax)
| _ZNK10OpenSubdiv6v3_6_03Bfr14SurfaceFactory24faceHasLimitNeighborhoodERKNS1_12FaceTopologyE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov al, [rax+28h]
shr al, 2
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_1B64BA
jmp short loc_1B64D9
loc_1B64BA:
lea rdi, aTestneighborho; "_testNeighborhoodForLimit"
lea rsi, aWorkspaceLlm4b_41; "/workspace/llm4binary/github/2025_star3"...
mov edx, 101h
lea rcx, aBoolOpensubdiv_5; "bool OpenSubdiv::v3_6_0::Bfr::SurfaceFa"...
call ___assert_fail
loc_1B64D9:
mov rsi, [rbp+var_18]
lea rdi, [rbp+var_1A]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr12FaceTopology6GetTagEv; OpenSubdiv::v3_6_0::Bfr::FaceTopology::GetTag(void)
mov rax, [rbp+var_38]
mov al, [rax+28h]
shr al, 3
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_1B6511
lea rdi, [rbp+var_1A]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr14MultiVertexTag19HasNonSharpBoundaryEv; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasNonSharpBoundary(void)
mov [rbp+var_39], al
jmp short $+2
loc_1B6508:
mov al, [rbp+var_39]
test al, 1
jnz short loc_1B653C
jmp short $+2
loc_1B6511:
mov rax, [rbp+var_38]
mov al, [rax+28h]
shr al, 4
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_1B6560
lea rdi, [rbp+var_1A]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr14MultiVertexTag21HasIrregularFaceSizesEv; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasIrregularFaceSizes(void)
mov [rbp+var_3A], al
jmp short $+2
loc_1B6533:
mov al, [rbp+var_3A]
test al, 1
jnz short loc_1B653C
jmp short loc_1B6560
loc_1B653C:
mov [rbp+var_1], 0
mov [rbp+var_30], 1
jmp short loc_1B656B
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
lea rdi, [rbp+var_1A]; this
call __ZN10OpenSubdiv6v3_6_03Bfr14MultiVertexTagD2Ev; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::~MultiVertexTag()
jmp short loc_1B657F
loc_1B6560:
mov [rbp+var_1], 1
mov [rbp+var_30], 1
loc_1B656B:
lea rdi, [rbp+var_1A]; this
call __ZN10OpenSubdiv6v3_6_03Bfr14MultiVertexTagD2Ev; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::~MultiVertexTag()
mov al, [rbp+var_1]
and al, 1
add rsp, 40h
pop rbp
retn
loc_1B657F:
mov rdi, [rbp+var_28]
call __Unwind_Resume
| bool OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this,
const OpenSubdiv::v3_6_0::Bfr::FaceTopology *a2)
{
_BYTE v3[2]; // [rsp+26h] [rbp-1Ah] BYREF
const OpenSubdiv::v3_6_0::Bfr::FaceTopology *v4; // [rsp+28h] [rbp-18h]
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *v5; // [rsp+30h] [rbp-10h]
bool v6; // [rsp+3Fh] [rbp-1h]
v5 = this;
v4 = a2;
if ( (*((_BYTE *)this + 40) & 4) == 0 )
__assert_fail(
"_testNeighborhoodForLimit",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp",
257LL,
"bool OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(const FaceTopology &) const");
OpenSubdiv::v3_6_0::Bfr::FaceTopology::GetTag((OpenSubdiv::v3_6_0::Bfr::FaceTopology *)v3);
v6 = ((*((_BYTE *)this + 40) & 8) == 0
|| (OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasNonSharpBoundary((OpenSubdiv::v3_6_0::Bfr::MultiVertexTag *)v3) & 1) == 0)
&& ((*((_BYTE *)this + 40) & 0x10) == 0
|| (OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasIrregularFaceSizes((OpenSubdiv::v3_6_0::Bfr::MultiVertexTag *)v3) & 1) == 0);
OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::~MultiVertexTag((OpenSubdiv::v3_6_0::Bfr::MultiVertexTag *)v3);
return v6;
}
| |||
43,314 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(OpenSubdiv::v3_6_0::Bfr::FaceTopology const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | bool
SurfaceFactory::faceHasLimitNeighborhood(FaceTopology const & topology) const {
assert(_testNeighborhoodForLimit);
MultiVertexTag tag = topology.GetTag();
if ((_rejectSmoothBoundariesForLimit && tag.HasNonSharpBoundary()) ||
(_rejectIrregularFacesForLimit && tag.HasIrregularFaceSizes())) {
return false;
}
return true;
} | O2 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(OpenSubdiv::v3_6_0::Bfr::FaceTopology const&) const:
movb 0x28(%rdi), %al
testb $0x4, %al
je 0xa8bc5
movzwl 0x14(%rsi), %ecx
movl %eax, %edx
shrb $0x3, %dl
movl %ecx, %esi
shrl $0xa, %esi
andl $0x1, %esi
testb %sil, %dl
je 0xa8bb8
xorl %eax, %eax
retq
testb $0x10, %al
sete %dl
testb %cl, %cl
setns %al
orb %dl, %al
retq
pushq %rax
leaq 0x237ec(%rip), %rdi # 0xcc3b9
leaq 0x237ff(%rip), %rsi # 0xcc3d3
leaq 0x23858(%rip), %rcx # 0xcc433
movl $0x101, %edx # imm = 0x101
callq 0x512a0
nop
| _ZNK10OpenSubdiv6v3_6_03Bfr14SurfaceFactory24faceHasLimitNeighborhoodERKNS1_12FaceTopologyE:
mov al, [rdi+28h]
test al, 4
jz short loc_A8BC5
movzx ecx, word ptr [rsi+14h]
mov edx, eax
shr dl, 3
mov esi, ecx
shr esi, 0Ah
and esi, 1
test dl, sil
jz short loc_A8BB8
xor eax, eax
retn
loc_A8BB8:
test al, 10h
setz dl
test cl, cl
setns al
or al, dl
retn
loc_A8BC5:
push rax
lea rdi, aTestneighborho; "_testNeighborhoodForLimit"
lea rsi, aWorkspaceLlm4b_42; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolOpensubdiv_5; "bool OpenSubdiv::v3_6_0::Bfr::SurfaceFa"...
mov edx, 101h
call ___assert_fail
| bool OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this,
const OpenSubdiv::v3_6_0::Bfr::FaceTopology *a2)
{
unsigned __int8 v2; // al
__int16 v3; // cx
v2 = *((_BYTE *)this + 40);
if ( (v2 & 4) == 0 )
__assert_fail(
"_testNeighborhoodForLimit",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp",
257LL,
"bool OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(const FaceTopology &) const");
v3 = *((_WORD *)a2 + 10);
return (((v3 & 0x400) != 0) & (v2 >> 3)) == 0 && ((v2 & 0x10) == 0 || (v3 & 0x80u) == 0);
}
| faceHasLimitNeighborhood:
MOV AL,byte ptr [RDI + 0x28]
TEST AL,0x4
JZ 0x001a8bc5
MOVZX ECX,word ptr [RSI + 0x14]
MOV EDX,EAX
SHR DL,0x3
MOV ESI,ECX
SHR ESI,0xa
AND ESI,0x1
TEST DL,SIL
JZ 0x001a8bb8
XOR EAX,EAX
RET
LAB_001a8bb8:
TEST AL,0x10
SETZ DL
TEST CL,CL
SETNS AL
OR AL,DL
RET
LAB_001a8bc5:
PUSH RAX
LEA RDI,[0x1cc3b9]
LEA RSI,[0x1cc3d3]
LEA RCX,[0x1cc433]
MOV EDX,0x101
CALL 0x001512a0
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(OpenSubdiv::v3_6_0::Bfr::FaceTopology
const&) const */
bool __thiscall
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood
(SurfaceFactory *this,FaceTopology *param_1)
{
SurfaceFactory SVar1;
SVar1 = this[0x28];
if (((byte)SVar1 & 4) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("_testNeighborhoodForLimit",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp"
,0x101,
"bool OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::faceHasLimitNeighborhood(const FaceTopology &) const"
);
}
if (((byte)SVar1 >> 3 & (byte)((ushort)*(int2 *)(param_1 + 0x14) >> 10) & 1) != 0) {
return false;
}
return -1 < (char)*(int2 *)(param_1 + 0x14) || ((byte)SVar1 & 0x10) == 0;
}
| |
43,315 | minja::Value::operator+(minja::Value const&) const | llama.cpp/common/minja/minja.hpp | Value operator+(const Value& rhs) const {
if (is_string() || rhs.is_string()) {
return to_str() + rhs.to_str();
} else if (is_number_integer() && rhs.is_number_integer()) {
return get<int64_t>() + rhs.get<int64_t>();
} else if (is_array() && rhs.is_array()) {
auto res = Value::array();
for (const auto& item : *array_) res.push_back(item);
for (const auto& item : *rhs.array_) res.push_back(item);
return res;
} else {
return get<double>() + rhs.get<double>();
}
} | O3 | cpp | minja::Value::operator+(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0x40(%rsi), %al
cmpb $0x3, %al
je 0xa7b85
movb 0x40(%r14), %cl
cmpb $0x3, %cl
jne 0xa7bf5
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x741ba
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x741ba
leaq 0x60(%rsp), %r12
movq -0x10(%r12), %rcx
movq -0x8(%r12), %r8
movq 0x30(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r12, %rcx
je 0xa7bc6
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
cmpq %rdi, %rax
jbe 0xa7be9
leaq 0x38(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0xa7be4
movq 0x38(%rsp), %rdi
cmpq %rdi, %rax
jbe 0xa7c4b
leaq 0x50(%rsp), %rdi
callq 0x1d470
jmp 0xa7c59
addb $-0x5, %al
addb $-0x5, %cl
orb %al, %cl
cmpb $0x1, %cl
ja 0xa7d10
movq %r15, %rdi
callq 0x6eed4
movq %rax, %r15
movq %r14, %rdi
callq 0x6eed4
addq %rax, %r15
leaq 0x40(%rbx), %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movupd %xmm0, 0x10(%rbx)
movupd %xmm0, 0x20(%rbx)
movupd %xmm0, 0x30(%rbx)
movupd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6a924
jmp 0xa7da4
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1d210
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %rdi, -0x10(%rdi)
movq (%rax), %rax
leaq 0x10(%r15), %r14
cmpq %r14, %rax
je 0xa7c80
movq %rax, 0x8(%rsp)
movq (%r14), %rax
movq %rax, 0x18(%rsp)
jmp 0xa7c8f
movq 0x8(%r15), %rdx
incq %rdx
movq %r14, %rsi
callq 0x1d0c0
movq %r15, %rax
addq $0x8, %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x10(%rsp)
movq %r14, (%r15)
movq $0x0, (%rax)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x602f8
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7cd5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7cf0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d160
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0xa7db1
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa7db1
cmpq $0x0, 0x10(%r15)
je 0xa7d66
cmpq $0x0, 0x10(%r14)
je 0xa7d66
xorpd %xmm0, %xmm0
leaq 0x70(%rsp), %rsi
movapd %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x6f81a
leaq 0x70(%rsp), %rdi
callq 0x63414
movq 0x10(%r15), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0xa7dc3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f93c
addq $0x50, %r15
jmp 0xa7d50
movq %r15, %rdi
callq 0x643e8
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
callq 0x643e8
addsd 0x48(%rsp), %xmm0
leaq 0x40(%rbx), %r14
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movq %r14, %rdi
callq 0x69eec
movq %r14, %rdi
movl $0x1, %esi
callq 0x60b38
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0xa7db1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f93c
addq $0x50, %r14
jmp 0xa7dce
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x63414
jmp 0xa7e60
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa7e16
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e36
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa7e36
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e60
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa7e60
jmp 0xa7e55
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a540
movq %r14, %rdi
callq 0x1d8e0
| _ZNK5minja5ValueplERKS0_:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov al, [rsi+40h]
cmp al, 3
jz short loc_A7B85
mov cl, [r14+40h]
cmp cl, 3
jnz short loc_A7BF5
loc_A7B85:
lea rdi, [rsp+0A8h+var_58]
mov rsi, r15
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea rdi, [rsp+0A8h+var_80]
mov rsi, r14
call _ZNK5minja5Value6to_strB5cxx11Ev; minja::Value::to_str(void)
lea r12, [rsp+0A8h+var_48]
mov rcx, [r12-10h]
mov r8, [r12-8]
mov rdx, [rsp+0A8h+var_78]
lea rax, [rdx+r8]
mov edi, 0Fh
cmp rcx, r12
jz short loc_A7BC6
mov rdi, [rsp+0A8h+var_48]
loc_A7BC6:
mov rsi, [rsp+0A8h+var_80]
cmp rax, rdi
jbe short loc_A7BE9
lea r9, [rsp+0A8h+var_70]
mov edi, 0Fh
cmp rsi, r9
jz short loc_A7BE4
mov rdi, [rsp+0A8h+var_70]
loc_A7BE4:
cmp rax, rdi
jbe short loc_A7C4B
loc_A7BE9:
lea rdi, [rsp+0A8h+var_58]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
jmp short loc_A7C59
loc_A7BF5:
add al, 0FBh
add cl, 0FBh
or cl, al
cmp cl, 1
ja loc_A7D10
mov rdi, r15
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
add r15, rax
lea r14, [rbx+40h]
xorpd xmm0, xmm0
movupd xmmword ptr [rbx], xmm0
movupd xmmword ptr [rbx+10h], xmm0
movupd xmmword ptr [rbx+20h], xmm0
movupd xmmword ptr [rbx+30h], xmm0
movupd xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_integer_t)
jmp loc_A7DA4
loc_A7C4B:
lea rdi, [rsp+0A8h+var_80]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_A7C59:
mov r15, rax
lea rdi, [rsp+0A8h+var_90]
mov [rdi-10h], rdi
mov rax, [rax]
lea r14, [r15+10h]
cmp rax, r14
jz short loc_A7C80
mov [rsp+0A8h+var_A0], rax
mov rax, [r14]
mov [rsp+0A8h+var_90], rax
jmp short loc_A7C8F
loc_A7C80:
mov rdx, [r15+8]
inc rdx
mov rsi, r14
call _memcpy
loc_A7C8F:
mov rax, r15
add rax, 8
mov rcx, [r15+8]
mov [rsp+0A8h+var_98], rcx
mov [r15], r14
mov qword ptr [rax], 0
mov byte ptr [r14], 0
lea rsi, [rsp+0A8h+var_A0]
mov rdi, rbx
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
lea rax, [rsp+0A8h+var_90]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A7CD5
mov rsi, [rsp+0A8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A7CD5:
lea rax, [rsp+0A8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A7CF0
mov rsi, [rsp+0A8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A7CF0:
mov rdi, [rsp+0A8h+var_58]; void *
cmp rdi, r12
jz loc_A7DB1
mov rsi, [rsp+0A8h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_A7DB1
loc_A7D10:
cmp qword ptr [r15+10h], 0
jz short loc_A7D66
cmp qword ptr [r14+10h], 0
jz short loc_A7D66
xorpd xmm0, xmm0
lea rsi, [rsp+0A8h+var_38]
movapd xmmword ptr [rsi], xmm0
mov qword ptr [rsi+10h], 0
mov rdi, rbx
call _ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE; minja::Value::array(std::vector<minja::Value>)
lea rdi, [rsp+0A8h+var_38]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
mov rax, [r15+10h]
mov r15, [rax]
mov r12, [rax+8]
loc_A7D50:
cmp r15, r12
jz short loc_A7DC3
mov rdi, rbx; this
mov rsi, r15; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r15, 50h ; 'P'
jmp short loc_A7D50
loc_A7D66:
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0A8h+var_60], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
addsd xmm0, [rsp+0A8h+var_60]
lea r14, [rbx+40h]
xorps xmm1, xmm1
movups xmmword ptr [rbx], xmm1
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx+20h], xmm1
movups xmmword ptr [rbx+30h], xmm1
movups xmmword ptr [rbx+40h], xmm1
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_float_t)
loc_A7DA4:
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_A7DB1:
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
loc_A7DC3:
mov rax, [r14+10h]
mov r14, [rax]
mov r15, [rax+8]
loc_A7DCE:
cmp r14, r15
jz short loc_A7DB1
mov rdi, rbx; this
mov rsi, r14; minja::Value *
call _ZN5minja5Value9push_backERKS0_; minja::Value::push_back(minja::Value const&)
add r14, 50h ; 'P'
jmp short loc_A7DCE
mov r14, rax
lea rdi, [rsp+arg_68]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
jmp short loc_A7E60
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A7E16
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A7E16
mov r14, rax
loc_A7E16:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A7E36
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A7E36
mov r14, rax
loc_A7E36:
lea rax, [rsp+arg_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A7E60
mov rsi, [rsp+arg_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A7E60
jmp short $+2
loc_A7E55:
mov r14, rax
mov rdi, rbx; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_A7E60:
mov rdi, r14
call __Unwind_Resume
| minja::Value * minja::Value::operator+(minja::Value *this, long long a2, long long a3)
{
char v5; // al
char v6; // cl
unsigned long long v7; // rax
unsigned long long v8; // rdi
unsigned long long v9; // rdi
_QWORD *v10; // rax
long long v11; // r15
long long v12; // rax
char *v13; // r14
_QWORD *v14; // r15
_QWORD *v15; // rax
_QWORD *v16; // r14
const minja::Value **v17; // rax
const minja::Value *v18; // r15
const minja::Value *v19; // r12
double v20; // xmm0_8
const minja::Value **v22; // rax
const minja::Value *v23; // r14
const minja::Value *v24; // r15
_QWORD *v25; // [rsp+8h] [rbp-A0h]
_QWORD v26[2]; // [rsp+18h] [rbp-90h] BYREF
_QWORD *v27; // [rsp+28h] [rbp-80h] BYREF
long long v28; // [rsp+30h] [rbp-78h]
_QWORD v29[2]; // [rsp+38h] [rbp-70h] BYREF
double v30; // [rsp+48h] [rbp-60h]
void *v31; // [rsp+50h] [rbp-58h] BYREF
long long v32; // [rsp+58h] [rbp-50h]
_QWORD v33[2]; // [rsp+60h] [rbp-48h] BYREF
__int128 v34; // [rsp+70h] [rbp-38h] BYREF
long long v35; // [rsp+80h] [rbp-28h]
v5 = *(_BYTE *)(a2 + 64);
if ( v5 != 3 )
{
v6 = *(_BYTE *)(a3 + 64);
if ( v6 != 3 )
{
if ( (unsigned __int8)((v5 - 5) | (v6 - 5)) > 1u )
{
if ( *(_QWORD *)(a2 + 16) && *(_QWORD *)(a3 + 16) )
{
v34 = 0LL;
v35 = 0LL;
minja::Value::array((long long)this, (long long *)&v34);
std::vector<minja::Value>::~vector(&v34);
v17 = *(const minja::Value ***)(a2 + 16);
v18 = *v17;
v19 = v17[1];
while ( v18 != v19 )
{
minja::Value::push_back(this, v18);
v18 = (const minja::Value *)((char *)v18 + 80);
}
v22 = *(const minja::Value ***)(a3 + 16);
v23 = *v22;
v24 = v22[1];
while ( v23 != v24 )
{
minja::Value::push_back(this, v23);
v23 = (const minja::Value *)((char *)v23 + 80);
}
return this;
}
v30 = minja::Value::get<double>((_QWORD *)a2);
v20 = minja::Value::get<double>((_QWORD *)a3) + v30;
v13 = (char *)this + 64;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 4) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)this + 64,
v20);
}
else
{
v11 = minja::Value::get<long>((_QWORD *)a2);
v12 = minja::Value::get<long>((_QWORD *)a3);
v13 = (char *)this + 64;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_OWORD *)this + 4) = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)this + 64,
v12 + v11);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
return this;
}
}
minja::Value::to_str[abi:cxx11](&v31, a2);
minja::Value::to_str[abi:cxx11](&v27, a3);
v7 = v28 + v32;
v8 = 15LL;
if ( v31 != v33 )
v8 = v33[0];
if ( v7 <= v8 )
goto LABEL_9;
v9 = 15LL;
if ( v27 != v29 )
v9 = v29[0];
if ( v7 <= v9 )
v10 = (_QWORD *)std::string::replace(&v27, 0LL, 0LL, v31, v32);
else
LABEL_9:
v10 = (_QWORD *)std::string::append(&v31, v27, v28);
v14 = v10;
v25 = v26;
v15 = (_QWORD *)*v10;
v16 = v14 + 2;
if ( v15 == v14 + 2 )
{
memcpy(v26, v14 + 2, v14[1] + 1LL);
}
else
{
v25 = v15;
v26[0] = *v16;
}
*v14 = v16;
v14[1] = 0LL;
*(_BYTE *)v16 = 0;
minja::Value::Value(this);
if ( v25 != v26 )
operator delete(v25, v26[0] + 1LL);
if ( v27 != v29 )
operator delete(v27, v29[0] + 1LL);
if ( v31 != v33 )
operator delete(v31, v33[0] + 1LL);
return this;
}
| operator+:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
CMP AL,0x3
JZ 0x001a7b85
MOV CL,byte ptr [R14 + 0x40]
CMP CL,0x3
JNZ 0x001a7bf5
LAB_001a7b85:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
CALL 0x001741ba
LAB_001a7b92:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x001741ba
LEA R12,[RSP + 0x60]
MOV RCX,qword ptr [R12 + -0x10]
MOV R8,qword ptr [R12 + -0x8]
MOV RDX,qword ptr [RSP + 0x30]
LEA RAX,[RDX + R8*0x1]
MOV EDI,0xf
CMP RCX,R12
JZ 0x001a7bc6
MOV RDI,qword ptr [RSP + 0x60]
LAB_001a7bc6:
MOV RSI,qword ptr [RSP + 0x28]
CMP RAX,RDI
JBE 0x001a7be9
LEA R9,[RSP + 0x38]
MOV EDI,0xf
CMP RSI,R9
JZ 0x001a7be4
MOV RDI,qword ptr [RSP + 0x38]
LAB_001a7be4:
CMP RAX,RDI
JBE 0x001a7c4b
LAB_001a7be9:
LEA RDI,[RSP + 0x50]
CALL 0x0011d470
LAB_001a7bf3:
JMP 0x001a7c59
LAB_001a7bf5:
ADD AL,0xfb
ADD CL,0xfb
OR CL,AL
CMP CL,0x1
JA 0x001a7d10
MOV RDI,R15
CALL 0x0016eed4
MOV R15,RAX
MOV RDI,R14
CALL 0x0016eed4
ADD R15,RAX
LEA R14,[RBX + 0x40]
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RBX],XMM0
MOVUPD xmmword ptr [RBX + 0x10],XMM0
MOVUPD xmmword ptr [RBX + 0x20],XMM0
MOVUPD xmmword ptr [RBX + 0x30],XMM0
MOVUPD xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,R15
CALL 0x0016a924
JMP 0x001a7da4
LAB_001a7c4b:
LEA RDI,[RSP + 0x28]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011d210
LAB_001a7c59:
MOV R15,RAX
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI + -0x10],RDI
MOV RAX,qword ptr [RAX]
LEA R14,[R15 + 0x10]
CMP RAX,R14
JZ 0x001a7c80
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001a7c8f
LAB_001a7c80:
MOV RDX,qword ptr [R15 + 0x8]
INC RDX
MOV RSI,R14
CALL 0x0011d0c0
LAB_001a7c8f:
MOV RAX,R15
ADD RAX,0x8
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [R15],R14
MOV qword ptr [RAX],0x0
MOV byte ptr [R14],0x0
LAB_001a7cad:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001602f8
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a7cd5
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011d160
LAB_001a7cd5:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a7cf0
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011d160
LAB_001a7cf0:
MOV RDI,qword ptr [RSP + 0x50]
CMP RDI,R12
JZ 0x001a7db1
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x0011d160
JMP 0x001a7db1
LAB_001a7d10:
CMP qword ptr [R15 + 0x10],0x0
JZ 0x001a7d66
CMP qword ptr [R14 + 0x10],0x0
JZ 0x001a7d66
XORPD XMM0,XMM0
LEA RSI,[RSP + 0x70]
MOVAPD xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x10],0x0
LAB_001a7d33:
MOV RDI,RBX
CALL 0x0016f81a
LEA RDI,[RSP + 0x70]
CALL 0x00163414
MOV RAX,qword ptr [R15 + 0x10]
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
LAB_001a7d50:
CMP R15,R12
JZ 0x001a7dc3
LAB_001a7d55:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0016f93c
LAB_001a7d60:
ADD R15,0x50
JMP 0x001a7d50
LAB_001a7d66:
MOV RDI,R15
CALL 0x001643e8
MOVSD qword ptr [RSP + 0x48],XMM0
MOV RDI,R14
CALL 0x001643e8
ADDSD XMM0,qword ptr [RSP + 0x48]
LEA R14,[RBX + 0x40]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RBX],XMM1
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX + 0x20],XMM1
MOVUPS xmmword ptr [RBX + 0x30],XMM1
MOVUPS xmmword ptr [RBX + 0x40],XMM1
MOV RDI,R14
CALL 0x00169eec
LAB_001a7da4:
MOV RDI,R14
MOV ESI,0x1
CALL 0x00160b38
LAB_001a7db1:
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001a7dc3:
MOV RAX,qword ptr [R14 + 0x10]
MOV R14,qword ptr [RAX]
MOV R15,qword ptr [RAX + 0x8]
LAB_001a7dce:
CMP R14,R15
JZ 0x001a7db1
LAB_001a7dd3:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016f93c
LAB_001a7dde:
ADD R14,0x50
JMP 0x001a7dce
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator+(Value *this,Value *param_1)
{
long *__src;
Value *pVVar1;
int8 *puVar2;
long lVar3;
long lVar4;
Value *in_RDX;
ulong uVar5;
Value *pVVar6;
double dVar7;
long *local_a0;
int8 local_98;
long local_90 [2];
ulong *local_80;
long local_78;
ulong local_70 [2];
double local_60;
ulong *local_58;
long local_50;
ulong local_48 [2];
int8 local_38;
int8 uStack_30;
int8 local_28;
if ((param_1[0x40] != (Value)0x3) && (in_RDX[0x40] != (Value)0x3)) {
if ((byte)((char)in_RDX[0x40] - 5U | (char)param_1[0x40] - 5U) < 2) {
lVar3 = get<long>(param_1);
lVar4 = get<long>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(this + 0x40,lVar3 + lVar4);
}
else {
if ((*(long *)(param_1 + 0x10) != 0) && (*(long *)(in_RDX + 0x10) != 0)) {
local_38 = 0;
uStack_30 = 0;
local_28 = 0;
/* try { // try from 001a7d33 to 001a7d3a has its CatchHandler @ 001a7de4 */
array(this);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)&local_38);
pVVar1 = (Value *)(*(int8 **)(param_1 + 0x10))[1];
for (pVVar6 = (Value *)**(int8 **)(param_1 + 0x10); pVVar6 != pVVar1;
pVVar6 = pVVar6 + 0x50) {
/* try { // try from 001a7d55 to 001a7d5f has its CatchHandler @ 001a7e55 */
push_back(this,pVVar6);
}
pVVar1 = (Value *)(*(int8 **)(in_RDX + 0x10))[1];
for (pVVar6 = (Value *)**(int8 **)(in_RDX + 0x10); pVVar6 != pVVar1;
pVVar6 = pVVar6 + 0x50) {
/* try { // try from 001a7dd3 to 001a7ddd has its CatchHandler @ 001a7e53 */
push_back(this,pVVar6);
}
return this;
}
local_60 = get<double>(param_1);
dVar7 = get<double>(in_RDX);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(dVar7 + local_60,this + 0x40);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant((bool)((char)this + '@'));
return this;
}
to_str_abi_cxx11_();
/* try { // try from 001a7b92 to 001a7b9e has its CatchHandler @ 001a7e33 */
to_str_abi_cxx11_();
uVar5 = 0xf;
if (local_58 != local_48) {
uVar5 = local_48[0];
}
if (uVar5 < (ulong)(local_78 + local_50)) {
uVar5 = 0xf;
if (local_80 != local_70) {
uVar5 = local_70[0];
}
if ((ulong)(local_78 + local_50) <= uVar5) {
/* try { // try from 001a7c4b to 001a7c58 has its CatchHandler @ 001a7e13 */
puVar2 = (int8 *)
std::__cxx11::string::replace((ulong)&local_80,0,(char *)0x0,(ulong)local_58);
goto LAB_001a7c59;
}
}
/* try { // try from 001a7be9 to 001a7bf2 has its CatchHandler @ 001a7e13 */
puVar2 = (int8 *)std::__cxx11::string::append((char *)&local_58,(ulong)local_80);
LAB_001a7c59:
local_a0 = local_90;
__src = puVar2 + 2;
if ((long *)*puVar2 == __src) {
memcpy(local_a0,__src,puVar2[1] + 1);
}
else {
local_90[0] = *__src;
local_a0 = (long *)*puVar2;
}
local_98 = puVar2[1];
*puVar2 = __src;
puVar2[1] = 0;
*(int1 *)__src = 0;
/* try { // try from 001a7cad to 001a7cb9 has its CatchHandler @ 001a7df3 */
Value(this,(string *)&local_a0);
if (local_a0 != local_90) {
operator_delete(local_a0,local_90[0] + 1);
}
if (local_80 != local_70) {
operator_delete(local_80,local_70[0] + 1);
}
if (local_58 != local_48) {
operator_delete(local_58,local_48[0] + 1);
}
return this;
}
| |
43,316 | my_wc_mb_bin | eloqsql/strings/ctype-bin.c | int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x8bbbf
xorl %eax, %eax
cmpq $0xff, %rsi
ja 0x8bbbf
movb %sil, (%rdx)
movl $0x1, %eax
popq %rbp
retq
| my_wc_mb_bin:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_8BBBF
xor eax, eax
cmp rsi, 0FFh
ja short loc_8BBBF
mov [rdx], sil
mov eax, 1
loc_8BBBF:
pop rbp
retn
| long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
result = 0LL;
if ( a2 <= 0xFF )
{
*a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0018bbbf
XOR EAX,EAX
CMP RSI,0xff
JA 0x0018bbbf
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_0018bbbf:
POP RBP
RET
|
int8 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9b;
if ((param_3 < param_4) && (uVar1 = 0, param_2 < 0x100)) {
*param_3 = (char)param_2;
uVar1 = 1;
}
return uVar1;
}
| |
43,317 | mbedtls_mpi_mod_mpi | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/bignum.c | int mbedtls_mpi_mod_mpi(mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
MPI_VALIDATE_RET(R != NULL);
MPI_VALIDATE_RET(A != NULL);
MPI_VALIDATE_RET(B != NULL);
if (mbedtls_mpi_cmp_int(B, 0) < 0) {
return MBEDTLS_ERR_MPI_NEGATIVE_VALUE;
}
MBEDTLS_MPI_CHK(mbedtls_mpi_div_mpi(NULL, R, A, B));
while (mbedtls_mpi_cmp_int(R, 0) < 0) {
MBEDTLS_MPI_CHK(mbedtls_mpi_add_mpi(R, R, B));
}
while (mbedtls_mpi_cmp_mpi(R, B) >= 0) {
MBEDTLS_MPI_CHK(mbedtls_mpi_sub_mpi(R, R, B));
}
cleanup:
return ret;
} | O3 | c | mbedtls_mpi_mod_mpi:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
movq $0x1, 0x8(%rsi)
movq %r12, 0x10(%rsi)
movq %rdx, %rdi
callq 0x7f0b0
testl %eax, %eax
js 0x800cd
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x7f9ad
testl %eax, %eax
jne 0x800d2
leaq 0x10(%rsp), %r15
movq $0x0, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f0b0
testl %eax, %eax
jns 0x800ba
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x7f3d8
testl %eax, %eax
je 0x8005c
jmp 0x800d2
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x7f3d8
testl %eax, %eax
jne 0x800d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7f0b0
testl %eax, %eax
jns 0x800a3
xorl %eax, %eax
jmp 0x800d2
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| mbedtls_mpi_mod_mpi:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
lea r12, [rsp+48h+var_40]
mov qword ptr [r12], 0
lea rsi, [rsp+48h+var_38]
mov dword ptr [rsi], 1
mov qword ptr [rsi+8], 1
mov [rsi+10h], r12
mov rdi, rdx
call mbedtls_mpi_cmp_mpi
test eax, eax
js loc_800CD
xor edi, edi
mov rsi, r14
mov rdx, r15
mov rcx, rbx
call mbedtls_mpi_div_mpi
test eax, eax
jnz short loc_800D2
lea r15, [rsp+48h+var_38]
loc_8005C:
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 1
mov [rsp+48h+var_30], 1
mov [rsp+48h+var_28], r12
mov rdi, r14
mov rsi, r15
call mbedtls_mpi_cmp_mpi
test eax, eax
jns short loc_800BA
mov rdi, r14
mov rsi, r14
mov rdx, rbx
mov ecx, 1
call add_sub_mpi
test eax, eax
jz short loc_8005C
jmp short loc_800D2
loc_800A3:
mov rdi, r14
mov rsi, r14
mov rdx, rbx
mov ecx, 0FFFFFFFFh
call add_sub_mpi
test eax, eax
jnz short loc_800D2
loc_800BA:
mov rdi, r14
mov rsi, rbx
call mbedtls_mpi_cmp_mpi
test eax, eax
jns short loc_800A3
xor eax, eax
jmp short loc_800D2
loc_800CD:
mov eax, 0FFFFFFF6h
loc_800D2:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
| long long mbedtls_mpi_mod_mpi(int *a1, long long a2, _QWORD *a3)
{
long long result; // rax
long long v5; // [rsp+8h] [rbp-40h] BYREF
int v6; // [rsp+10h] [rbp-38h] BYREF
long long v7; // [rsp+18h] [rbp-30h]
long long *v8; // [rsp+20h] [rbp-28h]
v5 = 0LL;
v6 = 1;
v7 = 1LL;
v8 = &v5;
if ( (int)mbedtls_mpi_cmp_mpi(a3, (long long)&v6) < 0 )
return 4294967286LL;
result = mbedtls_mpi_div_mpi(0LL, a1, a2, a3);
if ( !(_DWORD)result )
{
while ( 1 )
{
v5 = 0LL;
v6 = 1;
v7 = 1LL;
v8 = &v5;
if ( (int)mbedtls_mpi_cmp_mpi(a1, (long long)&v6) >= 0 )
break;
result = add_sub_mpi(a1, a1, a3, 1);
if ( (_DWORD)result )
return result;
}
while ( (int)mbedtls_mpi_cmp_mpi(a1, (long long)a3) >= 0 )
{
result = add_sub_mpi(a1, a1, a3, -1);
if ( (_DWORD)result )
return result;
}
return 0LL;
}
return result;
}
| mbedtls_mpi_mod_mpi:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],0x0
LEA RSI,[RSP + 0x10]
MOV dword ptr [RSI],0x1
MOV qword ptr [RSI + 0x8],0x1
MOV qword ptr [RSI + 0x10],R12
MOV RDI,RDX
CALL 0x0017f0b0
TEST EAX,EAX
JS 0x001800cd
XOR EDI,EDI
MOV RSI,R14
MOV RDX,R15
MOV RCX,RBX
CALL 0x0017f9ad
TEST EAX,EAX
JNZ 0x001800d2
LEA R15,[RSP + 0x10]
LAB_0018005c:
MOV qword ptr [RSP + 0x8],0x0
MOV dword ptr [RSP + 0x10],0x1
MOV qword ptr [RSP + 0x18],0x1
MOV qword ptr [RSP + 0x20],R12
MOV RDI,R14
MOV RSI,R15
CALL 0x0017f0b0
TEST EAX,EAX
JNS 0x001800ba
MOV RDI,R14
MOV RSI,R14
MOV RDX,RBX
MOV ECX,0x1
CALL 0x0017f3d8
TEST EAX,EAX
JZ 0x0018005c
JMP 0x001800d2
LAB_001800a3:
MOV RDI,R14
MOV RSI,R14
MOV RDX,RBX
MOV ECX,0xffffffff
CALL 0x0017f3d8
TEST EAX,EAX
JNZ 0x001800d2
LAB_001800ba:
MOV RDI,R14
MOV RSI,RBX
CALL 0x0017f0b0
TEST EAX,EAX
JNS 0x001800a3
XOR EAX,EAX
JMP 0x001800d2
LAB_001800cd:
MOV EAX,0xfffffff6
LAB_001800d2:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 mbedtls_mpi_mod_mpi(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
int8 local_40;
int4 local_38 [2];
int8 local_30;
int8 *local_28;
local_40 = 0;
local_38[0] = 1;
local_30 = 1;
local_28 = &local_40;
iVar1 = mbedtls_mpi_cmp_mpi(param_3);
if (iVar1 < 0) {
return 0xfffffff6;
}
uVar2 = mbedtls_mpi_div_mpi(0,param_1,param_2,param_3);
if ((int)uVar2 != 0) {
return uVar2;
}
do {
local_40 = 0;
local_38[0] = 1;
local_30 = 1;
local_28 = &local_40;
iVar1 = mbedtls_mpi_cmp_mpi(param_1,local_38);
if (-1 < iVar1) {
do {
iVar1 = mbedtls_mpi_cmp_mpi(param_1,param_3);
if (iVar1 < 0) {
return 0;
}
uVar2 = add_sub_mpi(param_1,param_1,param_3,0xffffffff);
} while ((int)uVar2 == 0);
return uVar2;
}
uVar2 = add_sub_mpi(param_1,param_1,param_3,1);
} while ((int)uVar2 == 0);
return uVar2;
}
| |
43,318 | mysql_select_db_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_select_db_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_select_db,
(parms->mysql, parms->db),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_select_db_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x40e20
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_select_db_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call mysql_select_db
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_select_db_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_select_db(*a1, a1[1]);
result = v2;
*v2 = 0;
return result;
}
| mysql_select_db_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00140e20
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_select_db_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_select_db(*param_1,param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
43,319 | print_comment | eloqsql/mysys/my_getopt.c | static uint print_comment(const char *comment,
int curpos, int startpos, int width)
{
const char *end= strend(comment);
int endpos= startpos + width;
for (; curpos < startpos; curpos++)
putchar(' ');
if (*comment == '.' || *comment == ',')
{
putchar(*comment);
comment++;
curpos++;
}
while (end - comment > endpos - curpos)
{
const char *line_end;
for (line_end= comment + endpos - curpos;
line_end > comment && *line_end != ' ';
line_end--);
for (; comment < line_end; comment++)
putchar(*comment);
while (*comment == ' ')
comment++; /* skip the space, as a newline will take it's place now */
putchar('\n');
for (curpos= 0; curpos < startpos; curpos++)
putchar(' ');
}
printf("%s", comment);
return curpos + (int)(end - comment);
} | O3 | c | print_comment:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
callq 0x6318c
movq %rax, %r14
cmpl $0x15, %r15d
jg 0x2edf5
addl $-0x16, %r15d
movl $0x20, %edi
callq 0x244c0
incl %r15d
jne 0x2ede0
movl $0x16, %r15d
movzbl (%rbx), %edi
movl %edi, %eax
orl $0x2, %eax
cmpl $0x2e, %eax
jne 0x2ee0d
callq 0x244c0
incq %rbx
incl %r15d
movq %r14, %r12
subq %rbx, %r12
movl $0x4f, %eax
subl %r15d, %eax
cltq
cmpq %rax, %r12
jle 0x2eec0
movl %r15d, %eax
incq %r14
movq %rbx, %r15
subq %rax, %r15
addq $0x4f, %r15
cmpq %rbx, %r15
jbe 0x2ee4c
cmpb $0x20, (%r15)
je 0x2ee4c
decq %r15
cmpq %rbx, %r15
ja 0x2ee3b
movq %rbx, %r15
cmpq %r15, %rbx
jae 0x2ee6c
movq %r15, %r12
subq %rbx, %r12
xorl %r13d, %r13d
movsbl (%rbx,%r13), %edi
callq 0x244c0
incq %r13
cmpq %r13, %r12
jne 0x2ee5a
cmpq %r15, %rbx
cmovaq %rbx, %r15
movq %r14, %r12
subq %r15, %r12
decq %r15
movq %r15, %rbx
decq %r12
cmpb $0x20, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
je 0x2ee7f
movl $0xa, %edi
callq 0x244c0
movl $0x16, %r15d
movl $0x20, %edi
callq 0x244c0
decl %r15d
jne 0x2ee9c
movl $0x16, %eax
cmpq $0x3a, %r12
jge 0x2ee2c
movl $0x16, %r15d
leaq 0x38ea4(%rip), %rsi # 0x67d6b
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x24030
addl %r15d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| print_comment:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, esi
mov rbx, rdi
call strend
mov r14, rax
cmp r15d, 15h
jg short loc_2EDF5
add r15d, 0FFFFFFEAh
loc_2EDE0:
mov edi, 20h ; ' '
call _putchar
inc r15d
jnz short loc_2EDE0
mov r15d, 16h
loc_2EDF5:
movzx edi, byte ptr [rbx]
mov eax, edi
or eax, 2
cmp eax, 2Eh ; '.'
jnz short loc_2EE0D
call _putchar
inc rbx
inc r15d
loc_2EE0D:
mov r12, r14
sub r12, rbx
mov eax, 4Fh ; 'O'
sub eax, r15d
cdqe
cmp r12, rax
jle loc_2EEC0
mov eax, r15d
inc r14
loc_2EE2C:
mov r15, rbx
sub r15, rax
add r15, 4Fh ; 'O'
cmp r15, rbx
jbe short loc_2EE4C
loc_2EE3B:
cmp byte ptr [r15], 20h ; ' '
jz short loc_2EE4C
dec r15
cmp r15, rbx
ja short loc_2EE3B
mov r15, rbx
loc_2EE4C:
cmp rbx, r15
jnb short loc_2EE6C
mov r12, r15
sub r12, rbx
xor r13d, r13d
loc_2EE5A:
movsx edi, byte ptr [rbx+r13]
call _putchar
inc r13
cmp r12, r13
jnz short loc_2EE5A
loc_2EE6C:
cmp rbx, r15
cmova r15, rbx
mov r12, r14
sub r12, r15
dec r15
mov rbx, r15
loc_2EE7F:
dec r12
cmp byte ptr [rbx+1], 20h ; ' '
lea rbx, [rbx+1]
jz short loc_2EE7F
mov edi, 0Ah
call _putchar
mov r15d, 16h
loc_2EE9C:
mov edi, 20h ; ' '
call _putchar
dec r15d
jnz short loc_2EE9C
mov eax, 16h
cmp r12, 3Ah ; ':'
jge loc_2EE2C
mov r15d, 16h
loc_2EEC0:
lea rsi, aAtLineDPosDS+13h; "%s"
mov edi, 1
mov rdx, rbx
xor eax, eax
call ___printf_chk
add r12d, r15d
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long print_comment(const char *a1, int a2)
{
unsigned int v2; // r15d
const char *v3; // rbx
long long v4; // r14
int v5; // r15d
long long v6; // rdi
long long v7; // r12
long long v8; // rax
long long v9; // r14
const char *v10; // r15
long long v11; // r13
int v13; // r15d
v2 = a2;
v3 = a1;
v4 = strend(a1);
if ( a2 <= 21 )
{
v5 = a2 - 22;
do
{
putchar(32LL);
++v5;
}
while ( v5 );
v2 = 22;
}
v6 = *(unsigned __int8 *)a1;
if ( (*(unsigned __int8 *)v3 | 2) == 0x2E )
{
putchar(v6);
++v3;
++v2;
}
LODWORD(v7) = v4 - (_DWORD)v3;
if ( v4 - (long long)v3 > (int)(79 - v2) )
{
v8 = v2;
v9 = v4 + 1;
do
{
v10 = &v3[-v8 + 79];
if ( v10 > v3 )
{
while ( *v10 != 32 )
{
if ( --v10 <= v3 )
{
v10 = v3;
break;
}
}
}
if ( v3 < v10 )
{
v11 = 0LL;
do
putchar((unsigned int)v3[v11++]);
while ( v10 - v3 != v11 );
}
if ( v3 > v10 )
v10 = v3;
v7 = v9 - (_QWORD)v10;
v3 = v10 - 1;
do
--v7;
while ( *++v3 == 32 );
putchar(10LL);
v13 = 22;
do
{
putchar(32LL);
--v13;
}
while ( v13 );
v8 = 22LL;
}
while ( v7 >= 58 );
v2 = 22;
}
__printf_chk(1LL, "%s", v3);
return v2 + (unsigned int)v7;
}
| print_comment:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ESI
MOV RBX,RDI
CALL 0x0016318c
MOV R14,RAX
CMP R15D,0x15
JG 0x0012edf5
ADD R15D,-0x16
LAB_0012ede0:
MOV EDI,0x20
CALL 0x001244c0
INC R15D
JNZ 0x0012ede0
MOV R15D,0x16
LAB_0012edf5:
MOVZX EDI,byte ptr [RBX]
MOV EAX,EDI
OR EAX,0x2
CMP EAX,0x2e
JNZ 0x0012ee0d
CALL 0x001244c0
INC RBX
INC R15D
LAB_0012ee0d:
MOV R12,R14
SUB R12,RBX
MOV EAX,0x4f
SUB EAX,R15D
CDQE
CMP R12,RAX
JLE 0x0012eec0
MOV EAX,R15D
INC R14
LAB_0012ee2c:
MOV R15,RBX
SUB R15,RAX
ADD R15,0x4f
CMP R15,RBX
JBE 0x0012ee4c
LAB_0012ee3b:
CMP byte ptr [R15],0x20
JZ 0x0012ee4c
DEC R15
CMP R15,RBX
JA 0x0012ee3b
MOV R15,RBX
LAB_0012ee4c:
CMP RBX,R15
JNC 0x0012ee6c
MOV R12,R15
SUB R12,RBX
XOR R13D,R13D
LAB_0012ee5a:
MOVSX EDI,byte ptr [RBX + R13*0x1]
CALL 0x001244c0
INC R13
CMP R12,R13
JNZ 0x0012ee5a
LAB_0012ee6c:
CMP RBX,R15
CMOVA R15,RBX
MOV R12,R14
SUB R12,R15
DEC R15
MOV RBX,R15
LAB_0012ee7f:
DEC R12
CMP byte ptr [RBX + 0x1],0x20
LEA RBX,[RBX + 0x1]
JZ 0x0012ee7f
MOV EDI,0xa
CALL 0x001244c0
MOV R15D,0x16
LAB_0012ee9c:
MOV EDI,0x20
CALL 0x001244c0
DEC R15D
JNZ 0x0012ee9c
MOV EAX,0x16
CMP R12,0x3a
JGE 0x0012ee2c
MOV R15D,0x16
LAB_0012eec0:
LEA RSI,[0x167d6b]
MOV EDI,0x1
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00124030
ADD R12D,R15D
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int print_comment(byte *param_1,uint param_2)
{
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uVar4 = (ulong)param_2;
lVar1 = strend();
if ((int)param_2 < 0x16) {
iVar3 = param_2 - 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + 1;
} while (iVar3 != 0);
uVar4 = 0x16;
}
if ((*param_1 | 2) == 0x2e) {
putchar((uint)*param_1);
param_1 = param_1 + 1;
uVar4 = (ulong)((int)uVar4 + 1);
}
lVar2 = lVar1 - (long)param_1;
iVar3 = (int)uVar4;
if (0x4f - iVar3 < lVar2) {
do {
pbVar5 = param_1 + (0x4f - uVar4);
pbVar6 = pbVar5;
for (; (param_1 < pbVar5 && (pbVar6 = pbVar5, *pbVar5 != 0x20)); pbVar5 = pbVar5 + -1) {
pbVar6 = param_1;
}
if (param_1 < pbVar6) {
lVar2 = 0;
do {
putchar((int)(char)param_1[lVar2]);
lVar2 = lVar2 + 1;
} while ((long)pbVar6 - (long)param_1 != lVar2);
}
if (pbVar6 < param_1) {
pbVar6 = param_1;
}
lVar2 = (lVar1 + 1) - (long)pbVar6;
param_1 = pbVar6 + -1;
do {
lVar2 = lVar2 + -1;
pbVar5 = param_1 + 1;
param_1 = param_1 + 1;
} while (*pbVar5 == 0x20);
putchar(10);
iVar3 = 0x16;
do {
putchar(0x20);
iVar3 = iVar3 + -1;
} while (iVar3 != 0);
uVar4 = 0x16;
} while (0x39 < lVar2);
iVar3 = 0x16;
}
__printf_chk(1,"%s",param_1);
return (int)lVar2 + iVar3;
}
| |
43,320 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++() | llama.cpp/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0xba827
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xba818
cmpl $0x1, %eax
jne 0xba81f
addq $0x30, 0x8(%rdi)
jmp 0xba823
addq $0x10, 0x10(%rdi)
jmp 0xba823
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x6aa77(%rip), %rdi # 0x1252a6
leaq 0x61bca(%rip), %rdx # 0x11c400
leaq 0x6f5c3(%rip), %rcx # 0x129e00
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x21ec0
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_BA827
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_BA818
cmp eax, 1
jnz short loc_BA81F
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_BA823
loc_BA818:
add qword ptr [rdi+10h], 10h
jmp short loc_BA823
loc_BA81F:
inc qword ptr [rdi+18h]
loc_BA823:
mov rax, rdi
retn
loc_BA827:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
long long v3; // rdx
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return std::operator+<char>("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp", 13248LL, v3);
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001ba827
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x001ba818
CMP EAX,0x1
JNZ 0x001ba81f
ADD qword ptr [RDI + 0x8],0x30
JMP 0x001ba823
LAB_001ba818:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x001ba823
LAB_001ba81f:
INC qword ptr [RDI + 0x18]
LAB_001ba823:
MOV RAX,RDI
RET
LAB_001ba827:
PUSH RAX
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x229e00]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x00121ec0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
43,321 | calculPerformance(int) | isyoCode[P]yoyologger/test/performance_test.cc | void calculPerformance(int threadum) {
std::cout << "***************************************************************"
"**********************"
<< std::endl;
std::vector<std::thread> vThread;
std::string msg = getTestMessage();
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < threadum; i++) {
vThread.emplace_back(logTest, msg);
}
for (int i = 0; i < threadum; i++) {
vThread[i].join();
}
auto end = std::chrono::high_resolution_clock::now();
auto consume =
std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
int num = ((LogNum * 5 * threadum * 1000) / consume.count());
std::cout << "Process message: " << LogNum * 5 * threadum
<< " consume time: " << consume.count() << " ms" << std::endl;
std::cout << "Total " << threadum << " threads "
<< "average: " << num << " per/second" << std::endl;
std::cout << "Per thread average: " << num / 5 << " per/second" << std::endl;
std::cout << "***************************************************************"
"**********************"
<< std::endl;
} | O2 | cpp | calculPerformance(int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edi, %ebx
movq 0x78a1(%rip), %rdi # 0xafd0
leaq 0x3983(%rip), %rsi # 0x70b9
callq 0x3290
movq %rax, %rdi
callq 0x3110
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x358c
callq 0x3030
movq %rax, 0x20(%rsp)
xorl %r14d, %r14d
testl %ebx, %ebx
cmovgl %ebx, %r14d
leaq -0x125(%rip), %r15 # 0x364f
movq %rsp, %r12
leaq 0x28(%rsp), %r13
movl %r14d, %ebp
subl $0x1, %ebp
jb 0x3794
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3b68
jmp 0x377f
movl %r14d, %r15d
shlq $0x3, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x37b5
movq (%rsp), %rdi
addq %r12, %rdi
callq 0x33b0
addq $0x8, %r12
jmp 0x379e
callq 0x3030
subq 0x20(%rsp), %rax
movl $0xf4240, %ecx # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %r15
movslq %ebx, %r12
movabsq $0x12a05f200, %rax # imm = 0x12A05F200
imulq %r12, %rax
xorl %edx, %edx
divq %r15
movq %rax, %r14
movq 0x77e4(%rip), %rdi # 0xafd0
leaq 0x391c(%rip), %rsi # 0x710f
callq 0x3290
imulq $0x4c4b40, %r12, %rsi # imm = 0x4C4B40
movq %rax, %rdi
callq 0x3190
leaq 0x3913(%rip), %rsi # 0x7121
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movq %r15, %rsi
callq 0x3280
leaq 0x3909(%rip), %rsi # 0x7131
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x3110
movq 0x7791(%rip), %rdi # 0xafd0
leaq 0x38ef(%rip), %rsi # 0x7135
callq 0x3290
movq %rax, %rdi
movl %ebx, %esi
callq 0x33c0
leaq 0x38e0(%rip), %rsi # 0x713c
movq %rax, %rdi
callq 0x3290
leaq 0x38f2(%rip), %rsi # 0x715d
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
movl %r14d, %esi
callq 0x33c0
leaq 0x38c1(%rip), %rsi # 0x7146
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x3110
movq 0x7734(%rip), %rdi # 0xafd0
leaq 0x38af(%rip), %rsi # 0x7152
callq 0x3290
movq %rax, %rdi
pushq $0x5
popq %rcx
movl %r14d, %eax
cltd
idivl %ecx
movl %eax, %esi
callq 0x33c0
leaq 0x3884(%rip), %rsi # 0x7146
movq %rax, %rdi
callq 0x3290
movq %rax, %rdi
callq 0x3110
movq 0x76f7(%rip), %rdi # 0xafd0
leaq 0x37d9(%rip), %rsi # 0x70b9
callq 0x3290
movq %rax, %rdi
callq 0x3110
leaq 0x28(%rsp), %rdi
callq 0x3a22
movq %rsp, %rdi
callq 0x3baa
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3924
jmp 0x3917
jmp 0x3917
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3a22
movq %rsp, %rdi
callq 0x3baa
movq %rbx, %rdi
callq 0x33e0
| _Z17calculPerformancei:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebx, edi
mov rdi, cs:_ZSt4cout_ptr
lea rsi, asc_70B9; "***************************************"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
xorps xmm0, xmm0
movaps [rsp+78h+var_78], xmm0
and [rsp+78h+var_68], 0
lea rdi, [rsp+78h+var_50]; this
call _Z14getTestMessageB5cxx11v; getTestMessage(void)
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rsp+78h+var_58], rax
xor r14d, r14d
test ebx, ebx
cmovg r14d, ebx
lea r15, _Z7logTestNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; logTest(std::string)
mov r12, rsp
lea r13, [rsp+78h+var_50]
mov ebp, r14d
loc_377F:
sub ebp, 1
jb short loc_3794
mov rdi, r12
mov rsi, r15
mov rdx, r13
call _ZNSt6vectorISt6threadSaIS0_EE12emplace_backIJRFvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEERS9_EEERS0_DpOT_; std::vector<std::thread>::emplace_back<void (&)(std::string),std::string&>(void (&)(std::string),std::string&)
jmp short loc_377F
loc_3794:
mov r15d, r14d
shl r15, 3
xor r12d, r12d
loc_379E:
cmp r15, r12
jz short loc_37B5
mov rdi, qword ptr [rsp+78h+var_78]
add rdi, r12; this
call __ZNSt6thread4joinEv; std::thread::join(void)
add r12, 8
jmp short loc_379E
loc_37B5:
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
sub rax, [rsp+78h+var_58]
mov ecx, 0F4240h
cqo
idiv rcx
mov r15, rax
movsxd r12, ebx
mov rax, 12A05F200h
imul rax, r12
xor edx, edx
div r15
mov r14, rax
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aProcessMessage; "Process message: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
imul rsi, r12, 4C4B40h
mov rdi, rax
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, aConsumeTime; " consume time: "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov rsi, r15
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
lea rsi, aMs; " ms"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aTotal; "Total "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aThreads; " threads "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, aPerThreadAvera+0Bh; "average: "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
mov esi, r14d
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aPerSecond; " per/second"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, aPerThreadAvera; "Per thread average: "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
push 5
pop rcx
mov eax, r14d
cdq
idiv ecx
mov esi, eax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aPerSecond; " per/second"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
mov rdi, cs:_ZSt4cout_ptr
lea rsi, asc_70B9; "***************************************"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
lea rdi, [rsp+78h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_3924
jmp short loc_3917
jmp short $+2
loc_3917:
mov rbx, rax
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_3924:
mov rdi, rsp
call _ZNSt6vectorISt6threadSaIS0_EED2Ev; std::vector<std::thread>::~vector()
mov rdi, rbx
call __Unwind_Resume
| long long calculPerformance(int a1)
{
long long v2; // rax
std::chrono::_V2::system_clock *v3; // rdi
unsigned int v4; // r14d
unsigned int v5; // ebp
long long i; // r12
long long v8; // rax
unsigned long long v9; // r15
unsigned long long v10; // r14
long long v11; // rax
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long v15; // rax
long long v16; // rax
long long v17; // rax
long long v18; // rax
long long v19; // rax
long long v20; // rax
long long v21; // rax
long long v22; // rax
long long v23; // rax
long long v24; // rax
long long v25; // rax
__int128 v27; // [rsp+0h] [rbp-78h] BYREF
long long v28; // [rsp+10h] [rbp-68h]
long long v29; // [rsp+20h] [rbp-58h]
_BYTE v30[80]; // [rsp+28h] [rbp-50h] BYREF
v2 = std::operator<<<std::char_traits<char>>(
&std::cout,
"*************************************************************************************");
std::endl<char,std::char_traits<char>>(v2);
v27 = 0LL;
v28 = 0LL;
v3 = (std::chrono::_V2::system_clock *)v30;
getTestMessage[abi:cxx11]((long long)v30);
v29 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)v30);
v4 = 0;
if ( a1 > 0 )
v4 = a1;
v5 = v4;
while ( v5-- != 0 )
{
v3 = (std::chrono::_V2::system_clock *)&v27;
std::vector<std::thread>::emplace_back<void (&)(std::string),std::string&>(&v27, logTest, v30);
}
for ( i = 0LL; 8LL * v4 != i; i += 8LL )
{
v3 = (std::chrono::_V2::system_clock *)(i + v27);
std::thread::join((std::thread *)(i + v27));
}
v8 = std::chrono::_V2::system_clock::now(v3);
v9 = (v8 - v29) / 1000000;
v10 = 5000000000LL * a1 / v9;
v11 = std::operator<<<std::char_traits<char>>(&std::cout, "Process message: ");
v12 = std::ostream::_M_insert<unsigned long>(v11, 5000000LL * a1);
v13 = std::operator<<<std::char_traits<char>>(v12, " consume time: ");
v14 = std::ostream::_M_insert<long>(v13, v9);
v15 = std::operator<<<std::char_traits<char>>(v14, " ms");
std::endl<char,std::char_traits<char>>(v15);
v16 = std::operator<<<std::char_traits<char>>(&std::cout, "Total ");
v17 = std::ostream::operator<<(v16, (unsigned int)a1);
v18 = std::operator<<<std::char_traits<char>>(v17, " threads ");
v19 = std::operator<<<std::char_traits<char>>(v18, "average: ");
v20 = std::ostream::operator<<(v19, (unsigned int)v10);
v21 = std::operator<<<std::char_traits<char>>(v20, " per/second");
std::endl<char,std::char_traits<char>>(v21);
v22 = std::operator<<<std::char_traits<char>>(&std::cout, "Per thread average: ");
v23 = std::ostream::operator<<(v22, (unsigned int)((int)v10 / 5));
v24 = std::operator<<<std::char_traits<char>>(v23, " per/second");
std::endl<char,std::char_traits<char>>(v24);
v25 = std::operator<<<std::char_traits<char>>(
&std::cout,
"*************************************************************************************");
std::endl<char,std::char_traits<char>>(v25);
std::string::~string(v30);
return std::vector<std::thread>::~vector(&v27);
}
| calculPerformance:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,EDI
MOV RDI,qword ptr [0x0010afd0]
LEA RSI,[0x1070b9]
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103110
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
AND qword ptr [RSP + 0x10],0x0
LAB_00103750:
LEA RDI,[RSP + 0x28]
CALL 0x0010358c
CALL 0x00103030
MOV qword ptr [RSP + 0x20],RAX
XOR R14D,R14D
TEST EBX,EBX
CMOVG R14D,EBX
LEA R15,[0x10364f]
MOV R12,RSP
LEA R13,[RSP + 0x28]
MOV EBP,R14D
LAB_0010377f:
SUB EBP,0x1
JC 0x00103794
LAB_00103784:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
CALL 0x00103b68
JMP 0x0010377f
LAB_00103794:
MOV R15D,R14D
SHL R15,0x3
XOR R12D,R12D
LAB_0010379e:
CMP R15,R12
JZ 0x001037b5
MOV RDI,qword ptr [RSP]
ADD RDI,R12
LAB_001037aa:
CALL 0x001033b0
ADD R12,0x8
JMP 0x0010379e
LAB_001037b5:
CALL 0x00103030
SUB RAX,qword ptr [RSP + 0x20]
MOV ECX,0xf4240
CQO
IDIV RCX
MOV R15,RAX
MOVSXD R12,EBX
MOV RAX,0x12a05f200
IMUL RAX,R12
XOR EDX,EDX
DIV R15
MOV R14,RAX
LAB_001037e5:
MOV RDI,qword ptr [0x0010afd0]
LEA RSI,[0x10710f]
CALL 0x00103290
IMUL RSI,R12,0x4c4b40
MOV RDI,RAX
CALL 0x00103190
LEA RSI,[0x107121]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
MOV RSI,R15
CALL 0x00103280
LEA RSI,[0x107131]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103110
MOV RDI,qword ptr [0x0010afd0]
LEA RSI,[0x107135]
CALL 0x00103290
MOV RDI,RAX
MOV ESI,EBX
CALL 0x001033c0
LEA RSI,[0x10713c]
MOV RDI,RAX
CALL 0x00103290
LEA RSI,[0x10715d]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
MOV ESI,R14D
CALL 0x001033c0
LEA RSI,[0x107146]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103110
MOV RDI,qword ptr [0x0010afd0]
LEA RSI,[0x107152]
CALL 0x00103290
MOV RDI,RAX
PUSH 0x5
POP RCX
MOV EAX,R14D
CDQ
IDIV ECX
MOV ESI,EAX
CALL 0x001033c0
LEA RSI,[0x107146]
MOV RDI,RAX
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103110
MOV RDI,qword ptr [0x0010afd0]
LEA RSI,[0x1070b9]
CALL 0x00103290
MOV RDI,RAX
CALL 0x00103110
LAB_001038ed:
LEA RDI,[RSP + 0x28]
CALL 0x00103a22
MOV RDI,RSP
CALL 0x00103baa
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* calculPerformance(int) */
void calculPerformance(int param_1)
{
int1 auVar1 [16];
int1 auVar2 [16];
ostream *poVar3;
int iVar4;
long lVar6;
ulong uVar7;
int8 local_78;
int8 uStack_70;
int8 local_68;
long local_58;
string local_50 [32];
ulong uVar5;
poVar3 = std::operator<<((ostream *)PTR_cout_0010afd0,
"*************************************************************************************"
);
std::endl<char,std::char_traits<char>>(poVar3);
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
/* try { // try from 00103750 to 00103759 has its CatchHandler @ 0010390e */
getTestMessage_abi_cxx11_();
local_58 = std::chrono::_V2::system_clock::now();
uVar7 = 0;
if (0 < param_1) {
uVar7 = (ulong)(uint)param_1;
}
uVar5 = uVar7;
while (iVar4 = (int)uVar5, uVar5 = (ulong)(iVar4 - 1), iVar4 != 0) {
/* try { // try from 00103784 to 00103791 has its CatchHandler @ 00103917 */
std::vector<std::thread,std::allocator<std::thread>>::
emplace_back<void(&)(std::__cxx11::string),std::__cxx11::string&>
((vector<std::thread,std::allocator<std::thread>> *)&local_78,logTest,local_50);
}
for (lVar6 = 0; uVar7 << 3 != lVar6; lVar6 = lVar6 + 8) {
/* try { // try from 001037aa to 001037ae has its CatchHandler @ 00103915 */
std::thread::join();
}
lVar6 = std::chrono::_V2::system_clock::now();
auVar1._8_8_ = 0;
auVar1._0_8_ = (lVar6 - local_58) / 1000000;
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_1 * 5000000000;
/* try { // try from 001037e5 to 001038ec has its CatchHandler @ 00103913 */
poVar3 = std::operator<<((ostream *)PTR_cout_0010afd0,"Process message: ");
poVar3 = std::ostream::_M_insert<unsigned_long>((ulong)poVar3);
poVar3 = std::operator<<(poVar3," consume time: ");
poVar3 = std::ostream::_M_insert<long>((long)poVar3);
poVar3 = std::operator<<(poVar3," ms");
std::endl<char,std::char_traits<char>>(poVar3);
poVar3 = std::operator<<((ostream *)PTR_cout_0010afd0,"Total ");
poVar3 = (ostream *)std::ostream::operator<<(poVar3,param_1);
poVar3 = std::operator<<(poVar3," threads ");
poVar3 = std::operator<<(poVar3,"average: ");
iVar4 = SUB164(auVar2 / auVar1,0);
poVar3 = (ostream *)std::ostream::operator<<(poVar3,iVar4);
poVar3 = std::operator<<(poVar3," per/second");
std::endl<char,std::char_traits<char>>(poVar3);
poVar3 = std::operator<<((ostream *)PTR_cout_0010afd0,"Per thread average: ");
poVar3 = (ostream *)
std::ostream::operator<<
(poVar3,(int)((long)((ulong)(uint)(iVar4 >> 0x1f) << 0x20 |
SUB168(auVar2 / auVar1,0) & 0xffffffff) / 5));
poVar3 = std::operator<<(poVar3," per/second");
std::endl<char,std::char_traits<char>>(poVar3);
poVar3 = std::operator<<((ostream *)PTR_cout_0010afd0,
"*************************************************************************************"
);
std::endl<char,std::char_traits<char>>(poVar3);
std::__cxx11::string::~string(local_50);
std::vector<std::thread,std::allocator<std::thread>>::~vector
((vector<std::thread,std::allocator<std::thread>> *)&local_78);
return;
}
| |
43,322 | mi_keyseg_write | eloqsql/storage/myisam/mi_open.c | int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
{
uchar buff[HA_KEYSEG_SIZE];
uchar *ptr=buff;
ulong pos;
*ptr++= keyseg->type;
*ptr++= keyseg->language & 0xFF; /* Collation ID, low byte */
*ptr++= keyseg->null_bit;
*ptr++= keyseg->bit_start;
*ptr++= keyseg->language >> 8; /* Collation ID, high byte */
*ptr++= keyseg->bit_length;
mi_int2store(ptr,keyseg->flag); ptr+=2;
mi_int2store(ptr,keyseg->length); ptr+=2;
mi_int4store(ptr,keyseg->start); ptr+=4;
pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
mi_int4store(ptr, pos);
ptr+=4;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O3 | c | mi_keyseg_write:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movb 0x18(%rsi), %al
movb %al, -0x30(%rbp)
movzwl 0x16(%rsi), %eax
movb %al, -0x2f(%rbp)
movb 0x19(%rsi), %cl
movb %cl, -0x2e(%rbp)
movb 0x1a(%rsi), %dl
movb %dl, -0x2d(%rbp)
movb %ah, -0x2c(%rbp)
movb 0x1b(%rsi), %al
movb %al, -0x2b(%rbp)
movzwl 0x12(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x2a(%rbp)
movzwl 0x14(%rsi), %eax
rolw $0x8, %ax
movw %ax, -0x28(%rbp)
movl 0x8(%rsi), %eax
bswapl %eax
movl %eax, -0x26(%rbp)
testb %cl, %cl
je 0x3757d
movl 0xc(%rsi), %eax
jmp 0x37581
movzwl 0x10(%rsi), %eax
bswapl %eax
movl %eax, -0x22(%rbp)
leaq 0x2f88c3(%rip), %rax # 0x32fe50
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x375e0
leaq -0x30(%rbp), %rsi
movl $0x12, %edx
movl $0x4, %ecx
movl %ebx, %edi
callq 0x2a351
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %cl
movq %fs:0x28, %rdx
cmpq -0x18(%rbp), %rdx
jne 0x375fa
movb %cl, %al
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rcx
callq 0x295e3
movq (%r14), %rcx
jmp 0x375be
callq 0x283f0
| mi_keyseg_write:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 70h
mov ebx, edi
mov rax, fs:28h
mov [rbp+var_18], rax
mov al, [rsi+18h]
mov [rbp+var_30], al
movzx eax, word ptr [rsi+16h]
mov [rbp+var_2F], al
mov cl, [rsi+19h]
mov [rbp+var_2E], cl
mov dl, [rsi+1Ah]
mov [rbp+var_2D], dl
mov [rbp+var_2C], ah
mov al, [rsi+1Bh]
mov [rbp+var_2B], al
movzx eax, word ptr [rsi+12h]
rol ax, 8
mov [rbp+var_2A], ax
movzx eax, word ptr [rsi+14h]
rol ax, 8
mov [rbp+var_28], ax
mov eax, [rsi+8]
bswap eax
mov [rbp+var_26], eax
test cl, cl
jz short loc_3757D
mov eax, [rsi+0Ch]
jmp short loc_37581
loc_3757D:
movzx eax, word ptr [rsi+10h]
loc_37581:
bswap eax
mov [rbp+var_22], eax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_80]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz short loc_375E0
lea rsi, [rbp+var_30]
mov edx, 12h
mov ecx, 4
mov edi, ebx
call my_write
mov rcx, rax
loc_375BE:
xor eax, eax
test rcx, rcx
setnz cl
mov rdx, fs:28h
cmp rdx, [rbp+var_18]
jnz short loc_375FA
mov al, cl
add rsp, 70h
pop rbx
pop r14
pop rbp
retn
loc_375E0:
lea rdx, [rbp+var_30]
lea r14, [rbp+var_38]
mov rdi, rax
mov esi, ebx
mov rcx, r14
call mi_keyseg_write_cold_1
mov rcx, [r14]
jmp short loc_375BE
loc_375FA:
call ___stack_chk_fail
| bool mi_keyseg_write(unsigned int a1, long long a2)
{
__int16 v2; // ax
unsigned int v3; // eax
long long v4; // rax
long long v5; // rcx
_BYTE v8[72]; // [rsp+0h] [rbp-80h] BYREF
long long v9; // [rsp+48h] [rbp-38h] BYREF
_BYTE v10[2]; // [rsp+50h] [rbp-30h] BYREF
char v11; // [rsp+52h] [rbp-2Eh]
char v12; // [rsp+53h] [rbp-2Dh]
char v13; // [rsp+54h] [rbp-2Ch]
char v14; // [rsp+55h] [rbp-2Bh]
__int16 v15; // [rsp+56h] [rbp-2Ah]
__int16 v16; // [rsp+58h] [rbp-28h]
unsigned __int32 v17; // [rsp+5Ah] [rbp-26h]
unsigned __int32 v18; // [rsp+5Eh] [rbp-22h]
unsigned long long v19; // [rsp+68h] [rbp-18h]
v19 = __readfsqword(0x28u);
v10[0] = *(_BYTE *)(a2 + 24);
v2 = *(_WORD *)(a2 + 22);
v10[1] = v2;
v11 = *(_BYTE *)(a2 + 25);
v12 = *(_BYTE *)(a2 + 26);
v13 = HIBYTE(v2);
v14 = *(_BYTE *)(a2 + 27);
v15 = __ROL2__(*(_WORD *)(a2 + 18), 8);
v16 = __ROL2__(*(_WORD *)(a2 + 20), 8);
v17 = _byteswap_ulong(*(_DWORD *)(a2 + 8));
if ( v11 )
v3 = *(_DWORD *)(a2 + 12);
else
v3 = *(unsigned __int16 *)(a2 + 16);
v18 = _byteswap_ulong(v3);
v4 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v8, a1, 7LL);
if ( v4 )
{
mi_keyseg_write_cold_1(v4, a1, (long long)v10, &v9);
v5 = v9;
}
else
{
v5 = my_write(a1, (long long)v10, 18LL, 4LL);
}
return v5 != 0;
}
| mi_keyseg_write:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV EBX,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV AL,byte ptr [RSI + 0x18]
MOV byte ptr [RBP + -0x30],AL
MOVZX EAX,word ptr [RSI + 0x16]
MOV byte ptr [RBP + -0x2f],AL
MOV CL,byte ptr [RSI + 0x19]
MOV byte ptr [RBP + -0x2e],CL
MOV DL,byte ptr [RSI + 0x1a]
MOV byte ptr [RBP + -0x2d],DL
MOV byte ptr [RBP + -0x2c],AH
MOV AL,byte ptr [RSI + 0x1b]
MOV byte ptr [RBP + -0x2b],AL
MOVZX EAX,word ptr [RSI + 0x12]
ROL AX,0x8
MOV word ptr [RBP + -0x2a],AX
MOVZX EAX,word ptr [RSI + 0x14]
ROL AX,0x8
MOV word ptr [RBP + -0x28],AX
MOV EAX,dword ptr [RSI + 0x8]
BSWAP EAX
MOV dword ptr [RBP + -0x26],EAX
TEST CL,CL
JZ 0x0013757d
MOV EAX,dword ptr [RSI + 0xc]
JMP 0x00137581
LAB_0013757d:
MOVZX EAX,word ptr [RSI + 0x10]
LAB_00137581:
BSWAP EAX
MOV dword ptr [RBP + -0x22],EAX
LEA RAX,[0x42fe50]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x80]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001375e0
LEA RSI,[RBP + -0x30]
MOV EDX,0x12
MOV ECX,0x4
MOV EDI,EBX
CALL 0x0012a351
MOV RCX,RAX
LAB_001375be:
XOR EAX,EAX
TEST RCX,RCX
SETNZ CL
MOV RDX,qword ptr FS:[0x28]
CMP RDX,qword ptr [RBP + -0x18]
JNZ 0x001375fa
MOV AL,CL
ADD RSP,0x70
POP RBX
POP R14
POP RBP
RET
LAB_001375e0:
LEA RDX,[RBP + -0x30]
LEA R14,[RBP + -0x38]
MOV RDI,RAX
MOV ESI,EBX
MOV RCX,R14
CALL 0x001295e3
MOV RCX,qword ptr [R14]
JMP 0x001375be
LAB_001375fa:
CALL 0x001283f0
|
bool mi_keyseg_write(int4 param_1,long param_2)
{
uint uVar1;
long lVar2;
long in_FS_OFFSET;
int1 local_88 [72];
long local_40;
int1 local_38;
int1 local_37;
char local_36;
int1 local_35;
int1 local_34;
int1 local_33;
ushort local_32;
ushort local_30;
uint local_2e;
uint local_2a;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = *(int1 *)(param_2 + 0x18);
local_37 = (int1)*(int2 *)(param_2 + 0x16);
local_36 = *(char *)(param_2 + 0x19);
local_35 = *(int1 *)(param_2 + 0x1a);
local_34 = (int1)((ushort)*(int2 *)(param_2 + 0x16) >> 8);
local_33 = *(int1 *)(param_2 + 0x1b);
local_32 = *(ushort *)(param_2 + 0x12) << 8 | *(ushort *)(param_2 + 0x12) >> 8;
local_30 = *(ushort *)(param_2 + 0x14) << 8 | *(ushort *)(param_2 + 0x14) >> 8;
uVar1 = *(uint *)(param_2 + 8);
local_2e = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
if (local_36 == '\0') {
uVar1 = (uint)*(ushort *)(param_2 + 0x10);
}
else {
uVar1 = *(uint *)(param_2 + 0xc);
}
local_2a = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
lVar2 = (**(code **)(PSI_server + 0x158))(local_88,param_1,7);
if (lVar2 == 0) {
local_40 = my_write(param_1,&local_38,0x12,4);
}
else {
mi_keyseg_write_cold_1(lVar2,param_1,&local_38,&local_40);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return local_40 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,323 | intx_shr | corpus-core[P]colibri-stateless/build_O1/_deps/intx-src/include/intx/intx.hpp | inline constexpr uint<N> operator>>(const uint<N>& x, const T& shift) noexcept
{
if (shift < T{sizeof(x) * 8})
return x >> static_cast<uint64_t>(shift);
return 0;
} | O1 | cpp | intx_shr:
cmpl $0xff, %edx
ja 0x818b6
pushq %r14
pushq %rbx
movq (%rsi), %rbx
movq 0x8(%rsi), %r8
bswapq %r8
bswapq %rbx
movl %edx, %eax
cmpl $0x7f, %edx
ja 0x818c6
cmpl $0x3f, %edx
ja 0x818f3
movq %r8, %r10
movl %eax, %ecx
shrq %cl, %r10
leaq (%rbx,%rbx), %r9
notb %cl
shlq %cl, %r9
orq %r10, %r9
movq %rbx, %r10
movl %eax, %ecx
shrq %cl, %r10
jmp 0x818fe
xorl %esi, %esi
xorl %r11d, %r11d
xorl %r9d, %r9d
xorl %r10d, %r10d
jmp 0x8198d
leaq -0x80(%rax), %rdx
cmpq $0x3f, %rdx
ja 0x81922
movl %edx, %ecx
shrq %cl, %r8
leaq (%rbx,%rbx), %rsi
notb %al
movl %eax, %ecx
shlq %cl, %rsi
movl %edx, %ecx
shrq %cl, %rbx
orq %r8, %rsi
xorl %r9d, %r9d
movq %rbx, %r11
jmp 0x81987
movq %rbx, %r9
movl %eax, %ecx
shrq %cl, %r9
xorl %r10d, %r10d
movq 0x10(%rsi), %r11
movl %eax, %ecx
cmpl $0x40, %edx
jb 0x81935
xorb $0x7f, %cl
movq %r8, %r14
shlq %cl, %r14
shlq %cl, %rbx
shrq %r8
movl %eax, %ecx
shrq %cl, %r8
orq %rbx, %r8
jmp 0x8193d
cmpq $0x7f, %rdx
ja 0x8197f
movl %eax, %ecx
shrq %cl, %rbx
xorl %r11d, %r11d
movq %rbx, %rsi
jmp 0x81984
notb %cl
shlq %cl, %r8
xorl %r14d, %r14d
bswapq %r11
shldq $0x1, %r14, %r8
addq %r14, %r14
cmpl $0x3f, %edx
ja 0x8196c
movq 0x18(%rsi), %rdx
bswapq %rdx
movl %eax, %ecx
shrq %cl, %rdx
leaq (%r11,%r11), %rsi
notb %cl
shlq %cl, %rsi
orq %rdx, %rsi
movl %eax, %ecx
shrq %cl, %r11
jmp 0x81977
movl %eax, %ecx
shrq %cl, %r11
movq %r11, %rsi
xorl %r11d, %r11d
orq %r8, %r11
orq %r14, %rsi
jmp 0x8198a
xorl %esi, %esi
xorl %r11d, %r11d
xorl %r9d, %r9d
xorl %r10d, %r10d
popq %rbx
popq %r14
bswapq %rsi
bswapq %r11
bswapq %r9
bswapq %r10
movq %r10, (%rdi)
movq %r9, 0x8(%rdi)
movq %r11, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
retq
| intx_shr:
cmp edx, 0FFh
ja short loc_818B6
push r14
push rbx
mov rbx, [rsi]
mov r8, [rsi+8]
bswap r8
bswap rbx
mov eax, edx
cmp edx, 7Fh
ja short loc_818C6
cmp edx, 3Fh ; '?'
ja short loc_818F3
mov r10, r8
mov ecx, eax
shr r10, cl
lea r9, [rbx+rbx]
not cl
shl r9, cl
or r9, r10
mov r10, rbx
mov ecx, eax
shr r10, cl
jmp short loc_818FE
loc_818B6:
xor esi, esi
xor r11d, r11d
xor r9d, r9d
xor r10d, r10d
jmp loc_8198D
loc_818C6:
lea rdx, [rax-80h]
cmp rdx, 3Fh ; '?'
ja short loc_81922
mov ecx, edx
shr r8, cl
lea rsi, [rbx+rbx]
not al
mov ecx, eax
shl rsi, cl
mov ecx, edx
shr rbx, cl
or rsi, r8
xor r9d, r9d
mov r11, rbx
jmp loc_81987
loc_818F3:
mov r9, rbx
mov ecx, eax
shr r9, cl
xor r10d, r10d
loc_818FE:
mov r11, [rsi+10h]
mov ecx, eax
cmp edx, 40h ; '@'
jb short loc_81935
xor cl, 7Fh
mov r14, r8
shl r14, cl
shl rbx, cl
shr r8, 1
mov ecx, eax
shr r8, cl
or r8, rbx
jmp short loc_8193D
loc_81922:
cmp rdx, 7Fh
ja short loc_8197F
mov ecx, eax
shr rbx, cl
xor r11d, r11d
mov rsi, rbx
jmp short loc_81984
loc_81935:
not cl
shl r8, cl
xor r14d, r14d
loc_8193D:
bswap r11
shld r8, r14, 1
add r14, r14
cmp edx, 3Fh ; '?'
ja short loc_8196C
mov rdx, [rsi+18h]
bswap rdx
mov ecx, eax
shr rdx, cl
lea rsi, [r11+r11]
not cl
shl rsi, cl
or rsi, rdx
mov ecx, eax
shr r11, cl
jmp short loc_81977
loc_8196C:
mov ecx, eax
shr r11, cl
mov rsi, r11
xor r11d, r11d
loc_81977:
or r11, r8
or rsi, r14
jmp short loc_8198A
loc_8197F:
xor esi, esi
xor r11d, r11d
loc_81984:
xor r9d, r9d
loc_81987:
xor r10d, r10d
loc_8198A:
pop rbx
pop r14
loc_8198D:
bswap rsi
bswap r11
bswap r9
bswap r10
mov [rdi], r10
mov [rdi+8], r9
mov [rdi+10h], r11
mov [rdi+18h], rsi
retn
| void intx_shr(_QWORD *a1, unsigned long long *a2, unsigned int a3)
{
unsigned long long v3; // r8
unsigned long long v4; // rbx
long long v5; // rax
unsigned long long v6; // r9
unsigned long long v7; // r10
unsigned long long v8; // rsi
unsigned long long v9; // r11
unsigned long long v10; // rdx
unsigned long long v11; // r14
unsigned long long v12; // r8
unsigned long long v13; // r11
long long v14; // r8
__int128 v15; // rt0
long long v16; // r14
unsigned long long v17; // rsi
unsigned long long v18; // r11
if ( a3 > 0xFF )
{
v8 = 0LL;
v9 = 0LL;
v6 = 0LL;
v7 = 0LL;
}
else
{
v3 = _byteswap_uint64(a2[1]);
v4 = _byteswap_uint64(*a2);
v5 = a3;
if ( a3 > 0x7F )
{
v10 = a3 - 128LL;
if ( (unsigned long long)(v5 - 128) > 0x3F )
{
if ( v10 > 0x7F )
{
v8 = 0LL;
v9 = 0LL;
}
else
{
v9 = 0LL;
v8 = v4 >> v5;
}
v6 = 0LL;
}
else
{
v8 = (v3 >> v10) | ((2 * v4) << ~(_BYTE)v5);
v6 = 0LL;
v9 = v4 >> v10;
}
v7 = 0LL;
}
else
{
if ( a3 > 0x3F )
{
v6 = v4 >> a3;
v7 = 0LL;
}
else
{
v6 = (v3 >> a3) | ((2 * v4) << ~(_BYTE)a3);
v7 = v4 >> a3;
}
if ( a3 < 0x40 )
{
v12 = v3 << ~(_BYTE)a3;
v11 = 0LL;
}
else
{
v11 = v3 << (a3 ^ 0x7F);
v12 = (v4 << (a3 ^ 0x7F)) | (v3 >> 1 >> a3);
}
v13 = _byteswap_uint64(a2[2]);
*((_QWORD *)&v15 + 1) = v12;
*(_QWORD *)&v15 = v11;
v14 = v15 >> 63;
v16 = 2 * v11;
if ( a3 > 0x3F )
{
v17 = v13 >> a3;
v18 = 0LL;
}
else
{
v17 = (_byteswap_uint64(a2[3]) >> a3) | ((2 * v13) << ~(_BYTE)a3);
v18 = v13 >> a3;
}
v9 = v14 | v18;
v8 = v16 | v17;
}
}
*a1 = _byteswap_uint64(v7);
a1[1] = _byteswap_uint64(v6);
a1[2] = _byteswap_uint64(v9);
a1[3] = _byteswap_uint64(v8);
}
| intx_shr:
CMP EDX,0xff
JA 0x001818b6
PUSH R14
PUSH RBX
MOV RBX,qword ptr [RSI]
MOV R8,qword ptr [RSI + 0x8]
BSWAP R8
BSWAP RBX
MOV EAX,EDX
CMP EDX,0x7f
JA 0x001818c6
CMP EDX,0x3f
JA 0x001818f3
MOV R10,R8
MOV ECX,EAX
SHR R10,CL
LEA R9,[RBX + RBX*0x1]
NOT CL
SHL R9,CL
OR R9,R10
MOV R10,RBX
MOV ECX,EAX
SHR R10,CL
JMP 0x001818fe
LAB_001818b6:
XOR ESI,ESI
XOR R11D,R11D
XOR R9D,R9D
XOR R10D,R10D
JMP 0x0018198d
LAB_001818c6:
LEA RDX,[RAX + -0x80]
CMP RDX,0x3f
JA 0x00181922
MOV ECX,EDX
SHR R8,CL
LEA RSI,[RBX + RBX*0x1]
NOT AL
MOV ECX,EAX
SHL RSI,CL
MOV ECX,EDX
SHR RBX,CL
OR RSI,R8
XOR R9D,R9D
MOV R11,RBX
JMP 0x00181987
LAB_001818f3:
MOV R9,RBX
MOV ECX,EAX
SHR R9,CL
XOR R10D,R10D
LAB_001818fe:
MOV R11,qword ptr [RSI + 0x10]
MOV ECX,EAX
CMP EDX,0x40
JC 0x00181935
XOR CL,0x7f
MOV R14,R8
SHL R14,CL
SHL RBX,CL
SHR R8,0x1
MOV ECX,EAX
SHR R8,CL
OR R8,RBX
JMP 0x0018193d
LAB_00181922:
CMP RDX,0x7f
JA 0x0018197f
MOV ECX,EAX
SHR RBX,CL
XOR R11D,R11D
MOV RSI,RBX
JMP 0x00181984
LAB_00181935:
NOT CL
SHL R8,CL
XOR R14D,R14D
LAB_0018193d:
BSWAP R11
SHLD R8,R14,0x1
ADD R14,R14
CMP EDX,0x3f
JA 0x0018196c
MOV RDX,qword ptr [RSI + 0x18]
BSWAP RDX
MOV ECX,EAX
SHR RDX,CL
LEA RSI,[R11 + R11*0x1]
NOT CL
SHL RSI,CL
OR RSI,RDX
MOV ECX,EAX
SHR R11,CL
JMP 0x00181977
LAB_0018196c:
MOV ECX,EAX
SHR R11,CL
MOV RSI,R11
XOR R11D,R11D
LAB_00181977:
OR R11,R8
OR RSI,R14
JMP 0x0018198a
LAB_0018197f:
XOR ESI,ESI
XOR R11D,R11D
LAB_00181984:
XOR R9D,R9D
LAB_00181987:
XOR R10D,R10D
LAB_0018198a:
POP RBX
POP R14
LAB_0018198d:
BSWAP RSI
BSWAP R11
BSWAP R9
BSWAP R10
MOV qword ptr [RDI],R10
MOV qword ptr [RDI + 0x8],R9
MOV qword ptr [RDI + 0x10],R11
MOV qword ptr [RDI + 0x18],RSI
RET
|
void intx_shr(ulong *param_1,ulong *param_2,uint param_3)
{
byte bVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
if (param_3 < 0x100) {
uVar6 = *param_2;
uVar2 = param_2[1];
uVar3 = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18 |
(uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 |
(uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
uVar2 = uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18 |
(uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 | (uVar6 & 0xff0000) << 0x18 |
(uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
bVar1 = (byte)param_3;
if (param_3 < 0x80) {
if (param_3 < 0x40) {
uVar4 = uVar2 * 2 << (~bVar1 & 0x3f) | uVar3 >> (bVar1 & 0x3f);
uVar5 = uVar2 >> (bVar1 & 0x3f);
}
else {
uVar4 = uVar2 >> (bVar1 & 0x3f);
uVar5 = 0;
}
uVar6 = param_2[2];
if (param_3 < 0x40) {
uVar3 = uVar3 << (~bVar1 & 0x3f);
uVar7 = 0;
}
else {
uVar7 = uVar3 << ((bVar1 ^ 0x7f) & 0x3f);
uVar3 = (uVar3 >> 1) >> (bVar1 & 0x3f) | uVar2 << ((bVar1 ^ 0x7f) & 0x3f);
}
uVar6 = uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18
| (uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 | (uVar6 & 0xff0000) << 0x18
| (uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
if (param_3 < 0x40) {
uVar2 = param_2[3];
uVar2 = uVar6 * 2 << (~bVar1 & 0x3f) |
(uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 |
(uVar2 & 0xff0000000000) >> 0x18 | (uVar2 & 0xff00000000) >> 8 |
(uVar2 & 0xff000000) << 8 | (uVar2 & 0xff0000) << 0x18 | (uVar2 & 0xff00) << 0x28 |
uVar2 << 0x38) >> (bVar1 & 0x3f);
uVar6 = uVar6 >> (bVar1 & 0x3f);
}
else {
uVar2 = uVar6 >> (bVar1 & 0x3f);
uVar6 = 0;
}
uVar6 = uVar6 | uVar3 << 1 | uVar7 >> 0x3f;
uVar2 = uVar2 | uVar7 * 2;
}
else {
uVar4 = (ulong)param_3 - 0x80;
if (uVar4 < 0x40) {
uVar6 = uVar2 >> ((byte)uVar4 & 0x3f);
uVar2 = uVar2 * 2 << (~bVar1 & 0x3f) | uVar3 >> ((byte)uVar4 & 0x3f);
}
else {
if (uVar4 < 0x80) {
uVar2 = uVar2 >> (bVar1 & 0x3f);
}
else {
uVar2 = 0;
}
uVar6 = 0;
}
uVar4 = 0;
uVar5 = 0;
}
}
else {
uVar2 = 0;
uVar6 = 0;
uVar4 = 0;
uVar5 = 0;
}
*param_1 = uVar5 >> 0x38 | (uVar5 & 0xff000000000000) >> 0x28 | (uVar5 & 0xff0000000000) >> 0x18 |
(uVar5 & 0xff00000000) >> 8 | (uVar5 & 0xff000000) << 8 | (uVar5 & 0xff0000) << 0x18 |
(uVar5 & 0xff00) << 0x28 | uVar5 << 0x38;
param_1[1] = uVar4 >> 0x38 | (uVar4 & 0xff000000000000) >> 0x28 | (uVar4 & 0xff0000000000) >> 0x18
| (uVar4 & 0xff00000000) >> 8 | (uVar4 & 0xff000000) << 8 |
(uVar4 & 0xff0000) << 0x18 | (uVar4 & 0xff00) << 0x28 | uVar4 << 0x38;
param_1[2] = uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18
| (uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 |
(uVar6 & 0xff0000) << 0x18 | (uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
param_1[3] = uVar2 >> 0x38 | (uVar2 & 0xff000000000000) >> 0x28 | (uVar2 & 0xff0000000000) >> 0x18
| (uVar2 & 0xff00000000) >> 8 | (uVar2 & 0xff000000) << 8 |
(uVar2 & 0xff0000) << 0x18 | (uVar2 & 0xff00) << 0x28 | uVar2 << 0x38;
return;
}
| |
43,324 | my_base64_decoder_skip_spaces | eloqsql/mysys/base64.c | static inline my_bool
my_base64_decoder_skip_spaces(MY_BASE64_DECODER *decoder)
{
for ( ; decoder->src < decoder->end; decoder->src++)
{
if (from_base64_table[(uchar) *decoder->src] != -2)
return FALSE;
}
if (decoder->state > 0)
decoder->error= 1; /* Unexpected end-of-input found */
return TRUE;
} | O0 | c | my_base64_decoder_skip_spaces:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x27e5d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1a56b4(%rip), %rax # 0x1cd4f0
movsbl (%rax,%rcx), %eax
cmpl $-0x2, %eax
je 0x27e4b
movb $0x0, -0x1(%rbp)
jmp 0x27e79
jmp 0x27e4d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x27e18
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x0, %eax
jle 0x27e75
movq -0x10(%rbp), %rax
movl $0x1, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
| my_base64_decoder_skip_spaces:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
loc_27E18:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jnb short loc_27E5D
mov rax, [rbp+var_10]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, from_base64_table
movsx eax, byte ptr [rax+rcx]
cmp eax, 0FFFFFFFEh
jz short loc_27E4B
mov [rbp+var_1], 0
jmp short loc_27E79
loc_27E4B:
jmp short $+2
loc_27E4D:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
jmp short loc_27E18
loc_27E5D:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+18h]
cmp eax, 0
jle short loc_27E75
mov rax, [rbp+var_10]
mov dword ptr [rax+14h], 1
loc_27E75:
mov [rbp+var_1], 1
loc_27E79:
mov al, [rbp+var_1]
pop rbp
retn
| char my_base64_decoder_skip_spaces(unsigned __int8 **a1)
{
while ( *a1 < a1[1] )
{
if ( from_base64_table[**a1] != -2 )
return 0;
++*a1;
}
if ( *((_BYTE *)a1 + 24) )
*((_DWORD *)a1 + 5) = 1;
return 1;
}
| my_base64_decoder_skip_spaces:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
LAB_00127e18:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JNC 0x00127e5d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x2cd4f0]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,-0x2
JZ 0x00127e4b
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00127e79
LAB_00127e4b:
JMP 0x00127e4d
LAB_00127e4d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
JMP 0x00127e18
LAB_00127e5d:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x18]
CMP EAX,0x0
JLE 0x00127e75
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],0x1
LAB_00127e75:
MOV byte ptr [RBP + -0x1],0x1
LAB_00127e79:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 my_base64_decoder_skip_spaces(ulong *param_1)
{
while( true ) {
if (param_1[1] <= *param_1) {
if ((char)param_1[3] != '\0') {
*(int4 *)((long)param_1 + 0x14) = 1;
}
return 1;
}
if (from_base64_table[*(byte *)*param_1] != -2) break;
*param_1 = *param_1 + 1;
}
return 0;
}
| |
43,325 | ggml_repeat_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_repeat_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_repeat(b, a));
struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS, b->ne);
result->op = GGML_OP_REPEAT_BACK;
result->src[0] = a;
return result;
} | O2 | c | ggml_repeat_back:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1ef60
testb %al, %al
je 0x22073
movl (%rbx), %esi
addq $0x10, %r14
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1d260
movl $0x13, 0x50(%rax)
movq %rbx, 0x98(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2c509(%rip), %rdi # 0x4e583
leaq 0x2c554(%rip), %rdx # 0x4e5d5
leaq 0x2c76c(%rip), %rcx # 0x4e7f4
movl $0x905, %esi # imm = 0x905
xorl %eax, %eax
callq 0x1f9b0
| ggml_repeat_back:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rdi, rdx
call _ggml_can_repeat
test al, al
jz short loc_22073
mov esi, [rbx]
add r14, 10h
push 4
pop rdx
mov rdi, r15
mov rcx, r14
call _ggml_new_tensor
mov dword ptr [rax+50h], 13h
mov [rax+98h], rbx
pop rbx
pop r14
pop r15
retn
loc_22073:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatB; "ggml_can_repeat(b, a)"
mov esi, 905h
xor eax, eax
call _ggml_abort
| long long ggml_repeat_back(
long long a1,
long long *a2,
_QWORD *a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
long long result; // rax
char v17; // [rsp+0h] [rbp-18h]
if ( !ggml_can_repeat(a3, a2) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
2309,
(long long)"GGML_ASSERT(%s) failed",
(long long)"ggml_can_repeat(b, a)",
v12,
v13,
a4,
a5,
a6,
a7,
v14,
v15,
a10,
a11,
v17);
result = ggml_new_tensor(a1, *(unsigned int *)a2, 4LL, (long long)(a3 + 2));
*(_DWORD *)(result + 80) = 19;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_repeat_back:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x0011ef60
TEST AL,AL
JZ 0x00122073
MOV ESI,dword ptr [RBX]
ADD R14,0x10
PUSH 0x4
POP RDX
MOV RDI,R15
MOV RCX,R14
CALL 0x0011d260
MOV dword ptr [RAX + 0x50],0x13
MOV qword ptr [RAX + 0x98],RBX
POP RBX
POP R14
POP R15
RET
LAB_00122073:
LEA RDI,[0x14e583]
LEA RDX,[0x14e5d5]
LEA RCX,[0x14e7f4]
MOV ESI,0x905
XOR EAX,EAX
CALL 0x0011f9b0
|
void ggml_repeat_back(int8 param_1,int4 *param_2,long param_3)
{
char cVar1;
long lVar2;
cVar1 = ggml_can_repeat(param_3);
if (cVar1 != '\0') {
lVar2 = ggml_new_tensor(param_1,*param_2,4,param_3 + 0x10);
*(int4 *)(lVar2 + 0x50) = 0x13;
*(int4 **)(lVar2 + 0x98) = param_2;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x905,"GGML_ASSERT(%s) failed","ggml_can_repeat(b, a)");
}
| |
43,326 | ggml_repeat_back | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_tensor * ggml_repeat_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_repeat(b, a));
struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS, b->ne);
result->op = GGML_OP_REPEAT_BACK;
result->src[0] = a;
return result;
} | O3 | c | ggml_repeat_back:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x175c0
testb %al, %al
je 0x1b604
movl (%rbx), %esi
addq $0x10, %r14
movq %r15, %rdi
movl $0x4, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a57f
movl $0x13, 0x50(%rax)
movq %rbx, 0x98(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x31008(%rip), %rdi # 0x4c613
leaq 0x31053(%rip), %rdx # 0x4c665
leaq 0x3126b(%rip), %rcx # 0x4c884
movl $0x905, %esi # imm = 0x905
xorl %eax, %eax
callq 0x17cd0
| ggml_repeat_back:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rdi, rdx
call _ggml_can_repeat
test al, al
jz short loc_1B604
mov esi, [rbx]
add r14, 10h
mov rdi, r15
mov edx, 4
mov rcx, r14
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov dword ptr [rax+50h], 13h
mov [rax+98h], rbx
pop rbx
pop r14
pop r15
retn
loc_1B604:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlCanRepeatB; "ggml_can_repeat(b, a)"
mov esi, 905h
xor eax, eax
call _ggml_abort
| long long ggml_repeat_back(long long a1, long long *a2, _QWORD *a3, double a4)
{
int v5; // r8d
int v6; // r9d
long long result; // rax
if ( !ggml_can_repeat(a3, a2) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
2309,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"ggml_can_repeat(b, a)",
v5,
v6);
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4u, a3 + 2, 0LL, 0LL, a4);
*(_DWORD *)(result + 80) = 19;
*(_QWORD *)(result + 152) = a2;
return result;
}
| ggml_repeat_back:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x001175c0
TEST AL,AL
JZ 0x0011b604
MOV ESI,dword ptr [RBX]
ADD R14,0x10
MOV RDI,R15
MOV EDX,0x4
MOV RCX,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011a57f
MOV dword ptr [RAX + 0x50],0x13
MOV qword ptr [RAX + 0x98],RBX
POP RBX
POP R14
POP R15
RET
LAB_0011b604:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14c884]
MOV ESI,0x905
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_repeat_back(int8 param_1,int4 *param_2,long param_3)
{
char cVar1;
long lVar2;
cVar1 = ggml_can_repeat(param_3);
if (cVar1 != '\0') {
lVar2 = ggml_new_tensor_impl(param_1,*param_2,4,param_3 + 0x10,0,0);
*(int4 *)(lVar2 + 0x50) = 0x13;
*(int4 **)(lVar2 + 0x98) = param_2;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x905,"GGML_ASSERT(%s) failed","ggml_can_repeat(b, a)");
}
| |
43,327 | reset_events_waits_by_class() | eloqsql/storage/perfschema/pfs_instr_class.cc | void reset_events_waits_by_class()
{
reset_file_class_io();
reset_socket_class_io();
global_idle_stat.reset();
global_table_io_stat.reset();
global_table_lock_stat.reset();
global_metadata_stat.reset();
} | O0 | cpp | reset_events_waits_by_class():
pushq %rbp
movq %rsp, %rbp
callq 0x44660
callq 0x446c0
leaq 0x3c800b(%rip), %rdi # 0x40c640
callq 0x30360
leaq 0x3c803f(%rip), %rdi # 0x40c680
callq 0x456f0
leaq 0x3c80f3(%rip), %rdi # 0x40c740
callq 0x45050
leaq 0x3c8267(%rip), %rdi # 0x40c8c0
callq 0x30360
popq %rbp
retq
| _Z27reset_events_waits_by_classv:
push rbp
mov rbp, rsp
call _Z19reset_file_class_iov; reset_file_class_io(void)
call _Z21reset_socket_class_iov; reset_socket_class_io(void)
lea rdi, global_idle_stat; this
call _ZN15PFS_single_stat5resetEv; PFS_single_stat::reset(void)
lea rdi, global_table_io_stat; this
call _ZN17PFS_table_io_stat5resetEv; PFS_table_io_stat::reset(void)
lea rdi, global_table_lock_stat; this
call _ZN19PFS_table_lock_stat5resetEv; PFS_table_lock_stat::reset(void)
lea rdi, global_metadata_stat; this
call _ZN15PFS_single_stat5resetEv; PFS_single_stat::reset(void)
pop rbp
retn
| PFS_single_stat *reset_events_waits_by_class(void)
{
reset_file_class_io();
reset_socket_class_io();
PFS_single_stat::reset((PFS_single_stat *)&global_idle_stat);
PFS_table_io_stat::reset((PFS_table_io_stat *)&global_table_io_stat);
PFS_table_lock_stat::reset((PFS_table_lock_stat *)&global_table_lock_stat);
return PFS_single_stat::reset((PFS_single_stat *)&global_metadata_stat);
}
| reset_events_waits_by_class:
PUSH RBP
MOV RBP,RSP
CALL 0x00144660
CALL 0x001446c0
LEA RDI,[0x50c640]
CALL 0x00130360
LEA RDI,[0x50c680]
CALL 0x001456f0
LEA RDI,[0x50c740]
CALL 0x00145050
LEA RDI,[0x50c8c0]
CALL 0x00130360
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_events_waits_by_class() */
void reset_events_waits_by_class(void)
{
reset_file_class_io();
reset_socket_class_io();
PFS_single_stat::reset((PFS_single_stat *)global_idle_stat);
PFS_table_io_stat::reset((PFS_table_io_stat *)global_table_io_stat);
PFS_table_lock_stat::reset((PFS_table_lock_stat *)global_table_lock_stat);
PFS_single_stat::reset((PFS_single_stat *)global_metadata_stat);
return;
}
| |
43,328 | ggml_backend_sched_reserve | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | bool ggml_backend_sched_reserve(ggml_backend_sched_t sched, struct ggml_cgraph * measure_graph) {
GGML_ASSERT((int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs);
ggml_backend_sched_split_graph(sched, measure_graph);
ggml_backend_sched_synchronize(sched);
if (!ggml_gallocr_reserve_n(sched->galloc, &sched->graph, sched->node_backend_ids, sched->leaf_backend_ids)) {
return false;
}
ggml_backend_sched_reset(sched);
return true;
} | O0 | cpp | ggml_backend_sched_reserve:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jge 0x5f87e
leaq 0x553b3(%rip), %rdi # 0xb4c17
movl $0x605, %esi # imm = 0x605
leaq 0x51d99(%rip), %rdx # 0xb1609
leaq 0x55857(%rip), %rcx # 0xb50ce
movb $0x0, %al
callq 0x48a00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f8f0
movq -0x10(%rbp), %rdi
callq 0x47190
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x158, %rsi # imm = 0x158
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rcx
callq 0x46c70
testb $0x1, %al
jne 0x5f8cf
movb $0x0, -0x1(%rbp)
jmp 0x5f8dc
movq -0x10(%rbp), %rdi
callq 0x447e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| ggml_backend_sched_reserve:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+110h]
mov rcx, [rbp+var_18]
mov ecx, [rcx+4]
mov rdx, [rbp+var_18]
add ecx, [rdx+8]
cmp eax, ecx
jge short loc_5F87E
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 605h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aIntSchedHashSe; "(int)sched->hash_set.size >= measure_gr"...
mov al, 0
call _ggml_abort
loc_5F87E:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _ZL30ggml_backend_sched_split_graphP18ggml_backend_schedP11ggml_cgraph; ggml_backend_sched_split_graph(ggml_backend_sched *,ggml_cgraph *)
mov rdi, [rbp+var_10]
call _ggml_backend_sched_synchronize
mov rax, [rbp+var_10]
mov rdi, [rax+108h]
mov rsi, [rbp+var_10]
add rsi, 158h
mov rax, [rbp+var_10]
mov rdx, [rax+138h]
mov rax, [rbp+var_10]
mov rcx, [rax+140h]
call _ggml_gallocr_reserve_n
test al, 1
jnz short loc_5F8CF
mov [rbp+var_1], 0
jmp short loc_5F8DC
loc_5F8CF:
mov rdi, [rbp+var_10]
call _ggml_backend_sched_reset
mov [rbp+var_1], 1
loc_5F8DC:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char ggml_backend_sched_reserve(long long *a1, long long a2)
{
if ( (int)a1[34] < *(_DWORD *)(a2 + 8) + *(_DWORD *)(a2 + 4) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1541,
(long long)"GGML_ASSERT(%s) failed",
"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs");
ggml_backend_sched_split_graph(a1, a2);
ggml_backend_sched_synchronize(a1);
if ( (ggml_gallocr_reserve_n(a1[33], (long long)(a1 + 43), a1[39], a1[40]) & 1) == 0 )
return 0;
ggml_backend_sched_reset(a1);
return 1;
}
| ggml_backend_sched_reserve:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x110]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD ECX,dword ptr [RDX + 0x8]
CMP EAX,ECX
JGE 0x0015f87e
LEA RDI,[0x1b4c17]
MOV ESI,0x605
LEA RDX,[0x1b1609]
LEA RCX,[0x1b50ce]
MOV AL,0x0
CALL 0x00148a00
LAB_0015f87e:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0015f8f0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00147190
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x108]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x158
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x138]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x140]
CALL 0x00146c70
TEST AL,0x1
JNZ 0x0015f8cf
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015f8dc
LAB_0015f8cf:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001447e0
MOV byte ptr [RBP + -0x1],0x1
LAB_0015f8dc:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x20
POP RBP
RET
|
bool ggml_backend_sched_reserve(ggml_backend_sched *param_1,ggml_cgraph *param_2)
{
ulong uVar1;
bool bVar2;
if ((int)*(int8 *)(param_1 + 0x110) < *(int *)(param_2 + 4) + *(int *)(param_2 + 8)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x605,"GGML_ASSERT(%s) failed",
"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs");
}
ggml_backend_sched_split_graph(param_1,param_2);
ggml_backend_sched_synchronize(param_1);
uVar1 = ggml_gallocr_reserve_n
(*(int8 *)(param_1 + 0x108),param_1 + 0x158,
*(int8 *)(param_1 + 0x138),*(int8 *)(param_1 + 0x140));
bVar2 = (uVar1 & 1) != 0;
if (bVar2) {
ggml_backend_sched_reset(param_1);
}
return bVar2;
}
| |
43,329 | ggml_backend_sched_reserve | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | bool ggml_backend_sched_reserve(ggml_backend_sched_t sched, struct ggml_cgraph * measure_graph) {
GGML_ASSERT((int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs);
ggml_backend_sched_split_graph(sched, measure_graph);
ggml_backend_sched_synchronize(sched);
if (!ggml_gallocr_reserve_n(sched->galloc, &sched->graph, sched->node_backend_ids, sched->leaf_backend_ids)) {
return false;
}
ggml_backend_sched_reset(sched);
return true;
} | O1 | cpp | ggml_backend_sched_reserve:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
addl 0x4(%rsi), %eax
cmpl 0x110(%rdi), %eax
jg 0x27d14
movq %rdi, %rbx
callq 0x27d35
cmpl $0x0, 0x4(%rbx)
jle 0x27cde
xorl %r14d, %r14d
movq 0x8(%rbx,%r14,8), %rdi
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x27cd2
callq *%rax
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x27cc2
leaq 0x158(%rbx), %rsi
movq 0x108(%rbx), %rdi
movq 0x138(%rbx), %rdx
movq 0x140(%rbx), %rcx
callq 0x184d0
movl %eax, %ebp
testb %al, %al
je 0x27d0d
movq %rbx, %rdi
callq 0x17af0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x27a59(%rip), %rdi # 0x4f774
leaq 0x2489f(%rip), %rdx # 0x4c5c1
leaq 0x27f02(%rip), %rcx # 0x4fc2b
movl $0x605, %esi # imm = 0x605
xorl %eax, %eax
callq 0x18ce0
| ggml_backend_sched_reserve:
push rbp
push r14
push rbx
mov eax, [rsi+8]
add eax, [rsi+4]
cmp eax, [rdi+110h]
jg short loc_27D14
mov rbx, rdi
call _ZL30ggml_backend_sched_split_graphP18ggml_backend_schedP11ggml_cgraph; ggml_backend_sched_split_graph(ggml_backend_sched *,ggml_cgraph *)
cmp dword ptr [rbx+4], 0
jle short loc_27CDE
xor r14d, r14d
loc_27CC2:
mov rdi, [rbx+r14*8+8]
mov rax, [rdi+30h]
test rax, rax
jz short loc_27CD2
call rax
loc_27CD2:
inc r14
movsxd rax, dword ptr [rbx+4]
cmp r14, rax
jl short loc_27CC2
loc_27CDE:
lea rsi, [rbx+158h]
mov rdi, [rbx+108h]
mov rdx, [rbx+138h]
mov rcx, [rbx+140h]
call _ggml_gallocr_reserve_n
mov ebp, eax
test al, al
jz short loc_27D0D
mov rdi, rbx
call _ggml_backend_sched_reset
loc_27D0D:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
loc_27D14:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aIntSchedHashSe; "(int)sched->hash_set.size >= measure_gr"...
mov esi, 605h
xor eax, eax
call _ggml_abort
| long long ggml_backend_sched_reserve(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
int a13,
int a14)
{
double v14; // xmm4_8
double v15; // xmm5_8
long long v16; // r14
void (*v17)(void); // rax
unsigned int v18; // ebp
if ( *(_DWORD *)(a2 + 4) + *(_DWORD *)(a2 + 8) > *(_DWORD *)(a1 + 272) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1541,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs",
a13,
a14);
ggml_backend_sched_split_graph();
if ( *(int *)(a1 + 4) > 0 )
{
v16 = 0LL;
do
{
v17 = *(void (**)(void))(*(_QWORD *)(a1 + 8 * v16 + 8) + 48LL);
if ( v17 )
v17();
++v16;
}
while ( v16 < *(int *)(a1 + 4) );
}
v18 = ggml_gallocr_reserve_n(
*(_QWORD *)(a1 + 264),
a1 + 344,
*(_QWORD *)(a1 + 312),
*(_QWORD *)(a1 + 320),
a3,
a4,
a5,
a6,
v14,
v15,
a9,
a10);
if ( (_BYTE)v18 )
ggml_backend_sched_reset(a1);
return v18;
}
| ggml_backend_sched_reserve:
PUSH RBP
PUSH R14
PUSH RBX
MOV EAX,dword ptr [RSI + 0x8]
ADD EAX,dword ptr [RSI + 0x4]
CMP EAX,dword ptr [RDI + 0x110]
JG 0x00127d14
MOV RBX,RDI
CALL 0x00127d35
CMP dword ptr [RBX + 0x4],0x0
JLE 0x00127cde
XOR R14D,R14D
LAB_00127cc2:
MOV RDI,qword ptr [RBX + R14*0x8 + 0x8]
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x00127cd2
CALL RAX
LAB_00127cd2:
INC R14
MOVSXD RAX,dword ptr [RBX + 0x4]
CMP R14,RAX
JL 0x00127cc2
LAB_00127cde:
LEA RSI,[RBX + 0x158]
MOV RDI,qword ptr [RBX + 0x108]
MOV RDX,qword ptr [RBX + 0x138]
MOV RCX,qword ptr [RBX + 0x140]
CALL 0x001184d0
MOV EBP,EAX
TEST AL,AL
JZ 0x00127d0d
MOV RDI,RBX
CALL 0x00117af0
LAB_00127d0d:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
LAB_00127d14:
LEA RDI,[0x14f774]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14fc2b]
MOV ESI,0x605
XOR EAX,EAX
CALL 0x00118ce0
|
int4 ggml_backend_sched_reserve(ggml_backend_sched *param_1,ggml_cgraph *param_2)
{
int4 uVar1;
long lVar2;
if (*(int *)(param_2 + 8) + *(int *)(param_2 + 4) <= *(int *)(param_1 + 0x110)) {
ggml_backend_sched_split_graph(param_1,param_2);
if (0 < *(int *)(param_1 + 4)) {
lVar2 = 0;
do {
if (*(code **)(*(long *)(param_1 + lVar2 * 8 + 8) + 0x30) != (code *)0x0) {
(**(code **)(*(long *)(param_1 + lVar2 * 8 + 8) + 0x30))();
}
lVar2 = lVar2 + 1;
} while (lVar2 < *(int *)(param_1 + 4));
}
uVar1 = ggml_gallocr_reserve_n
(*(int8 *)(param_1 + 0x108),param_1 + 0x158,
*(int8 *)(param_1 + 0x138),*(int8 *)(param_1 + 0x140));
if ((char)uVar1 != '\0') {
ggml_backend_sched_reset(param_1);
}
return uVar1;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x605,"GGML_ASSERT(%s) failed",
"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs");
}
| |
43,330 | ggml_backend_sched_reserve | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | bool ggml_backend_sched_reserve(ggml_backend_sched_t sched, struct ggml_cgraph * measure_graph) {
GGML_ASSERT((int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs);
ggml_backend_sched_split_graph(sched, measure_graph);
ggml_backend_sched_synchronize(sched);
if (!ggml_gallocr_reserve_n(sched->galloc, &sched->graph, sched->node_backend_ids, sched->leaf_backend_ids)) {
return false;
}
ggml_backend_sched_reset(sched);
return true;
} | O3 | cpp | ggml_backend_sched_reserve:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x8(%rsi), %eax
addl 0x4(%rsi), %eax
cmpl 0x110(%rdi), %eax
jg 0x268a3
movq %rdi, %rbx
callq 0x268c4
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x2686d
xorl %r14d, %r14d
movq 0x8(%rbx,%r14,8), %rdi
movq 0x30(%rdi), %rcx
testq %rcx, %rcx
je 0x26862
callq *%rcx
movl 0x4(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x2684f
leaq 0x158(%rbx), %rsi
movq 0x108(%rbx), %rdi
movq 0x138(%rbx), %rdx
movq 0x140(%rbx), %rcx
callq 0x174c0
movl %eax, %ebp
testb %al, %al
je 0x2689c
movq %rbx, %rdi
callq 0x16af0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28f6a(%rip), %rdi # 0x4f814
leaq 0x25db4(%rip), %rdx # 0x4c665
leaq 0x29413(%rip), %rcx # 0x4fccb
movl $0x605, %esi # imm = 0x605
xorl %eax, %eax
callq 0x17cd0
| ggml_backend_sched_reserve:
push rbp
push r14
push rbx
mov eax, [rsi+8]
add eax, [rsi+4]
cmp eax, [rdi+110h]
jg short loc_268A3
mov rbx, rdi
call _ZL30ggml_backend_sched_split_graphP18ggml_backend_schedP11ggml_cgraph; ggml_backend_sched_split_graph(ggml_backend_sched *,ggml_cgraph *)
mov eax, [rbx+4]
test eax, eax
jle short loc_2686D
xor r14d, r14d
loc_2684F:
mov rdi, [rbx+r14*8+8]
mov rcx, [rdi+30h]
test rcx, rcx
jz short loc_26862
call rcx
mov eax, [rbx+4]
loc_26862:
inc r14
movsxd rcx, eax
cmp r14, rcx
jl short loc_2684F
loc_2686D:
lea rsi, [rbx+158h]
mov rdi, [rbx+108h]
mov rdx, [rbx+138h]
mov rcx, [rbx+140h]
call _ggml_gallocr_reserve_n
mov ebp, eax
test al, al
jz short loc_2689C
mov rdi, rbx
call _ggml_backend_sched_reset
loc_2689C:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
loc_268A3:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aIntSchedHashSe; "(int)sched->hash_set.size >= measure_gr"...
mov esi, 605h
xor eax, eax
call _ggml_abort
| long long ggml_backend_sched_reserve(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
int a13,
int a14)
{
double v14; // xmm4_8
double v15; // xmm5_8
int v16; // eax
long long i; // r14
void (*v18)(void); // rcx
unsigned int v19; // ebp
if ( *(_DWORD *)(a2 + 4) + *(_DWORD *)(a2 + 8) > *(_DWORD *)(a1 + 272) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
1541,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs",
a13,
a14);
ggml_backend_sched_split_graph();
v16 = *(_DWORD *)(a1 + 4);
if ( v16 > 0 )
{
for ( i = 0LL; i < v16; ++i )
{
v18 = *(void (**)(void))(*(_QWORD *)(a1 + 8 * i + 8) + 48LL);
if ( v18 )
{
v18();
v16 = *(_DWORD *)(a1 + 4);
}
}
}
v19 = ggml_gallocr_reserve_n(
*(_QWORD *)(a1 + 264),
a1 + 344,
*(_QWORD *)(a1 + 312),
*(_QWORD *)(a1 + 320),
a3,
a4,
a5,
a6,
v14,
v15,
a9,
a10);
if ( (_BYTE)v19 )
ggml_backend_sched_reset(a1);
return v19;
}
| ggml_backend_sched_reserve:
PUSH RBP
PUSH R14
PUSH RBX
MOV EAX,dword ptr [RSI + 0x8]
ADD EAX,dword ptr [RSI + 0x4]
CMP EAX,dword ptr [RDI + 0x110]
JG 0x001268a3
MOV RBX,RDI
CALL 0x001268c4
MOV EAX,dword ptr [RBX + 0x4]
TEST EAX,EAX
JLE 0x0012686d
XOR R14D,R14D
LAB_0012684f:
MOV RDI,qword ptr [RBX + R14*0x8 + 0x8]
MOV RCX,qword ptr [RDI + 0x30]
TEST RCX,RCX
JZ 0x00126862
CALL RCX
MOV EAX,dword ptr [RBX + 0x4]
LAB_00126862:
INC R14
MOVSXD RCX,EAX
CMP R14,RCX
JL 0x0012684f
LAB_0012686d:
LEA RSI,[RBX + 0x158]
MOV RDI,qword ptr [RBX + 0x108]
MOV RDX,qword ptr [RBX + 0x138]
MOV RCX,qword ptr [RBX + 0x140]
CALL 0x001174c0
MOV EBP,EAX
TEST AL,AL
JZ 0x0012689c
MOV RDI,RBX
CALL 0x00116af0
LAB_0012689c:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
LAB_001268a3:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14fccb]
MOV ESI,0x605
XOR EAX,EAX
CALL 0x00117cd0
|
int4 ggml_backend_sched_reserve(ggml_backend_sched *param_1,ggml_cgraph *param_2)
{
int iVar1;
int4 uVar2;
long lVar3;
if (*(int *)(param_2 + 8) + *(int *)(param_2 + 4) <= *(int *)(param_1 + 0x110)) {
ggml_backend_sched_split_graph(param_1,param_2);
iVar1 = *(int *)(param_1 + 4);
if (0 < iVar1) {
lVar3 = 0;
do {
if (*(code **)(*(long *)(param_1 + lVar3 * 8 + 8) + 0x30) != (code *)0x0) {
(**(code **)(*(long *)(param_1 + lVar3 * 8 + 8) + 0x30))();
iVar1 = *(int *)(param_1 + 4);
}
lVar3 = lVar3 + 1;
} while (lVar3 < iVar1);
}
uVar2 = ggml_gallocr_reserve_n
(*(int8 *)(param_1 + 0x108),param_1 + 0x158,
*(int8 *)(param_1 + 0x138),*(int8 *)(param_1 + 0x140));
if ((char)uVar2 != '\0') {
ggml_backend_sched_reset(param_1);
}
return uVar2;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0x605,"GGML_ASSERT(%s) failed",
"(int)sched->hash_set.size >= measure_graph->n_nodes + measure_graph->n_leafs");
}
| |
43,331 | evmone::ExecutionState::get_tx_initcode_by_hash(evmc_bytes32 const&) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/execution_state.hpp | [[nodiscard]] TransactionInitcode* get_tx_initcode_by_hash(const evmc_bytes32& hash)
{
if (!m_initcodes.has_value())
{
m_initcodes.emplace();
const auto& tx_context = get_tx_context();
for (size_t i = 0; i < tx_context.initcodes_count; ++i)
{
const auto& initcode = tx_context.initcodes[i];
m_initcodes->insert({initcode.hash,
{.code = {initcode.code, initcode.code_size}, .is_valid = std::nullopt}});
}
}
const auto it = m_initcodes->find(hash);
return it != m_initcodes->end() ? &it->second : nullptr;
} | O0 | cpp | evmone::ExecutionState::get_tx_initcode_by_hash(evmc_bytes32 const&):
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
addq $0x1b8, %rdi # imm = 0x1B8
callq 0x887a0
testb $0x1, %al
jne 0x883b8
movq -0xe8(%rbp), %rdi
addq $0x1b8, %rdi # imm = 0x1B8
callq 0x887c0
movq -0xe8(%rbp), %rdi
callq 0x68e20
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0xf8(%rcx), %rax
jae 0x883b6
movq -0xe8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
addq $0x1b8, %rdi # imm = 0x1B8
callq 0x88800
movq %rax, -0xf0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x78(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x3df90
leaq -0x78(%rbp), %rdi
addq $0x10, %rdi
callq 0x88860
movq -0xf8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x88880
movq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x88820
movq %rax, -0x90(%rbp)
movb %dl, -0x88(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x882fd
jmp 0x883b8
movq -0xe8(%rbp), %rdi
addq $0x1b8, %rdi # imm = 0x1B8
callq 0x88800
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xd0(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0xc8(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x37a80
movq -0x100(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x88910
movq -0xe8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x1b8, %rdi # imm = 0x1B8
callq 0x88800
movq %rax, %rdi
callq 0x88970
movq %rax, -0xe0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x88940
xorb $-0x1, %al
testb $0x1, %al
jne 0x8848d
jmp 0x884a6
leaq -0x98(%rbp), %rdi
callq 0x889a0
addq $0x20, %rax
movq %rax, -0x108(%rbp)
jmp 0x884b1
xorl %eax, %eax
movq %rax, -0x108(%rbp)
jmp 0x884b1
movq -0x108(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN6evmone14ExecutionState23get_tx_initcode_by_hashERK12evmc_bytes32:
push rbp
mov rbp, rsp
sub rsp, 130h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov [rbp+var_E8], rdi
add rdi, 1B8h
call _ZNKSt8optionalISt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS2_ESt8equal_toIS2_ESaISt4pairIKS2_S4_EEEE9has_valueEv; std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::has_value(void)
test al, 1
jnz loc_883B8
mov rdi, [rbp+var_E8]
add rdi, 1B8h
call _ZNSt8optionalISt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS2_ESt8equal_toIS2_ESaISt4pairIKS2_S4_EEEE7emplaceIJEEENSt9enable_ifIX18is_constructible_vISD_DpT_EERSD_E4typeEDpOSH_
mov rdi, [rbp+var_E8]; this
call _ZN6evmone14ExecutionState14get_tx_contextEv; evmone::ExecutionState::get_tx_context(void)
mov [rbp+var_18], rax
mov [rbp+var_20], 0
loc_882FD:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
cmp rax, [rcx+0F8h]
jnb loc_883B6
mov rdi, [rbp+var_E8]
mov rax, [rbp+var_18]
mov rax, [rax+0F0h]
imul rcx, [rbp+var_20], 30h ; '0'
add rax, rcx
mov [rbp+var_28], rax
add rdi, 1B8h
call _ZNSt8optionalISt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS2_ESt8equal_toIS2_ESaISt4pairIKS2_S4_EEEEptEv; std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->(void)
mov [rbp+var_F0], rax
mov rax, [rbp+var_28]
mov [rbp+var_F8], rax
lea rdi, [rbp+var_78]
mov rax, [rbp+var_28]
mov rsi, [rax+20h]
mov rax, [rbp+var_28]
mov rdx, [rax+28h]
call _ZNSt17basic_string_viewIhN4evmc11byte_traitsIhEEEC2EPKhm; std::basic_string_view<uchar,evmc::byte_traits<uchar>>::basic_string_view(uchar const*,ulong)
lea rdi, [rbp+var_78]
add rdi, 10h
call _ZNSt8optionalIbEC2ESt9nullopt_t; std::optional<bool>::optional(std::nullopt_t)
mov rsi, [rbp+var_F8]
lea rdi, [rbp+var_60]
lea rdx, [rbp+var_78]
call _ZNSt4pairIKN4evmc7bytes32EN6evmone19TransactionInitcodeEEC2IRK12evmc_bytes32TnNSt9enable_ifIXclsr5_PCCPE13_MoveCopyPairILb1ET_S4_EEEbE4typeELb1EEEOSB_RKS4_
mov rdi, [rbp+var_F0]
lea rsi, [rbp+var_60]
call _ZNSt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS1_ESt8equal_toIS1_ESaISt4pairIKS1_S3_EEE6insertEOSA_; std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::insert(std::pair<evmc::bytes32 const,evmone::TransactionInitcode>&&)
mov [rbp+var_90], rax
mov [rbp+var_88], dl
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_882FD
loc_883B6:
jmp short $+2
loc_883B8:
mov rdi, [rbp+var_E8]
add rdi, 1B8h
call _ZNSt8optionalISt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS2_ESt8equal_toIS2_ESaISt4pairIKS2_S4_EEEEptEv; std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->(void)
mov [rbp+var_100], rax
mov rax, [rbp+var_10]
mov rcx, [rax]
mov [rbp+var_D8], rcx
mov rcx, [rax+8]
mov [rbp+var_D0], rcx
mov rcx, [rax+10h]
mov [rbp+var_C8], rcx
mov rax, [rax+18h]
mov [rbp+var_C0], rax
lea rdi, [rbp+var_B8]
lea rax, [rbp+var_D8]
mov rcx, [rax]
mov [rsp+130h+var_130], rcx
mov rcx, [rax+8]
mov [rsp+130h+var_128], rcx
mov rcx, [rax+10h]
mov [rsp+130h+var_120], rcx
mov rax, [rax+18h]
mov [rsp+130h+var_118], rax
call _ZN4evmc7bytes32C2E12evmc_bytes32; evmc::bytes32::bytes32(evmc_bytes32)
mov rdi, [rbp+var_100]
lea rsi, [rbp+var_B8]
call _ZNSt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS1_ESt8equal_toIS1_ESaISt4pairIKS1_S3_EEE4findERS9_; std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::find(evmc::bytes32 const&)
mov rdi, [rbp+var_E8]
mov [rbp+var_98], rax
add rdi, 1B8h
call _ZNSt8optionalISt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS2_ESt8equal_toIS2_ESaISt4pairIKS2_S4_EEEEptEv; std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->(void)
mov rdi, rax
call _ZNSt13unordered_mapIN4evmc7bytes32EN6evmone19TransactionInitcodeESt4hashIS1_ESt8equal_toIS1_ESaISt4pairIKS1_S3_EEE3endEv; std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::end(void)
mov [rbp+var_E0], rax
lea rdi, [rbp+var_98]
lea rsi, [rbp+var_E0]
call _ZNSt8__detaileqERKNS_19_Node_iterator_baseISt4pairIKN4evmc7bytes32EN6evmone19TransactionInitcodeEELb0EEESA_; std::__detail::operator==(std::__detail::_Node_iterator_base<std::pair<evmc::bytes32 const,evmone::TransactionInitcode>,false> const&,std::__detail::_Node_iterator_base<std::pair<evmc::bytes32 const,evmone::TransactionInitcode>,false> const&)
xor al, 0FFh
test al, 1
jnz short loc_8848D
jmp short loc_884A6
loc_8848D:
lea rdi, [rbp+var_98]
call _ZNKSt8__detail14_Node_iteratorISt4pairIKN4evmc7bytes32EN6evmone19TransactionInitcodeEELb0ELb0EEptEv; std::__detail::_Node_iterator<std::pair<evmc::bytes32 const,evmone::TransactionInitcode>,false,false>::operator->(void)
add rax, 20h ; ' '
mov [rbp+var_108], rax
jmp short loc_884B1
loc_884A6:
xor eax, eax
mov [rbp+var_108], rax
jmp short $+2
loc_884B1:
mov rax, [rbp+var_108]
add rsp, 130h
pop rbp
retn
| long long evmone::ExecutionState::get_tx_initcode_by_hash(evmone::ExecutionState *a1, long long *a2)
{
char v2; // dl
int v3; // edx
int v4; // r8d
int v5; // r9d
long long v6; // rax
long long v9; // [rsp+30h] [rbp-100h]
long long v10; // [rsp+38h] [rbp-F8h]
long long v11; // [rsp+40h] [rbp-F0h]
long long v12; // [rsp+50h] [rbp-E0h] BYREF
long long v13; // [rsp+58h] [rbp-D8h]
long long v14; // [rsp+60h] [rbp-D0h]
long long v15; // [rsp+68h] [rbp-C8h]
long long v16; // [rsp+70h] [rbp-C0h]
_QWORD v17[4]; // [rsp+78h] [rbp-B8h] BYREF
_QWORD v18[2]; // [rsp+98h] [rbp-98h] BYREF
char v19; // [rsp+A8h] [rbp-88h]
_QWORD v20[2]; // [rsp+B8h] [rbp-78h] BYREF
long long v21; // [rsp+C8h] [rbp-68h] BYREF
_BYTE v22[56]; // [rsp+D0h] [rbp-60h] BYREF
long long v23; // [rsp+108h] [rbp-28h]
unsigned long long i; // [rsp+110h] [rbp-20h]
long long tx_context; // [rsp+118h] [rbp-18h]
long long *v26; // [rsp+120h] [rbp-10h]
evmone::ExecutionState *v27; // [rsp+128h] [rbp-8h]
v27 = a1;
v26 = a2;
if ( (std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::has_value((char *)a1 + 440) & 1) == 0 )
{
std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::emplace<>((char *)a1 + 440);
tx_context = evmone::ExecutionState::get_tx_context(a1);
for ( i = 0LL; i < *(_QWORD *)(tx_context + 248); ++i )
{
v23 = 48 * i + *(_QWORD *)(tx_context + 240);
v11 = std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->((char *)a1 + 440);
v10 = v23;
std::basic_string_view<unsigned char,evmc::byte_traits<unsigned char>>::basic_string_view(
v20,
*(_QWORD *)(v23 + 32),
*(_QWORD *)(v23 + 40));
std::optional<bool>::optional(&v21);
ZNSt4pairIKN4evmc7bytes32EN6evmone19TransactionInitcodeEEC2IRK12evmc_bytes32TnNSt9enable_ifIXclsr5_PCCPE13_MoveCopyPairILb1ET_S4_EEEbE4typeELb1EEEOSB_RKS4_(
v22,
v10,
v20);
a2 = (long long *)v22;
v18[1] = std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::insert(v11, v22);
v19 = v2;
}
}
v9 = std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->((char *)a1 + 440);
v13 = *v26;
v14 = v26[1];
v15 = v26[2];
v16 = v26[3];
evmc::bytes32::bytes32(v17, (_DWORD)a2, v3, v15, v4, v5, v13, v14, v15, v16);
v18[0] = std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::find(v9, v17);
v6 = std::optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>>::operator->((char *)a1 + 440);
v12 = std::unordered_map<evmc::bytes32,evmone::TransactionInitcode>::end(v6);
if ( (std::__detail::operator==(v18, &v12) & 1) != 0 )
return 0LL;
else
return std::__detail::_Node_iterator<std::pair<evmc::bytes32 const,evmone::TransactionInitcode>,false,false>::operator->(v18)
+ 32;
}
| get_tx_initcode_by_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x130
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0xe8],RDI
ADD RDI,0x1b8
CALL 0x001887a0
TEST AL,0x1
JNZ 0x001883b8
MOV RDI,qword ptr [RBP + -0xe8]
ADD RDI,0x1b8
CALL 0x001887c0
MOV RDI,qword ptr [RBP + -0xe8]
CALL 0x00168e20
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x20],0x0
LAB_001882fd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0xf8]
JNC 0x001883b6
MOV RDI,qword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xf0]
IMUL RCX,qword ptr [RBP + -0x20],0x30
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
ADD RDI,0x1b8
CALL 0x00188800
MOV qword ptr [RBP + -0xf0],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xf8],RAX
LEA RDI,[RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX + 0x28]
CALL 0x0013df90
LEA RDI,[RBP + -0x78]
ADD RDI,0x10
CALL 0x00188860
MOV RSI,qword ptr [RBP + -0xf8]
LEA RDI,[RBP + -0x60]
LEA RDX,[RBP + -0x78]
CALL 0x00188880
MOV RDI,qword ptr [RBP + -0xf0]
LEA RSI,[RBP + -0x60]
CALL 0x00188820
MOV qword ptr [RBP + -0x90],RAX
MOV byte ptr [RBP + -0x88],DL
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001882fd
LAB_001883b6:
JMP 0x001883b8
LAB_001883b8:
MOV RDI,qword ptr [RBP + -0xe8]
ADD RDI,0x1b8
CALL 0x00188800
MOV qword ptr [RBP + -0x100],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xd8],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xd0],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xc8],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0xc0],RAX
LEA RDI,[RBP + -0xb8]
LEA RAX,[RBP + -0xd8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x18],RAX
CALL 0x00137a80
MOV RDI,qword ptr [RBP + -0x100]
LEA RSI,[RBP + -0xb8]
CALL 0x00188910
MOV RDI,qword ptr [RBP + -0xe8]
MOV qword ptr [RBP + -0x98],RAX
ADD RDI,0x1b8
CALL 0x00188800
MOV RDI,RAX
CALL 0x00188970
MOV qword ptr [RBP + -0xe0],RAX
LEA RDI,[RBP + -0x98]
LEA RSI,[RBP + -0xe0]
CALL 0x00188940
XOR AL,0xff
TEST AL,0x1
JNZ 0x0018848d
JMP 0x001884a6
LAB_0018848d:
LEA RDI,[RBP + -0x98]
CALL 0x001889a0
ADD RAX,0x20
MOV qword ptr [RBP + -0x108],RAX
JMP 0x001884b1
LAB_001884a6:
XOR EAX,EAX
MOV qword ptr [RBP + -0x108],RAX
JMP 0x001884b1
LAB_001884b1:
MOV RAX,qword ptr [RBP + -0x108]
ADD RSP,0x130
POP RBP
RET
|
/* evmone::ExecutionState::get_tx_initcode_by_hash(evmc_bytes32 const&) */
long __thiscall
evmone::ExecutionState::get_tx_initcode_by_hash(ExecutionState *this,evmc_bytes32 *param_1)
{
long lVar1;
ulong uVar2;
unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
*puVar3;
int1 extraout_DL;
long local_110;
int8 local_e8;
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
bytes32 local_c0 [32];
int8 local_a0;
int8 local_98;
int1 local_90;
basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>> local_80 [16];
int1 auStack_70 [8];
pair local_68 [56];
long local_30;
ulong local_28;
long local_20;
int8 *local_18;
ExecutionState *local_10;
local_18 = (int8 *)param_1;
local_10 = this;
uVar2 = std::
optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
::has_value((optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
*)(this + 0x1b8));
if ((uVar2 & 1) == 0) {
std::
optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
::emplace<>((optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
*)(this + 0x1b8));
local_20 = get_tx_context(this);
for (local_28 = 0; local_28 < *(ulong *)(local_20 + 0xf8); local_28 = local_28 + 1) {
local_30 = *(long *)(local_20 + 0xf0) + local_28 * 0x30;
puVar3 = (unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
*)std::
optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
::operator->((optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
*)(this + 0x1b8));
lVar1 = local_30;
std::basic_string_view<unsigned_char,evmc::byte_traits<unsigned_char>>::basic_string_view
(local_80,*(uchar **)(local_30 + 0x20),*(ulong *)(local_30 + 0x28));
std::optional<bool>::optional(auStack_70);
_ZNSt4pairIKN4evmc7bytes32EN6evmone19TransactionInitcodeEEC2IRK12evmc_bytes32TnNSt9enable_ifIXclsr5_PCCPE13_MoveCopyPairILb1ET_S4_EEEbE4typeELb1EEEOSB_RKS4_
(local_68,lVar1,local_80);
local_98 = std::
unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
::insert(puVar3,local_68);
local_90 = extraout_DL;
}
}
puVar3 = (unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
*)std::
optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
::operator->((optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
*)(this + 0x1b8));
local_e0 = *local_18;
local_d8 = local_18[1];
local_d0 = local_18[2];
local_c8 = local_18[3];
evmc::bytes32::bytes32(local_c0);
local_a0 = std::
unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
::find(puVar3,local_c0);
std::
optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
::operator->((optional<std::unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>>
*)(this + 0x1b8));
local_e8 = std::
unordered_map<evmc::bytes32,evmone::TransactionInitcode,std::hash<evmc::bytes32>,std::equal_to<evmc::bytes32>,std::allocator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>>>
::end();
uVar2 = std::__detail::operator==
((_Node_iterator_base *)&local_a0,(_Node_iterator_base *)&local_e8);
if (((uVar2 ^ 0xff) & 1) == 0) {
local_110 = 0;
}
else {
local_110 = std::__detail::
_Node_iterator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>,false,false>
::operator->((_Node_iterator<std::pair<evmc::bytes32_const,evmone::TransactionInitcode>,false,false>
*)&local_a0);
local_110 = local_110 + 0x20;
}
return local_110;
}
| |
43,332 | flush_partitioned_key_cache_blocks | eloqsql/mysys/mf_keycache.c | static
int flush_partitioned_key_cache_blocks(PARTITIONED_KEY_CACHE_CB *keycache,
File file, void *file_extra,
enum flush_type type)
{
uint i;
uint partitions= keycache->partitions;
int err= 0;
ulonglong *dirty_part_map= (ulonglong *) file_extra;
DBUG_ENTER("partitioned_flush_key_blocks");
DBUG_PRINT("enter", ("keycache: %p", keycache));
for (i= 0; i < partitions; i++)
{
SIMPLE_KEY_CACHE_CB *partition= keycache->partition_array[i];
if ((type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE) &&
!((*dirty_part_map) & ((ulonglong) 1 << i)))
continue;
err|= MY_TEST(flush_simple_key_cache_blocks(partition, file, 0, type));
}
*dirty_part_map= 0;
DBUG_RETURN(err);
} | O0 | c | flush_partitioned_key_cache_blocks:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xeb3b1
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xeb432
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xeb3df
cmpl $0x3, -0x1c(%rbp)
jne 0xeb3ff
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0xeb3ff
jmp 0xeb427
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0xe9970
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xeb3b8
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| flush_partitioned_key_cache_blocks:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_24], eax
mov [rbp+var_28], 0
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
jmp short $+2
loc_EB3B1:
mov [rbp+var_20], 0
loc_EB3B8:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jnb short loc_EB432
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_20]
mov rax, [rax+rcx*8]
mov [rbp+var_38], rax
cmp [rbp+var_1C], 0
jz short loc_EB3DF
cmp [rbp+var_1C], 3
jnz short loc_EB3FF
loc_EB3DF:
mov rax, [rbp+var_30]
mov rax, [rax]
mov ecx, [rbp+var_20]
mov edx, 1
shl rdx, cl
mov rcx, rdx
and rax, rcx
cmp rax, 0
jnz short loc_EB3FF
jmp short loc_EB427
loc_EB3FF:
mov rdi, [rbp+var_38]
mov esi, [rbp+var_C]
mov ecx, [rbp+var_1C]
xor eax, eax
mov edx, eax
call flush_simple_key_cache_blocks
mov edx, eax
xor eax, eax
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
or eax, [rbp+var_28]
mov [rbp+var_28], eax
loc_EB427:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_EB3B8
loc_EB432:
mov rax, [rbp+var_30]
mov qword ptr [rax], 0
mov eax, [rbp+var_28]
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
add rsp, 40h
pop rbp
retn
| long long flush_partitioned_key_cache_blocks(long long a1, unsigned int a2, _QWORD *a3, unsigned int a4)
{
unsigned int v6; // [rsp+18h] [rbp-28h]
unsigned int v7; // [rsp+1Ch] [rbp-24h]
unsigned int i; // [rsp+20h] [rbp-20h]
v7 = *(_DWORD *)(a1 + 28);
v6 = 0;
for ( i = 0; i < v7; ++i )
{
if ( a4 && a4 != 3 || ((1LL << i) & *a3) != 0 )
v6 |= (unsigned int)flush_simple_key_cache_blocks(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i), a2, 0LL, a4) != 0;
}
*a3 = 0LL;
return v6;
}
| flush_partitioned_key_cache_blocks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001eb3b1
LAB_001eb3b1:
MOV dword ptr [RBP + -0x20],0x0
LAB_001eb3b8:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x001eb432
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x38],RAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x001eb3df
CMP dword ptr [RBP + -0x1c],0x3
JNZ 0x001eb3ff
LAB_001eb3df:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
MOV EDX,0x1
SHL RDX,CL
MOV RCX,RDX
AND RAX,RCX
CMP RAX,0x0
JNZ 0x001eb3ff
JMP 0x001eb427
LAB_001eb3ff:
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0xc]
MOV ECX,dword ptr [RBP + -0x1c]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001e9970
MOV EDX,EAX
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
OR EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x28],EAX
LAB_001eb427:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001eb3b8
LAB_001eb432:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD RSP,0x40
POP RBP
RET
|
byte flush_partitioned_key_cache_blocks(long param_1,int4 param_2,ulong *param_3,int param_4)
{
uint uVar1;
byte bVar2;
int iVar3;
uint local_28;
uVar1 = *(uint *)(param_1 + 0x1c);
bVar2 = 0;
for (local_28 = 0; local_28 < uVar1; local_28 = local_28 + 1) {
if (((param_4 != 0) && (param_4 != 3)) || ((*param_3 & 1L << ((byte)local_28 & 0x3f)) != 0)) {
iVar3 = flush_simple_key_cache_blocks
(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_28 * 8),param_2,0,
param_4);
bVar2 = iVar3 != 0 | bVar2;
}
}
*param_3 = 0;
return bVar2;
}
| |
43,333 | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::vector<std::string> string_split(const std::string & str, const std::string & delimiter) {
std::vector<std::string> parts;
size_t start = 0;
size_t end = str.find(delimiter);
while (end != std::string::npos) {
parts.push_back(str.substr(start, end - start));
start = end + delimiter.length();
end = str.find(delimiter, start);
}
parts.push_back(str.substr(start));
return parts;
} | O0 | cpp | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movb $0x0, 0x7f(%rsp)
callq 0x62080
movq $0x0, 0x70(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5ab80
movq %rax, 0x68(%rsp)
cmpq $-0x1, 0x68(%rsp)
je 0xec7ab
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
subq %rdx, %rcx
leaq 0x48(%rsp), %rdi
callq 0x5b130
jmp 0xec71a
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf7510
jmp 0xec72b
leaq 0x48(%rsp), %rdi
callq 0x5b558
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
callq 0x5aa10
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x5ab80
movq %rax, 0x68(%rsp)
jmp 0xec6ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xec825
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b558
jmp 0xec825
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x18(%rsp), %rdi
movq $-0x1, %rcx
callq 0x5b130
jmp 0xec7cb
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf7510
jmp 0xec7dc
leaq 0x18(%rsp), %rdi
callq 0x5b558
movb $0x1, 0x7f(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0xec818
jmp 0xec80e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5b558
jmp 0xec825
movq 0x8(%rsp), %rdi
callq 0x620d0
movq 0x10(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x620d0
movq 0x40(%rsp), %rdi
callq 0x5abc0
nopl (%rax)
| _Z12string_splitRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
sub rsp, 98h
mov [rsp+98h+var_90], rdi
mov rax, rdi
mov [rsp+98h+var_88], rax
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov [rsp+98h+var_19], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov [rsp+98h+var_28], 0
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov [rsp+98h+var_30], rax
loc_EC6ED:
cmp [rsp+98h+var_30], 0FFFFFFFFFFFFFFFFh
jz loc_EC7AB
mov rsi, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_28]
mov rcx, [rsp+98h+var_30]
sub rcx, rdx
lea rdi, [rsp+98h+var_50]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_EC71A:
mov rdi, [rsp+98h+var_90]
lea rsi, [rsp+98h+var_50]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
jmp short $+2
loc_EC72B:
lea rdi, [rsp+98h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+98h+var_30]
mov [rsp+98h+var_98], rax
mov rdi, [rsp+98h+var_18]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov rcx, rax
mov rax, [rsp+98h+var_98]
add rax, rcx
mov [rsp+98h+var_28], rax
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_28]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findERKS4_m; std::string::find(std::string const&,ulong)
mov [rsp+98h+var_30], rax
jmp loc_EC6ED
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp loc_EC825
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_EC825
loc_EC7AB:
mov rsi, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_28]
lea rdi, [rsp+98h+var_80]
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_EC7CB:
mov rdi, [rsp+98h+var_90]
lea rsi, [rsp+98h+var_80]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
jmp short $+2
loc_EC7DC:
lea rdi, [rsp+98h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov [rsp+98h+var_19], 1
test [rsp+98h+var_19], 1
jnz short loc_EC818
jmp short loc_EC80E
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_EC825
loc_EC80E:
mov rdi, [rsp+98h+var_90]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_EC818:
mov rax, [rsp+98h+var_88]
add rsp, 98h
retn
loc_EC825:
mov rdi, [rsp+arg_0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_38]
call __Unwind_Resume
| long long string_split(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-98h]
_BYTE v5[48]; // [rsp+18h] [rbp-80h] BYREF
_BYTE v6[32]; // [rsp+48h] [rbp-50h] BYREF
long long i; // [rsp+68h] [rbp-30h]
long long v8; // [rsp+70h] [rbp-28h]
char v9; // [rsp+7Fh] [rbp-19h]
long long v10; // [rsp+80h] [rbp-18h]
long long v11; // [rsp+88h] [rbp-10h]
long long v12; // [rsp+90h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = 0;
std::vector<std::string>::vector(a1);
v8 = 0LL;
for ( i = std::string::find(a2, v10, 0LL); i != -1; i = std::string::find(v11, v10, v8) )
{
std::string::substr(v6, v11, v8, i - v8);
std::vector<std::string>::push_back(a1, v6);
std::string::~string(v6);
v4 = i;
v8 = std::string::length(v10) + v4;
}
std::string::substr(v5, v11, v8, -1LL);
std::vector<std::string>::push_back(a1, v5);
std::string::~string(v5);
return a1;
}
| string_split:
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x90],RDI
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV byte ptr [RSP + 0x7f],0x0
CALL 0x00162080
MOV qword ptr [RSP + 0x70],0x0
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0015ab80
MOV qword ptr [RSP + 0x68],RAX
LAB_001ec6ed:
CMP qword ptr [RSP + 0x68],-0x1
JZ 0x001ec7ab
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x68]
SUB RCX,RDX
LAB_001ec70e:
LEA RDI,[RSP + 0x48]
CALL 0x0015b130
JMP 0x001ec71a
LAB_001ec71a:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x48]
CALL 0x001f7510
JMP 0x001ec72b
LAB_001ec72b:
LEA RDI,[RSP + 0x48]
CALL 0x0015b558
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0015aa10
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
ADD RAX,RCX
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x70]
CALL 0x0015ab80
MOV qword ptr [RSP + 0x68],RAX
JMP 0x001ec6ed
LAB_001ec7ab:
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x70]
LAB_001ec7b8:
LEA RDI,[RSP + 0x18]
MOV RCX,-0x1
CALL 0x0015b130
JMP 0x001ec7cb
LAB_001ec7cb:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x18]
CALL 0x001f7510
LAB_001ec7da:
JMP 0x001ec7dc
LAB_001ec7dc:
LEA RDI,[RSP + 0x18]
CALL 0x0015b558
MOV byte ptr [RSP + 0x7f],0x1
TEST byte ptr [RSP + 0x7f],0x1
JNZ 0x001ec818
JMP 0x001ec80e
LAB_001ec80e:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001620d0
LAB_001ec818:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x98
RET
|
/* WARNING: Removing unreachable block (ram,0x001ec7f2) */
/* string_split(std::__cxx11::string const&, std::__cxx11::string const&) */
string * string_split(string *param_1,string *param_2)
{
long lVar1;
ulong in_RDX;
string local_80 [48];
string local_50 [32];
long local_30;
long local_28;
int1 local_19;
ulong local_18;
string *local_10;
string *local_8;
local_19 = 0;
local_18 = in_RDX;
local_10 = param_2;
local_8 = param_1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1);
local_28 = 0;
local_30 = std::__cxx11::string::find(local_10,local_18);
while (local_30 != -1) {
/* try { // try from 001ec70e to 001ec717 has its CatchHandler @ 001ec77e */
std::__cxx11::string::substr((ulong)local_50,(ulong)local_10);
/* try { // try from 001ec71a to 001ec728 has its CatchHandler @ 001ec791 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_50
);
std::__cxx11::string::~string(local_50);
lVar1 = local_30;
local_28 = std::__cxx11::string::length();
local_28 = lVar1 + local_28;
local_30 = std::__cxx11::string::find(local_10,local_18);
}
/* try { // try from 001ec7b8 to 001ec7c8 has its CatchHandler @ 001ec77e */
std::__cxx11::string::substr((ulong)local_80,(ulong)local_10);
/* try { // try from 001ec7cb to 001ec7d9 has its CatchHandler @ 001ec7f4 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,local_80);
std::__cxx11::string::~string(local_80);
return param_1;
}
| |
43,334 | nlohmann::json_abi_v3_11_3::detail::lexer<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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get_codepoint() | monkey531[P]llama/common/json.hpp | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get_codepoint():
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x75, 0x14(%rax)
je 0xa548a
leaq 0x16816e(%rip), %rdi # 0x20d5de
movl $0x1d79, %esi # imm = 0x1D79
leaq 0x161d5d(%rip), %rdx # 0x2071d9
leaq 0x168e8e(%rip), %rcx # 0x20e311
movb $0x0, %al
callq 0x5aef0
movl $0x0, 0x54(%rsp)
movl $0xc, 0x30(%rsp)
movl $0x8, 0x34(%rsp)
movl $0x4, 0x38(%rsp)
movl $0x0, 0x3c(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x4, 0x48(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa5870
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa5880
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xa55c8
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
callq 0xa4600
movq 0x8(%rsp), %rax
cmpl $0x30, 0x14(%rax)
jl 0xa5543
movq 0x8(%rsp), %rax
cmpl $0x39, 0x14(%rax)
jg 0xa5543
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x30, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa55b3
movq 0x8(%rsp), %rax
cmpl $0x41, 0x14(%rax)
jl 0xa5574
movq 0x8(%rsp), %rax
cmpl $0x46, 0x14(%rax)
jg 0xa5574
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x37, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa55b1
movq 0x8(%rsp), %rax
cmpl $0x61, 0x14(%rax)
jl 0xa55a5
movq 0x8(%rsp), %rax
cmpl $0x66, 0x14(%rax)
jg 0xa55a5
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x57, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa55af
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xa5603
jmp 0xa55b1
jmp 0xa55b3
jmp 0xa55b5
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0xa54ed
xorl %eax, %eax
cmpl 0x54(%rsp), %eax
jg 0xa55da
cmpl $0xffff, 0x54(%rsp) # imm = 0xFFFF
jle 0xa55fb
leaq 0x167ffd(%rip), %rdi # 0x20d5de
movl $0x1d93, %esi # imm = 0x1D93
leaq 0x161bec(%rip), %rdx # 0x2071d9
leaq 0x168d2c(%rip), %rcx # 0x20e320
movb $0x0, %al
callq 0x5aef0
movl 0x54(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_60], rax
cmp dword ptr [rax+14h], 75h ; 'u'
jz short loc_A548A
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1D79h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov al, 0
call _ggml_abort
loc_A548A:
mov [rsp+68h+var_14], 0
mov [rsp+68h+var_38], 0Ch
mov [rsp+68h+var_34], 8
mov [rsp+68h+var_30], 4
mov [rsp+68h+var_2C], 0
lea rax, [rsp+68h+var_38]
mov [rsp+68h+var_28], rax
mov [rsp+68h+var_20], 4
lea rax, [rsp+68h+var_28]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_40]
call _ZNKSt16initializer_listIjE5beginEv; std::initializer_list<uint>::begin(void)
mov [rsp+68h+var_48], rax
mov rdi, [rsp+68h+var_40]
call _ZNKSt16initializer_listIjE3endEv; std::initializer_list<uint>::end(void)
mov [rsp+68h+var_50], rax
loc_A54ED:
mov rax, [rsp+68h+var_48]
cmp rax, [rsp+68h+var_50]
jz loc_A55C8
mov rdi, [rsp+68h+var_60]
mov rax, [rsp+68h+var_48]
mov eax, [rax]
mov [rsp+68h+var_54], eax
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 30h ; '0'
jl short loc_A5543
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 39h ; '9'
jg short loc_A5543
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 30h ; '0'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A55B3
loc_A5543:
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 41h ; 'A'
jl short loc_A5574
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 46h ; 'F'
jg short loc_A5574
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 37h ; '7'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A55B1
loc_A5574:
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 61h ; 'a'
jl short loc_A55A5
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 66h ; 'f'
jg short loc_A55A5
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 57h ; 'W'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A55AF
loc_A55A5:
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_A5603
loc_A55AF:
jmp short $+2
loc_A55B1:
jmp short $+2
loc_A55B3:
jmp short $+2
loc_A55B5:
mov rax, [rsp+68h+var_48]
add rax, 4
mov [rsp+68h+var_48], rax
jmp loc_A54ED
loc_A55C8:
xor eax, eax
cmp eax, [rsp+68h+var_14]
jg short loc_A55DA
cmp [rsp+68h+var_14], 0FFFFh
jle short loc_A55FB
loc_A55DA:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1D93h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x0000Codepoin; "0x0000 <= codepoint && codepoint <= 0xF"...
mov al, 0
call _ggml_abort
loc_A55FB:
mov eax, [rsp+68h+var_14]
mov [rsp+68h+var_4], eax
loc_A5603:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
| long long nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_codepoint(
long long a1)
{
int v2; // [rsp+14h] [rbp-54h]
long long v3; // [rsp+18h] [rbp-50h]
int *v4; // [rsp+20h] [rbp-48h]
_DWORD v5[4]; // [rsp+30h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+40h] [rbp-28h] BYREF
unsigned int v7; // [rsp+54h] [rbp-14h]
long long v8; // [rsp+58h] [rbp-10h]
v8 = a1;
if ( *(_DWORD *)(a1 + 20) != 117 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
v7 = 0;
v5[0] = 12;
v5[1] = 8;
v5[2] = 4;
v5[3] = 0;
v6[0] = v5;
v6[1] = 4LL;
v4 = (int *)std::initializer_list<unsigned int>::begin(v6);
v3 = std::initializer_list<unsigned int>::end(v6);
while ( v4 != (int *)v3 )
{
v2 = *v4;
nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( *(int *)(a1 + 20) < 48 || *(int *)(a1 + 20) > 57 )
{
if ( *(int *)(a1 + 20) < 65 || *(int *)(a1 + 20) > 70 )
{
if ( *(int *)(a1 + 20) < 97 || *(int *)(a1 + 20) > 102 )
return (unsigned int)-1;
v7 += (*(_DWORD *)(a1 + 20) - 87) << v2;
}
else
{
v7 += (*(_DWORD *)(a1 + 20) - 55) << v2;
}
}
else
{
v7 += (*(_DWORD *)(a1 + 20) - 48) << v2;
}
++v4;
}
if ( v7 >= 0x10000 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7571LL,
"GGML_ASSERT(%s) failed",
"0x0000 <= codepoint && codepoint <= 0xFFFF");
return v7;
}
| get_codepoint:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RAX + 0x14],0x75
JZ 0x001a548a
LEA RDI,[0x30d5de]
MOV ESI,0x1d79
LEA RDX,[0x3071d9]
LEA RCX,[0x30e311]
MOV AL,0x0
CALL 0x0015aef0
LAB_001a548a:
MOV dword ptr [RSP + 0x54],0x0
MOV dword ptr [RSP + 0x30],0xc
MOV dword ptr [RSP + 0x34],0x8
MOV dword ptr [RSP + 0x38],0x4
MOV dword ptr [RSP + 0x3c],0x0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],0x4
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a5870
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a5880
MOV qword ptr [RSP + 0x18],RAX
LAB_001a54ed:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x18]
JZ 0x001a55c8
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x14],EAX
CALL 0x001a4600
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x30
JL 0x001a5543
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x39
JG 0x001a5543
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x30
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a55b3
LAB_001a5543:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x41
JL 0x001a5574
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x46
JG 0x001a5574
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x37
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a55b1
LAB_001a5574:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x61
JL 0x001a55a5
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x66
JG 0x001a55a5
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x57
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a55af
LAB_001a55a5:
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001a5603
LAB_001a55af:
JMP 0x001a55b1
LAB_001a55b1:
JMP 0x001a55b3
LAB_001a55b3:
JMP 0x001a55b5
LAB_001a55b5:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x4
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001a54ed
LAB_001a55c8:
XOR EAX,EAX
CMP EAX,dword ptr [RSP + 0x54]
JG 0x001a55da
CMP dword ptr [RSP + 0x54],0xffff
JLE 0x001a55fb
LAB_001a55da:
LEA RDI,[0x30d5de]
MOV ESI,0x1d93
LEA RDX,[0x3071d9]
LEA RCX,[0x30e320]
MOV AL,0x0
CALL 0x0015aef0
LAB_001a55fb:
MOV EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x64],EAX
LAB_001a5603:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::get_codepoint() */
int __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get_codepoint(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int4 uVar1;
int iVar2;
int4 *puVar3;
byte bVar4;
int4 *local_48;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 *local_28;
int8 local_20;
int local_14;
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*local_10;
local_10 = this;
if (*(int *)(this + 0x14) != 0x75) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1d79,
"GGML_ASSERT(%s) failed","current == \'u\'");
}
local_14 = 0;
local_38 = 0xc;
local_34 = 8;
local_30 = 4;
local_2c = 0;
local_28 = &local_38;
local_20 = 4;
local_48 = (int4 *)
std::initializer_list<unsigned_int>::begin((initializer_list<unsigned_int> *)&local_28)
;
puVar3 = (int4 *)
std::initializer_list<unsigned_int>::end((initializer_list<unsigned_int> *)&local_28);
do {
if (local_48 == puVar3) {
if ((local_14 < 0) || (0xffff < local_14)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1d93,"GGML_ASSERT(%s) failed","0x0000 <= codepoint && codepoint <= 0xFFFF");
}
return local_14;
}
uVar1 = *local_48;
get(this);
bVar4 = (byte)uVar1;
if ((*(int *)(this + 0x14) < 0x30) || (0x39 < *(int *)(this + 0x14))) {
if ((*(int *)(this + 0x14) < 0x41) || (0x46 < *(int *)(this + 0x14))) {
if ((*(int *)(this + 0x14) < 0x61) || (0x66 < *(int *)(this + 0x14))) {
return -1;
}
iVar2 = *(int *)(this + 0x14) + -0x57 << (bVar4 & 0x1f);
}
else {
iVar2 = *(int *)(this + 0x14) + -0x37 << (bVar4 & 0x1f);
}
}
else {
iVar2 = *(int *)(this + 0x14) + -0x30 << (bVar4 & 0x1f);
}
local_14 = iVar2 + local_14;
local_48 = local_48 + 1;
} while( true );
}
| |
43,335 | utf8_decode_buf8 | bluesky950520[P]quickjs/cutils.c | size_t utf8_decode_buf8(uint8_t *dest, size_t dest_len, const char *src, size_t src_len)
{
const uint8_t *p, *p_end;
size_t i;
p = (const uint8_t *)src;
p_end = p + src_len;
for (i = 0; p < p_end; i++) {
uint32_t c = *p++;
if (c >= 0xC0)
c = (c << 6) + *p++ - ((0xC0 << 6) + 0x80);
if (i < dest_len)
dest[i] = c;
}
if (i < dest_len)
dest[i] = '\0';
else if (dest_len > 0)
dest[dest_len - 1] = '\0';
return i;
} | O1 | c | utf8_decode_buf8:
testq %rcx, %rcx
jle 0x1b962
addq %rdx, %rcx
xorl %eax, %eax
movb (%rdx), %r8b
cmpb $-0x40, %r8b
jb 0x1b94c
shlb $0x6, %r8b
addb 0x1(%rdx), %r8b
addq $0x2, %rdx
addb $-0x80, %r8b
jmp 0x1b94f
incq %rdx
cmpq %rsi, %rax
jae 0x1b958
movb %r8b, (%rdi,%rax)
incq %rax
cmpq %rcx, %rdx
jb 0x1b931
jmp 0x1b964
xorl %eax, %eax
cmpq %rsi, %rax
jae 0x1b96e
addq %rax, %rdi
jmp 0x1b979
testq %rsi, %rsi
je 0x1b97c
addq %rsi, %rdi
decq %rdi
movb $0x0, (%rdi)
retq
| utf8_decode_buf8:
test rcx, rcx
jle short loc_1B962
add rcx, rdx
xor eax, eax
loc_1B931:
mov r8b, [rdx]
cmp r8b, 0C0h
jb short loc_1B94C
shl r8b, 6
add r8b, [rdx+1]
add rdx, 2
add r8b, 80h
jmp short loc_1B94F
loc_1B94C:
inc rdx
loc_1B94F:
cmp rax, rsi
jnb short loc_1B958
mov [rdi+rax], r8b
loc_1B958:
inc rax
cmp rdx, rcx
jb short loc_1B931
jmp short loc_1B964
loc_1B962:
xor eax, eax
loc_1B964:
cmp rax, rsi
jnb short loc_1B96E
add rdi, rax
jmp short loc_1B979
loc_1B96E:
test rsi, rsi
jz short locret_1B97C
add rdi, rsi
dec rdi
loc_1B979:
mov byte ptr [rdi], 0
locret_1B97C:
retn
| unsigned long long utf8_decode_buf8(long long a1, unsigned long long a2, char *a3, long long a4)
{
char *v4; // rcx
unsigned long long result; // rax
char v6; // r8
char v7; // r8
_BYTE *v8; // rdi
if ( a4 <= 0 )
{
result = 0LL;
}
else
{
v4 = &a3[a4];
result = 0LL;
do
{
v6 = *a3;
if ( (unsigned __int8)*a3 < 0xC0u )
{
++a3;
}
else
{
v7 = a3[1] + (v6 << 6);
a3 += 2;
v6 = v7 + 0x80;
}
if ( result < a2 )
*(_BYTE *)(a1 + result) = v6;
++result;
}
while ( a3 < v4 );
}
if ( result >= a2 )
{
if ( !a2 )
return result;
v8 = (_BYTE *)(a2 + a1 - 1);
}
else
{
v8 = (_BYTE *)(result + a1);
}
*v8 = 0;
return result;
}
| |||
43,336 | utf8_decode_buf8 | bluesky950520[P]quickjs/cutils.c | size_t utf8_decode_buf8(uint8_t *dest, size_t dest_len, const char *src, size_t src_len)
{
const uint8_t *p, *p_end;
size_t i;
p = (const uint8_t *)src;
p_end = p + src_len;
for (i = 0; p < p_end; i++) {
uint32_t c = *p++;
if (c >= 0xC0)
c = (c << 6) + *p++ - ((0xC0 << 6) + 0x80);
if (i < dest_len)
dest[i] = c;
}
if (i < dest_len)
dest[i] = '\0';
else if (dest_len > 0)
dest[dest_len - 1] = '\0';
return i;
} | O2 | c | utf8_decode_buf8:
addq %rdx, %rcx
xorl %eax, %eax
cmpq %rcx, %rdx
jae 0x161df
movb (%rdx), %r8b
cmpb $-0x40, %r8b
jb 0x161ce
shlb $0x6, %r8b
addb 0x1(%rdx), %r8b
addq $0x2, %rdx
addb $-0x80, %r8b
jmp 0x161d1
incq %rdx
cmpq %rsi, %rax
jae 0x161da
movb %r8b, (%rdi,%rax)
incq %rax
jmp 0x161ae
cmpq %rsi, %rax
jae 0x161e9
addq %rax, %rdi
jmp 0x161f4
testq %rsi, %rsi
je 0x161f7
addq %rsi, %rdi
decq %rdi
movb $0x0, (%rdi)
retq
| utf8_decode_buf8:
add rcx, rdx
xor eax, eax
loc_161AE:
cmp rdx, rcx
jnb short loc_161DF
mov r8b, [rdx]
cmp r8b, 0C0h
jb short loc_161CE
shl r8b, 6
add r8b, [rdx+1]
add rdx, 2
add r8b, 80h
jmp short loc_161D1
loc_161CE:
inc rdx
loc_161D1:
cmp rax, rsi
jnb short loc_161DA
mov [rdi+rax], r8b
loc_161DA:
inc rax
jmp short loc_161AE
loc_161DF:
cmp rax, rsi
jnb short loc_161E9
add rdi, rax
jmp short loc_161F4
loc_161E9:
test rsi, rsi
jz short locret_161F7
add rdi, rsi
dec rdi
loc_161F4:
mov byte ptr [rdi], 0
locret_161F7:
retn
| unsigned long long utf8_decode_buf8(long long a1, unsigned long long a2, char *a3, long long a4)
{
char *v4; // rcx
unsigned long long result; // rax
char v6; // r8
char v7; // r8
_BYTE *v8; // rdi
v4 = &a3[a4];
result = 0LL;
while ( a3 < v4 )
{
v6 = *a3;
if ( (unsigned __int8)*a3 < 0xC0u )
{
++a3;
}
else
{
v7 = a3[1] + (v6 << 6);
a3 += 2;
v6 = v7 + 0x80;
}
if ( result < a2 )
*(_BYTE *)(a1 + result) = v6;
++result;
}
if ( result >= a2 )
{
if ( !a2 )
return result;
v8 = (_BYTE *)(a2 + a1 - 1);
}
else
{
v8 = (_BYTE *)(result + a1);
}
*v8 = 0;
return result;
}
| utf8_decode_buf8:
ADD RCX,RDX
XOR EAX,EAX
LAB_001161ae:
CMP RDX,RCX
JNC 0x001161df
MOV R8B,byte ptr [RDX]
CMP R8B,0xc0
JC 0x001161ce
SHL R8B,0x6
ADD R8B,byte ptr [RDX + 0x1]
ADD RDX,0x2
ADD R8B,0x80
JMP 0x001161d1
LAB_001161ce:
INC RDX
LAB_001161d1:
CMP RAX,RSI
JNC 0x001161da
MOV byte ptr [RDI + RAX*0x1],R8B
LAB_001161da:
INC RAX
JMP 0x001161ae
LAB_001161df:
CMP RAX,RSI
JNC 0x001161e9
ADD RDI,RAX
JMP 0x001161f4
LAB_001161e9:
TEST RSI,RSI
JZ 0x001161f7
ADD RDI,RSI
DEC RDI
LAB_001161f4:
MOV byte ptr [RDI],0x0
LAB_001161f7:
RET
|
void utf8_decode_buf8(long param_1,ulong param_2,byte *param_3,long param_4)
{
byte *pbVar1;
ulong uVar2;
byte *pbVar3;
int1 *puVar4;
byte bVar5;
pbVar3 = param_3 + param_4;
uVar2 = 0;
while (param_3 < pbVar3) {
bVar5 = *param_3;
if (bVar5 < 0xc0) {
param_3 = param_3 + 1;
}
else {
pbVar1 = param_3 + 1;
param_3 = param_3 + 2;
bVar5 = bVar5 * '@' + *pbVar1 + 0x80;
}
if (uVar2 < param_2) {
*(byte *)(param_1 + uVar2) = bVar5;
}
uVar2 = uVar2 + 1;
}
if (uVar2 < param_2) {
puVar4 = (int1 *)(param_1 + uVar2);
}
else {
if (param_2 == 0) {
return;
}
puVar4 = (int1 *)(param_1 + param_2 + -1);
}
*puVar4 = 0;
return;
}
| |
43,337 | cleanup_memory_class() | eloqsql/storage/perfschema/pfs_instr_class.cc | void cleanup_memory_class(void)
{
PFS_FREE_ARRAY(& builtin_memory_memory_class,
memory_class_max, sizeof(PFS_memory_class),
memory_class_array);
memory_class_array= NULL;
memory_class_dirty_count= memory_class_allocated_count= 0;
memory_class_max= 0;
} | O0 | cpp | cleanup_memory_class():
pushq %rbp
movq %rsp, %rbp
movq 0x3cbf95(%rip), %rsi # 0x40ea80
movq 0x3cc826(%rip), %rcx # 0x40f318
leaq 0x3c9c07(%rip), %rdi # 0x40c700
movl $0xc0, %edx
callq 0x29970
movq $0x0, 0x3cc80a(%rip) # 0x40f318
movl $0x0, 0x3cc7f8(%rip) # 0x40f310
movl $0x0, 0x3cc7f2(%rip) # 0x40f314
movq $0x0, 0x3cbf53(%rip) # 0x40ea80
popq %rbp
retq
nop
| _Z20cleanup_memory_classv:
push rbp
mov rbp, rsp
mov rsi, cs:memory_class_max
mov rcx, cs:_ZL18memory_class_array; memory_class_array
lea rdi, builtin_memory_memory_class
mov edx, 0C0h
call _Z14pfs_free_arrayP24PFS_builtin_memory_classmmPv; pfs_free_array(PFS_builtin_memory_class *,ulong,ulong,void *)
mov cs:_ZL18memory_class_array, 0; memory_class_array
mov cs:_ZL28memory_class_allocated_count, 0; memory_class_allocated_count
mov cs:_ZL24memory_class_dirty_count, 0; memory_class_dirty_count
mov cs:memory_class_max, 0
pop rbp
retn
| long long cleanup_memory_class(void)
{
long long result; // rax
result = pfs_free_array(
(PFS_builtin_memory_class *)&builtin_memory_memory_class,
memory_class_max,
192LL,
(void *)memory_class_array);
memory_class_array = 0LL;
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = 0LL;
return result;
}
| cleanup_memory_class:
PUSH RBP
MOV RBP,RSP
MOV RSI,qword ptr [0x0050ea80]
MOV RCX,qword ptr [0x0050f318]
LEA RDI,[0x50c700]
MOV EDX,0xc0
CALL 0x00129970
MOV qword ptr [0x0050f318],0x0
MOV dword ptr [0x0050f310],0x0
MOV dword ptr [0x0050f314],0x0
MOV qword ptr [0x0050ea80],0x0
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cleanup_memory_class() */
void cleanup_memory_class(void)
{
pfs_free_array((PFS_builtin_memory_class *)builtin_memory_memory_class,memory_class_max,0xc0,
memory_class_array);
memory_class_array = (void *)0x0;
memory_class_allocated_count = 0;
memory_class_dirty_count = 0;
memory_class_max = 0;
return;
}
| |
43,338 | mz_zip_mem_read_func | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs,
void *pBuf, size_t n) {
mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
size_t s = (file_ofs >= pZip->m_archive_size)
? 0
: (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
return s;
} | O0 | c | mz_zip_mem_read_func:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jb 0xff73a
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xff776
movq 0x20(%rsp), %rax
movq (%rax), %rax
subq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0xff762
movq 0x20(%rsp), %rax
movq (%rax), %rax
subq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0xff76c
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x80(%rax), %rsi
addq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb600
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nop
| mz_zip_mem_read_func:
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
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_10]
mov rcx, [rsp+48h+var_28]
cmp rax, [rcx]
jb short loc_FF73A
xor eax, eax
mov [rsp+48h+var_38], rax
jmp short loc_FF776
loc_FF73A:
mov rax, [rsp+48h+var_28]
mov rax, [rax]
sub rax, [rsp+48h+var_10]
cmp rax, [rsp+48h+var_20]
jnb short loc_FF762
mov rax, [rsp+48h+var_28]
mov rax, [rax]
sub rax, [rsp+48h+var_10]
mov [rsp+48h+var_40], rax
jmp short loc_FF76C
loc_FF762:
mov rax, [rsp+48h+var_20]
mov [rsp+48h+var_40], rax
loc_FF76C:
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_38], rax
loc_FF776:
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_30], rax
mov rdi, [rsp+48h+var_18]
mov rax, [rsp+48h+var_28]
mov rax, [rax+68h]
mov rsi, [rax+80h]
add rsi, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_30]
call _memcpy
mov rax, [rsp+48h+var_30]
add rsp, 48h
retn
| unsigned long long mz_zip_mem_read_func(
unsigned long long *a1,
unsigned long long a2,
long long a3,
unsigned long long a4)
{
unsigned long long v5; // [rsp+8h] [rbp-40h]
unsigned long long v6; // [rsp+10h] [rbp-38h]
if ( a2 < *a1 )
{
if ( *a1 - a2 >= a4 )
v5 = a4;
else
v5 = *a1 - a2;
v6 = v5;
}
else
{
v6 = 0LL;
}
memcpy(a3, a2 + *(_QWORD *)(a1[13] + 128), v6);
return v6;
}
| mz_zip_mem_read_func:
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
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RCX]
JC 0x001ff73a
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001ff776
LAB_001ff73a:
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RSP + 0x38]
CMP RAX,qword ptr [RSP + 0x28]
JNC 0x001ff762
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001ff76c
LAB_001ff762:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
LAB_001ff76c:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_001ff776:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x68]
MOV RSI,qword ptr [RAX + 0x80]
ADD RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0010b600
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x48
RET
|
size_t mz_zip_mem_read_func(ulong *param_1,ulong param_2,void *param_3,ulong param_4)
{
ulong local_40;
size_t local_38;
if (param_2 < *param_1) {
local_40 = param_4;
if (*param_1 - param_2 < param_4) {
local_40 = *param_1 - param_2;
}
local_38 = local_40;
}
else {
local_38 = 0;
}
memcpy(param_3,(void *)(*(long *)(param_1[0xd] + 0x80) + param_2),local_38);
return local_38;
}
| |
43,339 | mz_zip_mem_read_func | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs,
void *pBuf, size_t n) {
mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
size_t s = (file_ofs >= pZip->m_archive_size)
? 0
: (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
return s;
} | O1 | c | mz_zip_mem_read_func:
pushq %rbx
movq (%rdi), %rax
movq %rax, %r8
subq %rsi, %r8
cmpq %rcx, %r8
cmovaeq %rcx, %r8
xorl %ebx, %ebx
cmpq %rsi, %rax
cmovaq %r8, %rbx
movq 0x68(%rdi), %rax
addq 0x80(%rax), %rsi
movq %rdx, %rdi
movq %rbx, %rdx
callq 0xa4c0
movq %rbx, %rax
popq %rbx
retq
| mz_zip_mem_read_func:
push rbx
mov rax, [rdi]
mov r8, rax
sub r8, rsi
cmp r8, rcx
cmovnb r8, rcx
xor ebx, ebx
cmp rax, rsi
cmova rbx, r8
mov rax, [rdi+68h]
add rsi, [rax+80h]
mov rdi, rdx
mov rdx, rbx
call _memcpy
mov rax, rbx
pop rbx
retn
| unsigned long long mz_zip_mem_read_func(_QWORD *a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // r8
unsigned long long v5; // rbx
v4 = *a1 - a2;
if ( v4 >= a4 )
v4 = a4;
v5 = 0LL;
if ( *a1 > a2 )
v5 = v4;
memcpy(a3, *(_QWORD *)(a1[13] + 128LL) + a2, v5);
return v5;
}
| |||
43,340 | mz_zip_mem_read_func | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs,
void *pBuf, size_t n) {
mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
size_t s = (file_ofs >= pZip->m_archive_size)
? 0
: (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
return s;
} | O2 | c | mz_zip_mem_read_func:
pushq %rbx
movq (%rdi), %rax
movq %rax, %r8
subq %rsi, %r8
cmpq %rcx, %r8
cmovaeq %rcx, %r8
xorl %ebx, %ebx
cmpq %rsi, %rax
cmovaq %r8, %rbx
movq 0x68(%rdi), %rax
addq 0x80(%rax), %rsi
movq %rdx, %rdi
movq %rbx, %rdx
callq 0xa4c0
movq %rbx, %rax
popq %rbx
retq
| mz_zip_mem_read_func:
push rbx
mov rax, [rdi]
mov r8, rax
sub r8, rsi
cmp r8, rcx
cmovnb r8, rcx
xor ebx, ebx
cmp rax, rsi
cmova rbx, r8
mov rax, [rdi+68h]
add rsi, [rax+80h]
mov rdi, rdx
mov rdx, rbx
call _memcpy
mov rax, rbx
pop rbx
retn
| unsigned long long mz_zip_mem_read_func(_QWORD *a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // r8
unsigned long long v5; // rbx
v4 = *a1 - a2;
if ( v4 >= a4 )
v4 = a4;
v5 = 0LL;
if ( *a1 > a2 )
v5 = v4;
memcpy(a3, *(_QWORD *)(a1[13] + 128LL) + a2, v5);
return v5;
}
| mz_zip_mem_read_func:
PUSH RBX
MOV RAX,qword ptr [RDI]
MOV R8,RAX
SUB R8,RSI
CMP R8,RCX
CMOVNC R8,RCX
XOR EBX,EBX
CMP RAX,RSI
CMOVA RBX,R8
MOV RAX,qword ptr [RDI + 0x68]
ADD RSI,qword ptr [RAX + 0x80]
MOV RDI,RDX
MOV RDX,RBX
CALL 0x0010a4c0
MOV RAX,RBX
POP RBX
RET
|
size_t mz_zip_mem_read_func(ulong *param_1,ulong param_2,void *param_3,ulong param_4)
{
size_t __n;
ulong uVar1;
uVar1 = *param_1 - param_2;
if (param_4 <= uVar1) {
uVar1 = param_4;
}
__n = 0;
if (param_2 < *param_1) {
__n = uVar1;
}
memcpy(param_3,(void *)(param_2 + *(long *)(param_1[0xd] + 0x80)),__n);
return __n;
}
| |
43,341 | mz_zip_mem_read_func | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs,
void *pBuf, size_t n) {
mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
size_t s = (file_ofs >= pZip->m_archive_size)
? 0
: (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
return s;
} | O3 | c | mz_zip_mem_read_func:
pushq %rbx
movq (%rdi), %rax
movq %rax, %r8
subq %rsi, %r8
cmpq %rcx, %r8
cmovaeq %rcx, %r8
xorl %ebx, %ebx
cmpq %rsi, %rax
cmovaq %r8, %rbx
movq 0x68(%rdi), %rax
addq 0x80(%rax), %rsi
movq %rdx, %rdi
movq %rbx, %rdx
callq 0xa4b0
movq %rbx, %rax
popq %rbx
retq
| mz_zip_mem_read_func:
push rbx
mov rax, [rdi]
mov r8, rax
sub r8, rsi
cmp r8, rcx
cmovnb r8, rcx
xor ebx, ebx
cmp rax, rsi
cmova rbx, r8
mov rax, [rdi+68h]
add rsi, [rax+80h]
mov rdi, rdx
mov rdx, rbx
call _memcpy
mov rax, rbx
pop rbx
retn
| unsigned long long mz_zip_mem_read_func(_QWORD *a1, unsigned long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // r8
unsigned long long v5; // rbx
v4 = *a1 - a2;
if ( v4 >= a4 )
v4 = a4;
v5 = 0LL;
if ( *a1 > a2 )
v5 = v4;
memcpy(a3, *(_QWORD *)(a1[13] + 128LL) + a2, v5);
return v5;
}
| |||
43,342 | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool) | llama.cpp/common/json.hpp | explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xe6cba
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
movups (%r12), %xmm0
movups %xmm0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movb %r15b, 0x38(%rbx)
movl $0xffffffff, 0x3c(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x40(%rbx)
leaq 0x88(%rbx), %rcx
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movb %al, 0x88(%rbx)
leaq 0x9ee66(%rip), %rcx # 0x185ab0
movq %rcx, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
movq %rax, 0xb0(%rbx)
callq 0xe6d52
movsbl %al, %eax
movl %eax, 0xb8(%rbx)
movb %bpl, 0xc0(%rbx)
movq %r14, %rdi
callq 0xe6d96
movl %eax, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xe6d18
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xe6ca9
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r15, %rdi
callq 0x25ca0
movq %rax, %rdi
callq 0x46453
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEEC2EOSG_St8functionIFbiNS1_13parse_event_tERSF_EEbb:
push rbp
push r15
push r14
push r12
push rbx
mov r15d, r8d
mov ebp, ecx
mov r12, rsi
mov rbx, rdi
mov rsi, rdx
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
mov dword ptr [rbx+20h], 0
lea r14, [rbx+28h]
movups xmm0, xmmword ptr [r12]
movups xmmword ptr [rbx+28h], xmm0
xorps xmm0, xmm0
movups xmmword ptr [r12], xmm0
mov [rbx+38h], r15b
mov dword ptr [rbx+3Ch], 0FFFFFFFFh
xor eax, eax
mov [rbx+40h], al
lea rcx, [rbx+88h]
movups xmmword ptr [rbx+48h], xmm0
movups xmmword ptr [rbx+58h], xmm0
movups xmmword ptr [rbx+68h], xmm0
mov [rbx+78h], rcx
mov [rbx+80h], rax
mov [rbx+88h], al
lea rcx, aExampleToolCal+1Dh; ""
mov [rbx+98h], rcx
movups xmmword ptr [rbx+0A0h], xmm0
mov [rbx+0B0h], rax
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE17get_decimal_pointEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_decimal_point(void)
movsx eax, al
mov [rbx+0B8h], eax
mov [rbx+0C0h], bpl
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEE4scanEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan(void)
mov [rbx+20h], eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov r15, rax
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_20input_stream_adapterEED2Ev; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::~lexer()
mov rax, [rbx+10h]
test rax, rax
jz short loc_E6CA9
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_E6CA9:
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(
long long a1,
_OWORD *a2,
long long a3,
char a4,
char a5)
{
long long result; // rax
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
a1,
a3);
*(_DWORD *)(a1 + 32) = 0;
*(_OWORD *)(a1 + 40) = *a2;
*a2 = 0LL;
*(_BYTE *)(a1 + 56) = a5;
*(_DWORD *)(a1 + 60) = -1;
*(_BYTE *)(a1 + 64) = 0;
*(_OWORD *)(a1 + 72) = 0LL;
*(_OWORD *)(a1 + 88) = 0LL;
*(_OWORD *)(a1 + 104) = 0LL;
*(_QWORD *)(a1 + 120) = a1 + 136;
*(_QWORD *)(a1 + 128) = 0LL;
*(_BYTE *)(a1 + 136) = 0;
*(_QWORD *)(a1 + 152) = "";
*(_OWORD *)(a1 + 160) = 0LL;
*(_QWORD *)(a1 + 176) = 0LL;
*(_DWORD *)(a1 + 184) = (char)nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get_decimal_point();
*(_BYTE *)(a1 + 192) = a4;
result = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::scan((nlohmann::json_abi_v3_11_3::detail::input_stream_adapter *)(a1 + 40));
*(_DWORD *)(a1 + 32) = result;
return result;
}
| parser:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,R8D
MOV EBP,ECX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RDX
CALL 0x001e6cba
MOV dword ptr [RBX + 0x20],0x0
LEA R14,[RBX + 0x28]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RBX + 0x28],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R12],XMM0
MOV byte ptr [RBX + 0x38],R15B
MOV dword ptr [RBX + 0x3c],0xffffffff
XOR EAX,EAX
MOV byte ptr [RBX + 0x40],AL
LEA RCX,[RBX + 0x88]
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
MOVUPS xmmword ptr [RBX + 0x68],XMM0
MOV qword ptr [RBX + 0x78],RCX
MOV qword ptr [RBX + 0x80],RAX
MOV byte ptr [RBX + 0x88],AL
LEA RCX,[0x285ab0]
MOV qword ptr [RBX + 0x98],RCX
MOVUPS xmmword ptr [RBX + 0xa0],XMM0
MOV qword ptr [RBX + 0xb0],RAX
CALL 0x001e6d52
MOVSX EAX,AL
MOV dword ptr [RBX + 0xb8],EAX
MOV byte ptr [RBX + 0xc0],BPL
LAB_001e6c74:
MOV RDI,R14
CALL 0x001e6d96
MOV dword ptr [RBX + 0x20],EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::parser(nlohmann::json_abi_v3_11_3::detail::input_stream_adapter&&,
std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >, void>&)>, bool, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::parser(parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*this,int8 *param_1,function *param_3,
parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
param_4,parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
param_5)
{
int8 uVar1;
char cVar2;
int4 uVar3;
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)this,param_3);
*(int4 *)(this + 0x20) = 0;
uVar1 = param_1[1];
*(int8 *)(this + 0x28) = *param_1;
*(int8 *)(this + 0x30) = uVar1;
*param_1 = 0;
param_1[1] = 0;
this[0x38] = param_5;
*(int4 *)(this + 0x3c) = 0xffffffff;
this[0x40] = (parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
)0x0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
**)(this + 0x78) = this + 0x88;
*(int8 *)(this + 0x80) = 0;
this[0x88] = (parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
)0x0;
*(char **)(this + 0x98) = "";
*(int8 *)(this + 0xa0) = 0;
*(int8 *)(this + 0xa8) = 0;
*(int8 *)(this + 0xb0) = 0;
cVar2 = lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::get_decimal_point();
*(int *)(this + 0xb8) = (int)cVar2;
this[0xc0] = param_4;
/* try { // try from 001e6c74 to 001e6c7b has its CatchHandler @ 001e6c88 */
uVar3 = lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
::scan((lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>
*)(this + 0x28));
*(int4 *)(this + 0x20) = uVar3;
return;
}
| |
43,343 | ma_trid_from_key | eloqsql/storage/maria/ma_search.c | TrID _ma_trid_from_key(const MARIA_KEY *key)
{
if (!(key->flag & (SEARCH_PAGE_KEY_HAS_TRANSID |
SEARCH_USER_KEY_HAS_TRANSID)))
return 0;
return transid_get_packed(key->keyinfo->share,
key->data + key->data_length +
key->keyinfo->share->rec_reflength);
} | O0 | c | ma_trid_from_key:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x180000, %eax # imm = 0x180000
cmpl $0x0, %eax
jne 0x6b227
movq $0x0, -0x8(%rbp)
jmp 0x6b260
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x740(%rax), %eax
addq %rax, %rsi
callq 0x33b20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_trid_from_key:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax+18h]
and eax, 180000h
cmp eax, 0
jnz short loc_6B227
mov [rbp+var_8], 0
jmp short loc_6B260
loc_6B227:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+10h]
add rsi, rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax]
mov eax, [rax+740h]
add rsi, rax
call transid_get_packed
mov [rbp+var_8], rax
loc_6B260:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| unsigned long long ma_trid_from_key(long long a1)
{
if ( (*(_DWORD *)(a1 + 24) & 0x180000) != 0 )
return transid_get_packed(
**(_QWORD **)(a1 + 8),
(unsigned __int8 *)(*(unsigned int *)(**(_QWORD **)(a1 + 8) + 1856LL)
+ *(unsigned int *)(a1 + 16)
+ *(_QWORD *)a1));
else
return 0LL;
}
| _ma_trid_from_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x18]
AND EAX,0x180000
CMP EAX,0x0
JNZ 0x0016b227
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0016b260
LAB_0016b227:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x740]
ADD RSI,RAX
CALL 0x00133b20
MOV qword ptr [RBP + -0x8],RAX
LAB_0016b260:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 _ma_trid_from_key(long *param_1)
{
int8 local_10;
if ((*(uint *)(param_1 + 3) & 0x180000) == 0) {
local_10 = 0;
}
else {
local_10 = transid_get_packed(*(int8 *)param_1[1],
*param_1 + (ulong)*(uint *)(param_1 + 2) +
(ulong)*(uint *)(*(long *)param_1[1] + 0x740));
}
return local_10;
}
| |
43,344 | bitmap_exists_intersection | eloqsql/mysys/my_bitmap.c | my_bool bitmap_exists_intersection(const MY_BITMAP **bitmap_array,
uint bitmap_count,
uint start_bit, uint end_bit)
{
uint i, j, start_idx, end_idx;
my_bitmap_map cur_res;
DBUG_ASSERT(bitmap_count);
DBUG_ASSERT(end_bit >= start_bit);
for (j= 0; j < bitmap_count; j++)
DBUG_ASSERT(end_bit < bitmap_array[j]->n_bits);
start_idx= start_bit/8/sizeof(my_bitmap_map);
end_idx= end_bit/8/sizeof(my_bitmap_map);
for (i= start_idx; i < end_idx; i++)
{
cur_res= ~0;
for (j= 0; cur_res && j < bitmap_count; j++)
cur_res &= bitmap_array[j]->bitmap[i];
if (cur_res)
return TRUE;
}
cur_res= ~last_word_mask(end_bit);
for (j= 0; cur_res && j < bitmap_count; j++)
cur_res &= bitmap_array[j]->bitmap[end_idx];
return cur_res != 0;
} | O3 | c | bitmap_exists_intersection:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
shrl $0x5, %edx
movl %ecx, %r8d
shrl $0x5, %r8d
cmpl %r8d, %edx
jae 0xa12ab
movl %esi, %r9d
leal (%r8,%rdx), %r10d
subl %edx, %r10d
movb $0x1, %al
testl %esi, %esi
je 0xa135b
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movl $0x1, %ebx
movq -0x8(%rdi,%rbx,8), %r14
movq (%r14), %r14
andl (%r14,%rdx,4), %r11d
je 0xa129a
leaq 0x1(%rbx), %r14
cmpq %r9, %rbx
movq %r14, %rbx
jb 0xa1280
testl %r11d, %r11d
jne 0xa135b
incq %rdx
cmpq %r10, %rdx
jne 0xa126d
movl %ecx, %eax
andl $0x7, %eax
addl $0x8, %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x48ddc(%rip), %rdx # 0xea09c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0xfe000000, %r9d # imm = 0xFE000000
movl %eax, %ecx
shll %cl, %r9d
xorl %edx, %edx
xorl %eax, %eax
jmp 0xa1301
movl $0xfffffe00, %edx # imm = 0xFFFFFE00
movl %eax, %ecx
shll %cl, %edx
movzwl %dx, %eax
xorl %ecx, %ecx
jmp 0xa1316
movl $0xfffe0000, %edx # imm = 0xFFFE0000
movl %eax, %ecx
shll %cl, %edx
andl $0xfe0000, %edx # imm = 0xFE0000
xorl %eax, %eax
movl $0xff000000, %r9d # imm = 0xFF000000
xorl %ecx, %ecx
jmp 0xa1321
movl $0xfffffffe, %edx # imm = 0xFFFFFFFE
movl %eax, %ecx
shll %cl, %edx
movzbl %dl, %ecx
movl $0xff00, %eax # imm = 0xFF00
movl $0xff0000, %edx # imm = 0xFF0000
movl $0xff000000, %r9d # imm = 0xFF000000
testl %esi, %esi
je 0xa1359
orl %r9d, %edx
orl %ecx, %eax
orl %edx, %eax
notl %eax
movl %r8d, %ecx
movl %esi, %edx
movl $0x1, %esi
movq -0x8(%rdi,%rsi,8), %r8
movq (%r8), %r8
andl (%r8,%rcx,4), %eax
je 0xa1352
leaq 0x1(%rsi), %r8
cmpq %rdx, %rsi
movq %r8, %rsi
jb 0xa1338
testl %eax, %eax
setne %al
jmp 0xa135b
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
| bitmap_exists_intersection:
push rbp
mov rbp, rsp
push r14
push rbx
shr edx, 5
mov r8d, ecx
shr r8d, 5
cmp edx, r8d
jnb short loc_A12AB
mov r9d, esi
lea r10d, [r8+rdx]
sub r10d, edx
mov al, 1
loc_A126D:
test esi, esi
jz loc_A135B
mov r11d, 0FFFFFFFFh
mov ebx, 1
loc_A1280:
mov r14, [rdi+rbx*8-8]
mov r14, [r14]
and r11d, [r14+rdx*4]
jz short loc_A129A
lea r14, [rbx+1]
cmp rbx, r9
mov rbx, r14
jb short loc_A1280
loc_A129A:
test r11d, r11d
jnz loc_A135B
inc rdx
cmp rdx, r10
jnz short loc_A126D
loc_A12AB:
mov eax, ecx
and eax, 7
add ecx, 8
shr ecx, 3
and ecx, 3
lea rdx, jpt_A12C7
movsxd rcx, ds:(jpt_A12C7 - 0EA09Ch)[rdx+rcx*4]; switch 4 cases
add rcx, rdx
jmp rcx; switch jump
loc_A12C9:
mov r9d, 0FE000000h; jumptable 00000000000A12C7 case 0
mov ecx, eax
shl r9d, cl
xor edx, edx
xor eax, eax
jmp short loc_A1301
loc_A12DA:
mov edx, 0FFFFFE00h; jumptable 00000000000A12C7 case 2
mov ecx, eax
shl edx, cl
movzx eax, dx
xor ecx, ecx
jmp short loc_A1316
loc_A12EA:
mov edx, 0FFFE0000h; jumptable 00000000000A12C7 case 3
mov ecx, eax
shl edx, cl
and edx, 0FE0000h
xor eax, eax
mov r9d, 0FF000000h
loc_A1301:
xor ecx, ecx
jmp short loc_A1321
loc_A1305:
mov edx, 0FFFFFFFEh; jumptable 00000000000A12C7 case 1
mov ecx, eax
shl edx, cl
movzx ecx, dl
mov eax, 0FF00h
loc_A1316:
mov edx, 0FF0000h
mov r9d, 0FF000000h
loc_A1321:
test esi, esi
jz short loc_A1359
or edx, r9d
or eax, ecx
or eax, edx
not eax
mov ecx, r8d
mov edx, esi
mov esi, 1
loc_A1338:
mov r8, [rdi+rsi*8-8]
mov r8, [r8]
and eax, [r8+rcx*4]
jz short loc_A1352
lea r8, [rsi+1]
cmp rsi, rdx
mov rsi, r8
jb short loc_A1338
loc_A1352:
test eax, eax
setnz al
jmp short loc_A135B
loc_A1359:
mov al, 1
loc_A135B:
pop rbx
pop r14
pop rbp
retn
| bool bitmap_exists_intersection(long long a1, unsigned int a2, unsigned int a3, unsigned int a4)
{
long long v4; // rdx
unsigned int v5; // r8d
bool result; // al
int v7; // r11d
unsigned long long v8; // rbx
bool v9; // cf
char v10; // al
int v11; // r9d
int v12; // edx
int v13; // eax
int v14; // ecx
int v15; // eax
unsigned long long v16; // rdx
unsigned long long v17; // rsi
v4 = a3 >> 5;
v5 = a4 >> 5;
if ( (unsigned int)v4 >= a4 >> 5 )
{
LABEL_9:
v10 = a4 & 7;
switch ( ((a4 + 8) >> 3) & 3 )
{
case 0u:
v11 = -33554432 << v10;
v12 = 0;
v13 = 0;
goto LABEL_13;
case 1u:
v14 = (unsigned __int8)(-2 << v10);
v13 = 65280;
goto LABEL_15;
case 2u:
v13 = (unsigned __int16)(-512 << v10);
v14 = 0;
LABEL_15:
v12 = 16711680;
v11 = -16777216;
break;
case 3u:
v12 = (-131072 << v10) & 0xFE0000;
v13 = 0;
v11 = -16777216;
LABEL_13:
v14 = 0;
break;
}
if ( a2 )
{
v15 = ~(v11 | v12 | v14 | v13);
v16 = a2;
v17 = 1LL;
do
{
v15 &= *(_DWORD *)(**(_QWORD **)(a1 + 8 * v17 - 8) + 4LL * v5);
if ( !v15 )
break;
v9 = v17++ < v16;
}
while ( v9 );
return v15 != 0;
}
else
{
return 1;
}
}
else
{
result = 1;
while ( a2 )
{
v7 = -1;
v8 = 1LL;
do
{
v7 &= *(_DWORD *)(**(_QWORD **)(a1 + 8 * v8 - 8) + 4 * v4);
if ( !v7 )
break;
v9 = v8++ < a2;
}
while ( v9 );
if ( v7 )
break;
if ( ++v4 == v5 )
goto LABEL_9;
}
}
return result;
}
| bitmap_exists_intersection:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SHR EDX,0x5
MOV R8D,ECX
SHR R8D,0x5
CMP EDX,R8D
JNC 0x001a12ab
MOV R9D,ESI
LEA R10D,[R8 + RDX*0x1]
SUB R10D,EDX
MOV AL,0x1
LAB_001a126d:
TEST ESI,ESI
JZ 0x001a135b
MOV R11D,0xffffffff
MOV EBX,0x1
LAB_001a1280:
MOV R14,qword ptr [RDI + RBX*0x8 + -0x8]
MOV R14,qword ptr [R14]
AND R11D,dword ptr [R14 + RDX*0x4]
JZ 0x001a129a
LEA R14,[RBX + 0x1]
CMP RBX,R9
MOV RBX,R14
JC 0x001a1280
LAB_001a129a:
TEST R11D,R11D
JNZ 0x001a135b
INC RDX
CMP RDX,R10
JNZ 0x001a126d
LAB_001a12ab:
MOV EAX,ECX
AND EAX,0x7
ADD ECX,0x8
SHR ECX,0x3
AND ECX,0x3
LEA RDX,[0x1ea09c]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_0:
MOV R9D,0xfe000000
MOV ECX,EAX
SHL R9D,CL
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001a1301
caseD_2:
MOV EDX,0xfffffe00
MOV ECX,EAX
SHL EDX,CL
MOVZX EAX,DX
XOR ECX,ECX
JMP 0x001a1316
caseD_3:
MOV EDX,0xfffe0000
MOV ECX,EAX
SHL EDX,CL
AND EDX,0xfe0000
XOR EAX,EAX
MOV R9D,0xff000000
LAB_001a1301:
XOR ECX,ECX
JMP 0x001a1321
caseD_1:
MOV EDX,0xfffffffe
MOV ECX,EAX
SHL EDX,CL
MOVZX ECX,DL
MOV EAX,0xff00
LAB_001a1316:
MOV EDX,0xff0000
MOV R9D,0xff000000
LAB_001a1321:
TEST ESI,ESI
JZ 0x001a1359
OR EDX,R9D
OR EAX,ECX
OR EAX,EDX
NOT EAX
MOV ECX,R8D
MOV EDX,ESI
MOV ESI,0x1
LAB_001a1338:
MOV R8,qword ptr [RDI + RSI*0x8 + -0x8]
MOV R8,qword ptr [R8]
AND EAX,dword ptr [R8 + RCX*0x4]
JZ 0x001a1352
LEA R8,[RSI + 0x1]
CMP RSI,RDX
MOV RSI,R8
JC 0x001a1338
LAB_001a1352:
TEST EAX,EAX
SETNZ AL
JMP 0x001a135b
LAB_001a1359:
MOV AL,0x1
LAB_001a135b:
POP RBX
POP R14
POP RBP
RET
|
bool bitmap_exists_intersection(long param_1,uint param_2,uint param_3,uint param_4)
{
uint uVar1;
byte bVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
bool bVar9;
uVar4 = (ulong)(param_3 >> 5);
uVar6 = param_4 >> 5;
if (param_3 >> 5 < uVar6) {
do {
if (param_2 == 0) {
return true;
}
uVar8 = 0xffffffff;
uVar5 = 1;
do {
uVar8 = uVar8 & *(uint *)(**(long **)(param_1 + -8 + uVar5 * 8) + uVar4 * 4);
if (uVar8 == 0) break;
bVar9 = uVar5 < param_2;
uVar5 = uVar5 + 1;
} while (bVar9);
if (uVar8 != 0) {
return true;
}
uVar4 = uVar4 + 1;
} while (uVar4 != uVar6);
}
bVar2 = (byte)param_4 & 7;
switch(param_4 + 8 >> 3 & 3) {
case 0:
uVar7 = -0x2000000 << bVar2;
uVar8 = 0;
break;
case 1:
uVar3 = -2 << bVar2 & 0xff;
uVar1 = 0xff00;
goto LAB_001a1316;
case 2:
uVar1 = -0x200 << bVar2 & 0xffff;
uVar3 = 0;
LAB_001a1316:
uVar8 = 0xff0000;
uVar7 = 0xff000000;
goto LAB_001a1321;
case 3:
uVar8 = -0x20000 << bVar2 & 0xfe0000;
uVar7 = 0xff000000;
}
uVar1 = 0;
uVar3 = 0;
LAB_001a1321:
if (param_2 == 0) {
bVar9 = true;
}
else {
uVar8 = ~(uVar1 | uVar3 | uVar8 | uVar7);
uVar4 = 1;
do {
uVar8 = uVar8 & *(uint *)(**(long **)(param_1 + -8 + uVar4 * 8) + (ulong)uVar6 * 4);
if (uVar8 == 0) break;
bVar9 = uVar4 < param_2;
uVar4 = uVar4 + 1;
} while (bVar9);
bVar9 = uVar8 != 0;
}
return bVar9;
}
| |
43,345 | my_hash_first | eloqsql/mysys/hash.c | uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
uchar *res;
DBUG_ASSERT(my_hash_inited(hash));
res= my_hash_first_from_hash_value(hash,
hash->hash_function(hash->charset, key,
length ? length :
hash->key_length),
key, length, current_record);
return res;
} | O0 | c | my_hash_first:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xb4eca
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb4f03
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xb4f0f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
callq *%rax
movq -0x48(%rbp), %rdi
movl %eax, %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xb4f90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_first:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
jmp short $+2
loc_B4ECA:
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+68h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
cmp [rbp+var_18], 0
jz short loc_B4F03
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_B4F0F
loc_B4F03:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_50], rax
loc_B4F0F:
mov rax, [rbp+var_40]
mov rsi, [rbp+var_30]
mov rdi, [rbp+var_38]
mov rdx, [rbp+var_50]
call rax
mov rdi, [rbp+var_48]
mov esi, eax
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call my_hash_first_from_hash_value
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 50h
pop rbp
retn
| long long my_hash_first(_QWORD *a1, long long a2, long long a3, long long a4)
{
unsigned int v4; // eax
long long ( *v6)(long long, long long, long long); // [rsp+10h] [rbp-40h]
long long v7; // [rsp+18h] [rbp-38h]
v6 = (long long ( *)(long long, long long, long long))a1[11];
v7 = a1[13];
if ( a3 )
v4 = v6(v7, a2, a3);
else
v4 = v6(v7, a2, a1[1]);
return my_hash_first_from_hash_value(a1, v4, a2, a3, a4);
}
| my_hash_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x001b4eca
LAB_001b4eca:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001b4f03
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001b4f0f
LAB_001b4f03:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x50],RAX
LAB_001b4f0f:
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x50]
CALL RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL 0x001b4f90
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x50
POP RBP
RET
|
int8 my_hash_first(long param_1,int8 param_2,long param_3,int8 param_4)
{
int4 uVar1;
int8 uVar2;
int8 local_58;
local_58 = param_3;
if (param_3 == 0) {
local_58 = *(long *)(param_1 + 8);
}
uVar1 = (**(code **)(param_1 + 0x58))(*(int8 *)(param_1 + 0x68),param_2,local_58);
uVar2 = my_hash_first_from_hash_value(param_1,uVar1,param_2,param_3,param_4);
return uVar2;
}
| |
43,346 | my_thread_destroy_internal_mutex | eloqsql/mysys/my_thr_init.c | void my_thread_destroy_internal_mutex(void)
{
mysql_mutex_destroy(&THR_LOCK_threads);
mysql_mutex_destroy(&THR_LOCK_malloc);
mysql_cond_destroy(&THR_COND_threads);
} | O3 | c | my_thread_destroy_internal_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xb6bf64(%rip), %rbx # 0xc14a38
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa8af2
leaq 0x2e83f4(%rip), %rax # 0x390ed8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6bf3f(%rip), %rdi # 0xc14a38
callq 0x2a0e0
leaq 0xb6bf7b(%rip), %rbx # 0xc14a80
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa8b23
leaq 0x2e83c3(%rip), %rax # 0x390ed8
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x40(%rbx)
leaq 0xb6bf56(%rip), %rdi # 0xc14a80
callq 0x2a0e0
leaq 0xb6bf92(%rip), %rax # 0xc14ac8
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0xa8b51
leaq 0xb6bf82(%rip), %rdi # 0xc14ac8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a250
callq 0x3032d
jmp 0xa8b3f
| my_thread_destroy_internal_mutex:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, THR_LOCK_threads
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A8AF2
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A8AF2:
lea rdi, THR_LOCK_threads
call _pthread_mutex_destroy
lea rbx, THR_LOCK_malloc
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_A8B23
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+40h], 0
loc_A8B23:
lea rdi, THR_LOCK_malloc
call _pthread_mutex_destroy
lea rax, THR_COND_threads
mov rdi, [rax+30h]
test rdi, rdi
jnz short loc_A8B51
loc_A8B3F:
lea rdi, THR_COND_threads
add rsp, 8
pop rbx
pop rbp
jmp _pthread_cond_destroy
loc_A8B51:
call my_thread_destroy_internal_mutex_cold_1
jmp short loc_A8B3F
| long long my_thread_destroy_internal_mutex()
{
long long v0; // rdi
long long v1; // rdi
v0 = THR_LOCK_threads[8];
if ( v0 )
{
((void ( *)(long long))PSI_server[9])(v0);
THR_LOCK_threads[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_threads);
v1 = THR_LOCK_malloc[8];
if ( v1 )
{
((void ( *)(long long))PSI_server[9])(v1);
THR_LOCK_malloc[8] = 0LL;
}
pthread_mutex_destroy(THR_LOCK_malloc);
if ( THR_COND_threads[6] )
my_thread_destroy_internal_mutex_cold_1();
return pthread_cond_destroy(THR_COND_threads);
}
| my_thread_destroy_internal_mutex:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0xd14a38]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a8af2
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a8af2:
LEA RDI,[0xd14a38]
CALL 0x0012a0e0
LEA RBX,[0xd14a80]
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001a8b23
LEA RAX,[0x490ed8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x40],0x0
LAB_001a8b23:
LEA RDI,[0xd14a80]
CALL 0x0012a0e0
LEA RAX,[0xd14ac8]
MOV RDI,qword ptr [RAX + 0x30]
TEST RDI,RDI
JNZ 0x001a8b51
LAB_001a8b3f:
LEA RDI,[0xd14ac8]
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0012a250
LAB_001a8b51:
CALL 0x0013032d
JMP 0x001a8b3f
|
void my_thread_destroy_internal_mutex(void)
{
if (THR_LOCK_threads._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_threads._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_threads);
if (THR_LOCK_malloc._64_8_ != 0) {
(**(code **)(PSI_server + 0x48))();
THR_LOCK_malloc._64_8_ = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)THR_LOCK_malloc);
if (THR_COND_threads._48_8_ != 0) {
my_thread_destroy_internal_mutex_cold_1();
}
pthread_cond_destroy((pthread_cond_t *)THR_COND_threads);
return;
}
| |
43,347 | my_strnncollsp_nchars_generic | eloqsql/strings/ctype.c | int my_strnncollsp_nchars_generic(CHARSET_INFO *cs,
const uchar *str1, size_t len1,
const uchar *str2, size_t len2,
size_t nchars)
{
int error;
len1= my_well_formed_length(cs, (const char *) str1,
(const char *) str1 + len1,
nchars, &error);
len2= my_well_formed_length(cs, (const char *) str2,
(const char *) str2 + len2,
nchars, &error);
DBUG_ASSERT((cs->state & MY_CS_NOPAD) == 0);
return cs->coll->strnncollsp(cs, str1, len1, str2, len2);
} | O0 | c | my_strnncollsp_nchars_generic:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x6dd30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x6dd30
movq %rax, -0x28(%rbp)
jmp 0x6dd04
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_strnncollsp_nchars_generic:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_18]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_34]
call my_well_formed_length
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_20]
add rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
lea r8, [rbp+var_34]
call my_well_formed_length
mov [rbp+var_28], rax
jmp short $+2
loc_6DD04:
mov rax, [rbp+var_8]
mov rax, [rax+0C0h]
mov rax, [rax+10h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call rax
add rsp, 40h
pop rbp
retn
| long long my_strnncollsp_nchars_generic(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
_BYTE v7[4]; // [rsp+Ch] [rbp-34h] BYREF
long long v8; // [rsp+10h] [rbp-30h]
long long v9; // [rsp+18h] [rbp-28h]
long long v10; // [rsp+20h] [rbp-20h]
long long v11; // [rsp+28h] [rbp-18h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v8 = a6;
v11 = my_well_formed_length(a1, a2, a3 + a2, a6, v7);
v9 = my_well_formed_length(v13, v10, v9 + v10, v8, v7);
return (*(long long ( **)(long long, long long, long long, long long, long long))(*(_QWORD *)(v13 + 192) + 16LL))(
v13,
v12,
v11,
v10,
v9);
}
| my_strnncollsp_nchars_generic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x34]
CALL 0x0016dd30
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
LEA R8,[RBP + -0x34]
CALL 0x0016dd30
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016dd04
LAB_0016dd04:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL RAX
ADD RSP,0x40
POP RBP
RET
|
void my_strnncollsp_nchars_generic
(long param_1,long param_2,long param_3,long param_4,long param_5,int8 param_6)
{
int1 local_3c [4];
int8 local_38;
long local_30;
long local_28;
long local_20;
long local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_20 = my_well_formed_length(param_1,param_2,param_2 + param_3,param_6,local_3c);
local_30 = my_well_formed_length(local_10,local_28,local_28 + local_30,local_38,local_3c);
(**(code **)(*(long *)(local_10 + 0xc0) + 0x10))(local_10,local_18,local_20,local_28,local_30);
return;
}
| |
43,348 | free_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
} | O0 | c | free_full_pages:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x5777e
movq $0x0, -0x80(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
leaq -0xa8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
cmpq -0xa8(%rbp), %rax
jbe 0x574fa
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x10000, %eax # imm = 0x10000
cmpq %rcx, %rax
jb 0x574c6
movq -0xb0(%rbp), %rcx
subq -0xa8(%rbp), %rcx
movl $0x8000, %eax # imm = 0x8000
cmpq %rcx, %rax
jae 0x574fa
movl $0x1000, %eax # imm = 0x1000
cmpq -0xa8(%rbp), %rax
ja 0x574fa
movb $0x0, -0x9a(%rbp)
movq -0x20(%rbp), %rax
movl 0xac(%rax), %ecx
movl %ecx, %eax
shll $0x3, %eax
subl %ecx, %eax
movl %eax, %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x98(%rbp)
jmp 0x57523
movb $0x1, -0x9a(%rbp)
movq -0x20(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edi, %edi
movl $0x10010, %edx # imm = 0x10010
callq 0xf3a20
movq %rax, -0x98(%rbp)
jmp 0x57525
cmpq $0x0, -0x98(%rbp)
jne 0x5753a
jmp 0x57531
movb $0x1, -0xd(%rbp)
jmp 0x5779e
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
movq -0x20(%rbp), %rcx
imull $0x7, 0xac(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jae 0x5761d
movq -0x78(%rbp), %rax
movzwl 0x5(%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0xffffbfff, %eax # imm = 0xFFFFBFFF
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
jne 0x575bd
cmpl $0x0, -0xb4(%rbp)
je 0x575bd
cmpq $0x0, -0x80(%rbp)
jne 0x575bb
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x5760c
cmpq $0x0, -0x80(%rbp)
je 0x5760a
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x2a090
movq -0xc0(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, -0x80(%rbp)
jmp 0x5760c
movq -0x78(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x78(%rbp)
jmp 0x57563
cmpq $0x0, -0x80(%rbp)
je 0x57662
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x2a090
movq -0xc8(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
subq %rcx, %rax
movl %eax, %eax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
jne 0x576a9
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x591f0
movb $0x0, -0xd(%rbp)
jmp 0x5779e
movq -0x70(%rbp), %rax
movl $0x7, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0xa0(%rbp)
leaq -0xc(%rbp), %rax
addq $0x2, %rax
movq %rax, -0xd0(%rbp)
movl -0xa0(%rbp), %eax
movw %ax, %cx
movq -0xd0(%rbp), %rax
movw %cx, (%rax)
leaq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movq -0x70(%rbp), %rax
addq $0x4, %rax
movl %eax, %r8d
leaq -0x60(%rbp), %r10
leaq -0xc(%rbp), %rax
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
movl $0x4, %r9d
xorl %r11d, %r11d
subq $0x20, %rsp
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x32050
addq $0x20, %rsp
movb %al, -0x99(%rbp)
movq -0x98(%rbp), %rdi
movsbl -0x9a(%rbp), %esi
callq 0x591f0
cmpb $0x0, -0x99(%rbp)
je 0x5777c
jmp 0x57776
movb $0x1, -0xd(%rbp)
jmp 0x5779e
jmp 0x5777e
jmp 0x57780
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rax
movl 0xac(%rax), %edx
callq 0x649e0
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movb %al, -0xd1(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x577c4
movb -0xd1(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
callq 0x2a250
nopl (%rax)
| free_full_pages:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_78], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp byte ptr [rax+7E7h], 0
jz loc_5777E
mov [rbp+var_80], 0
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov [rbp+var_A8], rax
mov rax, [rbp+var_18]
mov rax, [rax+78h]
mov rax, [rax]
lea rcx, [rbp+var_A8]
sub rax, rcx
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
cmp rax, [rbp+var_A8]
jbe short loc_574FA
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 10000h
cmp rax, rcx
jb short loc_574C6
mov rcx, [rbp+var_B0]
sub rcx, [rbp+var_A8]
mov eax, 8000h
cmp rax, rcx
jnb short loc_574FA
mov eax, 1000h
cmp rax, [rbp+var_A8]
ja short loc_574FA
loc_574C6:
mov [rbp+var_9A], 0
mov rax, [rbp+var_20]
mov ecx, [rax+0ACh]
mov eax, ecx
shl eax, 3
sub eax, ecx
mov ecx, eax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_98], rax
jmp short loc_57523
loc_574FA:
mov [rbp+var_9A], 1
mov rax, [rbp+var_20]
imul eax, [rax+0ACh], 7
mov eax, eax
mov esi, eax
xor edi, edi
mov edx, 10010h
call my_malloc
mov [rbp+var_98], rax
loc_57523:
jmp short $+2
loc_57525:
cmp [rbp+var_98], 0
jnz short loc_5753A
jmp short $+2
loc_57531:
mov [rbp+var_D], 1
jmp loc_5779E
loc_5753A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
mov rax, [rbp+var_78]
mov rcx, [rbp+var_20]
imul ecx, [rcx+0ACh], 7
mov ecx, ecx
add rax, rcx
mov [rbp+var_88], rax
loc_57563:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnb loc_5761D
mov rax, [rbp+var_78]
movzx eax, word ptr [rax+5]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 0FFFFBFFFh
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
and eax, 8000h
cmp eax, 0
jnz short loc_575BD
cmp [rbp+var_B4], 0
jz short loc_575BD
cmp [rbp+var_80], 0
jnz short loc_575BB
mov rax, [rbp+var_78]
mov [rbp+var_80], rax
loc_575BB:
jmp short loc_5760C
loc_575BD:
cmp [rbp+var_80], 0
jz short loc_5760A
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C0], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C0]
call _memcpy
mov rax, [rbp+var_C0]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
mov [rbp+var_80], 0
loc_5760A:
jmp short $+2
loc_5760C:
mov rax, [rbp+var_78]
add rax, 7
mov [rbp+var_78], rax
jmp loc_57563
loc_5761D:
cmp [rbp+var_80], 0
jz short loc_57662
mov rax, [rbp+var_78]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C8], rax
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_C8]
call _memcpy
mov rax, [rbp+var_C8]
add rax, [rbp+var_90]
mov [rbp+var_90], rax
loc_57662:
mov rax, [rbp+var_90]
mov rcx, [rbp+var_98]
sub rax, rcx
mov eax, eax
mov [rbp+var_70], rax
cmp rax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jnz short loc_576A9
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_0
mov [rbp+var_D], 0
jmp loc_5779E
loc_576A9:
mov rax, [rbp+var_70]
mov ecx, 7
xor edx, edx
div rcx
mov [rbp+var_A0], eax
lea rax, [rbp+var_C]
add rax, 2
mov [rbp+var_D0], rax
mov eax, [rbp+var_A0]
mov cx, ax
mov rax, [rbp+var_D0]
mov [rax], cx
lea rax, [rbp+var_C]
mov [rbp+var_40], rax
mov [rbp+var_38], 4
mov rax, [rbp+var_98]
mov [rbp+var_30], rax
mov rax, [rbp+var_70]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_18]
mov rax, [rbp+var_70]
add rax, 4
mov r8d, eax
lea r10, [rbp+var_60]
lea rax, [rbp+var_C]
lea rdi, [rbp+var_68]
mov esi, 8
mov r9d, 4
xor r11d, r11d
sub rsp, 20h
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 0
call translog_write_record
add rsp, 20h
mov [rbp+var_99], al
mov rdi, [rbp+var_98]
movsx esi, [rbp+var_9A]
call stack_alloc_free_0
cmp [rbp+var_99], 0
jz short loc_5777C
jmp short $+2
loc_57776:
mov [rbp+var_D], 1
jmp short loc_5779E
loc_5777C:
jmp short $+2
loc_5777E:
jmp short $+2
loc_57780:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rsi, [rax+10h]
mov rax, [rbp+var_20]
mov edx, [rax+0ACh]
call _ma_bitmap_free_full_pages
mov [rbp+var_D], al
loc_5779E:
mov al, [rbp+var_D]
mov [rbp+var_D1], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_577C4
mov al, [rbp+var_D1]
mov rsp, rbp
pop rbp
retn
loc_577C4:
call ___stack_chk_fail
| char free_full_pages(long long *a1, long long a2)
{
_QWORD v3[3]; // [rsp+20h] [rbp-E0h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-C8h]
unsigned long long v5; // [rsp+40h] [rbp-C0h]
int v6; // [rsp+4Ch] [rbp-B4h]
unsigned long long v7; // [rsp+50h] [rbp-B0h]
unsigned long long v8; // [rsp+58h] [rbp-A8h] BYREF
int v9; // [rsp+60h] [rbp-A0h]
char v10; // [rsp+66h] [rbp-9Ah]
char v11; // [rsp+67h] [rbp-99h]
char *v12; // [rsp+68h] [rbp-98h]
char *v13; // [rsp+70h] [rbp-90h]
unsigned long long v14; // [rsp+78h] [rbp-88h]
unsigned long long v15; // [rsp+80h] [rbp-80h]
unsigned long long v16; // [rsp+88h] [rbp-78h]
unsigned long long v17; // [rsp+90h] [rbp-70h]
_BYTE v18[8]; // [rsp+98h] [rbp-68h] BYREF
_QWORD v19[8]; // [rsp+A0h] [rbp-60h] BYREF
long long v20; // [rsp+E0h] [rbp-20h]
long long *v21; // [rsp+E8h] [rbp-18h]
__int16 v23; // [rsp+F4h] [rbp-Ch] BYREF
__int16 v24; // [rsp+F6h] [rbp-Ah] BYREF
unsigned long long v25; // [rsp+F8h] [rbp-8h]
v25 = __readfsqword(0x28u);
v21 = a1;
v20 = a2;
v16 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*a1 + 2023) )
return ma_bitmap_free_full_pages(v21, *(_QWORD *)(v20 + 16), *(unsigned int *)(v20 + 172));
v15 = 0LL;
v8 = (unsigned int)(7 * *(_DWORD *)(v20 + 172));
v7 = *(_QWORD *)v21[15] - (_QWORD)&v8;
if ( v7 <= v8 || v7 - v8 <= 0x10000 && (v7 - v8 <= 0x8000 || v8 < 0x1000) )
{
v10 = 1;
v12 = (char *)my_malloc(0LL, (unsigned int)(7 * *(_DWORD *)(v20 + 172)), 65552LL);
}
else
{
v10 = 0;
v12 = (char *)v3 - (((unsigned int)(7 * *(_DWORD *)(v20 + 172)) + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
}
if ( v12 )
{
v13 = v12;
v14 = (unsigned int)(7 * *(_DWORD *)(v20 + 172)) + v16;
while ( v16 < v14 )
{
v6 = *(unsigned __int16 *)(v16 + 5);
v6 &= ~0x4000u;
if ( (v6 & 0x8000) != 0 || !v6 )
{
if ( v15 )
{
v5 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v5;
v15 = 0LL;
}
}
else if ( !v15 )
{
v15 = v16;
}
v16 += 7LL;
}
if ( v15 )
{
v4 = v16 - v15;
memcpy(v13, v15, v16 - v15);
v13 += v4;
}
v17 = (unsigned int)((_DWORD)v13 - (_DWORD)v12);
if ( (_DWORD)v13 == (_DWORD)v12 )
{
stack_alloc_free_0(v12, (unsigned int)v10);
return 0;
}
v9 = v17 / 7;
v3[2] = &v24;
v24 = v17 / 7;
v19[4] = &v23;
v19[5] = 4LL;
v19[6] = v12;
v19[7] = v17;
v11 = translog_write_record((long long)v18, 8u, v21[1], v21, v17 + 4, 4u, v19, &v23, 0LL);
stack_alloc_free_0(v12, (unsigned int)v10);
if ( v11 )
return 1;
return ma_bitmap_free_full_pages(v21, *(_QWORD *)(v20 + 16), *(unsigned int *)(v20 + 172));
}
return 1;
}
| free_full_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0015777e
MOV qword ptr [RBP + -0x80],0x0
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RAX]
LEA RCX,[RBP + -0xa8]
SUB RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RBP + -0xa8]
JBE 0x001574fa
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x10000
CMP RAX,RCX
JC 0x001574c6
MOV RCX,qword ptr [RBP + -0xb0]
SUB RCX,qword ptr [RBP + -0xa8]
MOV EAX,0x8000
CMP RAX,RCX
JNC 0x001574fa
MOV EAX,0x1000
CMP RAX,qword ptr [RBP + -0xa8]
JA 0x001574fa
LAB_001574c6:
MOV byte ptr [RBP + -0x9a],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0xac]
MOV EAX,ECX
SHL EAX,0x3
SUB EAX,ECX
MOV ECX,EAX
ADD RCX,0xf
AND RCX,-0x10
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00157523
LAB_001574fa:
MOV byte ptr [RBP + -0x9a],0x1
MOV RAX,qword ptr [RBP + -0x20]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV EAX,EAX
MOV ESI,EAX
XOR EDI,EDI
MOV EDX,0x10010
CALL 0x001f3a20
MOV qword ptr [RBP + -0x98],RAX
LAB_00157523:
JMP 0x00157525
LAB_00157525:
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x0015753a
JMP 0x00157531
LAB_00157531:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0015779e
LAB_0015753a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x20]
IMUL ECX,dword ptr [RCX + 0xac],0x7
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x88],RAX
LAB_00157563:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNC 0x0015761d
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,word ptr [RAX + 0x5]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0xffffbfff
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
AND EAX,0x8000
CMP EAX,0x0
JNZ 0x001575bd
CMP dword ptr [RBP + -0xb4],0x0
JZ 0x001575bd
CMP qword ptr [RBP + -0x80],0x0
JNZ 0x001575bb
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
LAB_001575bb:
JMP 0x0015760c
LAB_001575bd:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x0015760a
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc0],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc0]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0xc0]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
MOV qword ptr [RBP + -0x80],0x0
LAB_0015760a:
JMP 0x0015760c
LAB_0015760c:
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x7
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00157563
LAB_0015761d:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x00157662
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc8],RAX
MOV RDI,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0xc8]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0xc8]
ADD RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x90],RAX
LAB_00157662:
MOV RAX,qword ptr [RBP + -0x90]
MOV RCX,qword ptr [RBP + -0x98]
SUB RAX,RCX
MOV EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JNZ 0x001576a9
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x001591f0
MOV byte ptr [RBP + -0xd],0x0
JMP 0x0015779e
LAB_001576a9:
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x7
XOR EDX,EDX
DIV RCX
MOV dword ptr [RBP + -0xa0],EAX
LEA RAX,[RBP + -0xc]
ADD RAX,0x2
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0xa0]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0xd0]
MOV word ptr [RAX],CX
LEA RAX,[RBP + -0xc]
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],0x4
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0x4
MOV R8D,EAX
LEA R10,[RBP + -0x60]
LEA RAX,[RBP + -0xc]
LEA RDI,[RBP + -0x68]
MOV ESI,0x8
MOV R9D,0x4
XOR R11D,R11D
SUB RSP,0x20
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00132050
ADD RSP,0x20
MOV byte ptr [RBP + -0x99],AL
MOV RDI,qword ptr [RBP + -0x98]
MOVSX ESI,byte ptr [RBP + -0x9a]
CALL 0x001591f0
CMP byte ptr [RBP + -0x99],0x0
JZ 0x0015777c
JMP 0x00157776
LAB_00157776:
MOV byte ptr [RBP + -0xd],0x1
JMP 0x0015779e
LAB_0015777c:
JMP 0x0015777e
LAB_0015777e:
JMP 0x00157780
LAB_00157780:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0xac]
CALL 0x001649e0
MOV byte ptr [RBP + -0xd],AL
LAB_0015779e:
MOV AL,byte ptr [RBP + -0xd]
MOV byte ptr [RBP + -0xd1],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001577c4
MOV AL,byte ptr [RBP + -0xd1]
MOV RSP,RBP
POP RBP
RET
LAB_001577c4:
CALL 0x0012a250
|
int8 free_full_pages(long *param_1,long param_2)
{
ushort uVar1;
int4 uVar2;
long lVar3;
int8 uVar4;
int1 auVar5 [16];
int1 *puVar6;
void *__src;
long *plVar7;
uint uVar8;
size_t sVar9;
int1 *puVar10;
int iVar11;
long in_FS_OFFSET;
int1 auStack_e8 [15];
int1 local_d9;
int2 *local_d8;
size_t local_d0;
size_t local_c8;
uint local_bc;
ulong local_b8;
ulong local_b0;
int4 local_a8;
char local_a2;
char local_a1;
int1 *local_a0;
int1 *local_98;
void *local_90;
void *local_88;
void *local_80;
ulong local_78;
int1 local_70 [8];
int1 local_68 [32];
int1 *local_48;
int8 local_40;
int1 *local_38;
ulong local_30;
long local_28;
long *local_20;
int1 local_15;
int1 local_14 [2];
int2 local_12;
long local_10;
puVar10 = auStack_e8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_80 = *(void **)(param_2 + 0x10);
local_28 = param_2;
local_20 = param_1;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
local_88 = (void *)0x0;
local_b0 = (ulong)(uint)(*(int *)(param_2 + 0xac) * 7);
local_b8 = *(long *)param_1[0xf] - (long)&local_b0;
if ((local_b0 < local_b8) &&
((0x10000 < local_b8 - local_b0 || ((0x8000 < local_b8 - local_b0 && (0xfff < local_b0))))))
{
local_a2 = '\0';
local_a0 = auStack_e8 +
-((ulong)(uint)(*(int *)(param_2 + 0xac) * 7) + 0xf & 0xfffffffffffffff0);
puVar10 = local_a0;
}
else {
local_a2 = '\x01';
local_a0 = (int1 *)my_malloc(0,*(int *)(param_2 + 0xac) * 7,0x10010);
puVar10 = auStack_e8;
}
if (local_a0 == (int1 *)0x0) {
local_15 = 1;
goto LAB_0015779e;
}
local_98 = local_a0;
local_90 = (void *)((long)local_80 + (ulong)(uint)(*(int *)(local_28 + 0xac) * 7));
for (; __src = local_88, puVar6 = local_98, local_80 < local_90;
local_80 = (void *)((long)local_80 + 7)) {
uVar1 = *(ushort *)((long)local_80 + 5);
local_bc = uVar1 & 0xffffbfff;
if (((uVar1 & 0x8000) == 0) && ((uVar1 & 0xbfff) != 0)) {
if (local_88 == (void *)0x0) {
local_88 = local_80;
}
}
else if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_c8 = sVar9;
*(int8 *)(puVar10 + -8) = 0x1575ed;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_c8;
local_88 = (void *)0x0;
}
}
if (local_88 != (void *)0x0) {
sVar9 = (long)local_80 - (long)local_88;
local_d0 = sVar9;
*(int8 *)(puVar10 + -8) = 0x15764d;
memcpy(puVar6,__src,sVar9);
local_98 = local_98 + local_d0;
}
plVar7 = local_20;
puVar6 = local_a0;
uVar8 = (int)local_98 - (int)local_a0;
local_78 = CONCAT44(0,uVar8);
if (local_78 == 0) {
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x1576a0;
stack_alloc_free(puVar6,iVar11);
local_15 = 0;
goto LAB_0015779e;
}
auVar5._8_8_ = 0;
auVar5._0_8_ = local_78;
local_a8 = SUB164(auVar5 / ZEXT816(7),0);
local_d8 = &local_12;
local_12 = SUB162(auVar5 / ZEXT816(7),0);
local_48 = local_14;
local_40 = 4;
local_38 = local_a0;
lVar3 = local_20[1];
local_30 = local_78;
*(int1 **)(puVar10 + -0x20) = local_68;
*(int1 **)(puVar10 + -0x18) = local_14;
*(int8 *)(puVar10 + -0x10) = 0;
*(int8 *)(puVar10 + -0x28) = 0x15774e;
local_a1 = translog_write_record(local_70,8,lVar3,plVar7,uVar8 + 4,4);
puVar6 = local_a0;
iVar11 = (int)local_a2;
*(int8 *)(puVar10 + -8) = 0x15776b;
stack_alloc_free(puVar6,iVar11);
if (local_a1 != '\0') {
local_15 = 1;
goto LAB_0015779e;
}
}
plVar7 = local_20;
uVar4 = *(int8 *)(local_28 + 0x10);
uVar2 = *(int4 *)(local_28 + 0xac);
*(int8 *)(puVar10 + -8) = 0x15779b;
local_15 = _ma_bitmap_free_full_pages(plVar7,uVar4,uVar2);
LAB_0015779e:
local_d9 = local_15;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
*(int8 *)(puVar10 + -8) = 0x1577c9;
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_15);
}
| |
43,349 | free_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
} | O3 | c | free_full_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rsi), %r14
movq (%rdi), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x4c01c
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
leaq -0xa0(%rbp), %r12
movq %r13, (%r12)
movq 0x78(%rbx), %rcx
movq (%rcx), %rcx
subq %r12, %rcx
subq %r13, %rcx
jbe 0x4beab
cmpq $0x10000, %rcx # imm = 0x10000
ja 0x4be8e
cmpl $0x1000, %r13d # imm = 0x1000
jb 0x4beab
cmpq $0x8001, %rcx # imm = 0x8001
jb 0x4beab
movq %r15, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movq %rsp, %rdi
leaq 0xf(%r13), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, %rsp
movb $0x1, %bl
jmp 0x4bee2
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
movq %r13, %rsi
callq 0x9fe9d
testq %rax, %rax
je 0x4bf84
movq %rax, %rdi
movq %rbx, -0x40(%rbp)
movq %r15, -0x48(%rbp)
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
xorl %ebx, %ebx
movq %rdi, %r15
testl %eax, %eax
je 0x4bf67
movl %ebx, -0x38(%rbp)
addq %r14, %r13
xorl %esi, %esi
movq %r14, %r12
movq %rdi, -0x50(%rbp)
movq %rdi, %r15
movzwl 0x5(%r14), %eax
testw %ax, %ax
sets %cl
testl $0xbfff, %eax # imm = 0xBFFF
sete %al
orb %cl, %al
jne 0x4bf1b
testq %rsi, %rsi
cmoveq %r14, %rsi
jmp 0x4bf36
testq %rsi, %rsi
je 0x4bf34
movq %r12, %rbx
subq %rsi, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r15
xorl %esi, %esi
addq $0x7, %r14
addq $0x7, %r12
cmpq %r13, %r14
jb 0x4befb
testq %rsi, %rsi
je 0x4bf59
subq %rsi, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x29080
addq %r12, %r15
leaq -0xa0(%rbp), %r12
movq -0x50(%rbp), %rdi
movl -0x38(%rbp), %ebx
subq %rdi, %r15
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
andq %r15, %rax
jne 0x4bf8b
testb %bl, %bl
jne 0x4bf7d
callq 0xa00ca
xorl %eax, %eax
jmp 0x4c02e
movb $0x1, %al
jmp 0x4c02e
movq %rdi, %r13
movl %r15d, %ecx
imulq $0x24924925, %rcx, %rcx # imm = 0x24924925
shrq $0x20, %rcx
movl %r15d, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x2, %edx
leaq -0x34(%rbp), %r10
movw %dx, 0x2(%r10)
movq %r10, -0x80(%rbp)
movq $0x4, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rdx
addl $0x4, %r15d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0x8, %esi
movq %rcx, -0x40(%rbp)
movl %r15d, %r8d
movl $0x4, %r9d
pushq $0x0
pushq %r10
pushq %r12
callq 0x29c44
addq $0x20, %rsp
movl %eax, %r14d
testb %bl, %bl
jne 0x4c009
movq %r13, %rdi
callq 0xa00ca
movb $0x1, %al
testb %r14b, %r14b
jne 0x4c02e
movq -0x48(%rbp), %r15
movq 0x10(%r15), %r14
movq -0x40(%rbp), %rbx
movl 0xac(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5476b
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x4c04c
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| free_full_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rsi+10h]
mov rax, [rdi]
cmp byte ptr [rax+7E7h], 0
jz loc_4C01C
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
lea r12, [rbp+var_A0]
mov [r12], r13
mov rcx, [rbx+78h]
mov rcx, [rcx]
sub rcx, r12
sub rcx, r13
jbe short loc_4BEAB
cmp rcx, offset stru_10000
ja short loc_4BE8E
cmp r13d, 1000h
jb short loc_4BEAB
cmp rcx, 8001h
jb short loc_4BEAB
loc_4BE8E:
mov [rbp+var_48], r15
mov [rbp+var_40], rbx
mov rdi, rsp
lea rcx, [r13+0Fh]
and rcx, 0FFFFFFFFFFFFFFF0h
sub rdi, rcx
mov rsp, rdi
mov bl, 1
jmp short loc_4BEE2
loc_4BEAB:
mov edx, 10010h
xor edi, edi
mov rsi, r13
call my_malloc
test rax, rax
jz loc_4BF84
mov rdi, rax
mov [rbp+var_40], rbx
mov [rbp+var_48], r15
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
xor ebx, ebx
loc_4BEE2:
mov r15, rdi
test eax, eax
jz short loc_4BF67
mov [rbp+var_38], ebx
add r13, r14
xor esi, esi
mov r12, r14
mov [rbp+var_50], rdi
mov r15, rdi
loc_4BEFB:
movzx eax, word ptr [r14+5]
test ax, ax
sets cl
test eax, 0BFFFh
setz al
or al, cl
jnz short loc_4BF1B
test rsi, rsi
cmovz rsi, r14
jmp short loc_4BF36
loc_4BF1B:
test rsi, rsi
jz short loc_4BF34
mov rbx, r12
sub rbx, rsi
mov rdi, r15
mov rdx, rbx
call _memcpy
add r15, rbx
loc_4BF34:
xor esi, esi
loc_4BF36:
add r14, 7
add r12, 7
cmp r14, r13
jb short loc_4BEFB
test rsi, rsi
jz short loc_4BF59
sub r12, rsi
mov rdi, r15
mov rdx, r12
call _memcpy
add r15, r12
loc_4BF59:
lea r12, [rbp+var_A0]
mov rdi, [rbp+var_50]
mov ebx, [rbp+var_38]
loc_4BF67:
sub r15, rdi
mov eax, 0FFFFFFFFh
and rax, r15
jnz short loc_4BF8B
test bl, bl
jnz short loc_4BF7D
call my_free
loc_4BF7D:
xor eax, eax
jmp loc_4C02E
loc_4BF84:
mov al, 1
jmp loc_4C02E
loc_4BF8B:
mov r13, rdi
mov ecx, r15d
imul rcx, 24924925h
shr rcx, 20h
mov edx, r15d
sub edx, ecx
shr edx, 1
add edx, ecx
shr edx, 2
lea r10, [rbp+var_34]
mov [r10+2], dx
mov [rbp+var_80], r10
mov [rbp+var_78], 4
mov [rbp+var_70], rdi
mov [rbp+var_68], rax
mov rcx, [rbp+var_40]
mov rdx, [rcx+8]
add r15d, 4
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 8
mov [rbp+var_40], rcx
mov r8d, r15d
mov r9d, 4
push 0
push r10
push r12
call translog_write_record
add rsp, 20h
mov r14d, eax
test bl, bl
jnz short loc_4C009
mov rdi, r13
call my_free
loc_4C009:
mov al, 1
test r14b, r14b
jnz short loc_4C02E
mov r15, [rbp+var_48]
mov r14, [r15+10h]
mov rbx, [rbp+var_40]
loc_4C01C:
mov edx, [r15+0ACh]
mov rdi, rbx
mov rsi, r14
call _ma_bitmap_free_full_pages
loc_4C02E:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_4C04C
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4C04C:
call ___stack_chk_fail
| char free_full_pages(_QWORD *a1, long long a2)
{
long long v2; // r15
_QWORD *v3; // rbx
unsigned long long v4; // r14
int v5; // eax
unsigned long long v6; // r13
unsigned long long v7; // rcx
bool v8; // cc
unsigned long long v9; // rcx
char *v10; // rdi
long long v11; // rax
char *v12; // r15
unsigned long long v13; // r13
unsigned long long v14; // rsi
unsigned long long v15; // r12
unsigned long long v16; // r12
unsigned int v17; // r15d
char result; // al
char v19; // r14
_OWORD v20[2]; // [rsp+0h] [rbp-A0h] BYREF
_WORD *v21; // [rsp+20h] [rbp-80h]
long long v22; // [rsp+28h] [rbp-78h]
char *v23; // [rsp+30h] [rbp-70h]
long long v24; // [rsp+38h] [rbp-68h]
char v25[8]; // [rsp+48h] [rbp-58h] BYREF
char *v26; // [rsp+50h] [rbp-50h]
long long v27; // [rsp+58h] [rbp-48h]
_QWORD *v28; // [rsp+60h] [rbp-40h]
int v29; // [rsp+68h] [rbp-38h]
_WORD v30[2]; // [rsp+6Ch] [rbp-34h] BYREF
unsigned long long v31; // [rsp+70h] [rbp-30h]
v2 = a2;
v3 = a1;
v31 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*a1 + 2023LL) )
return ma_bitmap_free_full_pages(v3, v4, *(unsigned int *)(v2 + 172));
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
*(_QWORD *)&v20[0] = v6;
v7 = *(_QWORD *)a1[15] - (_QWORD)v20;
v8 = v7 <= v6;
v9 = v7 - v6;
if ( v8 || v9 <= (unsigned long long)&stru_10000 && ((unsigned int)v6 < 0x1000 || v9 < 0x8001) )
{
v11 = my_malloc(0LL, (unsigned int)(7 * v5), 65552LL);
if ( !v11 )
return 1;
v10 = (char *)v11;
v28 = v3;
v27 = a2;
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
LODWORD(v3) = 0;
}
else
{
v27 = a2;
v28 = a1;
v10 = (char *)v20 - ((v6 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v3) = 1;
}
LODWORD(v12) = (_DWORD)v10;
if ( v5 )
{
v29 = (int)v3;
v13 = v4 + v6;
v14 = 0LL;
v15 = v4;
v26 = v10;
v12 = v10;
do
{
if ( *(__int16 *)(v4 + 5) < 0 || (*(_WORD *)(v4 + 5) & 0xBFFF) == 0 )
{
if ( v14 )
{
memcpy(v12, v14, v15 - v14);
v12 += v15 - v14;
}
v14 = 0LL;
}
else if ( !v14 )
{
v14 = v4;
}
v4 += 7LL;
v15 += 7LL;
}
while ( v4 < v13 );
if ( v14 )
{
v16 = v15 - v14;
memcpy(v12, v14, v16);
LODWORD(v12) = v16 + (_DWORD)v12;
}
v10 = v26;
LOBYTE(v3) = v29;
}
v17 = (_DWORD)v12 - (_DWORD)v10;
if ( !v17 )
{
if ( !(_BYTE)v3 )
my_free(v10);
return 0;
}
v30[1] = v17 / 7;
v21 = v30;
v22 = 4LL;
v23 = v10;
v24 = v17;
v19 = translog_write_record((unsigned long long)v25, &byte_8, v28[1], v28, v17 + 4, 4, v20, v30, 0LL);
if ( !(_BYTE)v3 )
my_free(v10);
result = 1;
if ( !v19 )
{
v2 = v27;
v4 = *(_QWORD *)(v27 + 16);
v3 = v28;
return ma_bitmap_free_full_pages(v3, v4, *(unsigned int *)(v2 + 172));
}
return result;
}
| free_full_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0014c01c
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
LEA R12,[RBP + -0xa0]
MOV qword ptr [R12],R13
MOV RCX,qword ptr [RBX + 0x78]
MOV RCX,qword ptr [RCX]
SUB RCX,R12
SUB RCX,R13
JBE 0x0014beab
CMP RCX,0x10000
JA 0x0014be8e
CMP R13D,0x1000
JC 0x0014beab
CMP RCX,0x8001
JC 0x0014beab
LAB_0014be8e:
MOV qword ptr [RBP + -0x48],R15
MOV qword ptr [RBP + -0x40],RBX
MOV RDI,RSP
LEA RCX,[R13 + 0xf]
AND RCX,-0x10
SUB RDI,RCX
MOV RSP,RDI
MOV BL,0x1
JMP 0x0014bee2
LAB_0014beab:
MOV EDX,0x10010
XOR EDI,EDI
MOV RSI,R13
CALL 0x0019fe9d
TEST RAX,RAX
JZ 0x0014bf84
MOV RDI,RAX
MOV qword ptr [RBP + -0x40],RBX
MOV qword ptr [RBP + -0x48],R15
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
XOR EBX,EBX
LAB_0014bee2:
MOV R15,RDI
TEST EAX,EAX
JZ 0x0014bf67
MOV dword ptr [RBP + -0x38],EBX
ADD R13,R14
XOR ESI,ESI
MOV R12,R14
MOV qword ptr [RBP + -0x50],RDI
MOV R15,RDI
LAB_0014befb:
MOVZX EAX,word ptr [R14 + 0x5]
TEST AX,AX
SETS CL
TEST EAX,0xbfff
SETZ AL
OR AL,CL
JNZ 0x0014bf1b
TEST RSI,RSI
CMOVZ RSI,R14
JMP 0x0014bf36
LAB_0014bf1b:
TEST RSI,RSI
JZ 0x0014bf34
MOV RBX,R12
SUB RBX,RSI
MOV RDI,R15
MOV RDX,RBX
CALL 0x00129080
ADD R15,RBX
LAB_0014bf34:
XOR ESI,ESI
LAB_0014bf36:
ADD R14,0x7
ADD R12,0x7
CMP R14,R13
JC 0x0014befb
TEST RSI,RSI
JZ 0x0014bf59
SUB R12,RSI
MOV RDI,R15
MOV RDX,R12
CALL 0x00129080
ADD R15,R12
LAB_0014bf59:
LEA R12,[RBP + -0xa0]
MOV RDI,qword ptr [RBP + -0x50]
MOV EBX,dword ptr [RBP + -0x38]
LAB_0014bf67:
SUB R15,RDI
MOV EAX,0xffffffff
AND RAX,R15
JNZ 0x0014bf8b
TEST BL,BL
JNZ 0x0014bf7d
CALL 0x001a00ca
LAB_0014bf7d:
XOR EAX,EAX
JMP 0x0014c02e
LAB_0014bf84:
MOV AL,0x1
JMP 0x0014c02e
LAB_0014bf8b:
MOV R13,RDI
MOV ECX,R15D
IMUL RCX,RCX,0x24924925
SHR RCX,0x20
MOV EDX,R15D
SUB EDX,ECX
SHR EDX,0x1
ADD EDX,ECX
SHR EDX,0x2
LEA R10,[RBP + -0x34]
MOV word ptr [R10 + 0x2],DX
MOV qword ptr [RBP + -0x80],R10
MOV qword ptr [RBP + -0x78],0x4
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RCX + 0x8]
ADD R15D,0x4
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0x8
MOV qword ptr [RBP + -0x40],RCX
MOV R8D,R15D
MOV R9D,0x4
PUSH 0x0
PUSH R10
PUSH R12
CALL 0x00129c44
ADD RSP,0x20
MOV R14D,EAX
TEST BL,BL
JNZ 0x0014c009
MOV RDI,R13
CALL 0x001a00ca
LAB_0014c009:
MOV AL,0x1
TEST R14B,R14B
JNZ 0x0014c02e
MOV R15,qword ptr [RBP + -0x48]
MOV R14,qword ptr [R15 + 0x10]
MOV RBX,qword ptr [RBP + -0x40]
LAB_0014c01c:
MOV EDX,dword ptr [R15 + 0xac]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0015476b
LAB_0014c02e:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0014c04c
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014c04c:
CALL 0x00129250
|
int8 free_full_pages(long *param_1,long param_2)
{
int4 uVar1;
long lVar2;
long *plVar3;
ulong *puVar4;
char cVar5;
int8 uVar6;
int iVar7;
ulong uVar8;
ulong *puVar9;
void *__src;
int1 *puVar10;
void *pvVar11;
void *pvVar12;
void *pvVar13;
int1 *__dest;
ulong uVar14;
long in_FS_OFFSET;
ulong local_a8 [4];
int1 *local_88;
int8 local_80;
int1 *local_78;
ulong local_70;
int1 local_60 [8];
int1 *local_58;
long local_50;
long *local_48;
uint local_40;
int1 local_3c [2];
int2 local_3a;
long local_38;
puVar9 = local_a8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pvVar11 = *(void **)(param_2 + 0x10);
puVar4 = local_a8;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = (*(long *)param_1[0xf] - (long)local_a8) - uVar14;
local_a8[0] = uVar14;
if ((uVar14 < (ulong)(*(long *)param_1[0xf] - (long)local_a8)) &&
((0x10000 < uVar8 || ((0xfff < (uint)(iVar7 * 7) && (0x8000 < uVar8)))))) {
__dest = (int1 *)((long)local_a8 - (uVar14 + 0xf & 0xfffffffffffffff0));
uVar8 = CONCAT71((int7)((ulong)param_1 >> 8),1);
puVar9 = (ulong *)__dest;
}
else {
__dest = (int1 *)my_malloc(0,uVar14,0x10010);
if (__dest == (int1 *)0x0) {
uVar6 = 1;
goto LAB_0014c02e;
}
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = 0;
puVar9 = local_a8;
}
puVar10 = __dest;
local_50 = param_2;
local_48 = param_1;
if (iVar7 != 0) {
local_40 = (uint)uVar8;
pvVar12 = (void *)(uVar14 + (long)pvVar11);
__src = (void *)0x0;
pvVar13 = pvVar11;
local_58 = __dest;
do {
if ((*(ushort *)((long)pvVar13 + 5) & 0xbfff) == 0 ||
(short)*(ushort *)((long)pvVar13 + 5) < 0) {
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x14bf31;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
__src = (void *)0x0;
}
else if (__src == (void *)0x0) {
__src = pvVar13;
}
pvVar13 = (void *)((long)pvVar13 + 7);
pvVar11 = (void *)((long)pvVar11 + 7);
} while (pvVar13 < pvVar12);
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x14bf56;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
uVar8 = (ulong)local_40;
puVar10 = local_58;
}
plVar3 = local_48;
uVar14 = (long)__dest - (long)puVar10;
if ((uVar14 & 0xffffffff) == 0) {
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x14bf7d;
my_free();
}
uVar6 = 0;
goto LAB_0014c02e;
}
iVar7 = (int)((uVar14 & 0xffffffff) * 0x24924925 >> 0x20);
local_3a = (int2)(((uint)((int)uVar14 - iVar7) >> 1) + iVar7 >> 2);
local_80 = 4;
lVar2 = local_48[1];
local_88 = local_3c;
local_78 = puVar10;
local_70 = uVar14 & 0xffffffff;
*(int8 *)((long)puVar9 + -0x10) = 0;
*(int1 **)((long)puVar9 + -0x18) = local_3c;
*(ulong **)((long)puVar9 + -0x20) = local_a8;
*(int8 *)((long)puVar9 + -0x28) = 0x14bff6;
cVar5 = translog_write_record(local_60,8,lVar2,plVar3,(int)uVar14 + 4,4);
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x14c009;
my_free(puVar10);
}
uVar6 = 1;
if (cVar5 != '\0') goto LAB_0014c02e;
pvVar11 = *(void **)(local_50 + 0x10);
param_1 = local_48;
puVar4 = puVar9;
param_2 = local_50;
}
puVar9 = puVar4;
uVar1 = *(int4 *)(param_2 + 0xac);
*(int8 *)((long)puVar9 + -8) = 0x14c02e;
uVar6 = _ma_bitmap_free_full_pages(param_1,pvVar11,uVar1);
LAB_0014c02e:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_read_block_record2;
__stack_chk_fail();
}
return uVar6;
}
| |
43,350 | ma_flush_table_files | eloqsql/storage/maria/ma_extra.c | int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
enum flush_type flush_type_for_data,
enum flush_type flush_type_for_index)
{
int error= 0;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_flush_table_files");
/* flush data file first because it's more critical */
if (flush_data_or_index & MARIA_FLUSH_DATA)
{
if ((info->opt_flag & WRITE_CACHE_USED) &&
flush_type_for_data != FLUSH_IGNORE_CHANGED &&
flush_io_cache(&info->rec_cache))
error= 1;
if (share->data_file_type == BLOCK_RECORD)
{
if (flush_type_for_data != FLUSH_IGNORE_CHANGED)
{
if (_ma_bitmap_flush(share))
error= 1;
}
else
{
mysql_mutex_lock(&share->bitmap.bitmap_lock);
share->bitmap.changed= 0;
share->bitmap.changed_not_flushed= 0;
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
}
if (flush_pagecache_blocks(share->pagecache, &info->dfile,
flush_type_for_data))
error= 1;
}
}
if ((flush_data_or_index & MARIA_FLUSH_INDEX) &&
flush_pagecache_blocks(share->pagecache, &share->kfile,
flush_type_for_index))
error= 1;
if (!error)
DBUG_RETURN(0);
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
} | O0 | c | ma_flush_table_files:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x32cf2
movq -0x10(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x32c3f
cmpl $0x2, -0x18(%rbp)
je 0x32c3f
movq -0x10(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe0bb0
cmpl $0x0, %eax
je 0x32c3f
movl $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, 0x7d0(%rax)
jne 0x32cf0
cmpl $0x2, -0x18(%rbp)
je 0x32c6c
movq -0x28(%rbp), %rdi
callq 0x41ab0
cmpb $0x0, %al
je 0x32c6a
movl $0x1, -0x20(%rbp)
jmp 0x32cbc
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0x11e7f9(%rip), %rsi # 0x15147e
movl $0x28c, %edx # imm = 0x28C
callq 0x32b00
movq -0x28(%rbp), %rax
movb $0x0, 0xa30(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xa31(%rax)
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x32b70
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2f780
cmpl $0x0, %eax
je 0x32cee
movl $0x1, -0x20(%rbp)
jmp 0x32cf0
jmp 0x32cf2
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x32d2f
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2f780
cmpl $0x0, %eax
je 0x32d2f
movl $0x1, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x32d40
jmp 0x32d37
movl $0x0, -0x4(%rbp)
jmp 0x32d55
movq -0x10(%rbp), %rdi
movl $0x7e, %esi
callq 0x33880
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| _ma_flush_table_files:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_20], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz loc_32CF2
mov rax, [rbp+var_10]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_32C3F
cmp [rbp+var_18], 2
jz short loc_32C3F
mov rdi, [rbp+var_10]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_32C3F
mov [rbp+var_20], 1
loc_32C3F:
mov rax, [rbp+var_28]
cmp dword ptr [rax+7D0h], 3
jnz loc_32CF0
cmp [rbp+var_18], 2
jz short loc_32C6C
mov rdi, [rbp+var_28]
call _ma_bitmap_flush
cmp al, 0
jz short loc_32C6A
mov [rbp+var_20], 1
loc_32C6A:
jmp short loc_32CBC
loc_32C6C:
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 28Ch
call inline_mysql_mutex_lock_0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A30h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A31h], 0
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_0
loc_32CBC:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov edx, [rbp+var_18]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_32CEE
mov [rbp+var_20], 1
loc_32CEE:
jmp short $+2
loc_32CF0:
jmp short $+2
loc_32CF2:
mov eax, [rbp+var_14]
and eax, 2
cmp eax, 0
jz short loc_32D2F
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_28]
add rsi, 750h
mov edx, [rbp+var_1C]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_32D2F
mov [rbp+var_20], 1
loc_32D2F:
cmp [rbp+var_20], 0
jnz short loc_32D40
jmp short $+2
loc_32D37:
mov [rbp+var_4], 0
jmp short loc_32D55
loc_32D40:
mov rdi, [rbp+var_10]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
mov [rbp+var_4], 1
loc_32D55:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long ma_flush_table_files(long long *a1, char a2, unsigned int a3, unsigned int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
BOOL v6; // [rsp+10h] [rbp-20h]
v6 = 0;
v5 = *a1;
if ( (a2 & 1) != 0 )
{
if ( (*((_DWORD *)a1 + 391) & 0x10) != 0 && a3 != 2 )
v6 = my_b_flush_io_cache(a1 + 151, 1LL) != 0;
if ( *(_DWORD *)(v5 + 2000) == 3 )
{
if ( a3 == 2 )
{
inline_mysql_mutex_lock_0(
v5 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c",
0x28Cu);
*(_BYTE *)(v5 + 2608) = 0;
*(_BYTE *)(v5 + 2609) = 0;
inline_mysql_mutex_unlock_0(v5 + 2712);
}
else if ( (unsigned __int8)ma_bitmap_flush(v5) )
{
v6 = 1;
}
if ( (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), (long long)(a1 + 142), a3, 0LL, 0LL) )
v6 = 1;
}
}
if ( (a2 & 2) != 0
&& (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), v5 + 1872, a4, 0LL, 0LL) )
{
v6 = 1;
}
if ( v6 )
{
ma_set_fatal_error(a1, 126LL);
return 1;
}
else
{
return 0;
}
}
| _ma_flush_table_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00132cf2
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00132c3f
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00132c3f
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e0bb0
CMP EAX,0x0
JZ 0x00132c3f
MOV dword ptr [RBP + -0x20],0x1
LAB_00132c3f:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x7d0],0x3
JNZ 0x00132cf0
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00132c6c
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00141ab0
CMP AL,0x0
JZ 0x00132c6a
MOV dword ptr [RBP + -0x20],0x1
LAB_00132c6a:
JMP 0x00132cbc
LAB_00132c6c:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x25147e]
MOV EDX,0x28c
CALL 0x00132b00
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa30],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa31],0x0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00132b70
LAB_00132cbc:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV EDX,dword ptr [RBP + -0x18]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0012f780
CMP EAX,0x0
JZ 0x00132cee
MOV dword ptr [RBP + -0x20],0x1
LAB_00132cee:
JMP 0x00132cf0
LAB_00132cf0:
JMP 0x00132cf2
LAB_00132cf2:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00132d2f
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x750
MOV EDX,dword ptr [RBP + -0x1c]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0012f780
CMP EAX,0x0
JZ 0x00132d2f
MOV dword ptr [RBP + -0x20],0x1
LAB_00132d2f:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00132d40
JMP 0x00132d37
LAB_00132d37:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00132d55
LAB_00132d40:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7e
CALL 0x00133880
MOV dword ptr [RBP + -0x4],0x1
LAB_00132d55:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
bool _ma_flush_table_files(long *param_1,uint param_2,int param_3,int4 param_4)
{
long lVar1;
bool bVar2;
char cVar3;
int iVar4;
bVar2 = false;
lVar1 = *param_1;
if ((param_2 & 1) != 0) {
if ((((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) && (param_3 != 2)) &&
(iVar4 = my_b_flush_io_cache(param_1 + 0x97,1), iVar4 != 0)) {
bVar2 = true;
}
if (*(int *)(lVar1 + 2000) == 3) {
if (param_3 == 2) {
inline_mysql_mutex_lock
(lVar1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c"
,0x28c);
*(int1 *)(lVar1 + 0xa30) = 0;
*(int1 *)(lVar1 + 0xa31) = 0;
inline_mysql_mutex_unlock(lVar1 + 0xa98);
}
else {
cVar3 = _ma_bitmap_flush(lVar1);
if (cVar3 != '\0') {
bVar2 = true;
}
}
iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),param_1 + 0x8e,param_3,0);
if (iVar4 != 0) {
bVar2 = true;
}
}
}
if (((param_2 & 2) != 0) &&
(iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,param_4,0), iVar4 != 0)) {
bVar2 = true;
}
if (bVar2) {
_ma_set_fatal_error(param_1,0x7e);
}
return bVar2;
}
| |
43,351 | GLOBAL__sub_I_crc32c.cc | eloqsql/mysys/crc32/crc32c.cc | static uint32_t cpuid_ecx()
{
#ifdef __GNUC__
uint32_t reax= 0, rebx= 0, recx= 0, redx= 0;
__cpuid(1, reax, rebx, recx, redx);
return recx;
#elif defined _MSC_VER
int regs[4];
__cpuid(regs, 1);
return regs[2];
#else
# error "unknown compiler"
#endif
} | O3 | cpp | GLOBAL__sub_I_crc32c.cc:
movl $0x1, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl $0x100002, %edx # imm = 0x100002
andl %edx, %ecx
cmpl $0x100000, %ecx # imm = 0x100000
leaq 0x7c0b7(%rip), %rsi # 0xac23b
leaq 0x7c191(%rip), %rax # 0xac31c
cmoveq %rsi, %rax
cmpl %edx, %ecx
jne 0x3019f
pushq %rbp
movq %rsp, %rbp
leaq 0x7c3c6(%rip), %rax # 0xac564
popq %rbp
movq %rax, 0xbdb9fa(%rip) # 0xc0bba0
retq
nopw (%rax,%rax)
| _GLOBAL__sub_I_crc32c_cc:
mov eax, 1
xchg rsi, rbx
cpuid
xchg rsi, rbx
mov edx, 100002h
and ecx, edx
cmp ecx, offset xmmword_100000
lea rsi, _ZN15mysys_namespace6crc32cL12crc32c_sse42EjPKcm; mysys_namespace::crc32c::crc32c_sse42(uint,char const*,ulong)
lea rax, _ZN15mysys_namespace6crc32cL11crc32c_slowEjPKcm; mysys_namespace::crc32c::crc32c_slow(uint,char const*,ulong)
cmovz rax, rsi
cmp ecx, edx
jnz short loc_3019F
push rbp
mov rbp, rsp
lea rax, crc32c_3way
pop rbp
loc_3019F:
mov cs:_ZN15mysys_namespace6crc32cL12ChosenExtendE, rax; mysys_namespace::crc32c::ChosenExtend
retn
| long long ( *GLOBAL__sub_I_crc32c_cc())()
{
int v5; // ecx
long long ( *result)(); // rax
_RAX = 1LL;
__asm { cpuid }
v5 = _RCX & 0x100002;
result = (long long ( *)())mysys_namespace::crc32c::crc32c_slow;
if ( v5 == (_DWORD)&xmmword_100000 )
result = (long long ( *)())mysys_namespace::crc32c::crc32c_sse42;
if ( v5 == 1048578 )
result = crc32c_3way;
mysys_namespace::crc32c::ChosenExtend = (long long)result;
return result;
}
| _GLOBAL__sub_I_crc32c.cc:
MOV EAX,0x1
XCHG RBX,RSI
CPUID
XCHG RBX,RSI
MOV EDX,0x100002
AND ECX,EDX
CMP ECX,0x100000
LEA RSI,[0x1ac23b]
LEA RAX,[0x1ac31c]
CMOVZ RAX,RSI
CMP ECX,EDX
JNZ 0x0013019f
PUSH RBP
MOV RBP,RSP
LEA RAX,[0x1ac564]
POP RBP
LAB_0013019f:
MOV qword ptr [0x00d0bba0],RAX
RET
|
/* WARNING: Removing unreachable block (ram,0x0013016b) */
void _GLOBAL__sub_I_crc32c_cc(void)
{
long lVar1;
uint uVar2;
lVar1 = cpuid_Version_info(1);
uVar2 = *(uint *)(lVar1 + 0xc) & 0x100002;
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_slow;
if (uVar2 == 0x100000) {
mysys_namespace::crc32c::ChosenExtend = mysys_namespace::crc32c::crc32c_sse42;
}
if (uVar2 == 0x100002) {
mysys_namespace::crc32c::ChosenExtend = crc32c_3way;
}
return;
}
| |
43,352 | hash_string | bluesky950520[P]quickjs/quickjs.c | static uint32_t hash_string(const JSString *str, uint32_t h)
{
if (str->is_wide_char)
h = hash_string16(str->u.str16, str->len, h);
else
h = hash_string8(str->u.str8, str->len, h);
return h;
} | O1 | c | hash_string:
movl %esi, %eax
movq 0x4(%rdi), %rdx
movl %edx, %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
testl %edx, %edx
js 0x3af62
testq %rcx, %rcx
je 0x3af7e
xorl %edx, %edx
imull $0x107, %eax, %esi # imm = 0x107
movzbl 0x18(%rdi,%rdx), %eax
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x3af4b
jmp 0x3af7e
testq %rcx, %rcx
je 0x3af7e
xorl %edx, %edx
imull $0x107, %eax, %esi # imm = 0x107
movzwl 0x18(%rdi,%rdx,2), %eax
addl %esi, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x3af69
retq
| hash_string:
mov eax, esi
mov rdx, [rdi+4]
mov ecx, edx
and ecx, 7FFFFFFFh
test edx, edx
js short loc_3AF62
test rcx, rcx
jz short locret_3AF7E
xor edx, edx
loc_3AF4B:
imul esi, eax, 107h
movzx eax, byte ptr [rdi+rdx+18h]
add eax, esi
inc rdx
cmp rcx, rdx
jnz short loc_3AF4B
jmp short locret_3AF7E
loc_3AF62:
test rcx, rcx
jz short locret_3AF7E
xor edx, edx
loc_3AF69:
imul esi, eax, 107h
movzx eax, word ptr [rdi+rdx*2+18h]
add eax, esi
inc rdx
cmp rcx, rdx
jnz short loc_3AF69
locret_3AF7E:
retn
| long long hash_string(long long a1, unsigned int a2)
{
long long result; // rax
long long v3; // rcx
long long j; // rdx
long long i; // rdx
result = a2;
v3 = *(_QWORD *)(a1 + 4) & 0x7FFFFFFFLL;
if ( (int)*(_QWORD *)(a1 + 4) < 0 )
{
if ( v3 )
{
for ( i = 0LL; i != v3; ++i )
result = 263 * (_DWORD)result + (unsigned int)*(unsigned __int16 *)(a1 + 2 * i + 24);
}
}
else if ( v3 )
{
for ( j = 0LL; j != v3; ++j )
result = 263 * (_DWORD)result + (unsigned int)*(unsigned __int8 *)(a1 + j + 24);
}
return result;
}
| hash_string:
MOV EAX,ESI
MOV RDX,qword ptr [RDI + 0x4]
MOV ECX,EDX
AND ECX,0x7fffffff
TEST EDX,EDX
JS 0x0013af62
TEST RCX,RCX
JZ 0x0013af7e
XOR EDX,EDX
LAB_0013af4b:
IMUL ESI,EAX,0x107
MOVZX EAX,byte ptr [RDI + RDX*0x1 + 0x18]
ADD EAX,ESI
INC RDX
CMP RCX,RDX
JNZ 0x0013af4b
JMP 0x0013af7e
LAB_0013af62:
TEST RCX,RCX
JZ 0x0013af7e
XOR EDX,EDX
LAB_0013af69:
IMUL ESI,EAX,0x107
MOVZX EAX,word ptr [RDI + RDX*0x2 + 0x18]
ADD EAX,ESI
INC RDX
CMP RCX,RDX
JNZ 0x0013af69
LAB_0013af7e:
RET
|
int hash_string(long param_1,int param_2)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
uVar2 = (uint)*(int8 *)(param_1 + 4);
uVar1 = (ulong)(uVar2 & 0x7fffffff);
if ((int)uVar2 < 0) {
if (uVar1 != 0) {
uVar3 = 0;
do {
param_2 = (uint)*(ushort *)(param_1 + 0x18 + uVar3 * 2) + param_2 * 0x107;
uVar3 = uVar3 + 1;
} while (uVar1 != uVar3);
}
}
else if (uVar1 != 0) {
uVar3 = 0;
do {
param_2 = (uint)*(byte *)(param_1 + 0x18 + uVar3) + param_2 * 0x107;
uVar3 = uVar3 + 1;
} while (uVar1 != uVar3);
}
return param_2;
}
| |
43,353 | my_hash_sort_utf16_nopad | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_nopad(CHARSET_INFO *cs,
const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((s < e) && (res= mb_wc(cs, &wc, (uchar *) s, (uchar *) e)) > 0)
{
my_tosort_utf16(uni_plane, &wc);
MY_HASH_ADD_16(m1, m2, wc);
s+= res;
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_utf16_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq (%rcx), %rbx
movq %r8, -0x48(%rbp)
movq (%r8), %r14
testq %rdx, %rdx
jle 0xe5831
movq %rdx, %r15
movq %rsi, %r12
movq 0x78(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
addq %rsi, %r15
movq %rdi, %r13
leaq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq *-0x50(%rbp)
testl %eax, %eax
jle 0xe5831
movq -0x38(%rbp), %rdx
movl $0xfffd, %esi # imm = 0xFFFD
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rdx
movq %r13, %rdi
ja 0xe57da
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq %rdx, %rcx
shrq $0x8, %rcx
movq (%rsi,%rcx,8), %rsi
testq %rsi, %rsi
je 0xe57e6
movzbl %dl, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rsi,%rcx,4), %esi
movq %rsi, -0x38(%rbp)
movl %esi, %ecx
shrl $0x8, %ecx
movq %rsi, %rdx
movl %ebx, %esi
andl $0x3f, %esi
addq %r14, %rsi
movzbl %dl, %edx
imulq %rsi, %rdx
movq %rbx, %rsi
shlq $0x8, %rsi
addq %rdx, %rsi
xorq %rbx, %rsi
movl %esi, %edx
andl $0x3f, %edx
addq %r14, %rdx
addq $0x3, %rdx
imulq %rcx, %rdx
movq %rsi, %rbx
shlq $0x8, %rbx
addq %rdx, %rbx
xorq %rsi, %rbx
addq $0x6, %r14
movl %eax, %eax
addq %rax, %r12
cmpq %r15, %r12
jb 0xe578a
movq -0x40(%rbp), %rax
movq %rbx, (%rax)
movq -0x48(%rbp), %rax
movq %r14, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_hash_sort_utf16_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_40], rcx
mov rbx, [rcx]
mov [rbp+var_48], r8
mov r14, [r8]
test rdx, rdx
jle loc_E5831
mov r15, rdx
mov r12, rsi
mov rax, [rdi+78h]
mov [rbp+var_30], rax
mov rax, [rdi+0B8h]
mov rax, [rax+28h]
mov [rbp+var_50], rax
add r15, rsi
loc_E578A:
mov r13, rdi
lea rsi, [rbp+var_38]
mov rdx, r12
mov rcx, r15
call [rbp+var_50]
test eax, eax
jle loc_E5831
mov rdx, [rbp+var_38]
mov esi, 0FFFDh
mov rcx, [rbp+var_30]
cmp rdx, [rcx]
mov rdi, r13
ja short loc_E57DA
mov rcx, [rbp+var_30]
mov rsi, [rcx+8]
mov rcx, rdx
shr rcx, 8
mov rsi, [rsi+rcx*8]
test rsi, rsi
jz short loc_E57E6
movzx ecx, dl
lea rcx, [rcx+rcx*2]
mov esi, [rsi+rcx*4+8]
loc_E57DA:
mov [rbp+var_38], rsi
mov ecx, esi
shr ecx, 8
mov rdx, rsi
loc_E57E6:
mov esi, ebx
and esi, 3Fh
add rsi, r14
movzx edx, dl
imul rdx, rsi
mov rsi, rbx
shl rsi, 8
add rsi, rdx
xor rsi, rbx
mov edx, esi
and edx, 3Fh
add rdx, r14
add rdx, 3
imul rdx, rcx
mov rbx, rsi
shl rbx, 8
add rbx, rdx
xor rbx, rsi
add r14, 6
mov eax, eax
add r12, rax
cmp r12, r15
jb loc_E578A
loc_E5831:
mov rax, [rbp+var_40]
mov [rax], rbx
mov rax, [rbp+var_48]
mov [rax], r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _QWORD * my_hash_sort_utf16_nopad(long long a1, unsigned long long a2, long long a3, long long *a4, _QWORD *a5)
{
long long v5; // rbx
long long v6; // r14
unsigned long long v7; // r12
unsigned long long v8; // r15
int v9; // eax
unsigned __int8 v10; // dl
long long v11; // rsi
unsigned long long v12; // rcx
long long v13; // rsi
long long v14; // rsi
_QWORD *result; // rax
long long ( *v16)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+0h] [rbp-50h]
unsigned long long v19; // [rsp+18h] [rbp-38h] BYREF
unsigned long long *v20; // [rsp+20h] [rbp-30h]
v5 = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = a2;
v20 = *(unsigned long long **)(a1 + 120);
v16 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v8 = a2 + a3;
while ( 1 )
{
v9 = v16(a1, &v19, v7, v8);
if ( v9 <= 0 )
goto LABEL_9;
v10 = v19;
v11 = 65533LL;
if ( v19 > *v20 )
goto LABEL_7;
v12 = v19 >> 8;
v13 = *(_QWORD *)(v20[1] + 8 * (v19 >> 8));
if ( v13 )
break;
LABEL_8:
v14 = v5 ^ ((v6 + (v5 & 0x3F)) * v10 + (v5 << 8));
v5 = v14 ^ (v12 * (v6 + (((unsigned __int8)v5 ^ (unsigned __int8)((v6 + (v5 & 0x3F)) * v10)) & 0x3F) + 3)
+ (v14 << 8));
v6 += 6LL;
v7 += (unsigned int)v9;
if ( v7 >= v8 )
goto LABEL_9;
}
v11 = *(unsigned int *)(v13 + 12LL * (unsigned __int8)v19 + 8);
LABEL_7:
v19 = v11;
v12 = (unsigned int)v11 >> 8;
v10 = v11;
goto LABEL_8;
}
LABEL_9:
*a4 = v5;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_utf16_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x40],RCX
MOV RBX,qword ptr [RCX]
MOV qword ptr [RBP + -0x48],R8
MOV R14,qword ptr [R8]
TEST RDX,RDX
JLE 0x001e5831
MOV R15,RDX
MOV R12,RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x50],RAX
ADD R15,RSI
LAB_001e578a:
MOV R13,RDI
LEA RSI,[RBP + -0x38]
MOV RDX,R12
MOV RCX,R15
CALL qword ptr [RBP + -0x50]
TEST EAX,EAX
JLE 0x001e5831
MOV RDX,qword ptr [RBP + -0x38]
MOV ESI,0xfffd
MOV RCX,qword ptr [RBP + -0x30]
CMP RDX,qword ptr [RCX]
MOV RDI,R13
JA 0x001e57da
MOV RCX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RCX + 0x8]
MOV RCX,RDX
SHR RCX,0x8
MOV RSI,qword ptr [RSI + RCX*0x8]
TEST RSI,RSI
JZ 0x001e57e6
MOVZX ECX,DL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RSI + RCX*0x4 + 0x8]
LAB_001e57da:
MOV qword ptr [RBP + -0x38],RSI
MOV ECX,ESI
SHR ECX,0x8
MOV RDX,RSI
LAB_001e57e6:
MOV ESI,EBX
AND ESI,0x3f
ADD RSI,R14
MOVZX EDX,DL
IMUL RDX,RSI
MOV RSI,RBX
SHL RSI,0x8
ADD RSI,RDX
XOR RSI,RBX
MOV EDX,ESI
AND EDX,0x3f
ADD RDX,R14
ADD RDX,0x3
IMUL RDX,RCX
MOV RBX,RSI
SHL RBX,0x8
ADD RBX,RDX
XOR RBX,RSI
ADD R14,0x6
MOV EAX,EAX
ADD R12,RAX
CMP R12,R15
JC 0x001e578a
LAB_001e5831:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RBX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_hash_sort_utf16_nopad(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
code *pcVar1;
long lVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
ulong local_40;
ulong *local_38;
uVar6 = *param_4;
lVar7 = *param_5;
if (0 < param_3) {
local_38 = *(ulong **)(param_1 + 0x78);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
uVar8 = param_3 + param_2;
do {
uVar3 = (*pcVar1)(param_1,&local_40,param_2,uVar8);
if ((int)uVar3 < 1) break;
uVar5 = 0xfffd;
if (*local_38 < local_40) {
LAB_001e57da:
uVar4 = uVar5 >> 8;
local_40 = uVar5;
}
else {
uVar4 = local_40 >> 8;
lVar2 = *(long *)(local_38[1] + uVar4 * 8);
if (lVar2 != 0) {
uVar5 = (ulong)*(uint *)(lVar2 + 8 + (local_40 & 0xff) * 0xc);
goto LAB_001e57da;
}
}
uVar6 = uVar6 * 0x100 + (local_40 & 0xff) * ((ulong)((uint)uVar6 & 0x3f) + lVar7) ^ uVar6;
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar7 + 3) * uVar4 ^ uVar6;
lVar7 = lVar7 + 6;
param_2 = param_2 + uVar3;
} while (param_2 < uVar8);
}
*param_4 = uVar6;
*param_5 = lVar7;
return;
}
| |
43,354 | translog_stop_writing | eloqsql/storage/maria/ma_loghandler.c | void translog_stop_writing()
{
DBUG_ENTER("translog_stop_writing");
DBUG_PRINT("error", ("errno: %d my_errno: %d", errno, my_errno));
translog_status= (translog_status == TRANSLOG_SHUTDOWN ?
TRANSLOG_UNINITED :
TRANSLOG_READONLY);
log_descriptor.is_everything_flushed= 1;
log_descriptor.open_flags= O_BINARY | O_RDONLY;
DBUG_ASSERT(0);
DBUG_VOID_RETURN;
} | O0 | c | translog_stop_writing:
pushq %rbp
movq %rsp, %rbp
jmp 0x89a76
jmp 0x89a78
movl 0x3fd792(%rip), %edx # 0x487210
movl $0x2, %eax
xorl %ecx, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
movl %eax, 0x3fd77f(%rip) # 0x487210
movb $0x1, 0xbff858(%rip) # 0xc892f0
movl $0x0, 0x3fe98a(%rip) # 0x48842c
jmp 0x89aa4
jmp 0x89aa6
jmp 0x89aa8
popq %rbp
retq
nopw (%rax,%rax)
| translog_stop_writing:
push rbp
mov rbp, rsp
jmp short $+2
loc_89A76:
jmp short $+2
loc_89A78:
mov edx, cs:translog_status
mov eax, 2
xor ecx, ecx
cmp edx, 3
cmovz eax, ecx
mov cs:translog_status, eax
mov cs:byte_C892F0, 1
mov cs:dword_48842C, 0
jmp short $+2
loc_89AA4:
jmp short $+2
loc_89AA6:
jmp short $+2
loc_89AA8:
pop rbp
retn
| long long translog_stop_writing()
{
long long result; // rax
result = 2LL;
if ( translog_status == 3 )
result = 0LL;
translog_status = result;
byte_C892F0 = 1;
dword_48842C = 0;
return result;
}
| translog_stop_writing:
PUSH RBP
MOV RBP,RSP
JMP 0x00189a76
LAB_00189a76:
JMP 0x00189a78
LAB_00189a78:
MOV EDX,dword ptr [0x00587210]
MOV EAX,0x2
XOR ECX,ECX
CMP EDX,0x3
CMOVZ EAX,ECX
MOV dword ptr [0x00587210],EAX
MOV byte ptr [0x00d892f0],0x1
MOV dword ptr [0x0058842c],0x0
JMP 0x00189aa4
LAB_00189aa4:
JMP 0x00189aa6
LAB_00189aa6:
JMP 0x00189aa8
LAB_00189aa8:
POP RBP
RET
|
void translog_stop_writing(void)
{
int4 uVar1;
uVar1 = 2;
if (translog_status == 3) {
uVar1 = 0;
}
translog_status = uVar1;
DAT_00d892f0 = 1;
DAT_0058842c = 0;
return;
}
| |
43,355 | getNextID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/src/flashcard.cpp | int getNextID(const std::string& fname) {
try {
rapidcsv::Document doc(fname, rapidcsv::LabelParams(0, -1), rapidcsv::SeparatorParams(SEP));
std::vector<int> ids = doc.GetColumn<int>("ID");
} catch (const std::ifstream::failure &e) {
return 0; // если файла нет, то возвращаем 0
} catch (const std::out_of_range &e) {
return 0; // если файл пуст, то возвращаем 0
} catch (const std::exception &e) {
std::cout << e.what() << std::endl;
return -1; // какая-то другая ошибка
}
rapidcsv::Document doc(fname, rapidcsv::LabelParams(0, -1), rapidcsv::SeparatorParams(SEP));
std::vector<int> ids = doc.GetColumn<int>("ID");
return ids.empty() ? 1 : ids.back() + 1;
// если айдишников нет, но заголовок есть, то возвращаем 1, иначе последний + 1
} | O1 | cpp | getNextID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movq %rdi, %rbx
movabsq $-0x100000000, %r13 # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rdx
movq %r13, (%rdx)
leaq 0x5e(%rsp), %rcx
movl $0x2c, (%rcx)
movw $0x2201, 0x4(%rcx) # imm = 0x2201
xorl %eax, %eax
leaq 0x20(%rsp), %r8
movb %al, (%r8)
fldt 0x2687b(%rip) # 0x3d780
fld %st(0)
fstpt 0x64(%rsp)
fstpt 0x30(%rsp)
movq $0x0, 0x20(%r8)
movb $0x1, 0x28(%r8)
leaq 0x5(%rsp), %r9
movw $0x2300, (%r9) # imm = 0x2300
movb %al, 0x2(%r9)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x1cec8
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2685f(%rip), %rsi # 0x3d7a7
leaq 0x2685a(%rip), %rdx # 0x3d7a9
leaq 0x20(%rsp), %rdi
callq 0x10884
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1d00e
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x16f84
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16f9b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xb400
leaq 0x120(%rsp), %rdi
callq 0x1ef48
leaq 0xf0(%rsp), %rdi
callq 0x1ef48
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
callq 0x1d6a8
movq -0x68(%r14), %rdi
leaq 0x80(%rsp), %r12
cmpq %r12, %rdi
je 0x16fe6
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xb400
leaq 0x8(%rsp), %rdx
movq %r13, (%rdx)
leaq 0x5e(%rsp), %rcx
movl $0x2c, (%rcx)
movw $0x2201, 0x4(%rcx) # imm = 0x2201
xorl %eax, %eax
leaq 0x20(%rsp), %r14
movb %al, (%r14)
fldt 0x64(%rsp)
fstpt 0x30(%rsp)
movq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
leaq 0x5(%rsp), %r9
movw $0x2300, (%r9) # imm = 0x2300
movb %al, 0x2(%r9)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %r8
callq 0x1cec8
movq %r15, (%r14)
leaq 0x26760(%rip), %rsi # 0x3d7a7
leaq 0x2675b(%rip), %rdx # 0x3d7a9
leaq 0x20(%rsp), %rdi
callq 0x10884
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1d00e
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x17083
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x17099
movl -0x4(%rax), %ebx
incl %ebx
jmp 0x1709e
movl $0x1, %ebx
testq %rdi, %rdi
je 0x170b0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xb400
leaq 0x120(%rsp), %rdi
callq 0x1ef48
leaq 0xf0(%rsp), %rdi
callq 0x1ef48
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
callq 0x1d6a8
movq -0x68(%r14), %rdi
cmpq %r12, %rdi
je 0x170f3
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xb400
movl %ebx, %eax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x17125
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x17125
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1d0d0
movq %rbx, %rdi
callq 0xb780
movq %rdx, %r14
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1715c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb400
jmp 0x1715c
movq %rdx, %r14
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1d0d0
jmp 0x1716e
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x3, %r14d
je 0x1717a
cmpl $0x2, %r14d
jne 0x1718e
movq %rbx, %rdi
callq 0xb160
callq 0xb6e0
xorl %ebx, %ebx
jmp 0x170f3
cmpl $0x1, %r14d
jne 0x1712f
movq %rbx, %rdi
callq 0xb160
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x42e0c(%rip), %rdi # 0x59fb8
movq %rax, %rsi
callq 0xb3d0
movq %rax, %rdi
callq 0xb1a0
callq 0xb6e0
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x170f3
movq %rax, %rbx
callq 0xb6e0
jmp 0x1712f
movq %rax, %rdi
callq 0x106a9
| _Z9getNextIDRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 160h
mov rbx, rdi
mov r13, 0FFFFFFFF00000000h
lea rdx, [rsp+188h+var_180]
mov [rdx], r13
lea rcx, [rsp+188h+var_12A]
mov dword ptr [rcx], 2Ch ; ','
mov word ptr [rcx+4], 2201h
xor eax, eax
lea r8, [rsp+188h+var_168]
mov [r8], al
fld cs:tbyte_3D780
fld st
fstp [rsp+188h+var_124]
fstp [rsp+188h+var_158]
mov qword ptr [r8+20h], 0
mov byte ptr [r8+28h], 1
lea r9, [rsp+188h+var_183]
mov word ptr [r9], 2300h
mov [r9+2], al
lea rdi, [rsp+188h+var_118]; this
mov rsi, rbx
call _ZN8rapidcsv8DocumentC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11LabelParamsERKNS_15SeparatorParamsERKNS_15ConverterParamsERKNS_16LineReaderParamsE; rapidcsv::Document::Document(std::string const&,rapidcsv::LabelParams const&,rapidcsv::SeparatorParams const&,rapidcsv::ConverterParams const&,rapidcsv::LineReaderParams const&)
lea r15, [rsp+188h+var_158]
mov [r15-10h], r15
lea rsi, unk_3D7A7
lea rdx, unk_3D7A9
lea rdi, [rsp+188h+var_168]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+188h+var_180]
lea rsi, [rsp+188h+var_118]
lea rdx, [rsp+188h+var_168]
call _ZNK8rapidcsv8Document9GetColumnIiEESt6vectorIT_SaIS3_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; rapidcsv::Document::GetColumn<int>(std::string const&)
mov rdi, [rsp+188h+var_168]; void *
cmp rdi, r15
jz short loc_16F84
mov rsi, qword ptr [rsp+188h+var_158]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16F84:
mov rdi, [rsp+188h+var_180]; void *
test rdi, rdi
jz short loc_16F9B
mov rsi, [rsp+188h+var_170]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16F9B:
lea rdi, [rsp+188h+var_68]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
lea rdi, [rsp+188h+var_98]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
lea r14, [rsp+188h+var_B0]
mov rdi, r14
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EED2Ev; std::vector<std::vector<std::string>>::~vector()
mov rdi, [r14-68h]; void *
lea r12, [rsp+188h+var_108]
cmp rdi, r12
jz short loc_16FE6
mov rsi, [rsp+188h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16FE6:
lea rdx, [rsp+188h+var_180]
mov [rdx], r13
lea rcx, [rsp+188h+var_12A]
mov dword ptr [rcx], 2Ch ; ','
mov word ptr [rcx+4], 2201h
xor eax, eax
lea r14, [rsp+188h+var_168]
mov [r14], al
fld [rsp+188h+var_124]
fstp [rsp+188h+var_158]
mov qword ptr [r14+20h], 0
mov byte ptr [r14+28h], 1
lea r9, [rsp+188h+var_183]
mov word ptr [r9], 2300h
mov [r9+2], al
lea rdi, [rsp+188h+var_118]; this
mov rsi, rbx
mov r8, r14
call _ZN8rapidcsv8DocumentC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11LabelParamsERKNS_15SeparatorParamsERKNS_15ConverterParamsERKNS_16LineReaderParamsE; rapidcsv::Document::Document(std::string const&,rapidcsv::LabelParams const&,rapidcsv::SeparatorParams const&,rapidcsv::ConverterParams const&,rapidcsv::LineReaderParams const&)
mov [r14], r15
lea rsi, unk_3D7A7
lea rdx, unk_3D7A9
lea rdi, [rsp+188h+var_168]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+188h+var_180]
lea rsi, [rsp+188h+var_118]
lea rdx, [rsp+188h+var_168]
call _ZNK8rapidcsv8Document9GetColumnIiEESt6vectorIT_SaIS3_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; rapidcsv::Document::GetColumn<int>(std::string const&)
mov rdi, [rsp+188h+var_168]; void *
cmp rdi, r15
jz short loc_17083
mov rsi, qword ptr [rsp+188h+var_158]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17083:
mov rdi, [rsp+188h+var_180]; void *
mov rax, [rsp+188h+var_178]
cmp rdi, rax
jz short loc_17099
mov ebx, [rax-4]
inc ebx
jmp short loc_1709E
loc_17099:
mov ebx, 1
loc_1709E:
test rdi, rdi
jz short loc_170B0
mov rsi, [rsp+188h+var_170]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_170B0:
lea rdi, [rsp+188h+var_68]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
lea rdi, [rsp+188h+var_98]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
lea r14, [rsp+188h+var_B0]
mov rdi, r14
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EED2Ev; std::vector<std::vector<std::string>>::~vector()
mov rdi, [r14-68h]; void *
cmp rdi, r12
jz short loc_170F3
mov rsi, [rsp+188h+var_108]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_170F3:
mov eax, ebx
add rsp, 160h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+188h+var_168]; void *
cmp rdi, r15
jz short loc_17125
mov rsi, qword ptr [rsp+188h+var_158]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_17125
mov rbx, rax
loc_17125:
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
loc_1712F:
mov rdi, rbx
call __Unwind_Resume
mov r14, rdx
mov rbx, rax
mov rdi, [rsp+188h+var_168]; void *
cmp rdi, r15
jz short loc_1715C
mov rsi, qword ptr [rsp+188h+var_158]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1715C
mov r14, rdx
mov rbx, rax
loc_1715C:
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
jmp short loc_1716E
mov r14, rdx
mov rbx, rax
loc_1716E:
cmp r14d, 3
jz short loc_1717A
cmp r14d, 2
jnz short loc_1718E
loc_1717A:
mov rdi, rbx; void *
call ___cxa_begin_catch
call ___cxa_end_catch
xor ebx, ebx
jmp loc_170F3
loc_1718E:
cmp r14d, 1
jnz short loc_1712F
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
mov rdi, cs:_ZSt4cout_ptr
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
call ___cxa_end_catch
mov ebx, 0FFFFFFFFh
jmp loc_170F3
mov rbx, rax
call ___cxa_end_catch
jmp loc_1712F
mov rdi, rax
call __clang_call_terminate
| long long getNextID()
{
unsigned int v0; // ebx
void *v2; // [rsp+8h] [rbp-180h] BYREF
_DWORD *v3; // [rsp+10h] [rbp-178h]
long long v4; // [rsp+18h] [rbp-170h]
void *v5[2]; // [rsp+20h] [rbp-168h] BYREF
long double v6; // [rsp+30h] [rbp-158h] BYREF
long long v7; // [rsp+40h] [rbp-148h]
char v8; // [rsp+48h] [rbp-140h]
int v9; // [rsp+5Eh] [rbp-12Ah]
__int16 v10; // [rsp+62h] [rbp-126h]
_BYTE v11[20]; // [rsp+64h] [rbp-124h] BYREF
_QWORD v12[11]; // [rsp+80h] [rbp-108h] BYREF
_BYTE v13[24]; // [rsp+D8h] [rbp-B0h] BYREF
_BYTE v14[48]; // [rsp+F0h] [rbp-98h] BYREF
_BYTE v15[104]; // [rsp+120h] [rbp-68h] BYREF
v2 = (void *)0xFFFFFFFF00000000LL;
v9 = 44;
v10 = 8705;
*(long double *)v11 = NAN;
v6 = NAN;
v7 = 0LL;
v8 = 1;
rapidcsv::Document::Document((rapidcsv::Document *)&v11[12]);
v5[0] = &v6;
std::string::_M_construct<char const*>(v5, byte_3D7A7, (long long)&unk_3D7A9);
rapidcsv::Document::GetColumn<int>(&v2, &v11[12], v5);
if ( v5[0] != &v6 )
operator delete(v5[0], *(_QWORD *)&v6 + 1LL);
if ( v2 )
operator delete(v2, v4 - (_QWORD)v2);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v15);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v14);
std::vector<std::vector<std::string>>::~vector(v13);
if ( *(_QWORD **)&v11[12] != v12 )
operator delete(*(void **)&v11[12], v12[0] + 1LL);
v2 = (void *)0xFFFFFFFF00000000LL;
v9 = 44;
v10 = 8705;
LOBYTE(v5[0]) = 0;
v6 = *(long double *)v11;
v7 = 0LL;
v8 = 1;
rapidcsv::Document::Document((rapidcsv::Document *)&v11[12]);
v5[0] = &v6;
std::string::_M_construct<char const*>(v5, byte_3D7A7, (long long)&unk_3D7A9);
rapidcsv::Document::GetColumn<int>(&v2, &v11[12], v5);
if ( v5[0] != &v6 )
operator delete(v5[0], *(_QWORD *)&v6 + 1LL);
if ( v2 == v3 )
v0 = 1;
else
v0 = *(v3 - 1) + 1;
if ( v2 )
operator delete(v2, v4 - (_QWORD)v2);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v15);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v14);
std::vector<std::vector<std::string>>::~vector(v13);
if ( *(_QWORD **)&v11[12] != v12 )
operator delete(*(void **)&v11[12], v12[0] + 1LL);
return v0;
}
| getNextID:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x160
MOV RBX,RDI
MOV R13,-0x100000000
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],R13
LEA RCX,[RSP + 0x5e]
MOV dword ptr [RCX],0x2c
MOV word ptr [RCX + 0x4],0x2201
XOR EAX,EAX
LEA R8,[RSP + 0x20]
MOV byte ptr [R8],AL
FLD tword ptr [0x0013d780]
FLD ST0
FSTP tword ptr [RSP + 0x64]
FSTP tword ptr [RSP + 0x30]
MOV qword ptr [R8 + 0x20],0x0
MOV byte ptr [R8 + 0x28],0x1
LEA R9,[RSP + 0x5]
MOV word ptr [R9],0x2300
MOV byte ptr [R9 + 0x2],AL
LAB_00116f2b:
LEA RDI,[RSP + 0x70]
MOV RSI,RBX
CALL 0x0011cec8
LEA R15,[RSP + 0x30]
MOV qword ptr [R15 + -0x10],R15
LAB_00116f41:
LEA RSI,[0x13d7a7]
LEA RDX,[0x13d7a9]
LEA RDI,[RSP + 0x20]
CALL 0x00110884
LAB_00116f59:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x70]
LEA RDX,[RSP + 0x20]
CALL 0x0011d00e
LAB_00116f6d:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R15
JZ 0x00116f84
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0010b400
LAB_00116f84:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00116f9b
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0010b400
LAB_00116f9b:
LEA RDI,[RSP + 0x120]
CALL 0x0011ef48
LEA RDI,[RSP + 0xf0]
CALL 0x0011ef48
LEA R14,[RSP + 0xd8]
MOV RDI,R14
CALL 0x0011d6a8
MOV RDI,qword ptr [R14 + -0x68]
LEA R12,[RSP + 0x80]
CMP RDI,R12
JZ 0x00116fe6
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0010b400
LAB_00116fe6:
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],R13
LEA RCX,[RSP + 0x5e]
MOV dword ptr [RCX],0x2c
MOV word ptr [RCX + 0x4],0x2201
XOR EAX,EAX
LEA R14,[RSP + 0x20]
MOV byte ptr [R14],AL
FLD tword ptr [RSP + 0x64]
FSTP tword ptr [RSP + 0x30]
MOV qword ptr [R14 + 0x20],0x0
MOV byte ptr [R14 + 0x28],0x1
LEA R9,[RSP + 0x5]
MOV word ptr [R9],0x2300
MOV byte ptr [R9 + 0x2],AL
LEA RDI,[RSP + 0x70]
MOV RSI,RBX
MOV R8,R14
CALL 0x0011cec8
MOV qword ptr [R14],R15
LAB_00117040:
LEA RSI,[0x13d7a7]
LEA RDX,[0x13d7a9]
LEA RDI,[RSP + 0x20]
CALL 0x00110884
LAB_00117058:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x70]
LEA RDX,[RSP + 0x20]
CALL 0x0011d00e
LAB_0011706c:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R15
JZ 0x00117083
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0010b400
LAB_00117083:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x10]
CMP RDI,RAX
JZ 0x00117099
MOV EBX,dword ptr [RAX + -0x4]
INC EBX
JMP 0x0011709e
LAB_00117099:
MOV EBX,0x1
LAB_0011709e:
TEST RDI,RDI
JZ 0x001170b0
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0010b400
LAB_001170b0:
LEA RDI,[RSP + 0x120]
CALL 0x0011ef48
LEA RDI,[RSP + 0xf0]
CALL 0x0011ef48
LEA R14,[RSP + 0xd8]
MOV RDI,R14
CALL 0x0011d6a8
MOV RDI,qword ptr [R14 + -0x68]
CMP RDI,R12
JZ 0x001170f3
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0010b400
LAB_001170f3:
MOV EAX,EBX
ADD RSP,0x160
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* getNextID(std::__cxx11::string const&) */
int getNextID(string *param_1)
{
int iVar1;
int2 local_183;
int1 local_181;
void *local_180;
void *local_178;
long local_170;
unkbyte10 *local_168 [2];
unkbyte10 local_158;
int8 local_148;
int1 local_140;
int4 local_12a;
int2 local_126;
unkbyte10 local_124;
long *local_118 [2];
long local_108 [11];
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
local_b0 [24];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_98 [48];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_68 [64];
local_180 = (void *)0xffffffff00000000;
local_12a = 0x2c;
local_126 = 0x2201;
local_168[0] = (unkbyte10 *)((ulong)local_168[0] & 0xffffffffffffff00);
local_124 = _DAT_0013d780;
local_158 = _DAT_0013d780;
local_148 = 0;
local_140 = 1;
local_183 = 0x2300;
local_181 = 0;
/* try { // try from 00116f2b to 00116f37 has its CatchHandler @ 00117168 */
rapidcsv::Document::Document
((Document *)local_118,param_1,(LabelParams *)&local_180,(SeparatorParams *)&local_12a,
(ConverterParams *)local_168,(LineReaderParams *)&local_183);
/* try { // try from 00116f41 to 00116f58 has its CatchHandler @ 00117156 */
local_168[0] = &local_158;
std::__cxx11::string::_M_construct<char_const*>(local_168,&DAT_0013d7a7,&DAT_0013d7a9);
/* try { // try from 00116f59 to 00116f6c has its CatchHandler @ 00117137 */
rapidcsv::Document::GetColumn<int>((string *)&local_180);
if (local_168[0] != &local_158) {
operator_delete(local_168[0],(long)local_158 + 1);
}
if (local_180 != (void *)0x0) {
operator_delete(local_180,local_170 - (long)local_180);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_68);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_98);
std::
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::~vector(local_b0);
if (local_118[0] != local_108) {
operator_delete(local_118[0],local_108[0] + 1);
}
local_180 = (void *)0xffffffff00000000;
local_12a = 0x2c;
local_126 = 0x2201;
local_168[0] = (unkbyte10 *)((ulong)local_168[0] & 0xffffffffffffff00);
local_158 = local_124;
local_148 = 0;
local_140 = 1;
local_183 = 0x2300;
local_181 = 0;
rapidcsv::Document::Document
((Document *)local_118,param_1,(LabelParams *)&local_180,(SeparatorParams *)&local_12a,
(ConverterParams *)local_168,(LineReaderParams *)&local_183);
/* try { // try from 00117040 to 00117057 has its CatchHandler @ 00117122 */
local_168[0] = &local_158;
std::__cxx11::string::_M_construct<char_const*>(local_168,&DAT_0013d7a7,&DAT_0013d7a9);
/* try { // try from 00117058 to 0011706b has its CatchHandler @ 00117106 */
rapidcsv::Document::GetColumn<int>((string *)&local_180);
if (local_168[0] != &local_158) {
operator_delete(local_168[0],(long)local_158 + 1);
}
if (local_180 == local_178) {
iVar1 = 1;
}
else {
iVar1 = *(int *)((long)local_178 + -4) + 1;
}
if (local_180 != (void *)0x0) {
operator_delete(local_180,local_170 - (long)local_180);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_68);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_98);
std::
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::~vector(local_b0);
if (local_118[0] != local_108) {
operator_delete(local_118[0],local_108[0] + 1);
}
return iVar1;
}
| |
43,356 | getNextID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Andrewchistyakov[P]flashcards_lyc/src/flashcard.cpp | int getNextID(const std::string& fname) {
try {
rapidcsv::Document doc(fname, rapidcsv::LabelParams(0, -1), rapidcsv::SeparatorParams(SEP));
std::vector<int> ids = doc.GetColumn<int>("ID");
} catch (const std::ifstream::failure &e) {
return 0; // если файла нет, то возвращаем 0
} catch (const std::out_of_range &e) {
return 0; // если файл пуст, то возвращаем 0
} catch (const std::exception &e) {
std::cout << e.what() << std::endl;
return -1; // какая-то другая ошибка
}
rapidcsv::Document doc(fname, rapidcsv::LabelParams(0, -1), rapidcsv::SeparatorParams(SEP));
std::vector<int> ids = doc.GetColumn<int>("ID");
return ids.empty() ? 1 : ids.back() + 1;
// если айдишников нет, но заголовок есть, то возвращаем 1, иначе последний + 1
} | O2 | cpp | getNextID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, %rbx
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
leaq 0x18(%rsp), %rdx
movq %r12, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x2c, (%rcx)
movw $0x2201, 0x4(%rcx) # imm = 0x2201
xorl %eax, %eax
leaq 0x30(%rsp), %r8
movb %al, (%r8)
fldt 0x1e055(%rip) # 0x32780
fld %st(0)
fstpt 0x64(%rsp)
fstpt 0x40(%rsp)
andq $0x0, 0x20(%r8)
movb $0x1, 0x28(%r8)
leaq 0x15(%rsp), %r9
movw $0x2300, (%r9) # imm = 0x2300
movb %al, 0x2(%r9)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x180bc
leaq 0x1e045(%rip), %rsi # 0x327a7
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x1017c
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x181c8
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xc8c8
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x1b19c
leaq 0x70(%rsp), %rdi
callq 0x18274
movq %r12, (%r15)
leaq 0xc(%rsp), %rcx
movl $0x2c, (%rcx)
movw $0x2201, 0x4(%rcx) # imm = 0x2201
xorl %eax, %eax
movb %al, (%r14)
fldt 0x64(%rsp)
fstpt 0x40(%rsp)
andq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
leaq 0x15(%rsp), %r9
movw $0x2300, (%r9) # imm = 0x2300
movb %al, 0x2(%r9)
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %r8
movq %rbx, %rsi
callq 0x180bc
leaq 0x1dfa6(%rip), %rsi # 0x327a7
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x1017c
leaq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x181c8
leaq 0x30(%rsp), %rdi
callq 0xc8c8
movq 0x20(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x14841
movl -0x4(%rax), %ebx
incl %ebx
jmp 0x14844
pushq $0x1
popq %rbx
leaq 0x18(%rsp), %rdi
callq 0x1b19c
leaq 0x70(%rsp), %rdi
callq 0x18274
movl %ebx, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc8c8
jmp 0x1487b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x18274
movq %rbx, %rdi
callq 0xc7f0
movq %rdx, %r14
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc8c8
jmp 0x148a5
movq %rdx, %r14
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x18274
jmp 0x148b7
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x3, %r14d
je 0x148c3
cmpl $0x2, %r14d
jne 0x148d4
movq %rbx, %rdi
callq 0xc1a0
callq 0xc770
xorl %ebx, %ebx
jmp 0x14858
cmpl $0x1, %r14d
jne 0x14885
movq %rbx, %rdi
callq 0xc1a0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x3d65e(%rip), %rdi # 0x51f50
movq %rax, %rsi
callq 0xc440
movq %rax, %rdi
callq 0xc200
callq 0xc770
pushq $-0x1
popq %rbx
jmp 0x14858
movq %rax, %rbx
callq 0xc770
jmp 0x14885
movq %rax, %rdi
callq 0x1012b
| _Z9getNextIDRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 168h
mov rbx, rdi
mov r12, 0FFFFFFFF00000000h
lea rdx, [rsp+188h+var_170]
mov [rdx], r12
lea rcx, [rsp+188h+var_17C]
mov dword ptr [rcx], 2Ch ; ','
mov word ptr [rcx+4], 2201h
xor eax, eax
lea r8, [rsp+188h+var_158]
mov [r8], al
fld cs:tbyte_32780
fld st
fstp [rsp+188h+var_124]
fstp [rsp+188h+var_148]
and qword ptr [r8+20h], 0
mov byte ptr [r8+28h], 1
lea r9, [rsp+188h+var_173]
mov word ptr [r9], 2300h
mov [r9+2], al
lea rdi, [rsp+188h+var_118]; this
mov rsi, rbx
call _ZN8rapidcsv8DocumentC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11LabelParamsERKNS_15SeparatorParamsERKNS_15ConverterParamsERKNS_16LineReaderParamsE; rapidcsv::Document::Document(std::string const&,rapidcsv::LabelParams const&,rapidcsv::SeparatorParams const&,rapidcsv::ConverterParams const&,rapidcsv::LineReaderParams const&)
lea rsi, unk_327A7
lea rdi, [rsp+188h+var_158]
lea rdx, [rsp+188h+var_17C]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+188h+var_170]
lea rsi, [rsp+188h+var_118]
lea rdx, [rsp+188h+var_158]
call _ZNK8rapidcsv8Document9GetColumnIiEESt6vectorIT_SaIS3_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; rapidcsv::Document::GetColumn<int>(std::string const&)
lea r14, [rsp+188h+var_158]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea r15, [rsp+188h+var_170]
mov rdi, r15
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
mov [r15], r12
lea rcx, [rsp+188h+var_17C]
mov dword ptr [rcx], 2Ch ; ','
mov word ptr [rcx+4], 2201h
xor eax, eax
mov [r14], al
fld [rsp+188h+var_124]
fstp [rsp+188h+var_148]
and qword ptr [r14+20h], 0
mov byte ptr [r14+28h], 1
lea r9, [rsp+188h+var_173]
mov word ptr [r9], 2300h
mov [r9+2], al
lea rdi, [rsp+188h+var_118]; this
lea rdx, [rsp+188h+var_170]
lea r8, [rsp+188h+var_158]
mov rsi, rbx
call _ZN8rapidcsv8DocumentC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_11LabelParamsERKNS_15SeparatorParamsERKNS_15ConverterParamsERKNS_16LineReaderParamsE; rapidcsv::Document::Document(std::string const&,rapidcsv::LabelParams const&,rapidcsv::SeparatorParams const&,rapidcsv::ConverterParams const&,rapidcsv::LineReaderParams const&)
lea rsi, unk_327A7
lea rdi, [rsp+188h+var_158]
lea rdx, [rsp+188h+var_17C]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+188h+var_170]
lea rsi, [rsp+188h+var_118]
lea rdx, [rsp+188h+var_158]
call _ZNK8rapidcsv8Document9GetColumnIiEESt6vectorIT_SaIS3_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; rapidcsv::Document::GetColumn<int>(std::string const&)
lea rdi, [rsp+188h+var_158]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, [rsp+188h+var_168]
cmp [rsp+188h+var_170], rax
jz short loc_14841
mov ebx, [rax-4]
inc ebx
jmp short loc_14844
loc_14841:
push 1
pop rbx
loc_14844:
lea rdi, [rsp+188h+var_170]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
loc_14858:
mov eax, ebx
add rsp, 168h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+188h+var_158]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_1487B
mov rbx, rax
loc_1487B:
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
loc_14885:
mov rdi, rbx
call __Unwind_Resume
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+188h+var_158]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_148A5
mov r14, rdx
mov rbx, rax
loc_148A5:
lea rdi, [rsp+188h+var_118]; this
call _ZN8rapidcsv8DocumentD2Ev; rapidcsv::Document::~Document()
jmp short loc_148B7
mov r14, rdx
mov rbx, rax
loc_148B7:
cmp r14d, 3
jz short loc_148C3
cmp r14d, 2
jnz short loc_148D4
loc_148C3:
mov rdi, rbx; void *
call ___cxa_begin_catch
call ___cxa_end_catch
xor ebx, ebx
jmp short loc_14858
loc_148D4:
cmp r14d, 1
jnz short loc_14885
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
mov rdi, cs:_ZSt4cout_ptr
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, rax
call __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_; std::endl<char,std::char_traits<char>>(std::ostream &)
call ___cxa_end_catch
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp loc_14858
mov rbx, rax
call ___cxa_end_catch
jmp loc_14885
mov rdi, rax
call __clang_call_terminate
| long long getNextID()
{
unsigned int v0; // ebx
unsigned long long v2; // [rsp+18h] [rbp-170h] BYREF
long long v3; // [rsp+20h] [rbp-168h]
_QWORD v4[2]; // [rsp+30h] [rbp-158h] BYREF
long double v5; // [rsp+40h] [rbp-148h]
long long v6; // [rsp+50h] [rbp-138h]
char v7; // [rsp+58h] [rbp-130h]
long double v8[18]; // [rsp+64h] [rbp-124h] BYREF
v2 = 0xFFFFFFFF00000000LL;
LOBYTE(v4[0]) = 0;
v8[0] = NAN;
v5 = NAN;
v6 = 0LL;
v7 = 1;
rapidcsv::Document::Document((rapidcsv::Document *)((char *)v8 + 12));
std::string::basic_string<std::allocator<char>>(v4, (long long)&unk_327A7);
rapidcsv::Document::GetColumn<int>(&v2, (char *)v8 + 12, v4);
std::string::~string(v4);
std::_Vector_base<int>::~_Vector_base(&v2);
rapidcsv::Document::~Document((rapidcsv::Document *)((char *)v8 + 12));
v2 = 0xFFFFFFFF00000000LL;
LOBYTE(v4[0]) = 0;
v5 = v8[0];
v6 = 0LL;
v7 = 1;
rapidcsv::Document::Document((rapidcsv::Document *)((char *)v8 + 12));
std::string::basic_string<std::allocator<char>>(v4, (long long)&unk_327A7);
rapidcsv::Document::GetColumn<int>(&v2, (char *)v8 + 12, v4);
std::string::~string(v4);
if ( v2 == v3 )
v0 = 1;
else
v0 = *(_DWORD *)(v3 - 4) + 1;
std::_Vector_base<int>::~_Vector_base(&v2);
rapidcsv::Document::~Document((rapidcsv::Document *)((char *)v8 + 12));
return v0;
}
| getNextID:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x168
MOV RBX,RDI
MOV R12,-0x100000000
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX],R12
LEA RCX,[RSP + 0xc]
MOV dword ptr [RCX],0x2c
MOV word ptr [RCX + 0x4],0x2201
XOR EAX,EAX
LEA R8,[RSP + 0x30]
MOV byte ptr [R8],AL
FLD tword ptr [0x00132780]
FLD ST0
FSTP tword ptr [RSP + 0x64]
FSTP tword ptr [RSP + 0x40]
AND qword ptr [R8 + 0x20],0x0
MOV byte ptr [R8 + 0x28],0x1
LEA R9,[RSP + 0x15]
MOV word ptr [R9],0x2300
MOV byte ptr [R9 + 0x2],AL
LAB_0011474e:
LEA RDI,[RSP + 0x70]
MOV RSI,RBX
CALL 0x001180bc
LAB_0011475b:
LEA RSI,[0x1327a7]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0xc]
CALL 0x0011017c
LAB_00114771:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x70]
LEA RDX,[RSP + 0x30]
CALL 0x001181c8
LAB_00114785:
LEA R14,[RSP + 0x30]
MOV RDI,R14
CALL 0x0010c8c8
LEA R15,[RSP + 0x18]
MOV RDI,R15
CALL 0x0011b19c
LEA RDI,[RSP + 0x70]
CALL 0x00118274
MOV qword ptr [R15],R12
LEA RCX,[RSP + 0xc]
MOV dword ptr [RCX],0x2c
MOV word ptr [RCX + 0x4],0x2201
XOR EAX,EAX
MOV byte ptr [R14],AL
FLD tword ptr [RSP + 0x64]
FSTP tword ptr [RSP + 0x40]
AND qword ptr [R14 + 0x20],0x0
MOV byte ptr [R14 + 0x28],0x1
LEA R9,[RSP + 0x15]
MOV word ptr [R9],0x2300
MOV byte ptr [R9 + 0x2],AL
LEA RDI,[RSP + 0x70]
LEA RDX,[RSP + 0x18]
LEA R8,[RSP + 0x30]
MOV RSI,RBX
CALL 0x001180bc
LAB_001147fa:
LEA RSI,[0x1327a7]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0xc]
CALL 0x0011017c
LAB_00114810:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x70]
LEA RDX,[RSP + 0x30]
CALL 0x001181c8
LAB_00114824:
LEA RDI,[RSP + 0x30]
CALL 0x0010c8c8
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RSP + 0x18],RAX
JZ 0x00114841
MOV EBX,dword ptr [RAX + -0x4]
INC EBX
JMP 0x00114844
LAB_00114841:
PUSH 0x1
POP RBX
LAB_00114844:
LEA RDI,[RSP + 0x18]
CALL 0x0011b19c
LEA RDI,[RSP + 0x70]
CALL 0x00118274
LAB_00114858:
MOV EAX,EBX
ADD RSP,0x168
POP RBX
POP R12
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* getNextID(std::__cxx11::string const&) */
int getNextID(string *param_1)
{
int iVar1;
int4 local_17c;
int2 local_178;
int2 local_173;
int1 local_171;
long local_170;
long local_168;
ConverterParams local_158 [16];
unkbyte10 local_148;
int8 local_138;
int1 local_130;
unkbyte10 local_124;
Document local_118 [248];
local_170 = 0xffffffff00000000;
local_17c = 0x2c;
local_178 = 0x2201;
local_158[0] = (ConverterParams)0x0;
local_124 = _DAT_00132780;
local_148 = _DAT_00132780;
local_138 = 0;
local_130 = 1;
local_173 = 0x2300;
local_171 = 0;
/* try { // try from 0011474e to 0011475a has its CatchHandler @ 001148b1 */
rapidcsv::Document::Document
(local_118,param_1,(LabelParams *)&local_170,(SeparatorParams *)&local_17c,local_158,
(LineReaderParams *)&local_173);
/* try { // try from 0011475b to 00114770 has its CatchHandler @ 0011489f */
std::__cxx11::string::string<std::allocator<char>>
((string *)local_158,"ID",(allocator *)&local_17c);
/* try { // try from 00114771 to 00114784 has its CatchHandler @ 0011488d */
rapidcsv::Document::GetColumn<int>((string *)&local_170);
std::__cxx11::string::~string((string *)local_158);
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_170);
rapidcsv::Document::~Document(local_118);
local_170 = -0x100000000;
local_17c = 0x2c;
local_178 = 0x2201;
local_158[0] = (ConverterParams)0x0;
local_148 = local_124;
local_138 = 0;
local_130 = 1;
local_173 = 0x2300;
local_171 = 0;
rapidcsv::Document::Document
(local_118,param_1,(LabelParams *)&local_170,(SeparatorParams *)&local_17c,local_158,
(LineReaderParams *)&local_173);
/* try { // try from 001147fa to 0011480f has its CatchHandler @ 00114878 */
std::__cxx11::string::string<std::allocator<char>>
((string *)local_158,"ID",(allocator *)&local_17c);
/* try { // try from 00114810 to 00114823 has its CatchHandler @ 00114869 */
rapidcsv::Document::GetColumn<int>((string *)&local_170);
std::__cxx11::string::~string((string *)local_158);
if (local_170 == local_168) {
iVar1 = 1;
}
else {
iVar1 = *(int *)(local_168 + -4) + 1;
}
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_170);
rapidcsv::Document::~Document(local_118);
return iVar1;
}
| |
43,357 | js_promise_finalizer | bluesky950520[P]quickjs/quickjs.c | static void js_promise_finalizer(JSRuntime *rt, JSValue val)
{
JSPromiseData *s = JS_GetOpaque(val, JS_CLASS_PROMISE);
struct list_head *el, *el1;
int i;
if (!s)
return;
for(i = 0; i < 2; i++) {
list_for_each_safe(el, el1, &s->promise_reactions[i]) {
JSPromiseReactionData *rd =
list_entry(el, JSPromiseReactionData, link);
promise_reaction_data_free(rt, rd);
}
}
JS_FreeValueRT(rt, s->promise_result);
js_free_rt(rt, s);
} | O2 | c | js_promise_finalizer:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, %edx
jne 0x4608c
cmpw $0x31, 0x6(%rsi)
jne 0x4608c
movq 0x30(%rsi), %r14
testq %r14, %r14
je 0x4608c
movq %rdi, %rbx
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x4609b
movq %r12, %rax
shlq $0x4, %rax
leaq (%r15,%rax), %r13
movq 0x8(%r15,%rax), %rsi
cmpq %r13, %rsi
je 0x46087
movq 0x8(%rsi), %rbp
movq %rbx, %rdi
callq 0x3b298
movq %rbp, %rsi
jmp 0x46071
incq %r12
jmp 0x4605b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x174b5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1654f
| js_promise_finalizer:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp edx, 0FFFFFFFFh
jnz short loc_4608C
cmp word ptr [rsi+6], 31h ; '1'
jnz short loc_4608C
mov r14, [rsi+30h]
test r14, r14
jz short loc_4608C
mov rbx, rdi
lea r15, [r14+8]
xor r12d, r12d
loc_4605B:
cmp r12, 2
jz short loc_4609B
mov rax, r12
shl rax, 4
lea r13, [r15+rax]
mov rsi, [r15+rax+8]
loc_46071:
cmp rsi, r13
jz short loc_46087
mov rbp, [rsi+8]
mov rdi, rbx
call promise_reaction_data_free
mov rsi, rbp
jmp short loc_46071
loc_46087:
inc r12
jmp short loc_4605B
loc_4608C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4609B:
mov rsi, [r14+30h]
mov rdx, [r14+38h]
mov rdi, rbx
call JS_FreeValueRT
mov rdi, rbx
mov rsi, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp js_free_rt
| long long js_promise_finalizer(long long a1, long long a2, int a3)
{
long long v3; // r14
long long v4; // r15
long long i; // r12
long long j; // rsi
long long v7; // rbp
long long result; // rax
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 49 )
{
v3 = *(_QWORD *)(a2 + 48);
if ( v3 )
{
v4 = v3 + 8;
for ( i = 0LL; i != 2; ++i )
{
for ( j = *(_QWORD *)(v4 + 16 * i + 8); j != v4 + 16 * i; j = v7 )
{
v7 = *(_QWORD *)(j + 8);
promise_reaction_data_free(a1, j);
}
}
JS_FreeValueRT(a1, *(unsigned int **)(v3 + 48), *(_QWORD *)(v3 + 56));
return js_free_rt(a1, v3);
}
}
return result;
}
| js_promise_finalizer:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP EDX,-0x1
JNZ 0x0014608c
CMP word ptr [RSI + 0x6],0x31
JNZ 0x0014608c
MOV R14,qword ptr [RSI + 0x30]
TEST R14,R14
JZ 0x0014608c
MOV RBX,RDI
LEA R15,[R14 + 0x8]
XOR R12D,R12D
LAB_0014605b:
CMP R12,0x2
JZ 0x0014609b
MOV RAX,R12
SHL RAX,0x4
LEA R13,[R15 + RAX*0x1]
MOV RSI,qword ptr [R15 + RAX*0x1 + 0x8]
LAB_00146071:
CMP RSI,R13
JZ 0x00146087
MOV RBP,qword ptr [RSI + 0x8]
MOV RDI,RBX
CALL 0x0013b298
MOV RSI,RBP
JMP 0x00146071
LAB_00146087:
INC R12
JMP 0x0014605b
LAB_0014608c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014609b:
MOV RSI,qword ptr [R14 + 0x30]
MOV RDX,qword ptr [R14 + 0x38]
MOV RDI,RBX
CALL 0x001174b5
MOV RDI,RBX
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011654f
|
void js_promise_finalizer(int8 param_1,long param_2,int param_3)
{
long lVar1;
long lVar2;
long lVar3;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x31)) &&
(lVar1 = *(long *)(param_2 + 0x30), lVar1 != 0)) {
for (lVar3 = 0; lVar3 != 2; lVar3 = lVar3 + 1) {
lVar2 = *(long *)(lVar1 + 0x10 + lVar3 * 0x10);
while (lVar2 != lVar1 + 8 + lVar3 * 0x10) {
lVar2 = *(long *)(lVar2 + 8);
promise_reaction_data_free(param_1);
}
}
JS_FreeValueRT(param_1,*(int8 *)(lVar1 + 0x30),*(int8 *)(lVar1 + 0x38));
js_free_rt(param_1,lVar1);
return;
}
return;
}
| |
43,358 | google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(google::protobuf::io::Printer*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/cpp/enum_field.cc | void RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("/*decltype($field$)*/{}");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
} | O0 | cpp | google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(google::protobuf::io::Printer*) const:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movq 0x78(%rsp), %rsi
addq $0x18, %rdx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdf0d0
movq 0x28(%rsp), %rdi
leaq 0x1fcf66(%rip), %rsi # 0x3d68ab
callq 0x5ae90
jmp 0x1d994c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2583f0
movb %al, 0x1f(%rsp)
jmp 0x1d9960
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1d996a
jmp 0x1d99d1
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3cb80
movq %rax, 0x10(%rsp)
jmp 0x1d997f
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xdf4b0
movb %al, 0xf(%rsp)
jmp 0x1d9998
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1d99a2
jmp 0x1d99d1
leaq 0x20251c(%rip), %rsi # 0x3dbec5
leaq 0x40(%rsp), %rdi
callq 0x5ae90
jmp 0x1d99b5
jmp 0x1d99d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdf130
jmp 0x1d99e3
leaq 0x40(%rsp), %rdi
callq 0xdf130
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x21700
nopl (%rax)
| _ZNK6google8protobuf8compiler3cpp26RepeatedEnumFieldGenerator37GenerateConstexprAggregateInitializerEPNS0_2io7PrinterE:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov rdx, [rsp+88h+var_8]
mov [rsp+88h+var_68], rdx
mov rsi, [rsp+88h+var_10]
add rdx, 18h
lea rdi, [rsp+88h+var_48]
mov [rsp+88h+var_60], rdi
call _ZN6google8protobuf8compiler3cpp9FormatterC2EPNS0_2io7PrinterERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESD_St4lessISD_ESaISt4pairIKSD_SD_EEE; google::protobuf::compiler::cpp::Formatter::Formatter(google::protobuf::io::Printer *,std::map<std::string,std::string> const&)
mov rdi, [rsp+88h+var_60]
lea rsi, aDecltypeField; "/*decltype($field$)*/{}"
call _ZNK6google8protobuf8compiler3cpp9FormatterclIJEEEvPKcDpRKT_
jmp short $+2
loc_1D994C:
mov rax, [rsp+88h+var_68]
mov rdi, [rax+8]; this
call _ZNK6google8protobuf15FieldDescriptor9is_packedEv; google::protobuf::FieldDescriptor::is_packed(void)
mov [rsp+88h+var_69], al
jmp short $+2
loc_1D9960:
mov al, [rsp+88h+var_69]
test al, 1
jnz short loc_1D996A
jmp short loc_1D99D1
loc_1D996A:
mov rax, [rsp+88h+var_68]
mov rdi, [rax+8]; this
call _ZNK6google8protobuf15FieldDescriptor4fileEv; google::protobuf::FieldDescriptor::file(void)
mov [rsp+88h+var_78], rax
jmp short $+2
loc_1D997F:
mov rdi, [rsp+88h+var_78]; this
mov rax, [rsp+88h+var_68]
mov rsi, [rax+10h]; google::protobuf::FileDescriptor *
call _ZN6google8protobuf8compiler3cpp19HasGeneratedMethodsEPKNS0_14FileDescriptorERKNS2_7OptionsE; google::protobuf::compiler::cpp::HasGeneratedMethods(google::protobuf::FileDescriptor const*,google::protobuf::compiler::cpp::Options const&)
mov [rsp+88h+var_79], al
jmp short $+2
loc_1D9998:
mov al, [rsp+88h+var_79]
test al, 1
jnz short loc_1D99A2
jmp short loc_1D99D1
loc_1D99A2:
lea rsi, aDecltypeCached_0; "\n, /*decltype($cached_byte_size_field$"...
lea rdi, [rsp+88h+var_48]
call _ZNK6google8protobuf8compiler3cpp9FormatterclIJEEEvPKcDpRKT_
jmp short $+2
loc_1D99B5:
jmp short loc_1D99D1
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]; this
call _ZN6google8protobuf8compiler3cpp9FormatterD2Ev; google::protobuf::compiler::cpp::Formatter::~Formatter()
jmp short loc_1D99E3
loc_1D99D1:
lea rdi, [rsp+88h+var_48]; this
call _ZN6google8protobuf8compiler3cpp9FormatterD2Ev; google::protobuf::compiler::cpp::Formatter::~Formatter()
add rsp, 88h
retn
loc_1D99E3:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| void google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(
google::protobuf::FieldDescriptor **this,
google::protobuf::io::Printer *a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
const google::protobuf::compiler::cpp::Options *v10; // rdx
bool *v11; // rcx
int v12; // edx
int v13; // ecx
int v14; // r8d
int v15; // r9d
google::protobuf::compiler::cpp *v16; // [rsp+10h] [rbp-78h]
_QWORD v17[9]; // [rsp+40h] [rbp-48h] BYREF
v17[8] = this;
v17[7] = a2;
google::protobuf::compiler::cpp::Formatter::Formatter(v17, (long long)a2, (long long)(this + 3), a4, a5, a6);
google::protobuf::compiler::cpp::Formatter::operator()<>(
(unsigned int)v17,
(unsigned int)"/*decltype($field$)*/{}",
v6,
v7,
v8,
v9);
if ( (google::protobuf::FieldDescriptor::is_packed(this[1]) & 1) != 0 )
{
v16 = (google::protobuf::compiler::cpp *)google::protobuf::FieldDescriptor::file(this[1]);
if ( google::protobuf::compiler::cpp::HasGeneratedMethods(v16, this[2], v10, v11) )
google::protobuf::compiler::cpp::Formatter::operator()<>(
(unsigned int)v17,
(unsigned int)"\n, /*decltype($cached_byte_size_field$)*/{0}",
v12,
v13,
v14,
v15);
}
google::protobuf::compiler::cpp::Formatter::~Formatter((google::protobuf::compiler::cpp::Formatter *)v17);
}
| |||
43,359 | google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(google::protobuf::io::Printer*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/cpp/enum_field.cc | void RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(
io::Printer* printer) const {
Formatter format(printer, variables_);
format("/*decltype($field$)*/{}");
if (descriptor_->is_packed() &&
HasGeneratedMethods(descriptor_->file(), options_)) {
format("\n, /*decltype($cached_byte_size_field$)*/{0}");
}
} | O3 | cpp | google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(google::protobuf::io::Printer*) const:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rax
leaq 0x8(%rsp), %rbx
movq %rsi, -0x8(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7e61e
leaq 0xd4f6f(%rip), %rsi # 0x1c7e46
movq %rsp, %rdi
callq 0x39938
movq 0x8(%r14), %rdi
callq 0x125036
testb %al, %al
je 0xf2f13
movq 0x8(%r14), %rax
movq 0x10(%r14), %rsi
movq 0x10(%rax), %rdi
xorl %edx, %edx
callq 0x38ac3
cmpl $0x2, %eax
je 0xf2f13
leaq 0xd9f67(%rip), %rsi # 0x1cce72
movq %rsp, %rdi
callq 0x39938
movq %rbx, %rdi
callq 0x2e5e0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e5e0
movq %r14, %rdi
callq 0x1f860
| _ZNK6google8protobuf8compiler3cpp26RepeatedEnumFieldGenerator37GenerateConstexprAggregateInitializerEPNS0_2io7PrinterE:
push r14
push rbx
sub rsp, 38h
mov r14, rdi
lea rax, [rdi+18h]
lea rbx, [rsp+48h+var_40]
mov [rbx-8], rsi
mov rdi, rbx
mov rsi, rax
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EEC2ERKSE_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>> const&)
lea rsi, aDecltypeField; "/*decltype($field$)*/{}"
mov rdi, rsp
call _ZNK6google8protobuf8compiler3cpp9FormatterclIJEEEvPKcDpRKT_
mov rdi, [r14+8]; this
call _ZNK6google8protobuf15FieldDescriptor9is_packedEv; google::protobuf::FieldDescriptor::is_packed(void)
test al, al
jz short loc_F2F13
mov rax, [r14+8]
mov rsi, [r14+10h]; google::protobuf::FileDescriptor *
mov rdi, [rax+10h]; this
xor edx, edx; google::protobuf::compiler::cpp::Options *
call _ZN6google8protobuf8compiler3cpp14GetOptimizeForEPKNS0_14FileDescriptorERKNS2_7OptionsEPb; google::protobuf::compiler::cpp::GetOptimizeFor(google::protobuf::FileDescriptor const*,google::protobuf::compiler::cpp::Options const&,bool *)
cmp eax, 2
jz short loc_F2F13
lea rsi, aDecltypeCached_0; "\n, /*decltype($cached_byte_size_field$"...
mov rdi, rsp
call _ZNK6google8protobuf8compiler3cpp9FormatterclIJEEEvPKcDpRKT_
loc_F2F13:
mov rdi, rbx
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree()
add rsp, 38h
pop rbx
pop r14
retn
mov r14, rax
mov rdi, rbx
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(
google::protobuf::FieldDescriptor **this,
google::protobuf::io::Printer *a2)
{
long long result; // rax
bool *v3; // rcx
google::protobuf::io::Printer *v4; // [rsp+0h] [rbp-48h] BYREF
_BYTE v5[64]; // [rsp+8h] [rbp-40h] BYREF
v4 = a2;
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::_Rb_tree(
(long long)v5,
(long long)(this + 3));
google::protobuf::compiler::cpp::Formatter::operator()<>(&v4, "/*decltype($field$)*/{}");
result = google::protobuf::FieldDescriptor::is_packed(this[1]);
if ( (_BYTE)result )
{
result = google::protobuf::compiler::cpp::GetOptimizeFor(
*((google::protobuf::compiler::cpp **)this[1] + 2),
this[2],
0LL,
v3);
if ( (_DWORD)result != 2 )
result = google::protobuf::compiler::cpp::Formatter::operator()<>(
&v4,
"\n, /*decltype($cached_byte_size_field$)*/{0}");
}
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::string>>>::~_Rb_tree((long long)v5);
return result;
}
| GenerateConstexprAggregateInitializer:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R14,RDI
LEA RAX,[RDI + 0x18]
LEA RBX,[RSP + 0x8]
MOV qword ptr [RBX + -0x8],RSI
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0017e61e
LAB_001f2ed0:
LEA RSI,[0x2c7e46]
MOV RDI,RSP
CALL 0x00139938
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x00225036
TEST AL,AL
JZ 0x001f2f13
MOV RAX,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R14 + 0x10]
MOV RDI,qword ptr [RAX + 0x10]
XOR EDX,EDX
CALL 0x00138ac3
CMP EAX,0x2
JZ 0x001f2f13
LEA RSI,[0x2cce72]
MOV RDI,RSP
CALL 0x00139938
LAB_001f2f13:
MOV RDI,RBX
CALL 0x0012e5e0
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer(google::protobuf::io::Printer*)
const */
void __thiscall
google::protobuf::compiler::cpp::RepeatedEnumFieldGenerator::GenerateConstexprAggregateInitializer
(RepeatedEnumFieldGenerator *this,Printer *param_1)
{
char cVar1;
int iVar2;
Printer *local_48;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
local_40 [48];
local_48 = param_1;
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::_Rb_tree(local_40,(_Rb_tree *)(this + 0x18));
/* try { // try from 001f2ed0 to 001f2f12 has its CatchHandler @ 001f2f23 */
Formatter::operator()<>((Formatter *)&local_48,"/*decltype($field$)*/{}");
cVar1 = FieldDescriptor::is_packed(*(FieldDescriptor **)(this + 8));
if (cVar1 != '\0') {
iVar2 = GetOptimizeFor(*(FileDescriptor **)(*(long *)(this + 8) + 0x10),
*(Options **)(this + 0x10),(bool *)0x0);
if (iVar2 != 2) {
Formatter::operator()<>
((Formatter *)&local_48,"\n, /*decltype($cached_byte_size_field$)*/{0}");
}
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::~_Rb_tree(local_40);
return;
}
| |
43,360 | google::protobuf::internal::ExtensionSet::MessageSetByteSize() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc | size_t ExtensionSet::MessageSetByteSize() const {
size_t total_size = 0;
ForEach([&total_size](int number, const Extension& ext) {
total_size += ext.MessageSetItemByteSize(number);
});
return total_size;
} | O3 | cpp | google::protobuf::internal::ExtensionSet::MessageSetByteSize() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movswq 0xa(%rdi), %r15
movq 0x10(%rdi), %rbx
testq %r15, %r15
js 0x9abc7
testw %r15w, %r15w
je 0x9abb7
shlq $0x5, %r15
addq %rbx, %r15
xorl %r14d, %r14d
movl (%rbx), %esi
leaq 0x8(%rbx), %rdi
callq 0x9ab06
addq %rax, %r14
addq $0x20, %rbx
cmpq %r15, %rbx
jne 0x9ab9e
jmp 0x9abba
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%rbx), %rdi
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9adea
movq (%r14), %r14
jmp 0x9abba
| _ZNK6google8protobuf8internal12ExtensionSet18MessageSetByteSizeEv:
push r15
push r14
push rbx
sub rsp, 10h
mov [rsp+28h+var_20], 0
movsx r15, word ptr [rdi+0Ah]
mov rbx, [rdi+10h]
test r15, r15
js short loc_9ABC7
test r15w, r15w
jz short loc_9ABB7
shl r15, 5
add r15, rbx
xor r14d, r14d
loc_9AB9E:
mov esi, [rbx]; int
lea rdi, [rbx+8]; this
call _ZNK6google8protobuf8internal12ExtensionSet9Extension22MessageSetItemByteSizeEi; google::protobuf::internal::ExtensionSet::Extension::MessageSetItemByteSize(int)
add r14, rax
add rbx, 20h ; ' '
cmp rbx, r15
jnz short loc_9AB9E
jmp short loc_9ABBA
loc_9ABB7:
xor r14d, r14d
loc_9ABBA:
mov rax, r14
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_9ABC7:
mov rdi, [rbx+18h]
add rbx, 8
lea r14, [rsp+28h+var_20]
mov rsi, rbx
mov rdx, r14
call _ZN6google8protobuf8internal12ExtensionSet7ForEachISt17_Rb_tree_iteratorISt4pairIKiNS2_9ExtensionEEEZNKS2_18MessageSetByteSizeEvE3$_0EET0_T_SC_SB_; google::protobuf::internal::ExtensionSet::ForEach<std::_Rb_tree_iterator<std::pair<int const,google::protobuf::internal::ExtensionSet::Extension>>,google::protobuf::internal::ExtensionSet::MessageSetByteSize(void)::$_0>(std::_Rb_tree_iterator<std::pair<int const,google::protobuf::internal::ExtensionSet::Extension>>,std::_Rb_tree_iterator<std::pair<int const,google::protobuf::internal::ExtensionSet::Extension>>,google::protobuf::internal::ExtensionSet::MessageSetByteSize(void)::$_0)
mov r14, [r14]
jmp short loc_9ABBA
| long long google::protobuf::internal::ExtensionSet::MessageSetByteSize(
google::protobuf::internal::ExtensionSet *this)
{
long long v1; // r15
long long v2; // rbx
long long v3; // r15
long long v4; // r14
_QWORD v6[4]; // [rsp+8h] [rbp-20h] BYREF
v6[0] = 0LL;
v1 = *((__int16 *)this + 5);
v2 = *((_QWORD *)this + 2);
if ( v1 < 0 )
{
google::protobuf::internal::ExtensionSet::ForEach<std::_Rb_tree_iterator<std::pair<int const,google::protobuf::internal::ExtensionSet::Extension>>,google::protobuf::internal::ExtensionSet::MessageSetByteSize(void)::$_0>(
*(_QWORD *)(v2 + 24),
v2 + 8,
v6);
return v6[0];
}
else if ( (_WORD)v1 )
{
v3 = v2 + 32 * v1;
v4 = 0LL;
do
{
v4 += google::protobuf::internal::ExtensionSet::Extension::MessageSetItemByteSize(
(long long **)(v2 + 8),
*(_DWORD *)v2);
v2 += 32LL;
}
while ( v2 != v3 );
}
else
{
return 0LL;
}
return v4;
}
| MessageSetByteSize:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP + 0x8],0x0
MOVSX R15,word ptr [RDI + 0xa]
MOV RBX,qword ptr [RDI + 0x10]
TEST R15,R15
JS 0x0019abc7
TEST R15W,R15W
JZ 0x0019abb7
SHL R15,0x5
ADD R15,RBX
XOR R14D,R14D
LAB_0019ab9e:
MOV ESI,dword ptr [RBX]
LEA RDI,[RBX + 0x8]
CALL 0x0019ab06
ADD R14,RAX
ADD RBX,0x20
CMP RBX,R15
JNZ 0x0019ab9e
JMP 0x0019abba
LAB_0019abb7:
XOR R14D,R14D
LAB_0019abba:
MOV RAX,R14
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_0019abc7:
MOV RDI,qword ptr [RBX + 0x18]
ADD RBX,0x8
LEA R14,[RSP + 0x8]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0019adea
MOV R14,qword ptr [R14]
JMP 0x0019abba
|
/* google::protobuf::internal::ExtensionSet::MessageSetByteSize() const */
long __thiscall google::protobuf::internal::ExtensionSet::MessageSetByteSize(ExtensionSet *this)
{
short sVar1;
long lVar2;
int *piVar3;
long lVar4;
int *piVar5;
long local_20;
local_20 = 0;
sVar1 = *(short *)(this + 10);
piVar3 = *(int **)(this + 0x10);
if ((long)sVar1 < 0) {
ForEach<std::_Rb_tree_iterator<std::pair<int_const,google::protobuf::internal::ExtensionSet::Extension>>,google::protobuf::internal::ExtensionSet::MessageSetByteSize()const::__0>
(*(int8 *)(piVar3 + 6),piVar3 + 2,&local_20);
lVar4 = local_20;
}
else if (sVar1 == 0) {
lVar4 = 0;
}
else {
piVar5 = piVar3 + (long)sVar1 * 8;
lVar4 = 0;
do {
lVar2 = Extension::MessageSetItemByteSize((Extension *)(piVar3 + 2),*piVar3);
lVar4 = lVar4 + lVar2;
piVar3 = piVar3 + 8;
} while (piVar3 != piVar5);
}
return lVar4;
}
| |
43,361 | 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;
} | O0 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9fed0
cmpl $0x5, (%rax)
je 0xa0ecc
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0xa0810
movl %eax, -0x4(%rbp)
jmp 0xa0f8c
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9fed0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0xa0fa0
cmpl $0x0, %eax
jne 0xa0f0d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa1010
movl %eax, -0x4(%rbp)
jmp 0xa0f8c
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0xa04a0
cmpl $0x0, %eax
jne 0xa0f29
movl $0x0, -0x4(%rbp)
jmp 0xa0f8c
jmp 0xa0f2b
movq -0x10(%rbp), %rdi
callq 0x9fed0
cmpl $0x5, (%rax)
jne 0xa0f85
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9fed0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0xa0fa0
cmpl $0x0, %eax
jne 0xa0f7a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa1010
movl %eax, -0x4(%rbp)
jmp 0xa0f8c
movq -0x10(%rbp), %rdi
callq 0xa06b0
jmp 0xa0f2b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jz short loc_A0ECC
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_expected_error
mov [rbp+var_4], eax
jmp loc_A0F8C
loc_A0ECC:
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_A0F0D
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_A0F8C
loc_A0F0D:
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_scan_term
cmp eax, 0
jnz short loc_A0F29
mov [rbp+var_4], 0
jmp short loc_A0F8C
loc_A0F29:
jmp short $+2
loc_A0F2B:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jnz short loc_A0F85
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_A0F7A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_A0F8C
loc_A0F7A:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
jmp short loc_A0F2B
loc_A0F85:
mov [rbp+var_4], 1
loc_A0F8C:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rax
if ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
{
if ( (unsigned int)my_coll_parser_scan_term(a1, 5u) )
{
while ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v5 = my_coll_parser_curr(a1);
if ( !(unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v5 + 36)) )
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
my_coll_parser_scan(a1);
}
return 1;
}
else
{
return 0;
}
}
else
{
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
}
}
else
{
return (unsigned int)my_coll_parser_expected_error(a1, 5u);
}
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019fed0
CMP dword ptr [RAX],0x5
JZ 0x001a0ecc
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x001a0810
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a0f8c
LAB_001a0ecc:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019fed0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001a0fa0
CMP EAX,0x0
JNZ 0x001a0f0d
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001a1010
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a0f8c
LAB_001a0f0d:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x001a04a0
CMP EAX,0x0
JNZ 0x001a0f29
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001a0f8c
LAB_001a0f29:
JMP 0x001a0f2b
LAB_001a0f2b:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019fed0
CMP dword ptr [RAX],0x5
JNZ 0x001a0f85
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019fed0
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x001a0fa0
CMP EAX,0x0
JNZ 0x001a0f7a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001a1010
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a0f8c
LAB_001a0f7a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001a06b0
JMP 0x001a0f2b
LAB_001a0f85:
MOV dword ptr [RBP + -0x4],0x1
LAB_001a0f8c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
my_coll_parser_scan_character_list
(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int4 uVar2;
int *piVar3;
long lVar4;
int4 local_c;
piVar3 = (int *)my_coll_parser_curr(param_1);
if (*piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
local_c = my_coll_parser_too_long_error(param_1,param_4);
}
else {
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
local_c = 0;
}
else {
while (piVar3 = (int *)my_coll_parser_curr(param_1), *piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
uVar2 = my_coll_parser_too_long_error(param_1,param_4);
return uVar2;
}
my_coll_parser_scan(param_1);
}
local_c = 1;
}
}
}
else {
local_c = my_coll_parser_expected_error(param_1,5);
}
return local_c;
}
| |
43,362 | mark_all_entries | eloqsql/storage/maria/ma_rt_split.c | static void mark_all_entries(SplitStruct *node, int n_entries, int n_group)
{
SplitStruct *cur= node;
SplitStruct *end= node + n_entries;
for (; cur < end; cur++)
{
if (cur->n_node)
{
continue;
}
cur->n_node= n_group;
}
} | O0 | c | mark_all_entries:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x84bb7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x84b9f
jmp 0x84ba9
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x84b89
popq %rbp
retq
nopl (%rax)
| mark_all_entries:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_C]
shl rcx, 5
add rax, rcx
mov [rbp+var_20], rax
loc_84B89:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_84BB7
mov rax, [rbp+var_18]
cmp dword ptr [rax+8], 0
jz short loc_84B9F
jmp short loc_84BA9
loc_84B9F:
mov ecx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+8], ecx
loc_84BA9:
mov rax, [rbp+var_18]
add rax, 20h ; ' '
mov [rbp+var_18], rax
jmp short loc_84B89
loc_84BB7:
pop rbp
retn
| unsigned long long mark_all_entries(unsigned long long a1, int a2, int a3)
{
unsigned long long result; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
for ( i = a1; ; i += 32LL )
{
result = i;
if ( i >= 32LL * a2 + a1 )
break;
if ( !*(_DWORD *)(i + 8) )
*(_DWORD *)(i + 8) = a3;
}
return result;
}
| mark_all_entries:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_00184b89:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00184bb7
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00184b9f
JMP 0x00184ba9
LAB_00184b9f:
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
LAB_00184ba9:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x20
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00184b89
LAB_00184bb7:
POP RBP
RET
|
void mark_all_entries(ulong param_1,int param_2,int4 param_3)
{
int8 local_20;
for (local_20 = param_1; local_20 < param_1 + (long)param_2 * 0x20; local_20 = local_20 + 0x20) {
if (*(int *)(local_20 + 8) == 0) {
*(int4 *)(local_20 + 8) = param_3;
}
}
return;
}
| |
43,363 | bf_set_overflow | bluesky950520[P]quickjs/libbf.c | static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
{
slimb_t i, l, e_max;
int rnd_mode;
rnd_mode = flags & BF_RND_MASK;
if (prec == BF_PREC_INF ||
rnd_mode == BF_RNDN ||
rnd_mode == BF_RNDNA ||
rnd_mode == BF_RNDA ||
(rnd_mode == BF_RNDD && sign == 1) ||
(rnd_mode == BF_RNDU && sign == 0)) {
bf_set_inf(r, sign);
} else {
/* set to maximum finite number */
l = (prec + LIMB_BITS - 1) / LIMB_BITS;
if (bf_resize(r, l)) {
bf_set_nan(r);
return BF_ST_MEM_ERROR;
}
r->tab[0] = limb_mask((-prec) & (LIMB_BITS - 1),
LIMB_BITS - 1);
for(i = 1; i < l; i++)
r->tab[i] = (limb_t)-1;
e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
r->expn = e_max;
r->sign = sign;
}
return BF_ST_OVERFLOW | BF_ST_INEXACT;
} | O1 | c | bf_set_overflow:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x5, %eax
je 0x8b38d
movl %ecx, %ebp
movq %rdx, %r15
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rdx
je 0x8b38d
movl %ebp, %ecx
andl $0x3, %ecx
je 0x8b38d
movl %eax, %ecx
xorl $0x2, %ecx
movl %r14d, %edx
xorl $0x1, %edx
orl %ecx, %edx
je 0x8b38d
xorl $0x3, %eax
orl %r14d, %eax
jne 0x8b3d7
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
movl $0x14, %ebp
cmpq $0x0, 0x18(%rbx)
je 0x8b3be
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f(%r15), %r13
movq %r13, %r12
shrq $0x6, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x83e5c
testl %eax, %eax
je 0x8b41d
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
incq %r15
cmpq $0x0, 0x18(%rbx)
movl $0x20, %ebp
je 0x8b49a
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %r14d, %r14d
jmp 0x8b3ad
negl %r15d
andl $0x3f, %r15d
movl %r15d, %ecx
negb %cl
movq $-0x1, %rax
shlq %cl, %rax
notq %rax
movl %r15d, %ecx
shlq %cl, %rax
xorl %ecx, %ecx
cmpl $0x1, %r15d
sbbq %rcx, %rcx
orq %rax, %rcx
movq 0x20(%rbx), %rdi
movq %rcx, (%rdi)
cmpq $0x80, %r13
jb 0x8b46e
addq $0x8, %rdi
leaq -0x8(,%r12,8), %rdx
movl $0xff, %esi
callq 0xe340
shrl $0x5, %ebp
andl $0x3f, %ebp
movb $0x3c, %al
subb %bpl, %al
cmpl $0x3f, %ebp
movzbl %al, %eax
movl $0x3d, %ecx
cmovnel %eax, %ecx
movl $0x1, %r15d
shlq %cl, %r15
movl $0x14, %ebp
jmp 0x8b3be
xorl %r14d, %r14d
jmp 0x8b3be
| bf_set_overflow:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, esi
mov rbx, rdi
mov eax, ecx
and eax, 7
cmp eax, 5
jz short loc_8B38D
mov ebp, ecx
mov r15, rdx
mov rcx, 3FFFFFFFFFFFFFFFh
cmp rdx, rcx
jz short loc_8B38D
mov ecx, ebp
and ecx, 3
jz short loc_8B38D
mov ecx, eax
xor ecx, 2
mov edx, r14d
xor edx, 1
or edx, ecx
jz short loc_8B38D
xor eax, 3
or eax, r14d
jnz short loc_8B3D7
loc_8B38D:
mov r15, 7FFFFFFFFFFFFFFEh
mov ebp, 14h
cmp qword ptr [rbx+18h], 0
jz short loc_8B3BE
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
loc_8B3AD:
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8B3BE:
mov [rbx+10h], r15
mov [rbx+8], r14d
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8B3D7:
lea r13, [r15+3Fh]
mov r12, r13
shr r12, 6
mov rdi, rbx
mov rsi, r12
call bf_resize
test eax, eax
jz short loc_8B41D
mov r15, 7FFFFFFFFFFFFFFEh
inc r15
cmp qword ptr [rbx+18h], 0
mov ebp, 20h ; ' '
jz loc_8B49A
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor r14d, r14d
jmp short loc_8B3AD
loc_8B41D:
neg r15d
and r15d, 3Fh
mov ecx, r15d
neg cl
mov rax, 0FFFFFFFFFFFFFFFFh
shl rax, cl
not rax
mov ecx, r15d
shl rax, cl
xor ecx, ecx
cmp r15d, 1
sbb rcx, rcx
or rcx, rax
mov rdi, [rbx+20h]
mov [rdi], rcx
cmp r13, 80h
jb short loc_8B46E
add rdi, 8
lea rdx, ds:0FFFFFFFFFFFFFFF8h[r12*8]
mov esi, 0FFh
call _memset
loc_8B46E:
shr ebp, 5
and ebp, 3Fh
mov al, 3Ch ; '<'
sub al, bpl
cmp ebp, 3Fh ; '?'
movzx eax, al
mov ecx, 3Dh ; '='
cmovnz ecx, eax
mov r15d, 1
shl r15, cl
mov ebp, 14h
jmp loc_8B3BE
loc_8B49A:
xor r14d, r14d
jmp loc_8B3BE
| long long bf_set_overflow(long long a1, int a2, long long a3, unsigned int a4)
{
int v4; // r14d
int v6; // eax
long long v9; // r15
unsigned int v10; // ebp
long long *v11; // rax
long long v12; // rsi
long long v13; // rdi
long long *v15; // rdi
int v16; // ebp
char v17; // cl
v4 = a2;
v6 = a4 & 7;
if ( v6 != 5 && a3 != 0x3FFFFFFFFFFFFFFFLL && (a4 & 3) != 0 && v6 ^ 2 | a2 ^ 1 && a2 | v6 ^ 3 )
{
if ( (unsigned int)bf_resize(a1, (unsigned long long)(a3 + 63) >> 6) )
{
v9 = 0x7FFFFFFFFFFFFFFFLL;
v10 = 32;
if ( !*(_QWORD *)(a1 + 24) )
{
v4 = 0;
goto LABEL_9;
}
v11 = *(long long **)a1;
v12 = *(_QWORD *)(a1 + 32);
v13 = **(_QWORD **)a1;
v4 = 0;
goto LABEL_8;
}
v15 = *(long long **)(a1 + 32);
*v15 = (~(-1LL << -(-(char)a3 & 0x3F)) << (-(char)a3 & 0x3F)) | -(long long)((-(int)a3 & 0x3F) == 0);
if ( (unsigned long long)(a3 + 63) >= 0x80 )
memset(v15 + 1, 255LL, 8 * ((unsigned long long)(a3 + 63) >> 6) - 8);
v16 = (a4 >> 5) & 0x3F;
v17 = 61;
if ( v16 != 63 )
v17 = 60 - v16;
v9 = 1LL << v17;
v10 = 20;
}
else
{
v9 = 0x7FFFFFFFFFFFFFFELL;
v10 = 20;
if ( *(_QWORD *)(a1 + 24) )
{
v11 = *(long long **)a1;
v12 = *(_QWORD *)(a1 + 32);
v13 = **(_QWORD **)a1;
LABEL_8:
*(_QWORD *)(a1 + 32) = ((long long ( *)(long long, long long, _QWORD))v11[1])(v13, v12, 0LL);
*(_QWORD *)(a1 + 24) = 0LL;
}
}
LABEL_9:
*(_QWORD *)(a1 + 16) = v9;
*(_DWORD *)(a1 + 8) = v4;
return v10;
}
| bf_set_overflow:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
MOV EAX,ECX
AND EAX,0x7
CMP EAX,0x5
JZ 0x0018b38d
MOV EBP,ECX
MOV R15,RDX
MOV RCX,0x3fffffffffffffff
CMP RDX,RCX
JZ 0x0018b38d
MOV ECX,EBP
AND ECX,0x3
JZ 0x0018b38d
MOV ECX,EAX
XOR ECX,0x2
MOV EDX,R14D
XOR EDX,0x1
OR EDX,ECX
JZ 0x0018b38d
XOR EAX,0x3
OR EAX,R14D
JNZ 0x0018b3d7
LAB_0018b38d:
MOV R15,0x7ffffffffffffffe
MOV EBP,0x14
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018b3be
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
LAB_0018b3ad:
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018b3be:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],R14D
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018b3d7:
LEA R13,[R15 + 0x3f]
MOV R12,R13
SHR R12,0x6
MOV RDI,RBX
MOV RSI,R12
CALL 0x00183e5c
TEST EAX,EAX
JZ 0x0018b41d
MOV R15,0x7ffffffffffffffe
INC R15
CMP qword ptr [RBX + 0x18],0x0
MOV EBP,0x20
JZ 0x0018b49a
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR R14D,R14D
JMP 0x0018b3ad
LAB_0018b41d:
NEG R15D
AND R15D,0x3f
MOV ECX,R15D
NEG CL
MOV RAX,-0x1
SHL RAX,CL
NOT RAX
MOV ECX,R15D
SHL RAX,CL
XOR ECX,ECX
CMP R15D,0x1
SBB RCX,RCX
OR RCX,RAX
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RDI],RCX
CMP R13,0x80
JC 0x0018b46e
ADD RDI,0x8
LEA RDX,[-0x8 + R12*0x8]
MOV ESI,0xff
CALL 0x0010e340
LAB_0018b46e:
SHR EBP,0x5
AND EBP,0x3f
MOV AL,0x3c
SUB AL,BPL
CMP EBP,0x3f
MOVZX EAX,AL
MOV ECX,0x3d
CMOVNZ ECX,EAX
MOV R15D,0x1
SHL R15,CL
MOV EBP,0x14
JMP 0x0018b3be
LAB_0018b49a:
XOR R14D,R14D
JMP 0x0018b3be
|
int8 bf_set_overflow(int8 *param_1,int param_2,long param_3,uint param_4)
{
ulong *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
int8 uVar5;
sbyte sVar6;
byte bVar7;
int8 uVar8;
int8 uVar9;
ulong uVar10;
long lVar11;
uVar2 = param_4 & 7;
if (((uVar2 == 5) || (param_3 == 0x3fffffffffffffff)) || ((param_4 & 3) == 0)) {
LAB_0018b38d:
lVar11 = 0x7ffffffffffffffe;
uVar8 = 0x14;
if (param_1[3] == 0) goto LAB_0018b3be;
puVar4 = (int8 *)*param_1;
uVar5 = param_1[4];
uVar9 = *puVar4;
}
else {
if ((param_2 == 1 && uVar2 == 2) || (uVar2 == 3 && param_2 == 0)) goto LAB_0018b38d;
uVar10 = param_3 + 0x3fU >> 6;
iVar3 = bf_resize(param_1,uVar10);
if (iVar3 == 0) {
uVar2 = -(int)param_3 & 0x3f;
sVar6 = (sbyte)uVar2;
puVar1 = (ulong *)param_1[4];
*puVar1 = -(ulong)(uVar2 == 0) | ~(-1L << (-sVar6 & 0x3fU)) << sVar6;
if (0x7f < param_3 + 0x3fU) {
memset(puVar1 + 1,0xff,uVar10 * 8 - 8);
}
uVar2 = param_4 >> 5 & 0x3f;
bVar7 = 0x3d;
if (uVar2 != 0x3f) {
bVar7 = 0x3c - (char)uVar2;
}
lVar11 = 1L << (bVar7 & 0x3f);
uVar8 = 0x14;
goto LAB_0018b3be;
}
lVar11 = 0x7fffffffffffffff;
uVar8 = 0x20;
if (param_1[3] == 0) {
param_2 = 0;
goto LAB_0018b3be;
}
puVar4 = (int8 *)*param_1;
uVar5 = param_1[4];
uVar9 = *puVar4;
param_2 = 0;
}
uVar5 = (*(code *)puVar4[1])(uVar9,uVar5,0);
param_1[4] = uVar5;
param_1[3] = 0;
LAB_0018b3be:
param_1[2] = lVar11;
*(int *)(param_1 + 1) = param_2;
return uVar8;
}
| |
43,364 | bf_set_overflow | bluesky950520[P]quickjs/libbf.c | static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
{
slimb_t i, l, e_max;
int rnd_mode;
rnd_mode = flags & BF_RND_MASK;
if (prec == BF_PREC_INF ||
rnd_mode == BF_RNDN ||
rnd_mode == BF_RNDNA ||
rnd_mode == BF_RNDA ||
(rnd_mode == BF_RNDD && sign == 1) ||
(rnd_mode == BF_RNDU && sign == 0)) {
bf_set_inf(r, sign);
} else {
/* set to maximum finite number */
l = (prec + LIMB_BITS - 1) / LIMB_BITS;
if (bf_resize(r, l)) {
bf_set_nan(r);
return BF_ST_MEM_ERROR;
}
r->tab[0] = limb_mask((-prec) & (LIMB_BITS - 1),
LIMB_BITS - 1);
for(i = 1; i < l; i++)
r->tab[i] = (limb_t)-1;
e_max = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
r->expn = e_max;
r->sign = sign;
}
return BF_ST_OVERFLOW | BF_ST_INEXACT;
} | O3 | c | bf_set_overflow:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x5, %eax
je 0x8de0d
movl %ecx, %ebp
movq %rdx, %r15
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rcx, %rdx
je 0x8de0d
movl %ebp, %ecx
andl $0x3, %ecx
je 0x8de0d
movl %eax, %ecx
xorl $0x2, %ecx
movl %r14d, %edx
xorl $0x1, %edx
orl %ecx, %edx
je 0x8de0d
xorl $0x3, %eax
orl %r14d, %eax
jne 0x8de57
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
movl $0x14, %ebp
cmpq $0x0, 0x18(%rbx)
je 0x8de3e
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f(%r15), %r13
movq %r13, %r12
shrq $0x6, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8687d
testl %eax, %eax
je 0x8de9d
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
incq %r15
cmpq $0x0, 0x18(%rbx)
movl $0x20, %ebp
je 0x8df1a
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %r14d, %r14d
jmp 0x8de2d
negl %r15d
andl $0x3f, %r15d
movl %r15d, %ecx
negb %cl
movq $-0x1, %rax
shlq %cl, %rax
notq %rax
movl %r15d, %ecx
shlq %cl, %rax
xorl %ecx, %ecx
cmpl $0x1, %r15d
sbbq %rcx, %rcx
orq %rax, %rcx
movq 0x20(%rbx), %rdi
movq %rcx, (%rdi)
cmpq $0x80, %r13
jb 0x8deee
addq $0x8, %rdi
leaq -0x8(,%r12,8), %rdx
movl $0xff, %esi
callq 0xe340
shrl $0x5, %ebp
andl $0x3f, %ebp
movb $0x3c, %al
subb %bpl, %al
cmpl $0x3f, %ebp
movzbl %al, %eax
movl $0x3d, %ecx
cmovnel %eax, %ecx
movl $0x1, %r15d
shlq %cl, %r15
movl $0x14, %ebp
jmp 0x8de3e
xorl %r14d, %r14d
jmp 0x8de3e
| bf_set_overflow:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, esi
mov rbx, rdi
mov eax, ecx
and eax, 7
cmp eax, 5
jz short loc_8DE0D
mov ebp, ecx
mov r15, rdx
mov rcx, 3FFFFFFFFFFFFFFFh
cmp rdx, rcx
jz short loc_8DE0D
mov ecx, ebp
and ecx, 3
jz short loc_8DE0D
mov ecx, eax
xor ecx, 2
mov edx, r14d
xor edx, 1
or edx, ecx
jz short loc_8DE0D
xor eax, 3
or eax, r14d
jnz short loc_8DE57
loc_8DE0D:
mov r15, 7FFFFFFFFFFFFFFEh
mov ebp, 14h
cmp qword ptr [rbx+18h], 0
jz short loc_8DE3E
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
loc_8DE2D:
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8DE3E:
mov [rbx+10h], r15
mov [rbx+8], r14d
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8DE57:
lea r13, [r15+3Fh]
mov r12, r13
shr r12, 6
mov rdi, rbx
mov rsi, r12
call bf_resize
test eax, eax
jz short loc_8DE9D
mov r15, 7FFFFFFFFFFFFFFEh
inc r15
cmp qword ptr [rbx+18h], 0
mov ebp, 20h ; ' '
jz loc_8DF1A
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor r14d, r14d
jmp short loc_8DE2D
loc_8DE9D:
neg r15d
and r15d, 3Fh
mov ecx, r15d
neg cl
mov rax, 0FFFFFFFFFFFFFFFFh
shl rax, cl
not rax
mov ecx, r15d
shl rax, cl
xor ecx, ecx
cmp r15d, 1
sbb rcx, rcx
or rcx, rax
mov rdi, [rbx+20h]
mov [rdi], rcx
cmp r13, 80h
jb short loc_8DEEE
add rdi, 8
lea rdx, ds:0FFFFFFFFFFFFFFF8h[r12*8]
mov esi, 0FFh
call _memset
loc_8DEEE:
shr ebp, 5
and ebp, 3Fh
mov al, 3Ch ; '<'
sub al, bpl
cmp ebp, 3Fh ; '?'
movzx eax, al
mov ecx, 3Dh ; '='
cmovnz ecx, eax
mov r15d, 1
shl r15, cl
mov ebp, 14h
jmp loc_8DE3E
loc_8DF1A:
xor r14d, r14d
jmp loc_8DE3E
| long long bf_set_overflow(long long a1, int a2, long long a3, unsigned int a4)
{
int v4; // r14d
int v6; // eax
long long v9; // r15
unsigned int v10; // ebp
long long *v11; // rax
long long v12; // rsi
long long v13; // rdi
long long *v15; // rdi
int v16; // ebp
char v17; // cl
v4 = a2;
v6 = a4 & 7;
if ( v6 != 5 && a3 != 0x3FFFFFFFFFFFFFFFLL && (a4 & 3) != 0 && v6 ^ 2 | a2 ^ 1 && a2 | v6 ^ 3 )
{
if ( (unsigned int)bf_resize(a1, (unsigned long long)(a3 + 63) >> 6) )
{
v9 = 0x7FFFFFFFFFFFFFFFLL;
v10 = 32;
if ( !*(_QWORD *)(a1 + 24) )
{
v4 = 0;
goto LABEL_9;
}
v11 = *(long long **)a1;
v12 = *(_QWORD *)(a1 + 32);
v13 = **(_QWORD **)a1;
v4 = 0;
goto LABEL_8;
}
v15 = *(long long **)(a1 + 32);
*v15 = (~(-1LL << -(-(char)a3 & 0x3F)) << (-(char)a3 & 0x3F)) | -(long long)((-(int)a3 & 0x3F) == 0);
if ( (unsigned long long)(a3 + 63) >= 0x80 )
memset(v15 + 1, 255LL, 8 * ((unsigned long long)(a3 + 63) >> 6) - 8);
v16 = (a4 >> 5) & 0x3F;
v17 = 61;
if ( v16 != 63 )
v17 = 60 - v16;
v9 = 1LL << v17;
v10 = 20;
}
else
{
v9 = 0x7FFFFFFFFFFFFFFELL;
v10 = 20;
if ( *(_QWORD *)(a1 + 24) )
{
v11 = *(long long **)a1;
v12 = *(_QWORD *)(a1 + 32);
v13 = **(_QWORD **)a1;
LABEL_8:
*(_QWORD *)(a1 + 32) = ((long long ( *)(long long, long long, _QWORD))v11[1])(v13, v12, 0LL);
*(_QWORD *)(a1 + 24) = 0LL;
}
}
LABEL_9:
*(_QWORD *)(a1 + 16) = v9;
*(_DWORD *)(a1 + 8) = v4;
return v10;
}
| bf_set_overflow:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,ESI
MOV RBX,RDI
MOV EAX,ECX
AND EAX,0x7
CMP EAX,0x5
JZ 0x0018de0d
MOV EBP,ECX
MOV R15,RDX
MOV RCX,0x3fffffffffffffff
CMP RDX,RCX
JZ 0x0018de0d
MOV ECX,EBP
AND ECX,0x3
JZ 0x0018de0d
MOV ECX,EAX
XOR ECX,0x2
MOV EDX,R14D
XOR EDX,0x1
OR EDX,ECX
JZ 0x0018de0d
XOR EAX,0x3
OR EAX,R14D
JNZ 0x0018de57
LAB_0018de0d:
MOV R15,0x7ffffffffffffffe
MOV EBP,0x14
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018de3e
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
LAB_0018de2d:
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018de3e:
MOV qword ptr [RBX + 0x10],R15
MOV dword ptr [RBX + 0x8],R14D
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018de57:
LEA R13,[R15 + 0x3f]
MOV R12,R13
SHR R12,0x6
MOV RDI,RBX
MOV RSI,R12
CALL 0x0018687d
TEST EAX,EAX
JZ 0x0018de9d
MOV R15,0x7ffffffffffffffe
INC R15
CMP qword ptr [RBX + 0x18],0x0
MOV EBP,0x20
JZ 0x0018df1a
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR R14D,R14D
JMP 0x0018de2d
LAB_0018de9d:
NEG R15D
AND R15D,0x3f
MOV ECX,R15D
NEG CL
MOV RAX,-0x1
SHL RAX,CL
NOT RAX
MOV ECX,R15D
SHL RAX,CL
XOR ECX,ECX
CMP R15D,0x1
SBB RCX,RCX
OR RCX,RAX
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RDI],RCX
CMP R13,0x80
JC 0x0018deee
ADD RDI,0x8
LEA RDX,[-0x8 + R12*0x8]
MOV ESI,0xff
CALL 0x0010e340
LAB_0018deee:
SHR EBP,0x5
AND EBP,0x3f
MOV AL,0x3c
SUB AL,BPL
CMP EBP,0x3f
MOVZX EAX,AL
MOV ECX,0x3d
CMOVNZ ECX,EAX
MOV R15D,0x1
SHL R15,CL
MOV EBP,0x14
JMP 0x0018de3e
LAB_0018df1a:
XOR R14D,R14D
JMP 0x0018de3e
|
int8 bf_set_overflow(int8 *param_1,int param_2,long param_3,uint param_4)
{
ulong *puVar1;
uint uVar2;
int iVar3;
int8 *puVar4;
int8 uVar5;
sbyte sVar6;
byte bVar7;
int8 uVar8;
int8 uVar9;
ulong uVar10;
long lVar11;
uVar2 = param_4 & 7;
if (((uVar2 == 5) || (param_3 == 0x3fffffffffffffff)) || ((param_4 & 3) == 0)) {
LAB_0018de0d:
lVar11 = 0x7ffffffffffffffe;
uVar8 = 0x14;
if (param_1[3] == 0) goto LAB_0018de3e;
puVar4 = (int8 *)*param_1;
uVar5 = param_1[4];
uVar9 = *puVar4;
}
else {
if ((param_2 == 1 && uVar2 == 2) || (uVar2 == 3 && param_2 == 0)) goto LAB_0018de0d;
uVar10 = param_3 + 0x3fU >> 6;
iVar3 = bf_resize(param_1,uVar10);
if (iVar3 == 0) {
uVar2 = -(int)param_3 & 0x3f;
sVar6 = (sbyte)uVar2;
puVar1 = (ulong *)param_1[4];
*puVar1 = -(ulong)(uVar2 == 0) | ~(-1L << (-sVar6 & 0x3fU)) << sVar6;
if (0x7f < param_3 + 0x3fU) {
memset(puVar1 + 1,0xff,uVar10 * 8 - 8);
}
uVar2 = param_4 >> 5 & 0x3f;
bVar7 = 0x3d;
if (uVar2 != 0x3f) {
bVar7 = 0x3c - (char)uVar2;
}
lVar11 = 1L << (bVar7 & 0x3f);
uVar8 = 0x14;
goto LAB_0018de3e;
}
lVar11 = 0x7fffffffffffffff;
uVar8 = 0x20;
if (param_1[3] == 0) {
param_2 = 0;
goto LAB_0018de3e;
}
puVar4 = (int8 *)*param_1;
uVar5 = param_1[4];
uVar9 = *puVar4;
param_2 = 0;
}
uVar5 = (*(code *)puVar4[1])(uVar9,uVar5,0);
param_1[4] = uVar5;
param_1[3] = 0;
LAB_0018de3e:
param_1[2] = lVar11;
*(int *)(param_1 + 1) = param_2;
return uVar8;
}
| |
43,365 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | monkey531[P]llama/common/json.hpp | static diyfp normalize(diyfp x) noexcept
{
JSON_ASSERT(x.f != 0);
while ((x.f >> 63u) == 0)
{
x.f <<= 1u;
x.e--;
}
return x;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rax
testq %rdi, %rdi
jne 0x87d32
leaq 0x280b9(%rip), %rdi # 0xafdcc
leaq 0x224f0(%rip), %rdx # 0xaa20a
leaq 0x2d88f(%rip), %rcx # 0xb55b0
movl $0x42a1, %esi # imm = 0x42A1
xorl %eax, %eax
callq 0x23ee0
addq %rdi, %rdi
decl %esi
testq %rdi, %rdi
jns 0x87d2d
movq %rdi, %rax
movl %esi, %edx
popq %rcx
retq
movq %rax, %rdi
callq 0x27867
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_:
push rax
test rdi, rdi
jnz short loc_87D32
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aXF0; "x.f != 0"
mov esi, 42A1h
xor eax, eax
call _ggml_abort
loc_87D2D:
add rdi, rdi
dec esi
loc_87D32:
test rdi, rdi
jns short loc_87D2D
mov rax, rdi
mov edx, esi
pop rcx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(long long a1, int a2)
{
if ( a1 )
goto LABEL_4;
a1 = (long long)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp";
a2 = 17057;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17057LL,
"GGML_ASSERT(%s) failed",
"x.f != 0");
do
{
a1 *= 2LL;
--a2;
LABEL_4:
;
}
while ( a1 >= 0 );
return a1;
}
| normalize:
PUSH RAX
TEST RDI,RDI
JNZ 0x00187d32
LAB_00187d0c:
LEA RDI,[0x1afdcc]
LEA RDX,[0x1aa20a]
LEA RCX,[0x1b55b0]
MOV ESI,0x42a1
XOR EAX,EAX
CALL 0x00123ee0
LAB_00187d2d:
ADD RDI,RDI
DEC ESI
LAB_00187d32:
TEST RDI,RDI
JNS 0x00187d2d
MOV RAX,RDI
MOV EDX,ESI
POP RCX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
*/
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(diyfp *this,int param_2)
{
int1 auVar1 [16];
if (this == (diyfp *)0x0) {
/* try { // try from 00187d0c to 00187d2c has its CatchHandler @ 00187d3e */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x42a1,
"GGML_ASSERT(%s) failed","x.f != 0");
}
for (; -1 < (long)this; this = (diyfp *)((long)this * 2)) {
param_2 = param_2 + -1;
}
auVar1._8_4_ = param_2;
auVar1._0_8_ = this;
auVar1._12_4_ = 0;
return auVar1;
}
| |
43,366 | flux::parser::Parser::dataDeclaration() | kvthweatt[P]FluxLang/src/parser/parser.cpp | std::unique_ptr<Decl> Parser::dataDeclaration() {
// Determine if it's signed or unsigned
bool isSigned = !check(lexer::TokenType::KEYWORD_UNSIGNED);
// Skip 'signed' or 'unsigned' if present
if (check(lexer::TokenType::KEYWORD_SIGNED) || check(lexer::TokenType::KEYWORD_UNSIGNED)) {
advance();
}
// Parse 'data' keyword if not already consumed
if (!previous_.is(lexer::TokenType::KEYWORD_DATA)) {
consume(lexer::TokenType::KEYWORD_DATA, "Expected 'data' keyword");
}
// Parse the bit size
consume(lexer::TokenType::LEFT_BRACE, "Expected '{' after 'data'");
// Parse the size expression
auto sizeToken = consume(lexer::TokenType::INTEGER_LITERAL, "Expected bit size");
int64_t bits = sizeToken.intValue();
consume(lexer::TokenType::RIGHT_BRACE, "Expected '}' after bit size");
// Check for array syntax
bool isArray = false;
std::unique_ptr<Expr> arraySizeExpr;
if (match(lexer::TokenType::LEFT_BRACKET)) {
isArray = true;
// Check if there's a size expression or an empty bracket for dynamic array
if (!check(lexer::TokenType::RIGHT_BRACKET)) {
arraySizeExpr = expression();
}
consume(lexer::TokenType::RIGHT_BRACKET, "Expected ']' after array size");
}
// Parse the type name
auto name = consume(lexer::TokenType::IDENTIFIER, "Expected data type name");
consume(lexer::TokenType::SEMICOLON, "Expected ';' after data declaration");
// Create the base data type
auto dataType = std::make_unique<DataTypeExpr>(
bits,
isSigned,
makeRange(previous_)
);
// If it's an array, wrap the data type in an array type
if (isArray) {
auto arrayType = std::make_unique<ArrayTypeExpr>(
std::move(dataType),
std::move(arraySizeExpr),
makeRange(previous_)
);
return std::make_unique<VarDecl>(
name.lexeme(),
std::move(arrayType),
nullptr, // no initializer
false, // not const
makeRange(previous_)
);
}
// If not an array, create a simple variable declaration
return std::make_unique<VarDecl>(
name.lexeme(),
std::move(dataType),
nullptr, // no initializer
false, // not const
makeRange(previous_)
);
} | O2 | cpp | flux::parser::Parser::dataDeclaration():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x378, %rsp # imm = 0x378
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x2c, %eax
setne 0xe(%rsp)
je 0x16e61
cmpl $0x20, %eax
jne 0x16e7e
leaq 0x318(%rsp), %rdi
movq %r14, %rsi
callq 0x122ec
leaq 0x358(%rsp), %rdi
callq 0x60e0
cmpl $0xe, 0x68(%r14)
je 0x16eaf
leaq 0xd8da(%rip), %r8 # 0x24766
leaq 0x2b8(%rsp), %rdi
pushq $0xe
popq %rdx
pushq $0x17
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x2f8(%rsp), %rdi
callq 0x60e0
leaq 0xd8c8(%rip), %r8 # 0x2477e
leaq 0x258(%rsp), %rdi
pushq $0x5f
popq %rdx
pushq $0x19
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x298(%rsp), %rdi
callq 0x60e0
leaq 0xd8b8(%rip), %r8 # 0x24798
leaq 0xd8(%rsp), %r15
pushq $0x1
popq %rdx
pushq $0x11
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f2a
movq %r15, %rdi
callq 0xae9e
movq %rax, 0x38(%rsp)
leaq 0xd89d(%rip), %r8 # 0x247aa
leaq 0x1f8(%rsp), %rdi
pushq $0x60
popq %rdx
pushq $0x1b
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x238(%rsp), %rdi
callq 0x60e0
andq $0x0, 0x20(%rsp)
xorl %r15d, %r15d
pushq $0x61
popq %rsi
movq %r14, %rdi
callq 0x12eaa
movl %eax, %ebp
testb %al, %al
je 0x16f56
cmpl $0x62, 0x8(%r14)
jne 0x16f5b
xorl %r15d, %r15d
jmp 0x16f72
xorl %r15d, %r15d
jmp 0x16f9c
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
callq 0x17cf0
movq 0x78(%rsp), %r15
movq %r15, 0x20(%rsp)
leaq 0xd84d(%rip), %r8 # 0x247c6
leaq 0x198(%rsp), %rdi
pushq $0x62
popq %rdx
pushq $0x1d
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x1d8(%rsp), %rdi
callq 0x60e0
leaq 0xd841(%rip), %r8 # 0x247e4
leaq 0x78(%rsp), %rdi
pushq $0x5
popq %rdx
pushq $0x17
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0xd83f(%rip), %r8 # 0x247fc
leaq 0x138(%rsp), %rdi
pushq $0x58
popq %rdx
pushq $0x23
popq %rcx
movq %r14, %rsi
callq 0x12f2a
leaq 0x178(%rsp), %rdi
callq 0x60e0
movups 0x80(%r14), %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movups 0x90(%r14), %xmm0
movaps %xmm0, 0x10(%rcx)
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0xe(%rsp), %rdx
callq 0x1ffdf
testb %bpl, %bpl
je 0x170b2
movups 0x80(%r14), %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movups 0x90(%r14), %xmm0
movaps %xmm0, 0x10(%rcx)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x20038
movups 0x80(%rsp), %xmm0
leaq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rcx
andq $0x0, (%rcx)
movups %xmm0, (%rsi)
leaq 0xf(%rsp), %r8
movb $0x0, (%r8)
movups 0x80(%r14), %xmm0
leaq 0x40(%rsp), %r9
movaps %xmm0, (%r9)
movups 0x90(%r14), %xmm0
movaps %xmm0, 0x10(%r9)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2009a
movq 0x28(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17109
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x17109
movups 0x80(%rsp), %xmm0
leaq 0x68(%rsp), %rsi
leaq 0x28(%rsp), %rcx
andq $0x0, (%rcx)
movups %xmm0, (%rsi)
leaq 0x30(%rsp), %r8
movb $0x0, (%r8)
movups 0x80(%r14), %xmm0
leaq 0x40(%rsp), %r9
movaps %xmm0, (%r9)
movups 0x90(%r14), %xmm0
movaps %xmm0, 0x10(%r9)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x20107
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x17119
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xb8(%rsp), %rdi
callq 0x60e0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x17136
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x118(%rsp), %rdi
callq 0x60e0
movq %rbx, %rax
addq $0x378, %rsp # imm = 0x378
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x171b0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17170
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x17170
jmp 0x1716d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x17187
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x17187
jmp 0x17184
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x60e0
movq 0x20(%rsp), %r15
jmp 0x171a0
jmp 0x1719d
movq %rax, %rbx
testq %r15, %r15
je 0x171b3
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x171b3
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x60e0
movq %rbx, %rdi
callq 0x63e0
| _ZN4flux6parser6Parser15dataDeclarationEv:
push rbp
push r15
push r14
push rbx
sub rsp, 378h
mov r14, rsi
mov rbx, rdi
mov eax, [rsi+8]
cmp eax, 2Ch ; ','
setnz [rsp+398h+var_38A]
jz short loc_16E61
cmp eax, 20h ; ' '
jnz short loc_16E7E
loc_16E61:
lea rdi, [rsp+398h+var_80]; this
mov rsi, r14
call _ZN4flux6parser6Parser7advanceEv; flux::parser::Parser::advance(void)
lea rdi, [rsp+398h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_16E7E:
cmp dword ptr [r14+68h], 0Eh
jz short loc_16EAF
lea r8, aExpectedDataKe; "Expected 'data' keyword"
lea rdi, [rsp+398h+var_E0]; this
push 0Eh
pop rdx
push 17h
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+398h+var_A0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_16EAF:
lea r8, aExpectedAfterD; "Expected '{' after 'data'"
lea rdi, [rsp+398h+var_140]; this
push 5Fh ; '_'
pop rdx
push 19h
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+398h+var_100]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea r8, aExpectedBitSiz; "Expected bit size"
lea r15, [rsp+398h+var_2C0]
push 1
pop rdx
push 11h
pop rcx
mov rdi, r15; this
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
mov rdi, r15; this
call _ZNK4flux5lexer5Token8intValueEv; flux::lexer::Token::intValue(void)
mov [rsp+398h+var_360], rax
lea r8, aExpectedAfterB; "Expected '}' after bit size"
lea rdi, [rsp+398h+var_1A0]; this
push 60h ; '`'
pop rdx
push 1Bh
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+398h+var_160]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
and [rsp+398h+var_378], 0
xor r15d, r15d
push 61h ; 'a'
pop rsi
mov rdi, r14
call _ZN4flux6parser6Parser5matchENS_5lexer9TokenTypeE; flux::parser::Parser::match(flux::lexer::TokenType)
mov ebp, eax
test al, al
jz short loc_16F56
cmp dword ptr [r14+8], 62h ; 'b'
jnz short loc_16F5B
xor r15d, r15d
jmp short loc_16F72
loc_16F56:
xor r15d, r15d
jmp short loc_16F9C
loc_16F5B:
lea rdi, [rsp+398h+var_320]; this
mov rsi, r14
call _ZN4flux6parser6Parser10expressionEv; flux::parser::Parser::expression(void)
mov r15, [rsp+398h+var_320]
mov [rsp+398h+var_378], r15
loc_16F72:
lea r8, aExpectedAfterA; "Expected ']' after array size"
lea rdi, [rsp+398h+var_200]; this
push 62h ; 'b'
pop rdx
push 1Dh
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+398h+var_1C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_16F9C:
lea r8, aExpectedDataTy; "Expected data type name"
lea rdi, [rsp+398h+var_320]; this
push 5
pop rdx
push 17h
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea r8, aExpectedAfterD_0; "Expected ';' after data declaration"
lea rdi, [rsp+398h+var_260]; this
push 58h ; 'X'
pop rdx
push 23h ; '#'
pop rcx
mov rsi, r14
call _ZN4flux6parser6Parser7consumeENS_5lexer9TokenTypeESt17basic_string_viewIcSt11char_traitsIcEE; flux::parser::Parser::consume(flux::lexer::TokenType,std::string_view)
lea rdi, [rsp+398h+var_220]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
movups xmm0, xmmword ptr [r14+80h]
lea rcx, [rsp+398h+var_358]
movaps xmmword ptr [rcx], xmm0
movups xmm0, xmmword ptr [r14+90h]
movaps xmmword ptr [rcx+10h], xmm0
lea rdi, [rsp+398h+var_380]
lea rsi, [rsp+398h+var_360]
lea rdx, [rsp+398h+var_38A]
call _ZSt11make_uniqueIN4flux6parser12DataTypeExprEJRlRbNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::DataTypeExpr,long &,bool &,flux::common::SourceRange>(long &,bool &,flux::common::SourceRange &&)
test bpl, bpl
jz loc_170B2
movups xmm0, xmmword ptr [r14+80h]
lea rcx, [rsp+398h+var_358]
movaps xmmword ptr [rcx], xmm0
movups xmm0, xmmword ptr [r14+90h]
movaps xmmword ptr [rcx+10h], xmm0
lea rdi, [rsp+398h+var_388]
lea rsi, [rsp+398h+var_380]
lea rdx, [rsp+398h+var_378]
call _ZSt11make_uniqueIN4flux6parser13ArrayTypeExprEJSt10unique_ptrINS1_12DataTypeExprESt14default_deleteIS4_EES3_INS1_4ExprES5_IS8_EENS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::ArrayTypeExpr,std::unique_ptr<flux::parser::DataTypeExpr>,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange>(std::unique_ptr<flux::parser::DataTypeExpr>,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange &&)
movups xmm0, [rsp+398h+var_318]
lea rsi, [rsp+398h+var_330]
lea rcx, [rsp+398h+var_368]
and qword ptr [rcx], 0
movups xmmword ptr [rsi], xmm0
lea r8, [rsp+398h+var_389]
mov byte ptr [r8], 0
movups xmm0, xmmword ptr [r14+80h]
lea r9, [rsp+398h+var_358]
movaps xmmword ptr [r9], xmm0
movups xmm0, xmmword ptr [r14+90h]
movaps xmmword ptr [r9+10h], xmm0
lea rdi, [rsp+398h+var_370]
lea rdx, [rsp+398h+var_388]
call _ZSt11make_uniqueIN4flux6parser7VarDeclEJSt17basic_string_viewIcSt11char_traitsIcEESt10unique_ptrINS1_13ArrayTypeExprESt14default_deleteIS8_EEDnbNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::VarDecl,std::string_view,std::unique_ptr<flux::parser::ArrayTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange>(std::string_view,std::unique_ptr<flux::parser::ArrayTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange &&)
mov rax, [rsp+398h+var_370]
mov [rbx], rax
mov rdi, [rsp+398h+var_388]
test rdi, rdi
jz short loc_17109
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_17109
loc_170B2:
movups xmm0, [rsp+398h+var_318]
lea rsi, [rsp+398h+var_330]
lea rcx, [rsp+398h+var_370]
and qword ptr [rcx], 0
movups xmmword ptr [rsi], xmm0
lea r8, [rsp+398h+var_368]
mov byte ptr [r8], 0
movups xmm0, xmmword ptr [r14+80h]
lea r9, [rsp+398h+var_358]
movaps xmmword ptr [r9], xmm0
movups xmm0, xmmword ptr [r14+90h]
movaps xmmword ptr [r9+10h], xmm0
lea rdi, [rsp+398h+var_388]
lea rdx, [rsp+398h+var_380]
call _ZSt11make_uniqueIN4flux6parser7VarDeclEJSt17basic_string_viewIcSt11char_traitsIcEESt10unique_ptrINS1_12DataTypeExprESt14default_deleteIS8_EEDnbNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::VarDecl,std::string_view,std::unique_ptr<flux::parser::DataTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange>(std::string_view,std::unique_ptr<flux::parser::DataTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange &&)
mov rax, [rsp+398h+var_388]
mov [rbx], rax
loc_17109:
mov rdi, [rsp+398h+var_380]
test rdi, rdi
jz short loc_17119
mov rax, [rdi]
call qword ptr [rax+8]
loc_17119:
lea rdi, [rsp+398h+var_2E0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, [rsp+398h+var_378]
test rdi, rdi
jz short loc_17136
mov rax, [rdi]
call qword ptr [rax+8]
loc_17136:
lea rdi, [rsp+398h+var_280]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 378h
pop rbx
pop r14
pop r15
pop rbp
retn
jmp short loc_171B0
mov rbx, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_17170
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_17170
jmp short $+2
loc_1716D:
mov rbx, rax
loc_17170:
mov rdi, [rsp+arg_10]
test rdi, rdi
jz short loc_17187
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_17187
jmp short $+2
loc_17184:
mov rbx, rax
loc_17187:
lea rdi, [rsp+arg_B0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov r15, [rsp+arg_18]
jmp short loc_171A0
jmp short $+2
loc_1719D:
mov rbx, rax
loc_171A0:
test r15, r15
jz short loc_171B3
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+8]
jmp short loc_171B3
loc_171B0:
mov rbx, rax
loc_171B3:
lea rdi, [rsp+arg_110]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| flux::parser::Parser * flux::parser::Parser::dataDeclaration(flux::parser::Parser *this, long long a2)
{
int v2; // eax
bool v3; // bp
bool v5; // [rsp+Eh] [rbp-38Ah] BYREF
char v6; // [rsp+Fh] [rbp-389h] BYREF
long long v7; // [rsp+10h] [rbp-388h] BYREF
long long v8; // [rsp+18h] [rbp-380h] BYREF
long long v9; // [rsp+20h] [rbp-378h] BYREF
long long v10; // [rsp+28h] [rbp-370h] BYREF
long long v11; // [rsp+30h] [rbp-368h] BYREF
long long v12; // [rsp+38h] [rbp-360h] BYREF
__int128 v13; // [rsp+40h] [rbp-358h]
__int128 v14; // [rsp+50h] [rbp-348h]
__int128 v15; // [rsp+68h] [rbp-330h] BYREF
long long v16; // [rsp+78h] [rbp-320h] BYREF
__int128 v17; // [rsp+80h] [rbp-318h]
_BYTE v18[32]; // [rsp+B8h] [rbp-2E0h] BYREF
_BYTE v19[64]; // [rsp+D8h] [rbp-2C0h] BYREF
_BYTE v20[32]; // [rsp+118h] [rbp-280h] BYREF
_BYTE v21[64]; // [rsp+138h] [rbp-260h] BYREF
_BYTE v22[32]; // [rsp+178h] [rbp-220h] BYREF
_BYTE v23[64]; // [rsp+198h] [rbp-200h] BYREF
_BYTE v24[32]; // [rsp+1D8h] [rbp-1C0h] BYREF
_BYTE v25[64]; // [rsp+1F8h] [rbp-1A0h] BYREF
_BYTE v26[32]; // [rsp+238h] [rbp-160h] BYREF
_BYTE v27[64]; // [rsp+258h] [rbp-140h] BYREF
_BYTE v28[32]; // [rsp+298h] [rbp-100h] BYREF
_BYTE v29[64]; // [rsp+2B8h] [rbp-E0h] BYREF
_BYTE v30[32]; // [rsp+2F8h] [rbp-A0h] BYREF
_BYTE v31[64]; // [rsp+318h] [rbp-80h] BYREF
_BYTE v32[64]; // [rsp+358h] [rbp-40h] BYREF
v2 = *(_DWORD *)(a2 + 8);
v5 = v2 != 44;
if ( v2 == 44 || v2 == 32 )
{
flux::parser::Parser::advance((flux::parser::Parser *)v31, a2);
std::string::~string(v32);
}
if ( *(_DWORD *)(a2 + 104) != 14 )
{
flux::parser::Parser::consume((flux::parser::Parser *)v29, a2, 14, 23LL, (long long)"Expected 'data' keyword");
std::string::~string(v30);
}
flux::parser::Parser::consume((flux::parser::Parser *)v27, a2, 95, 25LL, (long long)"Expected '{' after 'data'");
std::string::~string(v28);
flux::parser::Parser::consume((flux::parser::Parser *)v19, a2, 1, 17LL, (long long)"Expected bit size");
v12 = flux::lexer::Token::intValue((flux::lexer::Token *)v19);
flux::parser::Parser::consume((flux::parser::Parser *)v25, a2, 96, 27LL, (long long)"Expected '}' after bit size");
std::string::~string(v26);
v9 = 0LL;
v3 = flux::parser::Parser::match(a2, 97);
if ( v3 )
{
if ( *(_DWORD *)(a2 + 8) != 98 )
{
flux::parser::Parser::expression((flux::parser::Parser *)&v16);
v9 = v16;
}
flux::parser::Parser::consume((flux::parser::Parser *)v23, a2, 98, 29LL, (long long)"Expected ']' after array size");
std::string::~string(v24);
}
flux::parser::Parser::consume((flux::parser::Parser *)&v16, a2, 5, 23LL, (long long)"Expected data type name");
flux::parser::Parser::consume(
(flux::parser::Parser *)v21,
a2,
88,
35LL,
(long long)"Expected ';' after data declaration");
std::string::~string(v22);
v13 = *(_OWORD *)(a2 + 128);
v14 = *(_OWORD *)(a2 + 144);
std::make_unique<flux::parser::DataTypeExpr,long &,bool &,flux::common::SourceRange>(&v8, &v12, &v5);
if ( v3 )
{
v13 = *(_OWORD *)(a2 + 128);
v14 = *(_OWORD *)(a2 + 144);
std::make_unique<flux::parser::ArrayTypeExpr,std::unique_ptr<flux::parser::DataTypeExpr>,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange>(
&v7,
&v8,
&v9);
v11 = 0LL;
v15 = v17;
v6 = 0;
v13 = *(_OWORD *)(a2 + 128);
v14 = *(_OWORD *)(a2 + 144);
std::make_unique<flux::parser::VarDecl,std::string_view,std::unique_ptr<flux::parser::ArrayTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange>(
&v10,
&v15,
&v7,
&v11,
&v6);
*(_QWORD *)this = v10;
if ( v7 )
(*(void ( **)(long long))(*(_QWORD *)v7 + 8LL))(v7);
}
else
{
v10 = 0LL;
v15 = v17;
LOBYTE(v11) = 0;
v13 = *(_OWORD *)(a2 + 128);
v14 = *(_OWORD *)(a2 + 144);
std::make_unique<flux::parser::VarDecl,std::string_view,std::unique_ptr<flux::parser::DataTypeExpr>,decltype(nullptr),bool,flux::common::SourceRange>(
&v7,
&v15,
&v8,
&v10,
&v11);
*(_QWORD *)this = v7;
}
if ( v8 )
(*(void ( **)(long long))(*(_QWORD *)v8 + 8LL))(v8);
std::string::~string(v18);
if ( v9 )
(*(void ( **)(long long))(*(_QWORD *)v9 + 8LL))(v9);
std::string::~string(v20);
return this;
}
| dataDeclaration:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x378
MOV R14,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RSI + 0x8]
CMP EAX,0x2c
SETNZ byte ptr [RSP + 0xe]
JZ 0x00116e61
CMP EAX,0x20
JNZ 0x00116e7e
LAB_00116e61:
LEA RDI,[RSP + 0x318]
MOV RSI,R14
CALL 0x001122ec
LEA RDI,[RSP + 0x358]
CALL 0x001060e0
LAB_00116e7e:
CMP dword ptr [R14 + 0x68],0xe
JZ 0x00116eaf
LEA R8,[0x124766]
LEA RDI,[RSP + 0x2b8]
PUSH 0xe
POP RDX
PUSH 0x17
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x2f8]
CALL 0x001060e0
LAB_00116eaf:
LEA R8,[0x12477e]
LEA RDI,[RSP + 0x258]
PUSH 0x5f
POP RDX
PUSH 0x19
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x298]
CALL 0x001060e0
LEA R8,[0x124798]
LEA R15,[RSP + 0xd8]
PUSH 0x1
POP RDX
PUSH 0x11
POP RCX
MOV RDI,R15
MOV RSI,R14
CALL 0x00112f2a
LAB_00116ef9:
MOV RDI,R15
CALL 0x0010ae9e
MOV qword ptr [RSP + 0x38],RAX
LEA R8,[0x1247aa]
LEA RDI,[RSP + 0x1f8]
PUSH 0x60
POP RDX
PUSH 0x1b
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x238]
CALL 0x001060e0
AND qword ptr [RSP + 0x20],0x0
XOR R15D,R15D
LAB_00116f39:
PUSH 0x61
POP RSI
MOV RDI,R14
CALL 0x00112eaa
MOV EBP,EAX
TEST AL,AL
JZ 0x00116f56
CMP dword ptr [R14 + 0x8],0x62
JNZ 0x00116f5b
XOR R15D,R15D
JMP 0x00116f72
LAB_00116f56:
XOR R15D,R15D
JMP 0x00116f9c
LAB_00116f5b:
LEA RDI,[RSP + 0x78]
MOV RSI,R14
CALL 0x00117cf0
MOV R15,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x20],R15
LAB_00116f72:
LEA R8,[0x1247c6]
LEA RDI,[RSP + 0x198]
PUSH 0x62
POP RDX
PUSH 0x1d
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x1d8]
CALL 0x001060e0
LAB_00116f9c:
LEA R8,[0x1247e4]
LEA RDI,[RSP + 0x78]
PUSH 0x5
POP RDX
PUSH 0x17
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LAB_00116fb6:
LEA R8,[0x1247fc]
LEA RDI,[RSP + 0x138]
PUSH 0x58
POP RDX
PUSH 0x23
POP RCX
MOV RSI,R14
CALL 0x00112f2a
LEA RDI,[RSP + 0x178]
CALL 0x001060e0
MOVUPS XMM0,xmmword ptr [R14 + 0x80]
LEA RCX,[RSP + 0x40]
MOVAPS xmmword ptr [RCX],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x90]
MOVAPS xmmword ptr [RCX + 0x10],XMM0
LAB_00116ffc:
LEA RDI,[RSP + 0x18]
LEA RSI,[RSP + 0x38]
LEA RDX,[RSP + 0xe]
CALL 0x0011ffdf
TEST BPL,BPL
JZ 0x001170b2
MOVUPS XMM0,xmmword ptr [R14 + 0x80]
LEA RCX,[RSP + 0x40]
MOVAPS xmmword ptr [RCX],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x90]
MOVAPS xmmword ptr [RCX + 0x10],XMM0
LAB_00117035:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x20]
CALL 0x00120038
MOVUPS XMM0,xmmword ptr [RSP + 0x80]
LEA RSI,[RSP + 0x68]
LEA RCX,[RSP + 0x30]
AND qword ptr [RCX],0x0
MOVUPS xmmword ptr [RSI],XMM0
LEA R8,[RSP + 0xf]
MOV byte ptr [R8],0x0
MOVUPS XMM0,xmmword ptr [R14 + 0x80]
LEA R9,[RSP + 0x40]
MOVAPS xmmword ptr [R9],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x90]
MOVAPS xmmword ptr [R9 + 0x10],XMM0
LAB_00117089:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x10]
CALL 0x0012009a
LAB_00117098:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00117109
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
JMP 0x00117109
LAB_001170b2:
MOVUPS XMM0,xmmword ptr [RSP + 0x80]
LEA RSI,[RSP + 0x68]
LEA RCX,[RSP + 0x28]
AND qword ptr [RCX],0x0
MOVUPS xmmword ptr [RSI],XMM0
LEA R8,[RSP + 0x30]
MOV byte ptr [R8],0x0
MOVUPS XMM0,xmmword ptr [R14 + 0x80]
LEA R9,[RSP + 0x40]
MOVAPS xmmword ptr [R9],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x90]
MOVAPS xmmword ptr [R9 + 0x10],XMM0
LAB_001170f2:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x18]
CALL 0x00120107
LAB_00117101:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX],RAX
LAB_00117109:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00117119
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00117119:
LEA RDI,[RSP + 0xb8]
CALL 0x001060e0
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00117136
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00117136:
LEA RDI,[RSP + 0x118]
CALL 0x001060e0
MOV RAX,RBX
ADD RSP,0x378
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* flux::parser::Parser::dataDeclaration() */
void flux::parser::Parser::dataDeclaration(void)
{
int iVar1;
char cVar2;
long in_RSI;
int8 *in_RDI;
SourceRange local_38a;
SourceRange local_389;
_func_decltype_nullptr *local_388;
_func_decltype_nullptr *local_380;
long *local_378;
int8 local_370;
ulong local_368;
int8 local_360;
int8 local_358;
int8 uStack_350;
int8 local_348;
int8 uStack_340;
int8 local_330;
int8 uStack_328;
long *local_320;
int8 local_318;
int8 uStack_310;
string local_2e0 [32];
Token local_2c0 [64];
string local_280 [32];
int1 local_260 [64];
string local_220 [32];
int1 local_200 [64];
string local_1c0 [32];
int1 local_1a0 [64];
string local_160 [32];
int1 local_140 [64];
string local_100 [32];
int1 local_e0 [64];
string local_a0 [96];
string local_40 [32];
iVar1 = *(int *)(in_RSI + 8);
local_38a = (SourceRange)(iVar1 != 0x2c);
if ((iVar1 == 0x2c) || (iVar1 == 0x20)) {
advance();
std::__cxx11::string::~string(local_40);
}
if (*(int *)(in_RSI + 0x68) != 0xe) {
consume(local_e0);
std::__cxx11::string::~string(local_a0);
}
consume(local_140);
std::__cxx11::string::~string(local_100);
consume(local_2c0);
/* try { // try from 00116ef9 to 00116f22 has its CatchHandler @ 001171b0 */
local_360 = lexer::Token::intValue(local_2c0);
consume(local_1a0);
std::__cxx11::string::~string(local_160);
local_378 = (long *)0x0;
/* try { // try from 00116f39 to 00116f43 has its CatchHandler @ 0011719d */
cVar2 = match();
if (cVar2 != '\0') {
if (*(int *)(in_RSI + 8) != 0x62) {
/* try { // try from 00116f5b to 00116f67 has its CatchHandler @ 00117154 */
expression((Parser *)&local_320);
local_378 = local_320;
}
/* try { // try from 00116f72 to 00116f8e has its CatchHandler @ 0011719d */
consume(local_200);
std::__cxx11::string::~string(local_1c0);
}
/* try { // try from 00116f9c to 00116fb5 has its CatchHandler @ 0011719b */
consume(&local_320);
/* try { // try from 00116fb6 to 00116fd2 has its CatchHandler @ 00117184 */
consume(local_260);
std::__cxx11::string::~string(local_220);
local_358 = *(int8 *)(in_RSI + 0x80);
uStack_350 = *(int8 *)(in_RSI + 0x88);
local_348 = *(int8 *)(in_RSI + 0x90);
uStack_340 = *(int8 *)(in_RSI + 0x98);
/* try { // try from 00116ffc to 0011700f has its CatchHandler @ 00117182 */
std::make_unique<flux::parser::DataTypeExpr,long&,bool&,flux::common::SourceRange>
((long *)&local_380,(bool *)&local_360,&local_38a);
if (cVar2 == '\0') {
local_370 = 0;
local_330 = local_318;
uStack_328 = uStack_310;
local_368 = local_368 & 0xffffffffffffff00;
local_358 = *(int8 *)(in_RSI + 0x80);
uStack_350 = *(int8 *)(in_RSI + 0x88);
local_348 = *(int8 *)(in_RSI + 0x90);
uStack_340 = *(int8 *)(in_RSI + 0x98);
/* try { // try from 001170f2 to 00117100 has its CatchHandler @ 0011716b */
std::
make_unique<flux::parser::VarDecl,std::basic_string_view<char,std::char_traits<char>>,std::unique_ptr<flux::parser::DataTypeExpr,std::default_delete<flux::parser::DataTypeExpr>>,decltype(nullptr),bool,flux::common::SourceRange>
((basic_string_view *)&local_388,(unique_ptr *)&local_330,&local_380,
(bool *)&local_370,(SourceRange *)&local_368);
*in_RDI = local_388;
}
else {
local_358 = *(int8 *)(in_RSI + 0x80);
uStack_350 = *(int8 *)(in_RSI + 0x88);
local_348 = *(int8 *)(in_RSI + 0x90);
uStack_340 = *(int8 *)(in_RSI + 0x98);
/* try { // try from 00117035 to 00117048 has its CatchHandler @ 0011716d */
std::
make_unique<flux::parser::ArrayTypeExpr,std::unique_ptr<flux::parser::DataTypeExpr,std::default_delete<flux::parser::DataTypeExpr>>,std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,flux::common::SourceRange>
((unique_ptr *)&local_388,(unique_ptr *)&local_380,(SourceRange *)&local_378);
local_368 = 0;
local_330 = local_318;
uStack_328 = uStack_310;
local_389 = (SourceRange)0x0;
local_358 = *(int8 *)(in_RSI + 0x80);
uStack_350 = *(int8 *)(in_RSI + 0x88);
local_348 = *(int8 *)(in_RSI + 0x90);
uStack_340 = *(int8 *)(in_RSI + 0x98);
/* try { // try from 00117089 to 00117097 has its CatchHandler @ 00117156 */
std::
make_unique<flux::parser::VarDecl,std::basic_string_view<char,std::char_traits<char>>,std::unique_ptr<flux::parser::ArrayTypeExpr,std::default_delete<flux::parser::ArrayTypeExpr>>,decltype(nullptr),bool,flux::common::SourceRange>
((basic_string_view *)&local_370,(unique_ptr *)&local_330,&local_388,
(bool *)&local_368,&local_389);
*in_RDI = local_370;
if (local_388 != (_func_decltype_nullptr *)0x0) {
(**(code **)(*(long *)local_388 + 8))();
}
}
if (local_380 != (_func_decltype_nullptr *)0x0) {
(**(code **)(*(long *)local_380 + 8))();
}
std::__cxx11::string::~string(local_2e0);
if (local_378 != (long *)0x0) {
(**(code **)(*local_378 + 8))();
}
std::__cxx11::string::~string(local_280);
return;
}
| |
43,367 | js_error_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_error_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue name, msg;
if (!JS_IsObject(this_val))
return JS_ThrowTypeErrorNotAnObject(ctx);
name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
if (JS_IsUndefined(name))
name = JS_AtomToString(ctx, JS_ATOM_Error);
else
name = JS_ToStringFree(ctx, name);
if (JS_IsException(name))
return JS_EXCEPTION;
msg = JS_GetProperty(ctx, this_val, JS_ATOM_message);
if (JS_IsUndefined(msg))
msg = JS_AtomToString(ctx, JS_ATOM_empty_string);
else
msg = JS_ToStringFree(ctx, msg);
if (JS_IsException(msg)) {
JS_FreeValue(ctx, name);
return JS_EXCEPTION;
}
if (!JS_IsEmptyString(name) && !JS_IsEmptyString(msg))
name = JS_ConcatString3(ctx, "", name, ": ");
return JS_ConcatString(ctx, name, msg);
} | O0 | c | js_error_toString:
subq $0xc8, %rsp
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq %r8, 0x90(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x2af70
cmpl $0x0, %eax
jne 0xbde5a
movq 0xa0(%rsp), %rdi
callq 0x2f5a0
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
jmp 0xbe123
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movl $0x37, %ecx
callq 0x29d80
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
je 0xbdef2
movq 0xa0(%rsp), %rdi
movl $0x95, %esi
callq 0x29000
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x88(%rsp)
jmp 0xbdf33
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x50670
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xbdf69
movl $0x0, 0xb8(%rsp)
movq $0x6, 0xc0(%rsp)
jmp 0xbe123
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movl $0x33, %ecx
callq 0x29d80
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
je 0xbdfef
movq 0xa0(%rsp), %rdi
movl $0x2f, %esi
callq 0x29000
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xbe024
movq 0xa0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x50670
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xbe071
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x23c90
movl $0x0, 0xb8(%rsp)
movq $0x6, 0xc0(%rsp)
jmp 0xbe123
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x851a0
cmpl $0x0, %eax
jne 0xbe0ec
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x851a0
cmpl $0x0, %eax
jne 0xbe0ec
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x4b5a2(%rip), %rsi # 0x109660
leaq 0x4ba2f(%rip), %r8 # 0x109af4
callq 0x6f970
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq 0x78(%rsp), %r8
callq 0x6ab90
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rdx
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
| js_error_toString:
sub rsp, 0C8h
mov [rsp+0C8h+var_20], rsi
mov [rsp+0C8h+var_18], rdx
mov [rsp+0C8h+var_28], rdi
mov [rsp+0C8h+var_2C], ecx
mov [rsp+0C8h+var_38], r8
mov rdi, [rsp+0C8h+var_20]
mov rsi, [rsp+0C8h+var_18]
call JS_IsObject
cmp eax, 0
jnz short loc_BDE5A
mov rdi, [rsp+0C8h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+0C8h+var_10], rax
mov [rsp+0C8h+var_8], rdx
jmp loc_BE123
loc_BDE5A:
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_20]
mov rdx, [rsp+0C8h+var_18]
mov ecx, 37h ; '7'
call JS_GetProperty
mov [rsp+0C8h+var_68], rax
mov [rsp+0C8h+var_60], rdx
mov rax, [rsp+0C8h+var_68]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_60]
mov [rsp+0C8h+var_40], rax
mov rdi, [rsp+0C8h+var_48]
mov rsi, [rsp+0C8h+var_40]
call JS_IsUndefined_0
cmp eax, 0
jz short loc_BDEF2
mov rdi, [rsp+0C8h+var_28]
mov esi, 95h
call JS_AtomToString
mov [rsp+0C8h+var_78], rax
mov [rsp+0C8h+var_70], rdx
mov rax, [rsp+0C8h+var_78]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_40], rax
jmp short loc_BDF33
loc_BDEF2:
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
call JS_ToStringFree
mov [rsp+0C8h+var_88], rax
mov [rsp+0C8h+var_80], rdx
mov rax, [rsp+0C8h+var_88]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_80]
mov [rsp+0C8h+var_40], rax
loc_BDF33:
mov rdi, [rsp+0C8h+var_48]
mov rsi, [rsp+0C8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_BDF69
mov dword ptr [rsp+0C8h+var_10], 0
mov [rsp+0C8h+var_8], 6
jmp loc_BE123
loc_BDF69:
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_20]
mov rdx, [rsp+0C8h+var_18]
mov ecx, 33h ; '3'
call JS_GetProperty
mov [rsp+0C8h+var_98], rax
mov [rsp+0C8h+var_90], rdx
mov rax, [rsp+0C8h+var_98]
mov [rsp+0C8h+var_58], rax
mov rax, [rsp+0C8h+var_90]
mov [rsp+0C8h+var_50], rax
mov rdi, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_50]
call JS_IsUndefined_0
cmp eax, 0
jz short loc_BDFEF
mov rdi, [rsp+0C8h+var_28]
mov esi, 2Fh ; '/'
call JS_AtomToString
mov [rsp+0C8h+var_A8], rax
mov [rsp+0C8h+var_A0], rdx
mov rax, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_58], rax
mov rax, [rsp+0C8h+var_A0]
mov [rsp+0C8h+var_50], rax
jmp short loc_BE024
loc_BDFEF:
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_58]
mov rdx, [rsp+0C8h+var_50]
call JS_ToStringFree
mov [rsp+0C8h+var_B8], rax
mov [rsp+0C8h+var_B0], rdx
mov rax, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_58], rax
mov rax, [rsp+0C8h+var_B0]
mov [rsp+0C8h+var_50], rax
loc_BE024:
mov rdi, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_BE071
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
call JS_FreeValue
mov dword ptr [rsp+0C8h+var_10], 0
mov [rsp+0C8h+var_8], 6
jmp loc_BE123
loc_BE071:
mov rdi, [rsp+0C8h+var_48]
mov rsi, [rsp+0C8h+var_40]
call JS_IsEmptyString
cmp eax, 0
jnz short loc_BE0EC
mov rdi, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_50]
call JS_IsEmptyString
cmp eax, 0
jnz short loc_BE0EC
mov rdi, [rsp+0C8h+var_28]
mov rdx, [rsp+0C8h+var_48]
mov rcx, [rsp+0C8h+var_40]
lea rsi, aIncludeQuickjs+1Bh; ""
lea r8, aPossiblyUnhand+24h; ": "
call JS_ConcatString3
mov [rsp+0C8h+var_C8], rax
mov [rsp+0C8h+var_C0], rdx
mov rax, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_48], rax
mov rax, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_40], rax
loc_BE0EC:
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
mov rcx, [rsp+0C8h+var_58]
mov r8, [rsp+0C8h+var_50]
call JS_ConcatString
mov [rsp+0C8h+var_10], rax
mov [rsp+0C8h+var_8], rdx
loc_BE123:
mov rax, [rsp+0C8h+var_10]
mov rdx, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| long long js_error_toString(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
long long v23; // rdx
long long v24; // rdx
long long v25; // rcx
long long v26; // r8
long long v27; // r9
long long v28; // rdx
long long v29; // r9
long long v30; // rdx
long long v32; // [rsp+30h] [rbp-98h]
long long Property; // [rsp+60h] [rbp-68h]
long long v34; // [rsp+70h] [rbp-58h]
long long v35; // [rsp+78h] [rbp-50h]
long long v36; // [rsp+78h] [rbp-50h]
long long v37; // [rsp+80h] [rbp-48h]
long long v38; // [rsp+88h] [rbp-40h]
long long v39; // [rsp+88h] [rbp-40h]
int v41; // [rsp+A8h] [rbp-20h]
int v42; // [rsp+B0h] [rbp-18h]
long long v43; // [rsp+B8h] [rbp-10h]
v41 = a2;
v42 = a3;
if ( !JS_IsObject(a2, a3) )
return JS_ThrowTypeErrorNotAnObject(a1, a4, a5, a6, a7, v17, v18, a10, a11, a3, v13, v14, v15, v16);
Property = JS_GetProperty(a1, v41, v42, 55);
v38 = v19;
if ( JS_IsUndefined_0(Property, v19) )
v37 = JS_AtomToString(a1, 0x95u);
else
v37 = JS_ToStringFree(a1, Property, v38, v20, v21, v22);
v39 = v23;
if ( JS_IsException_1(v37, v23) )
{
LODWORD(v43) = 0;
}
else
{
v32 = JS_GetProperty(a1, v41, v42, 51);
v35 = v24;
if ( JS_IsUndefined_0(v32, v24) )
v34 = JS_AtomToString(a1, 0x2Fu);
else
v34 = JS_ToStringFree(a1, v32, v35, v25, v26, v27);
v36 = v28;
if ( JS_IsException_1(v34, v28) )
{
JS_FreeValue(a1, v37, v39);
LODWORD(v43) = 0;
}
else
{
if ( !JS_IsEmptyString(v37, v39) && !JS_IsEmptyString(v34, v36) )
{
v37 = JS_ConcatString3(a1, (long long)"", v37, v39, (long long)": ", v29);
v39 = v30;
}
return JS_ConcatString(a1, v37, v39, v34, v36, v29);
}
}
return v43;
}
| js_error_toString:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa0],RDI
MOV dword ptr [RSP + 0x9c],ECX
MOV qword ptr [RSP + 0x90],R8
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x0012af70
CMP EAX,0x0
JNZ 0x001bde5a
MOV RDI,qword ptr [RSP + 0xa0]
CALL 0x0012f5a0
MOV qword ptr [RSP + 0xb8],RAX
MOV qword ptr [RSP + 0xc0],RDX
JMP 0x001be123
LAB_001bde5a:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
MOV ECX,0x37
CALL 0x00129d80
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x0012e260
CMP EAX,0x0
JZ 0x001bdef2
MOV RDI,qword ptr [RSP + 0xa0]
MOV ESI,0x95
CALL 0x00129000
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x88],RAX
JMP 0x001bdf33
LAB_001bdef2:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00150670
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x88],RAX
LAB_001bdf33:
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001bdf69
MOV dword ptr [RSP + 0xb8],0x0
MOV qword ptr [RSP + 0xc0],0x6
JMP 0x001be123
LAB_001bdf69:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
MOV ECX,0x33
CALL 0x00129d80
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x0012e260
CMP EAX,0x0
JZ 0x001bdfef
MOV RDI,qword ptr [RSP + 0xa0]
MOV ESI,0x2f
CALL 0x00129000
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
JMP 0x001be024
LAB_001bdfef:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x00150670
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x78],RAX
LAB_001be024:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001be071
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00123c90
MOV dword ptr [RSP + 0xb8],0x0
MOV qword ptr [RSP + 0xc0],0x6
JMP 0x001be123
LAB_001be071:
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x001851a0
CMP EAX,0x0
JNZ 0x001be0ec
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x001851a0
CMP EAX,0x0
JNZ 0x001be0ec
MOV RDI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RSP + 0x88]
LEA RSI,[0x209660]
LEA R8,[0x209af4]
CALL 0x0016f970
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x88],RAX
LAB_001be0ec:
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV RCX,qword ptr [RSP + 0x70]
MOV R8,qword ptr [RSP + 0x78]
CALL 0x0016ab90
MOV qword ptr [RSP + 0xb8],RAX
MOV qword ptr [RSP + 0xc0],RDX
LAB_001be123:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
int1 [16] js_error_toString(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar1 = JS_IsObject(param_2,param_3);
if (iVar1 == 0) {
auVar2 = JS_ThrowTypeErrorNotAnObject(param_1);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
auVar2 = JS_GetProperty(param_1,param_2,param_3,0x37);
iVar1 = JS_IsUndefined(auVar2._0_8_,auVar2._8_8_);
if (iVar1 == 0) {
auVar2 = JS_ToStringFree(param_1,auVar2._0_8_,auVar2._8_8_);
}
else {
auVar2 = JS_AtomToString(param_1,0x95);
}
local_40 = auVar2._8_8_;
local_48 = auVar2._0_8_;
iVar1 = JS_IsException(local_48,local_40);
if (iVar1 == 0) {
auVar3 = JS_GetProperty(param_1,param_2,param_3,0x33);
iVar1 = JS_IsUndefined(auVar3._0_8_,auVar3._8_8_);
if (iVar1 == 0) {
auVar3 = JS_ToStringFree(param_1,auVar3._0_8_,auVar3._8_8_);
}
else {
auVar3 = JS_AtomToString(param_1,0x2f);
}
local_50 = auVar3._8_8_;
local_58 = auVar3._0_8_;
iVar1 = JS_IsException(local_58,local_50);
if (iVar1 == 0) {
iVar1 = JS_IsEmptyString(local_48,local_40);
if (iVar1 == 0) {
iVar1 = JS_IsEmptyString(local_58,local_50);
if (iVar1 == 0) {
auVar2 = JS_ConcatString3(param_1,"",local_48,local_40,": ");
}
}
local_40 = auVar2._8_8_;
local_48 = auVar2._0_8_;
auVar2 = JS_ConcatString(param_1,local_48,local_40,local_58,local_50);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
JS_FreeValue(param_1,local_48,local_40);
local_10 = 0;
local_8 = 6;
}
}
else {
local_10 = 0;
local_8 = 6;
}
}
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
43,368 | js_error_toString | bluesky950520[P]quickjs/quickjs.c | static JSValue js_error_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue name, msg;
if (!JS_IsObject(this_val))
return JS_ThrowTypeErrorNotAnObject(ctx);
name = JS_GetProperty(ctx, this_val, JS_ATOM_name);
if (JS_IsUndefined(name))
name = JS_AtomToString(ctx, JS_ATOM_Error);
else
name = JS_ToStringFree(ctx, name);
if (JS_IsException(name))
return JS_EXCEPTION;
msg = JS_GetProperty(ctx, this_val, JS_ATOM_message);
if (JS_IsUndefined(msg))
msg = JS_AtomToString(ctx, JS_ATOM_empty_string);
else
msg = JS_ToStringFree(ctx, msg);
if (JS_IsException(msg)) {
JS_FreeValue(ctx, name);
return JS_EXCEPTION;
}
if (!JS_IsEmptyString(name) && !JS_IsEmptyString(msg))
name = JS_ConcatString3(ctx, "", name, ": ");
return JS_ConcatString(ctx, name, msg);
} | O1 | c | js_error_toString:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rdi, %rbx
cmpl $-0x1, %r13d
jne 0x6fc9c
movq %rsi, %rbp
movq %rbx, %rdi
movq %r13, %rdx
movl $0x37, %ecx
movq %rsi, %r8
movq %r13, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rdx, %r15
cmpl $0x3, %r15d
jne 0x6fcbb
movq 0x18(%rbx), %rax
movq 0x68(%rax), %rax
movq 0x4a8(%rax), %rsi
movq 0x4(%rsi), %rcx
movq %rcx, %rdx
shrq $0x3e, %rdx
cmpl $0x1, %edx
je 0x6fc8c
movl $0xfffffff9, %edx # imm = 0xFFFFFFF9
addq $-0x7ffffff9, %rdx # imm = 0x80000007
movl %ecx, %ecx
cmpl %edx, %ecx
jne 0x6fc8c
movq 0x178(%rax), %rsi
movq %rsi, 0x8(%rsp)
incl (%rsi)
movq $-0x7, %r14
jmp 0x6fce5
leaq 0x2f382(%rip), %rsi # 0x9f025
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %r12d
jmp 0x6fd89
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x27add
movq %rax, 0x8(%rsp)
movq %rdx, %r14
movq 0x18(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq %r14, (%rsp)
movl %r14d, %r14d
movl $0x6, %r12d
cmpq $0x6, %r14
je 0x6fd86
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movl $0x33, %ecx
movq %rbp, %r8
movq %r13, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rdx, %r13
cmpl $0x3, %r13d
jne 0x6fd41
movq 0x18(%rbx), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %r15
incl (%r15)
movq $-0x7, %rbp
jmp 0x6fd69
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x27add
movq %rdx, %rbp
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rax, %r15
movq %r13, %rdx
callq 0x1d8c6
movq 0x8(%rsp), %r9
movl %ebp, %eax
cmpq $0x6, %rax
jne 0x6fda3
movq 0x18(%rbx), %rdi
movq %r9, %rsi
movq (%rsp), %rdx
callq 0x1d8c6
xorl %r14d, %r14d
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffff9, %ecx # imm = 0xFFFFFFF9
movq %r9, 0x10(%rsp)
cmpl %ecx, %r14d
jne 0x6fdc1
movq 0x10(%rsp), %rdx
movq 0x4(%rdx), %rdx
shlq $0x21, %rdx
je 0x6fdfe
movq %r15, 0x10(%rsp)
cmpl %ecx, %eax
movq (%rsp), %rcx
jne 0x6fddd
movq 0x10(%rsp), %rax
movq 0x4(%rax), %rax
shlq $0x21, %rax
je 0x6fe02
leaq 0x2b7fc(%rip), %rsi # 0x9b5e0
leaq 0x2bbf1(%rip), %r8 # 0x9b9dc
movq %rbx, %rdi
movq %r9, %rdx
callq 0x41f02
movq %rax, %r9
movq %rdx, %rcx
jmp 0x6fe02
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r9, %rsi
movq %rcx, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x40436
movq %rdx, %r12
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x6fd8b
| js_error_toString:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rdx
mov rbx, rdi
cmp r13d, 0FFFFFFFFh
jnz short loc_6FC9C
mov rbp, rsi
mov rdi, rbx
mov rdx, r13
mov ecx, 37h ; '7'
mov r8, rsi
mov r9, r13
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r15, rdx
cmp r15d, 3
jnz short loc_6FCBB
mov rax, [rbx+18h]
mov rax, [rax+68h]
mov rsi, [rax+4A8h]
mov rcx, [rsi+4]
mov rdx, rcx
shr rdx, 3Eh
cmp edx, 1
jz short loc_6FC8C
mov edx, 0FFFFFFF9h
add rdx, 0FFFFFFFF80000007h
mov ecx, ecx
cmp ecx, edx
jnz short loc_6FC8C
mov rsi, [rax+178h]
loc_6FC8C:
mov [rsp+48h+var_40], rsi
inc dword ptr [rsi]
mov r14, 0FFFFFFFFFFFFFFF9h
jmp short loc_6FCE5
loc_6FC9C:
lea rsi, aOperandPrototy+20h; "not an object"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov r12d, 6
jmp loc_6FD89
loc_6FCBB:
mov r12, rax
mov rdi, rbx
mov rsi, rax
mov rdx, r15
xor ecx, ecx
call JS_ToStringInternal
mov [rsp+48h+var_40], rax
mov r14, rdx
mov rdi, [rbx+18h]
mov rsi, r12
mov rdx, r15
call JS_FreeValueRT
loc_6FCE5:
mov [rsp+48h+var_48], r14
mov r14d, r14d
mov r12d, 6
cmp r14, 6
jz loc_6FD86
mov rdi, rbx
mov rsi, rbp
mov rdx, r13
mov ecx, 33h ; '3'
mov r8, rbp
mov r9, r13
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r13, rdx
cmp r13d, 3
jnz short loc_6FD41
mov rax, [rbx+18h]
mov rax, [rax+68h]
mov r15, [rax+178h]
inc dword ptr [r15]
mov rbp, 0FFFFFFFFFFFFFFF9h
jmp short loc_6FD69
loc_6FD41:
mov r15, rax
mov rdi, rbx
mov rsi, rax
mov rdx, r13
xor ecx, ecx
call JS_ToStringInternal
mov rbp, rdx
mov rdi, [rbx+18h]
mov rsi, r15
mov r15, rax
mov rdx, r13
call JS_FreeValueRT
loc_6FD69:
mov r9, [rsp+48h+var_40]
mov eax, ebp
cmp rax, 6
jnz short loc_6FDA3
mov rdi, [rbx+18h]
mov rsi, r9
mov rdx, [rsp+48h+var_48]
call JS_FreeValueRT
loc_6FD86:
xor r14d, r14d
loc_6FD89:
xor ecx, ecx
loc_6FD8B:
or r14, rcx
mov rax, r14
mov rdx, r12
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6FDA3:
mov ecx, 0FFFFFFF9h
mov [rsp+48h+var_38], r9
cmp r14d, ecx
jnz short loc_6FDC1
mov rdx, [rsp+48h+var_38]
mov rdx, [rdx+4]
shl rdx, 21h
jz short loc_6FDFE
loc_6FDC1:
mov [rsp+48h+var_38], r15
cmp eax, ecx
mov rcx, [rsp+48h+var_48]
jnz short loc_6FDDD
mov rax, [rsp+48h+var_38]
mov rax, [rax+4]
shl rax, 21h
jz short loc_6FE02
loc_6FDDD:
lea rsi, aIncludeQuickjs+1Bh; ""
lea r8, aPossiblyUnhand+24h; ": "
mov rdi, rbx
mov rdx, r9
call JS_ConcatString3
mov r9, rax
mov rcx, rdx
jmp short loc_6FE02
loc_6FDFE:
mov rcx, [rsp+48h+var_48]
loc_6FE02:
mov rdi, rbx
mov rsi, r9
mov rdx, rcx
mov rcx, r15
mov r8, rbp
call JS_ConcatString
mov r12, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp loc_6FD8B
| unsigned long long js_error_toString(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned long long PropertyInternal2; // rax
long long v17; // rdx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // r15
long long v23; // rax
unsigned long long v24; // rsi
unsigned long long v25; // rcx
long long v26; // r14
long long v27; // r14
_DWORD *v28; // r12
long long v29; // rdx
unsigned long long v30; // rax
long long v31; // rdx
long long v32; // r8
long long v33; // r9
__m128 v34; // xmm4
__m128 v35; // xmm5
long long v36; // r13
unsigned long long v37; // r15
long long v38; // rbp
_DWORD *v39; // r15
unsigned long long v40; // rax
long long v41; // rdx
_DWORD *v42; // rsi
_DWORD *v43; // r9
unsigned long long v44; // rcx
long long v46; // rcx
long long v47; // rdx
unsigned long long v48; // rax
char v49; // [rsp+0h] [rbp-48h]
unsigned long long v50; // [rsp+8h] [rbp-40h]
if ( (_DWORD)a3 != -1 )
{
v27 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v49);
LABEL_16:
v44 = 0LL;
return v44 | v27;
}
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, 0x37u, a2, a3, 0LL, 0);
v22 = v17;
if ( (_DWORD)v17 == 3 )
{
v23 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL);
v24 = *(_QWORD *)(v23 + 1192);
v25 = *(_QWORD *)(v24 + 4);
if ( v25 >> 62 != 1 && (_DWORD)v25 == 0x80000000 )
v24 = *(_QWORD *)(v23 + 376);
v50 = v24;
++*(_DWORD *)v24;
v26 = -7LL;
}
else
{
v28 = (_DWORD *)PropertyInternal2;
v50 = JS_ToStringInternal(a1, PropertyInternal2, v17, 0, v18, v19, a7, a8, a9, a10, v20, v21, a13, a14);
v26 = v29;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v28, v22);
}
if ( (unsigned int)v26 == 6LL )
{
LABEL_15:
v27 = 0LL;
goto LABEL_16;
}
v30 = JS_GetPropertyInternal2(a1, a2, a3, 0x33u, a2, a3, 0LL, 0);
v36 = v31;
if ( (_DWORD)v31 == 3 )
{
v37 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 376LL);
++*(_DWORD *)v37;
v38 = -7LL;
}
else
{
v39 = (_DWORD *)v30;
v40 = JS_ToStringInternal(a1, v30, v31, 0, v32, v33, a7, a8, a9, a10, v34, v35, a13, a14);
v38 = v41;
v42 = v39;
v37 = v40;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v42, v36);
}
v43 = (_DWORD *)v50;
if ( (unsigned int)v38 == 6LL )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v50, v26);
goto LABEL_15;
}
if ( (_DWORD)v26 == -7 && !(*(_QWORD *)(v50 + 4) << 33) )
{
v46 = v26;
}
else
{
v46 = v26;
if ( (_DWORD)v38 != -7 || *(_QWORD *)(v37 + 4) << 33 )
{
v43 = JS_ConcatString3(
a1,
(long long)"",
(_DWORD *)v50,
v26,
(long long)": ",
v50,
a7,
a8,
a9,
a10,
v34,
v35,
a13,
a14);
v46 = v47;
}
}
v48 = (unsigned long long)JS_ConcatString(
a1,
v43,
v46,
(_DWORD *)v37,
v38,
(long long)v43,
a7,
a8,
a9,
a10,
v34,
v35,
a13,
a14);
v44 = v48 & 0xFFFFFFFF00000000LL;
v27 = (unsigned int)v48;
return v44 | v27;
}
| |||
43,369 | common_embd_normalize(float const*, float*, int, int) | monkey531[P]llama/common/common.cpp | void common_embd_normalize(const float * inp, float * out, int n, int embd_norm) {
double sum = 0.0;
switch (embd_norm) {
case -1: // no normalisation
sum = 1.0;
break;
case 0: // max absolute
for (int i = 0; i < n; i++) {
if (sum < std::abs(inp[i])) {
sum = std::abs(inp[i]);
}
}
sum /= 32760.0; // make an int16 range
break;
case 2: // euclidean
for (int i = 0; i < n; i++) {
sum += inp[i] * inp[i];
}
sum = std::sqrt(sum);
break;
default: // p-norm (euclidean is p-norm p=2)
for (int i = 0; i < n; i++) {
sum += std::pow(std::abs(inp[i]), embd_norm);
}
sum = std::pow(sum, 1.0 / embd_norm);
break;
}
const float norm = sum > 0.0 ? 1.0 / sum : 0.0f;
for (int i = 0; i < n; i++) {
out[i] = inp[i] * norm;
}
} | O1 | cpp | common_embd_normalize(float const*, float*, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x717f9(%rip), %xmm3 # 0x10d5d0
movapd %xmm3, %xmm0
cmpl $-0x1, %ecx
je 0x9beec
testl %ecx, %ecx
je 0x9be2a
cmpl $0x2, %ecx
jne 0x9be60
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x9be17
movl %ebp, %eax
xorl %ecx, %ecx
movss (%r14,%rcx,4), %xmm2
mulss %xmm2, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x9bdfd
ucomisd %xmm1, %xmm0
jb 0x9beba
sqrtsd %xmm0, %xmm0
jmp 0x9beec
testl %ebp, %ebp
jle 0x9bec1
movl %ebp, %eax
xorpd %xmm2, %xmm2
xorl %ecx, %ecx
movaps 0x70d9f(%rip), %xmm1 # 0x10cbe0
movss (%r14,%rcx,4), %xmm0
andps %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
maxsd %xmm2, %xmm0
incq %rcx
movapd %xmm0, %xmm2
cmpq %rcx, %rax
jne 0x9be41
jmp 0x9bec5
cvtsi2sd %ecx, %xmm2
testl %ebp, %ebp
jle 0x9becf
movl %ebp, %r15d
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, (%rsp)
movss (%r14,%r12,4), %xmm0
andps 0x70d56(%rip), %xmm0 # 0x10cbe0
cvtss2sd %xmm0, %xmm0
movapd %xmm2, %xmm1
callq 0x1e600
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r12
cmpq %r12, %r15
jne 0x9be78
jmp 0x9bed3
callq 0x1d980
jmp 0x9bee4
xorpd %xmm0, %xmm0
divsd 0x7b043(%rip), %xmm0 # 0x116f10
jmp 0x9beec
xorpd %xmm0, %xmm0
movsd 0x716f5(%rip), %xmm1 # 0x10d5d0
divsd %xmm2, %xmm1
callq 0x1e600
movsd 0x716e4(%rip), %xmm3 # 0x10d5d0
testl %ebp, %ebp
jle 0x9bf22
divsd %xmm0, %xmm3
xorps %xmm1, %xmm1
cmpltsd %xmm0, %xmm1
andpd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movl %ebp, %eax
xorl %ecx, %ecx
movss (%r14,%rcx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x9bf0b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _Z21common_embd_normalizePKfPfii:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, edx
mov rbx, rsi
mov r14, rdi
movsd xmm3, cs:qword_10D5D0
movapd xmm0, xmm3
cmp ecx, 0FFFFFFFFh
jz loc_9BEEC
test ecx, ecx
jz short loc_9BE2A
cmp ecx, 2
jnz short loc_9BE60
xorpd xmm1, xmm1
xorpd xmm0, xmm0
test ebp, ebp
jle short loc_9BE17
mov eax, ebp
xor ecx, ecx
loc_9BDFD:
movss xmm2, dword ptr [r14+rcx*4]
mulss xmm2, xmm2
cvtss2sd xmm2, xmm2
addsd xmm0, xmm2
inc rcx
cmp rax, rcx
jnz short loc_9BDFD
loc_9BE17:
ucomisd xmm0, xmm1
jb loc_9BEBA
sqrtsd xmm0, xmm0
jmp loc_9BEEC
loc_9BE2A:
test ebp, ebp
jle loc_9BEC1
mov eax, ebp
xorpd xmm2, xmm2
xor ecx, ecx
movaps xmm1, cs:xmmword_10CBE0
loc_9BE41:
movss xmm0, dword ptr [r14+rcx*4]
andps xmm0, xmm1
cvtss2sd xmm0, xmm0
maxsd xmm0, xmm2
inc rcx
movapd xmm2, xmm0
cmp rax, rcx
jnz short loc_9BE41
jmp short loc_9BEC5
loc_9BE60:
cvtsi2sd xmm2, ecx
test ebp, ebp
jle short loc_9BECF
mov r15d, ebp
xorpd xmm0, xmm0
xor r12d, r12d
movsd [rsp+38h+var_30], xmm2
loc_9BE78:
movsd [rsp+38h+var_38], xmm0
movss xmm0, dword ptr [r14+r12*4]
andps xmm0, cs:xmmword_10CBE0
cvtss2sd xmm0, xmm0
movapd xmm1, xmm2
call _pow
movsd xmm2, [rsp+38h+var_30]
movsd xmm1, [rsp+38h+var_38]
addsd xmm1, xmm0
movsd [rsp+38h+var_38], xmm1
movsd xmm0, [rsp+38h+var_38]
inc r12
cmp r15, r12
jnz short loc_9BE78
jmp short loc_9BED3
loc_9BEBA:
call _sqrt
jmp short loc_9BEE4
loc_9BEC1:
xorpd xmm0, xmm0
loc_9BEC5:
divsd xmm0, cs:qword_116F10
jmp short loc_9BEEC
loc_9BECF:
xorpd xmm0, xmm0
loc_9BED3:
movsd xmm1, cs:qword_10D5D0
divsd xmm1, xmm2
call _pow
loc_9BEE4:
movsd xmm3, cs:qword_10D5D0
loc_9BEEC:
test ebp, ebp
jle short loc_9BF22
divsd xmm3, xmm0
xorps xmm1, xmm1
cmpltsd xmm1, xmm0
andpd xmm1, xmm3
xorps xmm0, xmm0
cvtsd2ss xmm0, xmm1
mov eax, ebp
xor ecx, ecx
loc_9BF0B:
movss xmm1, dword ptr [r14+rcx*4]
mulss xmm1, xmm0
movss dword ptr [rbx+rcx*4], xmm1
inc rcx
cmp rax, rcx
jnz short loc_9BF0B
loc_9BF22:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| void common_embd_normalize(const float *a1, float *a2, int a3, int a4)
{
__m128d v5; // xmm0
double v6; // xmm0_8
long long i; // rcx
double v8; // xmm2_8
long long v9; // rcx
double v10; // xmm0_8
double v11; // xmm2_8
double v12; // xmm0_8
long long v13; // r12
double v14; // xmm0_8
float v15; // xmm0_4
long long v16; // rcx
double v17; // [rsp+0h] [rbp-38h]
double v18; // [rsp+8h] [rbp-30h]
v5.m128d_f64[0] = 1.0;
if ( a4 != -1 )
{
if ( a4 )
{
if ( a4 == 2 )
{
v6 = 0.0;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
v6 = v6 + (float)(a1[i] * a1[i]);
}
if ( v6 < 0.0 )
v5.m128d_f64[0] = sqrt(v6);
else
v5.m128d_f64[0] = sqrt(v6);
}
else
{
v11 = (double)a4;
if ( a3 <= 0 )
{
v12 = 0.0;
}
else
{
v12 = 0.0;
v13 = 0LL;
v18 = (double)a4;
do
{
v17 = v12;
v14 = pow(fabs(a1[v13]), v11);
v11 = v18;
v12 = v17 + v14;
++v13;
}
while ( a3 != v13 );
}
v5.m128d_f64[0] = pow(v12, 1.0 / v11);
}
}
else
{
if ( a3 <= 0 )
{
v10 = 0.0;
}
else
{
v8 = 0.0;
v9 = 0LL;
do
{
v10 = fmax(fabs(a1[v9++]), v8);
v8 = v10;
}
while ( a3 != v9 );
}
v5.m128d_f64[0] = v10 / 32760.0;
}
}
if ( a3 > 0 )
{
v15 = COERCE_DOUBLE(*(_OWORD *)&_mm_cmplt_sd((__m128d)0LL, v5) & COERCE_UNSIGNED_INT64(1.0 / v5.m128d_f64[0]));
v16 = 0LL;
do
{
a2[v16] = a1[v16] * v15;
++v16;
}
while ( a3 != v16 );
}
}
| common_embd_normalize:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,EDX
MOV RBX,RSI
MOV R14,RDI
MOVSD XMM3,qword ptr [0x0020d5d0]
MOVAPD XMM0,XMM3
CMP ECX,-0x1
JZ 0x0019beec
TEST ECX,ECX
JZ 0x0019be2a
CMP ECX,0x2
JNZ 0x0019be60
XORPD XMM1,XMM1
XORPD XMM0,XMM0
TEST EBP,EBP
JLE 0x0019be17
MOV EAX,EBP
XOR ECX,ECX
LAB_0019bdfd:
MOVSS XMM2,dword ptr [R14 + RCX*0x4]
MULSS XMM2,XMM2
CVTSS2SD XMM2,XMM2
ADDSD XMM0,XMM2
INC RCX
CMP RAX,RCX
JNZ 0x0019bdfd
LAB_0019be17:
UCOMISD XMM0,XMM1
JC 0x0019beba
SQRTSD XMM0,XMM0
JMP 0x0019beec
LAB_0019be2a:
TEST EBP,EBP
JLE 0x0019bec1
MOV EAX,EBP
XORPD XMM2,XMM2
XOR ECX,ECX
MOVAPS XMM1,xmmword ptr [0x0020cbe0]
LAB_0019be41:
MOVSS XMM0,dword ptr [R14 + RCX*0x4]
ANDPS XMM0,XMM1
CVTSS2SD XMM0,XMM0
MAXSD XMM0,XMM2
INC RCX
MOVAPD XMM2,XMM0
CMP RAX,RCX
JNZ 0x0019be41
JMP 0x0019bec5
LAB_0019be60:
CVTSI2SD XMM2,ECX
TEST EBP,EBP
JLE 0x0019becf
MOV R15D,EBP
XORPD XMM0,XMM0
XOR R12D,R12D
MOVSD qword ptr [RSP + 0x8],XMM2
LAB_0019be78:
MOVSD qword ptr [RSP],XMM0
MOVSS XMM0,dword ptr [R14 + R12*0x4]
ANDPS XMM0,xmmword ptr [0x0020cbe0]
CVTSS2SD XMM0,XMM0
MOVAPD XMM1,XMM2
CALL 0x0011e600
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
ADDSD XMM1,XMM0
MOVSD qword ptr [RSP],XMM1
MOVSD XMM0,qword ptr [RSP]
INC R12
CMP R15,R12
JNZ 0x0019be78
JMP 0x0019bed3
LAB_0019beba:
CALL 0x0011d980
JMP 0x0019bee4
LAB_0019bec1:
XORPD XMM0,XMM0
LAB_0019bec5:
DIVSD XMM0,qword ptr [0x00216f10]
JMP 0x0019beec
LAB_0019becf:
XORPD XMM0,XMM0
LAB_0019bed3:
MOVSD XMM1,qword ptr [0x0020d5d0]
DIVSD XMM1,XMM2
CALL 0x0011e600
LAB_0019bee4:
MOVSD XMM3,qword ptr [0x0020d5d0]
LAB_0019beec:
TEST EBP,EBP
JLE 0x0019bf22
DIVSD XMM3,XMM0
XORPS XMM1,XMM1
CMPLTSD XMM1,XMM0
ANDPD XMM1,XMM3
XORPS XMM0,XMM0
CVTSD2SS XMM0,XMM1
MOV EAX,EBP
XOR ECX,ECX
LAB_0019bf0b:
MOVSS XMM1,dword ptr [R14 + RCX*0x4]
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + RCX*0x4],XMM1
INC RCX
CMP RAX,RCX
JNZ 0x0019bf0b
LAB_0019bf22:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_normalize(float const*, float*, int, int) */
void common_embd_normalize(float *param_1,float *param_2,int param_3,int param_4)
{
ulong uVar1;
double dVar2;
double dVar3;
dVar2 = DAT_0020d5d0;
if (param_4 != -1) {
if (param_4 == 0) {
if (param_3 < 1) {
dVar2 = 0.0;
}
else {
uVar1 = 0;
dVar3 = 0.0;
do {
dVar2 = (double)(float)((uint)param_1[uVar1] & _DAT_0020cbe0);
if ((double)(float)((uint)param_1[uVar1] & _DAT_0020cbe0) <= dVar3) {
dVar2 = dVar3;
}
uVar1 = uVar1 + 1;
dVar3 = dVar2;
} while ((uint)param_3 != uVar1);
}
dVar2 = dVar2 / _DAT_00216f10;
}
else if (param_4 == 2) {
dVar2 = 0.0;
if (0 < param_3) {
uVar1 = 0;
do {
dVar2 = dVar2 + (double)(param_1[uVar1] * param_1[uVar1]);
uVar1 = uVar1 + 1;
} while ((uint)param_3 != uVar1);
}
if (0.0 <= dVar2) {
dVar2 = SQRT(dVar2);
}
else {
dVar2 = sqrt(dVar2);
}
}
else {
if (param_3 < 1) {
dVar2 = 0.0;
}
else {
dVar2 = 0.0;
uVar1 = 0;
do {
dVar3 = pow((double)(float)((uint)param_1[uVar1] & _DAT_0020cbe0),(double)param_4);
dVar2 = dVar2 + dVar3;
uVar1 = uVar1 + 1;
} while ((uint)param_3 != uVar1);
}
dVar2 = pow(dVar2,DAT_0020d5d0 / (double)param_4);
}
}
if (0 < param_3) {
dVar3 = DAT_0020d5d0 / dVar2;
uVar1 = 0;
do {
param_2[uVar1] = param_1[uVar1] * (float)(double)(-(ulong)(0.0 < dVar2) & (ulong)dVar3);
uVar1 = uVar1 + 1;
} while ((uint)param_3 != uVar1);
}
return;
}
| |
43,370 | stbi__gif_test(stbi__context*) | llama.cpp/examples/llava/../../common/stb_image.h | static int stbi__gif_test(stbi__context *s)
{
int r = stbi__gif_test_raw(s);
stbi__rewind(s);
return r;
} | O3 | c | stbi__gif_test(stbi__context*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc0(%rdi), %rcx
cmpq 0xc8(%rdi), %rcx
jb 0x2b1a8
cmpl $0x0, 0x30(%rbx)
je 0x2b2c6
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0xc0(%rbx)
xorl %ebp, %ebp
cmpb $0x47, (%rcx)
jne 0x2b2c8
cmpq 0xc8(%rbx), %rax
jb 0x2b1e0
cmpl $0x0, 0x30(%rbx)
je 0x2b2c8
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
cmpb $0x49, (%rax)
jne 0x2b2c8
cmpq 0xc8(%rbx), %rcx
jb 0x2b216
cmpl $0x0, 0x30(%rbx)
je 0x2b2c8
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0xc0(%rbx)
cmpb $0x46, (%rcx)
jne 0x2b2c8
cmpq 0xc8(%rbx), %rax
jb 0x2b24c
cmpl $0x0, 0x30(%rbx)
je 0x2b2c8
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
cmpb $0x38, (%rax)
jne 0x2b2c8
cmpq 0xc8(%rbx), %rcx
jb 0x2b27a
cmpl $0x0, 0x30(%rbx)
je 0x2b2c8
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0xc0(%rbx)
movzbl (%rcx), %ecx
cmpl $0x39, %ecx
je 0x2b292
cmpl $0x37, %ecx
jne 0x2b2c8
cmpq 0xc8(%rbx), %rax
jb 0x2b2b0
cmpl $0x0, 0x30(%rbx)
je 0x2b2c8
movq %rbx, %rdi
callq 0x2f0a9
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
xorl %ebp, %ebp
cmpb $0x61, (%rax)
sete %bpl
jmp 0x2b2c8
xorl %ebp, %ebp
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _ZL14stbi__gif_testP13stbi__context:
push rbp
push rbx
push rax
mov rbx, rdi
mov rcx, [rdi+0C0h]
cmp rcx, [rdi+0C8h]
jb short loc_2B1A8
cmp dword ptr [rbx+30h], 0
jz loc_2B2C6
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rcx, [rbx+0C0h]
loc_2B1A8:
lea rax, [rcx+1]
mov [rbx+0C0h], rax
xor ebp, ebp
cmp byte ptr [rcx], 47h ; 'G'
jnz loc_2B2C8
cmp rax, [rbx+0C8h]
jb short loc_2B1E0
cmp dword ptr [rbx+30h], 0
jz loc_2B2C8
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_2B1E0:
lea rcx, [rax+1]
mov [rbx+0C0h], rcx
cmp byte ptr [rax], 49h ; 'I'
jnz loc_2B2C8
cmp rcx, [rbx+0C8h]
jb short loc_2B216
cmp dword ptr [rbx+30h], 0
jz loc_2B2C8
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rcx, [rbx+0C0h]
loc_2B216:
lea rax, [rcx+1]
mov [rbx+0C0h], rax
cmp byte ptr [rcx], 46h ; 'F'
jnz loc_2B2C8
cmp rax, [rbx+0C8h]
jb short loc_2B24C
cmp dword ptr [rbx+30h], 0
jz loc_2B2C8
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_2B24C:
lea rcx, [rax+1]
mov [rbx+0C0h], rcx
cmp byte ptr [rax], 38h ; '8'
jnz short loc_2B2C8
cmp rcx, [rbx+0C8h]
jb short loc_2B27A
cmp dword ptr [rbx+30h], 0
jz short loc_2B2C8
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rcx, [rbx+0C0h]
loc_2B27A:
lea rax, [rcx+1]
mov [rbx+0C0h], rax
movzx ecx, byte ptr [rcx]
cmp ecx, 39h ; '9'
jz short loc_2B292
cmp ecx, 37h ; '7'
jnz short loc_2B2C8
loc_2B292:
cmp rax, [rbx+0C8h]
jb short loc_2B2B0
cmp dword ptr [rbx+30h], 0
jz short loc_2B2C8
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_2B2B0:
lea rcx, [rax+1]
mov [rbx+0C0h], rcx
xor ebp, ebp
cmp byte ptr [rax], 61h ; 'a'
setz bpl
jmp short loc_2B2C8
loc_2B2C6:
xor ebp, ebp
loc_2B2C8:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
mov eax, ebp
add rsp, 8
pop rbx
pop rbp
retn
| _BOOL8 stbi__gif_test(long long a1)
{
_BYTE *v1; // rcx
_BYTE *v2; // rax
BOOL v3; // ebp
_BYTE *v4; // rcx
_BYTE *v5; // rax
unsigned __int8 *v6; // rcx
_BYTE *v7; // rax
int v8; // ecx
v1 = *(_BYTE **)(a1 + 192);
if ( (unsigned long long)v1 >= *(_QWORD *)(a1 + 200) )
{
if ( !*(_DWORD *)(a1 + 48) )
{
v3 = 0;
goto LABEL_27;
}
stbi__refill_buffer(a1);
v1 = *(_BYTE **)(a1 + 192);
}
v2 = v1 + 1;
*(_QWORD *)(a1 + 192) = v1 + 1;
v3 = 0;
if ( *v1 == 71 )
{
if ( (unsigned long long)v2 >= *(_QWORD *)(a1 + 200) )
{
if ( !*(_DWORD *)(a1 + 48) )
goto LABEL_27;
stbi__refill_buffer(a1);
v2 = *(_BYTE **)(a1 + 192);
}
v4 = v2 + 1;
*(_QWORD *)(a1 + 192) = v2 + 1;
if ( *v2 == 73 )
{
if ( (unsigned long long)v4 >= *(_QWORD *)(a1 + 200) )
{
if ( !*(_DWORD *)(a1 + 48) )
goto LABEL_27;
stbi__refill_buffer(a1);
v4 = *(_BYTE **)(a1 + 192);
}
v5 = v4 + 1;
*(_QWORD *)(a1 + 192) = v4 + 1;
if ( *v4 == 70 )
{
if ( (unsigned long long)v5 >= *(_QWORD *)(a1 + 200) )
{
if ( !*(_DWORD *)(a1 + 48) )
goto LABEL_27;
stbi__refill_buffer(a1);
v5 = *(_BYTE **)(a1 + 192);
}
v6 = v5 + 1;
*(_QWORD *)(a1 + 192) = v5 + 1;
if ( *v5 == 56 )
{
if ( (unsigned long long)v6 >= *(_QWORD *)(a1 + 200) )
{
if ( !*(_DWORD *)(a1 + 48) )
goto LABEL_27;
stbi__refill_buffer(a1);
v6 = *(unsigned __int8 **)(a1 + 192);
}
v7 = v6 + 1;
*(_QWORD *)(a1 + 192) = v6 + 1;
v8 = *v6;
if ( v8 == 57 || v8 == 55 )
{
if ( (unsigned long long)v7 < *(_QWORD *)(a1 + 200) )
{
LABEL_25:
*(_QWORD *)(a1 + 192) = v7 + 1;
v3 = *v7 == 97;
goto LABEL_27;
}
if ( *(_DWORD *)(a1 + 48) )
{
stbi__refill_buffer(a1);
v7 = *(_BYTE **)(a1 + 192);
goto LABEL_25;
}
}
}
}
}
}
LABEL_27:
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return v3;
}
| stbi__gif_test:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0xc0]
CMP RCX,qword ptr [RDI + 0xc8]
JC 0x0012b1a8
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c6
MOV RDI,RBX
CALL 0x0012f0a9
MOV RCX,qword ptr [RBX + 0xc0]
LAB_0012b1a8:
LEA RAX,[RCX + 0x1]
MOV qword ptr [RBX + 0xc0],RAX
XOR EBP,EBP
CMP byte ptr [RCX],0x47
JNZ 0x0012b2c8
CMP RAX,qword ptr [RBX + 0xc8]
JC 0x0012b1e0
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c8
MOV RDI,RBX
CALL 0x0012f0a9
MOV RAX,qword ptr [RBX + 0xc0]
LAB_0012b1e0:
LEA RCX,[RAX + 0x1]
MOV qword ptr [RBX + 0xc0],RCX
CMP byte ptr [RAX],0x49
JNZ 0x0012b2c8
CMP RCX,qword ptr [RBX + 0xc8]
JC 0x0012b216
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c8
MOV RDI,RBX
CALL 0x0012f0a9
MOV RCX,qword ptr [RBX + 0xc0]
LAB_0012b216:
LEA RAX,[RCX + 0x1]
MOV qword ptr [RBX + 0xc0],RAX
CMP byte ptr [RCX],0x46
JNZ 0x0012b2c8
CMP RAX,qword ptr [RBX + 0xc8]
JC 0x0012b24c
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c8
MOV RDI,RBX
CALL 0x0012f0a9
MOV RAX,qword ptr [RBX + 0xc0]
LAB_0012b24c:
LEA RCX,[RAX + 0x1]
MOV qword ptr [RBX + 0xc0],RCX
CMP byte ptr [RAX],0x38
JNZ 0x0012b2c8
CMP RCX,qword ptr [RBX + 0xc8]
JC 0x0012b27a
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c8
MOV RDI,RBX
CALL 0x0012f0a9
MOV RCX,qword ptr [RBX + 0xc0]
LAB_0012b27a:
LEA RAX,[RCX + 0x1]
MOV qword ptr [RBX + 0xc0],RAX
MOVZX ECX,byte ptr [RCX]
CMP ECX,0x39
JZ 0x0012b292
CMP ECX,0x37
JNZ 0x0012b2c8
LAB_0012b292:
CMP RAX,qword ptr [RBX + 0xc8]
JC 0x0012b2b0
CMP dword ptr [RBX + 0x30],0x0
JZ 0x0012b2c8
MOV RDI,RBX
CALL 0x0012f0a9
MOV RAX,qword ptr [RBX + 0xc0]
LAB_0012b2b0:
LEA RCX,[RAX + 0x1]
MOV qword ptr [RBX + 0xc0],RCX
XOR EBP,EBP
CMP byte ptr [RAX],0x61
SETZ BPL
JMP 0x0012b2c8
LAB_0012b2c6:
XOR EBP,EBP
LAB_0012b2c8:
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* stbi__gif_test(stbi__context*) */
bool stbi__gif_test(stbi__context *param_1)
{
char *pcVar1;
char *pcVar2;
bool bVar3;
bool bVar4;
pcVar2 = *(char **)(param_1 + 0xc0);
if (*(char **)(param_1 + 200) <= pcVar2) {
if (*(int *)(param_1 + 0x30) == 0) {
bVar4 = false;
goto LAB_0012b2c8;
}
stbi__refill_buffer(param_1);
pcVar2 = *(char **)(param_1 + 0xc0);
}
pcVar1 = pcVar2 + 1;
*(char **)(param_1 + 0xc0) = pcVar1;
bVar4 = false;
bVar3 = false;
if (*pcVar2 == 'G') {
if (*(char **)(param_1 + 200) <= pcVar1) {
if (*(int *)(param_1 + 0x30) == 0) goto LAB_0012b2c8;
stbi__refill_buffer(param_1);
pcVar1 = *(char **)(param_1 + 0xc0);
}
pcVar2 = pcVar1 + 1;
*(char **)(param_1 + 0xc0) = pcVar2;
if (*pcVar1 == 'I') {
bVar4 = bVar3;
if (*(char **)(param_1 + 200) <= pcVar2) {
if (*(int *)(param_1 + 0x30) == 0) goto LAB_0012b2c8;
stbi__refill_buffer(param_1);
pcVar2 = *(char **)(param_1 + 0xc0);
}
pcVar1 = pcVar2 + 1;
*(char **)(param_1 + 0xc0) = pcVar1;
if (*pcVar2 == 'F') {
if (*(char **)(param_1 + 200) <= pcVar1) {
if (*(int *)(param_1 + 0x30) == 0) goto LAB_0012b2c8;
stbi__refill_buffer(param_1);
pcVar1 = *(char **)(param_1 + 0xc0);
}
pcVar2 = pcVar1 + 1;
*(char **)(param_1 + 0xc0) = pcVar2;
if (*pcVar1 == '8') {
if (*(char **)(param_1 + 200) <= pcVar2) {
if (*(int *)(param_1 + 0x30) == 0) goto LAB_0012b2c8;
stbi__refill_buffer(param_1);
pcVar2 = *(char **)(param_1 + 0xc0);
}
pcVar1 = pcVar2 + 1;
*(char **)(param_1 + 0xc0) = pcVar1;
if ((*pcVar2 == '9') || (*pcVar2 == '7')) {
if (*(char **)(param_1 + 200) <= pcVar1) {
if (*(int *)(param_1 + 0x30) == 0) goto LAB_0012b2c8;
stbi__refill_buffer(param_1);
pcVar1 = *(char **)(param_1 + 0xc0);
}
*(char **)(param_1 + 0xc0) = pcVar1 + 1;
bVar4 = *pcVar1 == 'a';
}
}
}
}
}
LAB_0012b2c8:
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 0xd0);
*(int8 *)(param_1 + 200) = *(int8 *)(param_1 + 0xd8);
return bVar4;
}
| |
43,371 | int FileDescriptor::CheckSystemCall<int>(std::basic_string_view<char, std::char_traits<char>>, int) const | minnow/util/file_descriptor.cc | T FileDescriptor::CheckSystemCall( string_view s_attempt, T return_value ) const
{
if ( not internal_fd_ ) {
throw runtime_error( "internal error: missing internal_fd_" );
}
return internal_fd_->CheckSystemCall( s_attempt, return_value );
} | O0 | cpp | int FileDescriptor::CheckSystemCall<int>(std::basic_string_view<char, std::char_traits<char>>, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x19990
testb $0x1, %al
jne 0x176f8
movl $0x10, %edi
callq 0x5140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x4108(%rip), %rsi # 0x1b7cb
callq 0x50e0
jmp 0x176ca
movq -0x50(%rbp), %rdi
movq 0x11903(%rip), %rsi # 0x28fd8
movq 0x118b4(%rip), %rdx # 0x28f90
callq 0x53d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x51f0
jmp 0x1772a
movq -0x48(%rbp), %rdi
callq 0xd170
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x16b40
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x53f0
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK14FileDescriptor15CheckSystemCallIiEET_St17basic_string_viewIcSt11char_traitsIcEES1_:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rsi
mov [rbp+var_8], rdx
mov [rbp+var_18], rdi
mov [rbp+var_1C], ecx
mov rdi, [rbp+var_18]
mov [rbp+var_48], rdi
call _ZNKSt12__shared_ptrIN14FileDescriptor9FDWrapperELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_176F8
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rbp+var_50], rax
lea rsi, aInternalErrorM; "internal error: missing internal_fd_"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_176CA:
mov rdi, [rbp+var_50]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rbp+var_50]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], eax
call ___cxa_free_exception
jmp short loc_1772A
loc_176F8:
mov rdi, [rbp+var_48]
call _ZNKSt19__shared_ptr_accessIN14FileDescriptor9FDWrapperELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov ecx, [rbp+var_1C]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
call _ZNK14FileDescriptor9FDWrapper15CheckSystemCallIiEET_St17basic_string_viewIcSt11char_traitsIcEES2_; FileDescriptor::FDWrapper::CheckSystemCall<int>(std::string_view,int)
add rsp, 50h
pop rbp
retn
loc_1772A:
mov rdi, [rbp+var_28]
call __Unwind_Resume
| long long FileDescriptor::CheckSystemCall<int>(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rax
std::runtime_error *exception; // [rsp+0h] [rbp-50h]
if ( (std::__shared_ptr<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2>::operator bool() & 1) == 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "internal error: missing internal_fd_");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1);
return FileDescriptor::FDWrapper::CheckSystemCall<int>(v4, a2, a3, a4);
}
| CheckSystemCall<int>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x8],RDX
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ECX
MOV RDI,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RDI
CALL 0x00119990
TEST AL,0x1
JNZ 0x001176f8
MOV EDI,0x10
CALL 0x00105140
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RBP + -0x50],RAX
LAB_001176bc:
LEA RSI,[0x11b7cb]
CALL 0x001050e0
LAB_001176c8:
JMP 0x001176ca
LAB_001176ca:
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [0x00128fd8]
MOV RDX,qword ptr [0x00128f90]
CALL 0x001053d0
LAB_001176f8:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0010d170
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00116b40
ADD RSP,0x50
POP RBP
RET
|
/* int FileDescriptor::CheckSystemCall<int>(std::basic_string_view<char, std::char_traits<char> >,
int) const */
int FileDescriptor::CheckSystemCall<int>
(__shared_ptr *param_1,int8 param_2,int8 param_3,int4 param_4)
{
bool bVar1;
int iVar2;
runtime_error *this;
int8 uVar3;
bVar1 = std::__shared_ptr::operator_cast_to_bool(param_1);
if (!bVar1) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001176bc to 001176c7 has its CatchHandler @ 001176e1 */
std::runtime_error::runtime_error(this,"internal error: missing internal_fd_");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00128fd8,PTR__runtime_error_00128f90);
}
uVar3 = std::__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->((__shared_ptr_access<FileDescriptor::FDWrapper,(__gnu_cxx::_Lock_policy)2,false,false>
*)param_1);
iVar2 = FDWrapper::CheckSystemCall<int>(uVar3,param_2,param_3,param_4);
return iVar2;
}
| |
43,372 | Binary_string::strrstr(Binary_string const&, unsigned int) | eloqsql/sql/sql_string.h | inline uint32 length() const { return str_length;} | O3 | c | Binary_string::strrstr(Binary_string const&, unsigned int):
movl 0x8(%rsi), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %edx, %ecx
ja 0x53e05
cmpl %edx, 0x8(%rdi)
jb 0x53e05
testq %rcx, %rcx
je 0x53e03
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r10
movl %edx, %r11d
leaq -0x1(%r10,%r11), %rdi
movq (%rsi), %r8
leaq (%r10,%rcx), %r9
addq $-0x2, %r9
movl $0x1, %esi
subl %edx, %esi
leaq (%r10,%r11), %rdx
addq $-0x2, %rdx
movl $0x1, %r10d
subq %rcx, %r10
leaq (%rcx,%r8), %r11
addq $-0x2, %r11
cmpq %r9, %rdi
je 0x53dfc
movb (%rdi), %bl
cmpb -0x1(%r8,%rcx), %bl
jne 0x53ded
xorl %ebx, %ebx
cmpq %rbx, %r10
je 0x53df8
movb (%rdx,%rbx), %r14b
leaq -0x1(%rbx), %r15
cmpb (%r11,%rbx), %r14b
movq %r15, %rbx
je 0x53dd7
decq %rdi
incq %rsi
decq %rdx
jmp 0x53dc7
subl %esi, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %edx, %eax
retq
| _ZN13Binary_string7strrstrERKS_j:
mov ecx, [rsi+8]
mov eax, 0FFFFFFFFh
cmp ecx, edx
ja locret_53E05
cmp [rdi+8], edx
jb locret_53E05
test rcx, rcx
jz short loc_53E03
push rbp
mov rbp, rsp
push r15
push r14
push rbx
mov r10, [rdi]
mov r11d, edx
lea rdi, [r10+r11-1]
mov r8, [rsi]
lea r9, [r10+rcx]
add r9, 0FFFFFFFFFFFFFFFEh
mov esi, 1
sub esi, edx
lea rdx, [r10+r11]
add rdx, 0FFFFFFFFFFFFFFFEh
mov r10d, 1
sub r10, rcx
lea r11, [rcx+r8]
add r11, 0FFFFFFFFFFFFFFFEh
loc_53DC7:
cmp rdi, r9
jz short loc_53DFC
mov bl, [rdi]
cmp bl, [r8+rcx-1]
jnz short loc_53DED
xor ebx, ebx
loc_53DD7:
cmp r10, rbx
jz short loc_53DF8
mov r14b, [rdx+rbx]
lea r15, [rbx-1]
cmp r14b, [r11+rbx]
mov rbx, r15
jz short loc_53DD7
loc_53DED:
dec rdi
inc rsi
dec rdx
jmp short loc_53DC7
loc_53DF8:
sub ebx, esi
mov eax, ebx
loc_53DFC:
pop rbx
pop r14
pop r15
pop rbp
retn
loc_53E03:
mov eax, edx
locret_53E05:
retn
| long long Binary_string::strrstr(Binary_string *this, const Binary_string *a2, unsigned int a3)
{
long long v3; // rcx
long long result; // rax
long long v5; // r10
_BYTE *v6; // rdi
long long v7; // r8
unsigned int v8; // esi
long long v9; // rdx
long long v10; // rbx
bool v11; // zf
v3 = *((unsigned int *)a2 + 2);
result = 0xFFFFFFFFLL;
if ( (unsigned int)v3 <= a3 && *((_DWORD *)this + 2) >= a3 )
{
if ( *((_DWORD *)a2 + 2) )
{
v5 = *(_QWORD *)this;
v6 = (_BYTE *)(*(_QWORD *)this + a3 - 1LL);
v7 = *(_QWORD *)a2;
v8 = 1 - a3;
v9 = v5 + a3 - 2;
while ( v6 != (_BYTE *)(v5 + v3 - 2) )
{
if ( *v6 == *(_BYTE *)(v7 + v3 - 1) )
{
v10 = 0LL;
while ( 1 - v3 != v10 )
{
v11 = *(_BYTE *)(v9 + v10) == *(_BYTE *)(v3 + v7 - 2 + v10);
--v10;
if ( !v11 )
goto LABEL_10;
}
return (unsigned int)v10 - v8;
}
LABEL_10:
--v6;
++v8;
--v9;
}
}
else
{
return a3;
}
}
return result;
}
| strrstr:
MOV ECX,dword ptr [RSI + 0x8]
MOV EAX,0xffffffff
CMP ECX,EDX
JA 0x00153e05
CMP dword ptr [RDI + 0x8],EDX
JC 0x00153e05
TEST RCX,RCX
JZ 0x00153e03
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
MOV R10,qword ptr [RDI]
MOV R11D,EDX
LEA RDI,[R10 + R11*0x1 + -0x1]
MOV R8,qword ptr [RSI]
LEA R9,[R10 + RCX*0x1]
ADD R9,-0x2
MOV ESI,0x1
SUB ESI,EDX
LEA RDX,[R10 + R11*0x1]
ADD RDX,-0x2
MOV R10D,0x1
SUB R10,RCX
LEA R11,[RCX + R8*0x1]
ADD R11,-0x2
LAB_00153dc7:
CMP RDI,R9
JZ 0x00153dfc
MOV BL,byte ptr [RDI]
CMP BL,byte ptr [R8 + RCX*0x1 + -0x1]
JNZ 0x00153ded
XOR EBX,EBX
LAB_00153dd7:
CMP R10,RBX
JZ 0x00153df8
MOV R14B,byte ptr [RDX + RBX*0x1]
LEA R15,[RBX + -0x1]
CMP R14B,byte ptr [R11 + RBX*0x1]
MOV RBX,R15
JZ 0x00153dd7
LAB_00153ded:
DEC RDI
INC RSI
DEC RDX
JMP 0x00153dc7
LAB_00153df8:
SUB EBX,ESI
MOV EAX,EBX
LAB_00153dfc:
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00153e03:
MOV EAX,EDX
LAB_00153e05:
RET
|
/* Binary_string::strrstr(Binary_string const&, unsigned int) */
uint __thiscall Binary_string::strrstr(Binary_string *this,Binary_string *param_1,uint param_2)
{
char *pcVar1;
char *pcVar2;
long lVar3;
uint uVar4;
ulong uVar5;
long lVar6;
long lVar7;
int iVar8;
char *pcVar9;
uVar5 = (ulong)*(uint *)(param_1 + 8);
uVar4 = 0xffffffff;
if (((*(uint *)(param_1 + 8) <= param_2) && (param_2 <= *(uint *)(this + 8))) &&
(uVar4 = param_2, uVar5 != 0)) {
lVar3 = *(long *)this;
pcVar9 = (char *)(lVar3 + -1 + (ulong)param_2);
iVar8 = -param_2;
lVar6 = lVar3 + (ulong)param_2 + -2;
do {
iVar8 = iVar8 + 1;
if (pcVar9 == (char *)(lVar3 + uVar5 + -2)) {
return 0xffffffff;
}
if (*pcVar9 == *(char *)(*(long *)param_1 + -1 + uVar5)) {
lVar7 = 0;
do {
if (1 - uVar5 == lVar7) {
return (int)lVar7 - iVar8;
}
pcVar1 = (char *)(lVar6 + lVar7);
pcVar2 = (char *)(uVar5 + *(long *)param_1 + -2 + lVar7);
lVar7 = lVar7 + -1;
} while (*pcVar1 == *pcVar2);
}
pcVar9 = pcVar9 + -1;
lVar6 = lVar6 + -1;
} while( true );
}
return uVar4;
}
| |
43,373 | minja::TextNode::~TextNode() | monkey531[P]llama/common/minja.hpp | TextNode(const Location & location, const std::string& t) : TemplateNode(location), text(t) {} | O3 | cpp | minja::TextNode::~TextNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8cb55(%rip), %rax # 0x12a228
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x9d6f2
movq (%rax), %rsi
incq %rsi
callq 0x1a8c0
leaq 0x8c8df(%rip), %rax # 0x129fd8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9d70e
callq 0x6d25e
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8c0
| _ZN5minja8TextNodeD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja8TextNodeE; `vtable for'minja::TextNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_9D6F2
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9D6F2:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9D70E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9D70E:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::TextNode::~TextNode(minja::TextNode *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::TextNode + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~TextNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22a228]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x0019d6f2
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a8c0
LAB_0019d6f2:
LEA RAX,[0x229fd8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019d70e
CALL 0x0016d25e
LAB_0019d70e:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011a8c0
|
/* minja::TextNode::~TextNode() */
void __thiscall minja::TextNode::~TextNode(TextNode *this)
{
*(int ***)this = &PTR_do_render_0022a238;
if (*(TextNode **)(this + 0x20) != this + 0x30) {
operator_delete(*(TextNode **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_00229fe8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x40);
return;
}
| |
43,374 | fmt::v10::detail::bigint::align(fmt::v10::detail::bigint const&) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR20 void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
bigits_[j] = bigits_[i];
std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
exp_ -= exp_difference;
} | O3 | c | fmt::v10::detail::bigint::align(fmt::v10::detail::bigint const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0xa0(%rdi), %r15d
subl 0xa0(%rsi), %r15d
jle 0x48229
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
leal (%r15,%r12), %r14d
movq 0x18(%rdi), %rax
cmpq %r14, %rax
jae 0x481cf
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r14, %rax
cmovbq %rax, %r14
movq %r14, 0x10(%rbx)
testl %r12d, %r12d
jle 0x48210
movl %r12d, %eax
decl %eax
leal (%r12,%r15), %ecx
decl %ecx
movq 0x8(%rbx), %rdi
movslq %ecx, %rdx
leaq (%rdi,%rax,4), %rcx
notq %rax
leaq (%rdi,%rdx,4), %rdx
xorl %esi, %esi
movl (%rcx,%rsi,4), %r8d
movl %r8d, (%rdx,%rsi,4)
decq %rsi
cmpq %rsi, %rax
jne 0x481fe
jmp 0x48214
movq 0x8(%rbx), %rdi
movl %r15d, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x113a0
subl %r15d, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN3fmt3v106detail6bigint5alignERKS2_:
push r15
push r14
push r12
push rbx
push rax
mov r15d, [rdi+0A0h]
sub r15d, [rsi+0A0h]
jle short loc_48229
mov rbx, rdi
mov r12d, [rdi+10h]
lea r14d, [r15+r12]
mov rax, [rdi+18h]
cmp rax, r14
jnb short loc_481CF
mov rax, [rbx]
mov rdi, rbx
mov rsi, r14
call qword ptr [rax]
mov rax, [rbx+18h]
loc_481CF:
cmp rax, r14
cmovb r14, rax
mov [rbx+10h], r14
test r12d, r12d
jle short loc_48210
mov eax, r12d
dec eax
lea ecx, [r12+r15]
dec ecx
mov rdi, [rbx+8]
movsxd rdx, ecx
lea rcx, [rdi+rax*4]
not rax
lea rdx, [rdi+rdx*4]
xor esi, esi
loc_481FE:
mov r8d, [rcx+rsi*4]
mov [rdx+rsi*4], r8d
dec rsi
cmp rax, rsi
jnz short loc_481FE
jmp short loc_48214
loc_48210:
mov rdi, [rbx+8]
loc_48214:
mov edx, r15d
shl rdx, 2
xor esi, esi
call _memset
sub [rbx+0A0h], r15d
loc_48229:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long fmt::v10::detail::bigint::align(fmt::v10::detail::bigint *this, const fmt::v10::detail::bigint *a2)
{
long long result; // rax
int v3; // r15d
bool v4; // cc
unsigned int v5; // r15d
int v7; // r12d
unsigned long long v8; // r14
unsigned long long v9; // rax
long long v10; // rax
long long v11; // rdi
long long v12; // rcx
long long v13; // rax
long long v14; // rsi
v3 = *((_DWORD *)this + 40);
v4 = v3 <= *((_DWORD *)a2 + 40);
v5 = v3 - *((_DWORD *)a2 + 40);
if ( !v4 )
{
v7 = *((_DWORD *)this + 4);
v8 = v5 + v7;
v9 = *((_QWORD *)this + 3);
if ( v9 < v8 )
{
(**(void ( ***)(fmt::v10::detail::bigint *, _QWORD))this)(this, v5 + v7);
v9 = *((_QWORD *)this + 3);
}
if ( v9 < v8 )
v8 = v9;
*((_QWORD *)this + 2) = v8;
if ( v7 <= 0 )
{
v11 = *((_QWORD *)this + 1);
}
else
{
v10 = (unsigned int)(v7 - 1);
v11 = *((_QWORD *)this + 1);
v12 = v11 + 4 * v10;
v13 = ~v10;
v14 = 0LL;
do
{
*(_DWORD *)(v11 + 4LL * (int)(v7 + v5 - 1) + 4 * v14) = *(_DWORD *)(v12 + 4 * v14);
--v14;
}
while ( v13 != v14 );
}
result = memset(v11, 0LL, 4LL * v5);
*((_DWORD *)this + 40) -= v5;
}
return result;
}
| align:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,dword ptr [RDI + 0xa0]
SUB R15D,dword ptr [RSI + 0xa0]
JLE 0x00148229
MOV RBX,RDI
MOV R12D,dword ptr [RDI + 0x10]
LEA R14D,[R15 + R12*0x1]
MOV RAX,qword ptr [RDI + 0x18]
CMP RAX,R14
JNC 0x001481cf
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
MOV RSI,R14
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x18]
LAB_001481cf:
CMP RAX,R14
CMOVC R14,RAX
MOV qword ptr [RBX + 0x10],R14
TEST R12D,R12D
JLE 0x00148210
MOV EAX,R12D
DEC EAX
LEA ECX,[R12 + R15*0x1]
DEC ECX
MOV RDI,qword ptr [RBX + 0x8]
MOVSXD RDX,ECX
LEA RCX,[RDI + RAX*0x4]
NOT RAX
LEA RDX,[RDI + RDX*0x4]
XOR ESI,ESI
LAB_001481fe:
MOV R8D,dword ptr [RCX + RSI*0x4]
MOV dword ptr [RDX + RSI*0x4],R8D
DEC RSI
CMP RAX,RSI
JNZ 0x001481fe
JMP 0x00148214
LAB_00148210:
MOV RDI,qword ptr [RBX + 0x8]
LAB_00148214:
MOV EDX,R15D
SHL RDX,0x2
XOR ESI,ESI
CALL 0x001113a0
SUB dword ptr [RBX + 0xa0],R15D
LAB_00148229:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* fmt::v10::detail::bigint::align(fmt::v10::detail::bigint const&) */
void __thiscall fmt::v10::detail::bigint::align(bigint *this,bigint *param_1)
{
int iVar1;
ulong uVar2;
void *__s;
ulong uVar3;
uint uVar4;
uVar4 = *(int *)(this + 0xa0) - *(int *)(param_1 + 0xa0);
if (uVar4 != 0 && *(int *)(param_1 + 0xa0) <= *(int *)(this + 0xa0)) {
iVar1 = *(int *)(this + 0x10);
uVar3 = (ulong)(uVar4 + iVar1);
uVar2 = *(ulong *)(this + 0x18);
if (uVar2 < uVar3) {
(*(code *)**(int8 **)this)(this);
uVar2 = *(ulong *)(this + 0x18);
}
if (uVar2 < uVar3) {
uVar3 = uVar2;
}
*(ulong *)(this + 0x10) = uVar3;
if (iVar1 < 1) {
__s = *(void **)(this + 8);
}
else {
__s = *(void **)(this + 8);
uVar2 = 0;
do {
*(int4 *)((long)__s + uVar2 * 4 + (long)(int)(iVar1 + uVar4 + -1) * 4) =
*(int4 *)((long)__s + uVar2 * 4 + (ulong)(iVar1 - 1) * 4);
uVar2 = uVar2 - 1;
} while (~(ulong)(iVar1 - 1) != uVar2);
}
memset(__s,0,(ulong)uVar4 << 2);
*(uint *)(this + 0xa0) = *(int *)(this + 0xa0) - uVar4;
}
return;
}
| |
43,375 | ggml_vec_dot_q4_1_q8_1 | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_q4_1_q8_1(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
const int qk = QK8_1;
const int nb = n / qk;
assert(n % qk == 0);
#if defined(__ARM_FEATURE_MATMUL_INT8)
assert((nrc == 2) || (nrc == 1));
#else
assert(nrc == 1);
#endif
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_q4_1 * restrict x = vx;
const block_q8_1 * restrict y = vy;
#if defined(__ARM_FEATURE_MATMUL_INT8)
if (nrc == 2) {
const block_q4_1 * restrict vx0 = vx;
const block_q4_1 * restrict vx1 = (const block_q4_1 *) ((const uint8_t*)vx + bx);
const block_q8_1 * restrict vy0 = vy;
const block_q8_1 * restrict vy1 = (const block_q8_1 *) ((const uint8_t*)vy + by);
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t summs0 = vdupq_n_f32(0.0f);
for (int i = 0; i < nb; i++) {
const block_q4_1 * restrict b_x0 = &vx0[i];
const block_q4_1 * restrict b_x1 = &vx1[i];
const block_q8_1 * restrict b_y0 = &vy0[i];
const block_q8_1 * restrict b_y1 = &vy1[i];
float32_t summs_t[4] = {
GGML_FP16_TO_FP32(b_x0->m) * GGML_FP16_TO_FP32(b_y0->s),
GGML_FP16_TO_FP32(b_x1->m) * GGML_FP16_TO_FP32(b_y0->s),
GGML_FP16_TO_FP32(b_x0->m) * GGML_FP16_TO_FP32(b_y1->s),
GGML_FP16_TO_FP32(b_x1->m) * GGML_FP16_TO_FP32(b_y1->s)
};
summs0 = vaddq_f32(summs0, vld1q_f32(summs_t));
const uint8x16_t m4b = vdupq_n_u8(0x0F);
const uint8x16_t v0_0 = vld1q_u8(b_x0->qs);
const uint8x16_t v0_1 = vld1q_u8(b_x1->qs);
// 4-bit -> 8-bit
const int8x16_t x0_l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t x0_h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t x1_l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t x1_h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// load y
const int8x16_t y0_l = vld1q_s8(b_y0->qs);
const int8x16_t y0_h = vld1q_s8(b_y0->qs + 16);
const int8x16_t y1_l = vld1q_s8(b_y1->qs);
const int8x16_t y1_h = vld1q_s8(b_y1->qs + 16);
// mmla into int32x4_t
float32_t _scale[4] = {
GGML_FP16_TO_FP32(b_x0->d)*GGML_FP16_TO_FP32(b_y0->d),
GGML_FP16_TO_FP32(b_x0->d)*GGML_FP16_TO_FP32(b_y1->d),
GGML_FP16_TO_FP32(b_x1->d)*GGML_FP16_TO_FP32(b_y0->d),
GGML_FP16_TO_FP32(b_x1->d)*GGML_FP16_TO_FP32(b_y1->d)
};
float32x4_t scale = vld1q_f32(_scale);
int8x16_t l0 = vreinterpretq_s8_s64(vzip1q_s64(vreinterpretq_s64_s8(x0_l), vreinterpretq_s64_s8(x1_l)));
int8x16_t l1 = vreinterpretq_s8_s64(vzip2q_s64(vreinterpretq_s64_s8(x0_l), vreinterpretq_s64_s8(x1_l)));
int8x16_t l2 = vreinterpretq_s8_s64(vzip1q_s64(vreinterpretq_s64_s8(x0_h), vreinterpretq_s64_s8(x1_h)));
int8x16_t l3 = vreinterpretq_s8_s64(vzip2q_s64(vreinterpretq_s64_s8(x0_h), vreinterpretq_s64_s8(x1_h)));
int8x16_t r0 = vreinterpretq_s8_s64(vzip1q_s64(vreinterpretq_s64_s8(y0_l), vreinterpretq_s64_s8(y1_l)));
int8x16_t r1 = vreinterpretq_s8_s64(vzip2q_s64(vreinterpretq_s64_s8(y0_l), vreinterpretq_s64_s8(y1_l)));
int8x16_t r2 = vreinterpretq_s8_s64(vzip1q_s64(vreinterpretq_s64_s8(y0_h), vreinterpretq_s64_s8(y1_h)));
int8x16_t r3 = vreinterpretq_s8_s64(vzip2q_s64(vreinterpretq_s64_s8(y0_h), vreinterpretq_s64_s8(y1_h)));
sumv0 = vmlaq_f32(sumv0,(vcvtq_f32_s32(vmmlaq_s32((vmmlaq_s32((vmmlaq_s32((vmmlaq_s32(vdupq_n_s32(0), l0, r0)),
l1, r1)), l2, r2)), l3, r3))), scale);
}
float32x4_t sumv1 = vextq_f32 (sumv0, sumv0, 2);
float32x4_t sumv2 = vzip1q_f32(sumv0, sumv1);
sumv2 = vaddq_f32(sumv2, summs0);
vst1_f32(s, vget_low_f32 (sumv2));
vst1_f32(s + bs, vget_high_f32(sumv2));
return;
}
#endif
int ib = 0;
float sumf = 0;
// TODO: add WASM SIMD
#if defined(__ARM_NEON)
float32x4_t sumv0 = vdupq_n_f32(0.0f);
float32x4_t sumv1 = vdupq_n_f32(0.0f);
float summs = 0;
for (; ib + 1 < nb; ib += 2) {
const block_q4_1 * restrict x0 = &x[ib + 0];
const block_q4_1 * restrict x1 = &x[ib + 1];
const block_q8_1 * restrict y0 = &y[ib + 0];
const block_q8_1 * restrict y1 = &y[ib + 1];
summs += GGML_FP16_TO_FP32(x0->m) * GGML_FP16_TO_FP32(y0->s) + GGML_FP16_TO_FP32(x1->m) * GGML_FP16_TO_FP32(y1->s);
const uint8x16_t m4b = vdupq_n_u8(0x0F);
const uint8x16_t v0_0 = vld1q_u8(x0->qs);
const uint8x16_t v0_1 = vld1q_u8(x1->qs);
// 4-bit -> 8-bit
const int8x16_t v0_0l = vreinterpretq_s8_u8(vandq_u8 (v0_0, m4b));
const int8x16_t v0_0h = vreinterpretq_s8_u8(vshrq_n_u8(v0_0, 4));
const int8x16_t v0_1l = vreinterpretq_s8_u8(vandq_u8 (v0_1, m4b));
const int8x16_t v0_1h = vreinterpretq_s8_u8(vshrq_n_u8(v0_1, 4));
// load y
const int8x16_t v1_0l = vld1q_s8(y0->qs);
const int8x16_t v1_0h = vld1q_s8(y0->qs + 16);
const int8x16_t v1_1l = vld1q_s8(y1->qs);
const int8x16_t v1_1h = vld1q_s8(y1->qs + 16);
// dot product into int32x4_t
const int32x4_t p_0 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_0l, v1_0l), v0_0h, v1_0h);
const int32x4_t p_1 = ggml_vdotq_s32(ggml_vdotq_s32(vdupq_n_s32(0), v0_1l, v1_1l), v0_1h, v1_1h);
sumv0 = vmlaq_n_f32(sumv0, vcvtq_f32_s32(p_0), GGML_FP16_TO_FP32(x0->d)*GGML_FP16_TO_FP32(y0->d));
sumv1 = vmlaq_n_f32(sumv1, vcvtq_f32_s32(p_1), GGML_FP16_TO_FP32(x1->d)*GGML_FP16_TO_FP32(y1->d));
}
sumf = vaddvq_f32(sumv0) + vaddvq_f32(sumv1) + summs;
#elif defined(__AVX2__) || defined(__AVX__)
// Initialize accumulator with zeros
__m256 acc = _mm256_setzero_ps();
float summs = 0;
// Main loop
for (; ib < nb; ++ib) {
const float d0 = GGML_FP16_TO_FP32(x[ib].d);
const float d1 = GGML_FP16_TO_FP32(y[ib].d);
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
const __m256 d0v = _mm256_set1_ps( d0 );
const __m256 d1v = _mm256_set1_ps( d1 );
// Compute combined scales
const __m256 d0d1 = _mm256_mul_ps( d0v, d1v );
// Load 16 bytes, and unpack 4 bit fields into bytes, making 32 bytes
const __m256i qx = bytes_from_nibbles_32(x[ib].qs);
const __m256i qy = _mm256_loadu_si256( (const __m256i *)y[ib].qs );
const __m256 xy = mul_sum_us8_pairs_float(qx, qy);
// Accumulate d0*d1*x*y
#if defined(__AVX2__)
acc = _mm256_fmadd_ps( d0d1, xy, acc );
#else
acc = _mm256_add_ps( _mm256_mul_ps( d0d1, xy ), acc );
#endif
}
sumf = hsum_float_8(acc) + summs;
#elif defined(__riscv_v_intrinsic)
size_t vl = __riscv_vsetvl_e8m1(qk/2);
for (; ib < nb; ++ib) {
// load elements
vuint8mf2_t tx = __riscv_vle8_v_u8mf2(x[ib].qs, vl);
vint8mf2_t y0 = __riscv_vle8_v_i8mf2(y[ib].qs, vl);
vint8mf2_t y1 = __riscv_vle8_v_i8mf2(y[ib].qs+16, vl);
// mask and store lower part of x, and then upper part
vuint8mf2_t x_a = __riscv_vand_vx_u8mf2(tx, 0x0F, vl);
vuint8mf2_t x_l = __riscv_vsrl_vx_u8mf2(tx, 0x04, vl);
vint8mf2_t v0 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_a);
vint8mf2_t v1 = __riscv_vreinterpret_v_u8mf2_i8mf2(x_l);
vint16m1_t vec_mul1 = __riscv_vwmul_vv_i16m1(v0, y0, vl);
vint16m1_t vec_mul2 = __riscv_vwmul_vv_i16m1(v1, y1, vl);
vint32m1_t vec_zero = __riscv_vmv_v_x_i32m1(0, vl);
vint32m1_t vs1 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul1, vec_zero, vl);
vint32m1_t vs2 = __riscv_vwredsum_vs_i16m1_i32m1(vec_mul2, vs1, vl);
int sumi = __riscv_vmv_x_s_i32m1_i32(vs2);
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
#elif defined(__POWER9_VECTOR__)
const vector signed char lowMask = vec_splats((signed char)0xF);
const vector signed int v0 = vec_splats((int32_t)0);
const vector unsigned char v4 = vec_splats((unsigned char)0x4);
vector float vsumf0 = vec_splats(0.0f);
#pragma GCC unroll 4
for (; ib < nb; ++ib) {
__builtin_prefetch(x[ib].qs, 0, 1);
__builtin_prefetch(y[ib].qs, 0, 1);
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[ib].d));
vector float vyd = vec_splats(GGML_FP16_TO_FP32(y[ib].d));
vector float vd = vec_mul(vxd, vyd);
vector float vxmin = vec_splats(GGML_FP16_TO_FP32(x[ib].m));
vector float vys = {GGML_FP16_TO_FP32(y[ib].s), 0.0f, 0.0f, 0.0f};
vsumf0 = vec_madd(vxmin, vys, vsumf0);
vector signed char qxs = (vector signed char)vec_xl( 0, x[ib].qs);
vector signed char q8y0 = vec_xl( 0, y[ib].qs);
vector signed char q8y1 = vec_xl(16, y[ib].qs);
vector unsigned char q4x0 = (vector unsigned char)vec_and(qxs, lowMask);
vector unsigned char q4x1 = (vector unsigned char)vec_sr(qxs, v4);
vector signed int vsumi0 = v0;
vsumi0 = vec_msum(q8y0, q4x0, vsumi0);
vsumi0 = vec_msum(q8y1, q4x1, vsumi0);
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
}
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
sumf = vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
// Initialize accumulator with zeros
__m256 acc = (__m256)__lasx_xvldi(0);
float summs = 0;
// Main loop
for (; ib < nb; ++ib) {
const float d0 = GGML_FP16_TO_FP32(x[ib].d);
const float d1 = GGML_FP16_TO_FP32(y[ib].d);
summs += GGML_FP16_TO_FP32(x[ib].m) * GGML_FP16_TO_FP32(y[ib].s);
const __m256 d0v = __lasx_xvreplfr2vr_s( d0 );
const __m256 d1v = __lasx_xvreplfr2vr_s( d1 );
// Compute combined scales
const __m256 d0d1 = __lasx_xvfmul_s( d0v, d1v );
// Load 16 bytes, and unpack 4 bit fields into bytes, making 32 bytes
const __m256i qx = bytes_from_nibbles_32(x[ib].qs);
const __m256i qy = __lasx_xvld( (const __m256i *)y[ib].qs, 0);
const __m256 xy = mul_sum_us8_pairs_float(qx, qy);
// Accumulate d0*d1*x*y
acc = __lasx_xvfmadd_s( d0d1, xy, acc );
}
sumf = hsum_float_8(acc) + summs;
#endif
for (; ib < nb; ++ib) {
int sumi0 = 0;
int sumi1 = 0;
for (int j = 0; j < qk/2; ++j) {
const int v0 = (x[ib].qs[j] & 0x0F);
const int v1 = (x[ib].qs[j] >> 4);
sumi0 += (v0 * y[ib].qs[j]);
sumi1 += (v1 * y[ib].qs[j + qk/2]);
}
int sumi = sumi0 + sumi1;
sumf += (GGML_FP16_TO_FP32(x[ib].d)*GGML_FP16_TO_FP32(y[ib].d))*sumi + GGML_FP16_TO_FP32(x[ib].m)*GGML_FP16_TO_FP32(y[ib].s);
}
*s = sumf;
} | O2 | c | ggml_vec_dot_q4_1_q8_1:
movl %edi, %eax
pushq $0x20
popq %rdi
cltd
idivl %edi
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
imulq $0x14, %rax, %rax
addq $0x4, %r9
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm0, %xmm0, %xmm0
xorl %edx, %edx
movq 0x2bc97(%rip), %rdi # 0x58f70
vpbroadcastb 0x1b202(%rip), %ymm2 # 0x484e4
vpbroadcastw 0x1b1fb(%rip), %ymm3 # 0x484e6
cmpq %rdx, %rax
je 0x2d353
movzwl (%rcx,%rdx), %r8d
vmovss (%rdi,%r8,4), %xmm4
movzwl -0x4(%r9), %r8d
movzwl 0x2(%rcx,%rdx), %r10d
vmovss (%rdi,%r10,4), %xmm5
movzwl -0x2(%r9), %r10d
vfmadd231ss (%rdi,%r10,4), %xmm5, %xmm0 # xmm0 = (xmm5 * mem) + xmm0
vmulss (%rdi,%r8,4), %xmm4, %xmm4
vmovdqu 0x4(%rcx,%rdx), %xmm5
vpsrlw $0x4, %xmm5, %xmm6
vinserti128 $0x1, %xmm6, %ymm5, %ymm5
vpand %ymm2, %ymm5, %ymm5
vpmaddubsw (%r9), %ymm5, %ymm5
vbroadcastss %xmm4, %ymm4
vpmaddwd %ymm5, %ymm3, %ymm5
vcvtdq2ps %ymm5, %ymm5
vfmadd231ps %ymm5, %ymm4, %ymm1 # ymm1 = (ymm4 * ymm5) + ymm1
addq $0x14, %rdx
addq $0x24, %r9
jmp 0x2d2eb
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm1, %xmm2, %xmm1
vshufpd $0x1, %xmm1, %xmm1, %xmm2 # xmm2 = xmm1[1,0]
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss %xmm1, %xmm0, %xmm0
vmovss %xmm0, (%rsi)
vzeroupper
retq
| ggml_vec_dot_q4_1_q8_1:
mov eax, edi
push 20h ; ' '
pop rdi
cdq
idiv edi
mov edx, eax
sar edx, 1Fh
andn eax, edx, eax
imul rax, 14h
add r9, 4
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
xor edx, edx
mov rdi, cs:ggml_table_f32_f16_ptr
vpbroadcastb ymm2, cs:byte_484E4
vpbroadcastw ymm3, cs:word_484E6
loc_2D2EB:
cmp rax, rdx
jz short loc_2D353
movzx r8d, word ptr [rcx+rdx]
vmovss xmm4, dword ptr [rdi+r8*4]
movzx r8d, word ptr [r9-4]
movzx r10d, word ptr [rcx+rdx+2]
vmovss xmm5, dword ptr [rdi+r10*4]
movzx r10d, word ptr [r9-2]
vfmadd231ss xmm0, xmm5, dword ptr [rdi+r10*4]
vmulss xmm4, xmm4, dword ptr [rdi+r8*4]
vmovdqu xmm5, xmmword ptr [rcx+rdx+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [r9]
vbroadcastss ymm4, xmm4
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
add rdx, 14h
add r9, 24h ; '$'
jmp short loc_2D2EB
loc_2D353:
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
retn
| long long ggml_vec_dot_q4_1_q8_1(
int a1,
long long _RSI,
__m128 _XMM0,
__m128 _XMM1,
long long a5,
long long _RCX,
long long a7,
long long a8)
{
long long result; // rax
long long v11; // r9
result = 20LL * ((a1 / 32) & (unsigned int)~((a1 / 32) >> 31));
v11 = a8 + 4;
__asm
{
vxorps xmm1, xmm1, xmm1
vxorps xmm0, xmm0, xmm0
}
_RDX = 0LL;
_RDI = &ggml_table_f32_f16;
__asm
{
vpbroadcastb ymm2, cs:byte_484E4
vpbroadcastw ymm3, cs:word_484E6
}
while ( result != _RDX )
{
_R8 = *(unsigned __int16 *)(_RCX + _RDX);
__asm { vmovss xmm4, dword ptr [rdi+r8*4] }
_R10 = *(unsigned __int16 *)(_RCX + _RDX + 2);
__asm
{
vmovss xmm5, dword ptr [rdi+r10*4]
vfmadd231ss xmm0, xmm5, dword ptr [rdi+r10*4]
vmulss xmm4, xmm4, dword ptr [rdi+r8*4]
vmovdqu xmm5, xmmword ptr [rcx+rdx+4]
vpsrlw xmm6, xmm5, 4
vinserti128 ymm5, ymm5, xmm6, 1
vpand ymm5, ymm5, ymm2
vpmaddubsw ymm5, ymm5, ymmword ptr [r9]
vbroadcastss ymm4, xmm4
vpmaddwd ymm5, ymm3, ymm5
vcvtdq2ps ymm5, ymm5
vfmadd231ps ymm1, ymm4, ymm5
}
_RDX += 20LL;
v11 += 36LL;
}
__asm
{
vextractf128 xmm2, ymm1, 1
vaddps xmm1, xmm2, xmm1
vshufpd xmm2, xmm1, xmm1, 1
vaddps xmm1, xmm1, xmm2
vhaddps xmm1, xmm1, xmm1
vaddss xmm0, xmm0, xmm1
vmovss dword ptr [rsi], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_q4_1_q8_1:
MOV EAX,EDI
PUSH 0x20
POP RDI
CDQ
IDIV EDI
MOV EDX,EAX
SAR EDX,0x1f
ANDN EAX,EDX,EAX
IMUL RAX,RAX,0x14
ADD R9,0x4
VXORPS XMM1,XMM1,XMM1
VXORPS XMM0,XMM0,XMM0
XOR EDX,EDX
MOV RDI,qword ptr [0x00158f70]
VPBROADCASTB YMM2,byte ptr [0x001484e4]
VPBROADCASTW YMM3,word ptr [0x001484e6]
LAB_0012d2eb:
CMP RAX,RDX
JZ 0x0012d353
MOVZX R8D,word ptr [RCX + RDX*0x1]
VMOVSS XMM4,dword ptr [RDI + R8*0x4]
MOVZX R8D,word ptr [R9 + -0x4]
MOVZX R10D,word ptr [RCX + RDX*0x1 + 0x2]
VMOVSS XMM5,dword ptr [RDI + R10*0x4]
MOVZX R10D,word ptr [R9 + -0x2]
VFMADD231SS XMM0,XMM5,dword ptr [RDI + R10*0x4]
VMULSS XMM4,XMM4,dword ptr [RDI + R8*0x4]
VMOVDQU XMM5,xmmword ptr [RCX + RDX*0x1 + 0x4]
VPSRLW XMM6,XMM5,0x4
VINSERTI128 YMM5,YMM5,XMM6,0x1
VPAND YMM5,YMM5,YMM2
VPMADDUBSW YMM5,YMM5,ymmword ptr [R9]
VBROADCASTSS YMM4,XMM4
VPMADDWD YMM5,YMM3,YMM5
VCVTDQ2PS YMM5,YMM5
VFMADD231PS YMM1,YMM4,YMM5
ADD RDX,0x14
ADD R9,0x24
JMP 0x0012d2eb
LAB_0012d353:
VEXTRACTF128 XMM2,YMM1,0x1
VADDPS XMM1,XMM2,XMM1
VSHUFPD XMM2,XMM1,XMM1,0x1
VADDPS XMM1,XMM1,XMM2
VHADDPS XMM1,XMM1,XMM1
VADDSS XMM0,XMM0,XMM1
VMOVSS dword ptr [RSI],XMM0
VZEROUPPER
RET
|
void ggml_vec_dot_q4_1_q8_1
(int param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6)
{
float fVar1;
long lVar2;
int1 (*pauVar3) [32];
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [32];
int1 auVar8 [32];
int1 auVar9 [32];
int1 auVar10 [32];
int1 auVar11 [16];
pauVar3 = (int1 (*) [32])(param_6 + 4);
auVar5 = ZEXT816(0) << 0x40;
auVar4 = ZEXT816(0) << 0x40;
auVar7[1] = DAT_001484e4;
auVar7[0] = DAT_001484e4;
auVar7[2] = DAT_001484e4;
auVar7[3] = DAT_001484e4;
auVar7[4] = DAT_001484e4;
auVar7[5] = DAT_001484e4;
auVar7[6] = DAT_001484e4;
auVar7[7] = DAT_001484e4;
auVar7[8] = DAT_001484e4;
auVar7[9] = DAT_001484e4;
auVar7[10] = DAT_001484e4;
auVar7[0xb] = DAT_001484e4;
auVar7[0xc] = DAT_001484e4;
auVar7[0xd] = DAT_001484e4;
auVar7[0xe] = DAT_001484e4;
auVar7[0xf] = DAT_001484e4;
auVar7[0x10] = DAT_001484e4;
auVar7[0x11] = DAT_001484e4;
auVar7[0x12] = DAT_001484e4;
auVar7[0x13] = DAT_001484e4;
auVar7[0x14] = DAT_001484e4;
auVar7[0x15] = DAT_001484e4;
auVar7[0x16] = DAT_001484e4;
auVar7[0x17] = DAT_001484e4;
auVar7[0x18] = DAT_001484e4;
auVar7[0x19] = DAT_001484e4;
auVar7[0x1a] = DAT_001484e4;
auVar7[0x1b] = DAT_001484e4;
auVar7[0x1c] = DAT_001484e4;
auVar7[0x1d] = DAT_001484e4;
auVar7[0x1e] = DAT_001484e4;
auVar7[0x1f] = DAT_001484e4;
auVar8._2_2_ = DAT_001484e6;
auVar8._0_2_ = DAT_001484e6;
auVar8._4_2_ = DAT_001484e6;
auVar8._6_2_ = DAT_001484e6;
auVar8._8_2_ = DAT_001484e6;
auVar8._10_2_ = DAT_001484e6;
auVar8._12_2_ = DAT_001484e6;
auVar8._14_2_ = DAT_001484e6;
auVar8._16_2_ = DAT_001484e6;
auVar8._18_2_ = DAT_001484e6;
auVar8._20_2_ = DAT_001484e6;
auVar8._22_2_ = DAT_001484e6;
auVar8._24_2_ = DAT_001484e6;
auVar8._26_2_ = DAT_001484e6;
auVar8._28_2_ = DAT_001484e6;
auVar8._30_2_ = DAT_001484e6;
for (lVar2 = 0; (ulong)(uint)(~(param_1 / 0x20 >> 0x1f) & param_1 / 0x20) * 0x14 - lVar2 != 0;
lVar2 = lVar2 + 0x14) {
auVar4 = vfmadd231ss_fma(auVar4,ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00158f70 +
(ulong)*(ushort *)(param_4 + 2 + lVar2) * 4)),
ZEXT416(*(uint *)(PTR_ggml_table_f32_f16_00158f70 +
(ulong)*(ushort *)(pauVar3[-1] + 0x1e) * 4)));
fVar1 = *(float *)(PTR_ggml_table_f32_f16_00158f70 + (ulong)*(ushort *)(param_4 + lVar2) * 4) *
*(float *)(PTR_ggml_table_f32_f16_00158f70 + (ulong)*(ushort *)(pauVar3[-1] + 0x1c) * 4)
;
auVar6 = *(int1 (*) [16])(param_4 + 4 + lVar2);
auVar11 = vpsrlw_avx(auVar6,4);
auVar10._0_16_ = ZEXT116(0) * auVar11 + ZEXT116(1) * auVar6;
auVar10._16_16_ = ZEXT116(0) * SUB4816((int1 [48])0x0,0) + ZEXT116(1) * auVar11;
auVar10 = vpand_avx2(auVar10,auVar7);
auVar10 = vpmaddubsw_avx2(auVar10,*pauVar3);
auVar9._4_4_ = fVar1;
auVar9._0_4_ = fVar1;
auVar9._8_4_ = fVar1;
auVar9._12_4_ = fVar1;
auVar9._16_4_ = fVar1;
auVar9._20_4_ = fVar1;
auVar9._24_4_ = fVar1;
auVar9._28_4_ = fVar1;
auVar10 = vpmaddwd_avx2(auVar8,auVar10);
auVar10 = vcvtdq2ps_avx(auVar10);
auVar5 = vfmadd231ps_fma(ZEXT1632(auVar5),auVar9,auVar10);
pauVar3 = (int1 (*) [32])(pauVar3[1] + 4);
}
auVar6._0_4_ = auVar5._0_4_ + 0.0;
auVar6._4_4_ = auVar5._4_4_ + 0.0;
auVar6._8_4_ = auVar5._8_4_ + 0.0;
auVar6._12_4_ = auVar5._12_4_ + 0.0;
auVar5 = vshufpd_avx(auVar6,auVar6,1);
auVar11._0_4_ = auVar6._0_4_ + auVar5._0_4_;
auVar11._4_4_ = auVar6._4_4_ + auVar5._4_4_;
auVar11._8_4_ = auVar6._8_4_ + auVar5._8_4_;
auVar11._12_4_ = auVar6._12_4_ + auVar5._12_4_;
auVar5 = vhaddps_avx(auVar11,auVar11);
*param_2 = auVar4._0_4_ + auVar5._0_4_;
return;
}
| |
43,376 | my_string_repertoire | eloqsql/strings/ctype.c | my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
} | O3 | c | my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x98(%rdi)
jne 0xd2817
testb $0x20, 0xd(%r15)
jne 0xd2817
movl $0x1, %eax
testq %rbx, %rbx
jle 0xd287d
addq %r14, %rbx
cmpb $0x0, (%r14)
js 0xd288a
incq %r14
cmpq %rbx, %r14
jb 0xd2807
jmp 0xd287d
addq %r14, %rbx
movq 0xb8(%r15), %rax
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xd2873
cmpq $0x7f, -0x28(%rbp)
ja 0xd2873
leaq -0x28(%rbp), %r12
movq %r14, %rcx
movl %eax, %r14d
addq %rcx, %r14
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testl %eax, %eax
setg %cl
jle 0xd2873
cmpq $0x80, -0x28(%rbp)
jb 0xd2843
movzbl %cl, %eax
leal 0x1(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3, %eax
jmp 0xd287d
| my_string_repertoire:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
cmp dword ptr [rdi+98h], 1
jnz short loc_D2817
test byte ptr [r15+0Dh], 20h
jnz short loc_D2817
mov eax, 1
test rbx, rbx
jle short loc_D287D
add rbx, r14
loc_D2807:
cmp byte ptr [r14], 0
js short loc_D288A
inc r14
cmp r14, rbx
jb short loc_D2807
jmp short loc_D287D
loc_D2817:
add rbx, r14
mov rax, [r15+0B8h]
lea rsi, [rbp+var_28]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_D2873
cmp [rbp+var_28], 7Fh
ja short loc_D2873
lea r12, [rbp+var_28]
loc_D2843:
mov rcx, r14
mov r14d, eax
add r14, rcx
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov rcx, rbx
call qword ptr [rax+28h]
test eax, eax
setnle cl
jle short loc_D2873
cmp [rbp+var_28], 80h
jb short loc_D2843
loc_D2873:
movzx eax, cl
lea eax, ds:1[rax*2]
loc_D287D:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_D288A:
mov eax, 3
jmp short loc_D287D
| long long my_string_repertoire(long long a1, char *a2, long long a3)
{
char *v3; // r14
long long result; // rax
char *v5; // rbx
int v6; // eax
bool v7; // cl
_QWORD v8[5]; // [rsp+8h] [rbp-28h] BYREF
v3 = a2;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_BYTE *)(a1 + 13) & 0x20) != 0 )
{
v5 = &a2[a3];
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
a2,
&a2[a3]);
v7 = v6 > 0;
if ( v6 > 0 && v8[0] <= 0x7FuLL )
{
do
{
v3 += (unsigned int)v6;
v6 = (*(long long ( **)(long long, _QWORD *, char *, char *))(*(_QWORD *)(a1 + 184) + 40LL))(
a1,
v8,
v3,
v5);
v7 = v6 > 0;
}
while ( v6 > 0 && v8[0] < 0x80uLL );
}
return 2 * (unsigned int)v7 + 1;
}
else
{
result = 1LL;
if ( a3 > 0 )
{
while ( *v3 >= 0 )
{
if ( ++v3 >= &a2[a3] )
return result;
}
return 3LL;
}
}
return result;
}
| my_string_repertoire:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
CMP dword ptr [RDI + 0x98],0x1
JNZ 0x001d2817
TEST byte ptr [R15 + 0xd],0x20
JNZ 0x001d2817
MOV EAX,0x1
TEST RBX,RBX
JLE 0x001d287d
ADD RBX,R14
LAB_001d2807:
CMP byte ptr [R14],0x0
JS 0x001d288a
INC R14
CMP R14,RBX
JC 0x001d2807
JMP 0x001d287d
LAB_001d2817:
ADD RBX,R14
MOV RAX,qword ptr [R15 + 0xb8]
LEA RSI,[RBP + -0x28]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001d2873
CMP qword ptr [RBP + -0x28],0x7f
JA 0x001d2873
LEA R12,[RBP + -0x28]
LAB_001d2843:
MOV RCX,R14
MOV R14D,EAX
ADD R14,RCX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
SETG CL
JLE 0x001d2873
CMP qword ptr [RBP + -0x28],0x80
JC 0x001d2843
LAB_001d2873:
MOVZX EAX,CL
LEA EAX,[0x1 + RAX*0x2]
LAB_001d287d:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001d288a:
MOV EAX,0x3
JMP 0x001d287d
|
char my_string_repertoire(long param_1,char *param_2,long param_3)
{
char cVar1;
uint uVar2;
bool bVar3;
char *pcVar4;
ulong local_30;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(byte *)(param_1 + 0xd) & 0x20) == 0)) {
cVar1 = '\x01';
if (0 < param_3) {
pcVar4 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return '\x03';
}
param_2 = param_2 + 1;
} while (param_2 < pcVar4);
}
}
else {
pcVar4 = param_2 + param_3;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((0 < (int)uVar2) && (local_30 < 0x80)) {
do {
param_2 = param_2 + uVar2;
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x28))(param_1,&local_30,param_2,pcVar4);
bVar3 = 0 < (int)uVar2;
if ((int)uVar2 < 1) break;
} while (local_30 < 0x80);
}
cVar1 = bVar3 * '\x02' + '\x01';
}
return cVar1;
}
| |
43,377 | ps_fetch_double | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_double(MYSQL_BIND *r_param, const MYSQL_FIELD * field , unsigned char **row)
{
switch (r_param->buffer_type)
{
case MYSQL_TYPE_DOUBLE:
{
double *value= (double *)r_param->buffer;
float8get(*value, *row);
r_param->buffer_length= 8;
}
break;
default:
{
double value;
float8get(value, *row);
convert_from_double(r_param, field, value, sizeof(double));
}
break;
}
(*row)+= 8;
} | O0 | c | ps_fetch_double:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x5, %eax
jne 0x93bbd
jmp 0x93b92
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x8, 0x40(%rax)
jmp 0x93be2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
movl $0x8, %edx
callq 0x95aa0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ps_fetch_double:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
sub eax, 5
jnz short loc_93BBD
jmp short $+2
loc_93B92:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov rcx, [rcx]
mov [rax], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+40h], 8
jmp short loc_93BE2
loc_93BBD:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
movsd xmm0, [rbp+var_28]
mov edx, 8
call convert_from_double
loc_93BE2:
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 8
mov [rax], rcx
add rsp, 30h
pop rbp
retn
| double ** ps_fetch_double(long long a1, long long a2, double **a3)
{
double **result; // rax
if ( *(_DWORD *)(a1 + 96) == 5 )
{
**(double **)(a1 + 16) = **a3;
*(_QWORD *)(a1 + 64) = 8LL;
}
else
{
convert_from_double(a1, a2, 8LL, **a3);
}
result = a3;
++*a3;
return result;
}
| ps_fetch_double:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x5
JNZ 0x00193bbd
JMP 0x00193b92
LAB_00193b92:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],0x8
JMP 0x00193be2
LAB_00193bbd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RBP + -0x28]
MOV EDX,0x8
CALL 0x00195aa0
LAB_00193be2:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x8
MOV qword ptr [RAX],RCX
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_double(long param_1,int8 param_2,long *param_3)
{
if (*(int *)(param_1 + 0x60) == 5) {
**(int8 **)(param_1 + 0x10) = *(int8 *)*param_3;
*(int8 *)(param_1 + 0x40) = 8;
}
else {
convert_from_double(*(int8 *)*param_3,param_1,param_2,8);
}
*param_3 = *param_3 + 8;
return;
}
| |
43,378 | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_strip(const std::string & str) {
size_t start = 0;
size_t end = str.size();
while (start < end && std::isspace(str[start])) {
start++;
}
while (end > start && std::isspace(str[end - 1])) {
end--;
}
return str.substr(start, end - start);
} | O1 | cpp | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x71f2e
movq (%r14), %r12
xorl %r15d, %r15d
movsbl (%r12,%r15), %edi
callq 0x1b0c0
testl %eax, %eax
je 0x71f31
incq %r15
cmpq %r15, %r13
jne 0x71f13
movq %r13, %r15
jmp 0x71f31
xorl %r15d, %r15d
movq (%r14), %rbp
cmpq %r13, %r15
movq %r13, %r12
cmovbq %r15, %r12
cmpq %r15, %r13
jbe 0x71f5b
movsbl -0x1(%rbp,%r13), %edi
decq %r13
callq 0x1b0c0
testl %eax, %eax
jne 0x71f3e
incq %r13
movq %r13, %r12
subq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1b910
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z12string_stripRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov r13, [rsi+8]
test r13, r13
jz short loc_71F2E
mov r12, [r14]
xor r15d, r15d
loc_71F13:
movsx edi, byte ptr [r12+r15]
call _isspace
test eax, eax
jz short loc_71F31
inc r15
cmp r13, r15
jnz short loc_71F13
mov r15, r13
jmp short loc_71F31
loc_71F2E:
xor r15d, r15d
loc_71F31:
mov rbp, [r14]
cmp r15, r13
mov r12, r13
cmovb r12, r15
loc_71F3E:
cmp r13, r15
jbe short loc_71F5B
movsx edi, byte ptr [rbp+r13-1]
dec r13
call _isspace
test eax, eax
jnz short loc_71F3E
inc r13
mov r12, r13
loc_71F5B:
sub r12, r15
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_strip(long long a1, long long *a2)
{
unsigned long long v3; // r13
long long v4; // r12
unsigned long long v5; // r15
long long v6; // rbp
unsigned long long v7; // r12
long long v8; // rdi
v3 = a2[1];
if ( v3 )
{
v4 = *a2;
v5 = 0LL;
while ( (unsigned int)isspace((unsigned int)*(char *)(v4 + v5)) )
{
if ( v3 == ++v5 )
{
v5 = v3;
break;
}
}
}
else
{
v5 = 0LL;
}
v6 = *a2;
v7 = v3;
if ( v5 < v3 )
v7 = v5;
while ( v3 > v5 )
{
v8 = (unsigned int)*(char *)(v6 + v3-- - 1);
if ( !(unsigned int)isspace(v8) )
{
v7 = v3 + 1;
break;
}
}
std::string::substr(a1, a2, v5, v7 - v5);
return a1;
}
| string_strip:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x8]
TEST R13,R13
JZ 0x00171f2e
MOV R12,qword ptr [R14]
XOR R15D,R15D
LAB_00171f13:
MOVSX EDI,byte ptr [R12 + R15*0x1]
CALL 0x0011b0c0
TEST EAX,EAX
JZ 0x00171f31
INC R15
CMP R13,R15
JNZ 0x00171f13
MOV R15,R13
JMP 0x00171f31
LAB_00171f2e:
XOR R15D,R15D
LAB_00171f31:
MOV RBP,qword ptr [R14]
CMP R15,R13
MOV R12,R13
CMOVC R12,R15
LAB_00171f3e:
CMP R13,R15
JBE 0x00171f5b
MOVSX EDI,byte ptr [RBP + R13*0x1 + -0x1]
DEC R13
CALL 0x0011b0c0
TEST EAX,EAX
JNZ 0x00171f3e
INC R13
MOV R12,R13
LAB_00171f5b:
SUB R12,R15
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x0011b910
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_strip(std::__cxx11::string const&) */
string * string_strip(string *param_1)
{
char *pcVar1;
long lVar2;
int iVar3;
long *in_RSI;
ulong uVar4;
ulong uVar5;
ulong uVar6;
uVar4 = in_RSI[1];
if (uVar4 == 0) {
uVar6 = 0;
}
else {
lVar2 = *in_RSI;
uVar5 = 0;
do {
iVar3 = isspace((int)*(char *)(lVar2 + uVar5));
uVar6 = uVar5;
if (iVar3 == 0) break;
uVar5 = uVar5 + 1;
uVar6 = uVar4;
} while (uVar4 != uVar5);
}
lVar2 = *in_RSI;
do {
if (uVar4 <= uVar6) break;
pcVar1 = (char *)(lVar2 + -1 + uVar4);
uVar4 = uVar4 - 1;
iVar3 = isspace((int)*pcVar1);
} while (iVar3 != 0);
std::__cxx11::string::substr((ulong)param_1,(ulong)in_RSI);
return param_1;
}
| |
43,379 | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_strip(const std::string & str) {
size_t start = 0;
size_t end = str.size();
while (start < end && std::isspace(str[start])) {
start++;
}
while (end > start && std::isspace(str[end - 1])) {
end--;
}
return str.substr(start, end - start);
} | O3 | cpp | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rbp
movq 0x8(%rsi), %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x726e7
movsbl (%rbp,%r15), %edi
callq 0x1b0c0
testl %eax, %eax
je 0x726e7
incq %r15
cmpq %r15, %r13
jne 0x726cd
movq %r13, %r15
cmpq %r13, %r15
movq %r13, %r12
cmovbq %r15, %r12
cmpq %r15, %r13
jbe 0x7270e
movsbl -0x1(%rbp,%r13), %edi
decq %r13
callq 0x1b0c0
testl %eax, %eax
jne 0x726f1
incq %r13
movq %r13, %r12
subq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1b910
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z12string_stripRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rbp, [rsi]
mov r13, [rsi+8]
xor r15d, r15d
test r13, r13
jz short loc_726E7
loc_726CD:
movsx edi, byte ptr [rbp+r15+0]
call _isspace
test eax, eax
jz short loc_726E7
inc r15
cmp r13, r15
jnz short loc_726CD
mov r15, r13
loc_726E7:
cmp r15, r13
mov r12, r13
cmovb r12, r15
loc_726F1:
cmp r13, r15
jbe short loc_7270E
movsx edi, byte ptr [rbp+r13-1]
dec r13
call _isspace
test eax, eax
jnz short loc_726F1
inc r13
mov r12, r13
loc_7270E:
sub r12, r15
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_strip(long long a1, long long *a2)
{
long long v3; // rbp
unsigned long long v4; // r13
unsigned long long v5; // r15
unsigned long long v6; // r12
long long v7; // rdi
v3 = *a2;
v4 = a2[1];
v5 = 0LL;
if ( v4 )
{
while ( (unsigned int)isspace((unsigned int)*(char *)(v3 + v5)) )
{
if ( v4 == ++v5 )
{
v5 = v4;
break;
}
}
}
v6 = v4;
if ( v5 < v4 )
v6 = v5;
while ( v4 > v5 )
{
v7 = (unsigned int)*(char *)(v3 + v4-- - 1);
if ( !(unsigned int)isspace(v7) )
{
v6 = v4 + 1;
break;
}
}
std::string::substr(a1, a2, v5, v6 - v5);
return a1;
}
| string_strip:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RBP,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
XOR R15D,R15D
TEST R13,R13
JZ 0x001726e7
LAB_001726cd:
MOVSX EDI,byte ptr [RBP + R15*0x1]
CALL 0x0011b0c0
TEST EAX,EAX
JZ 0x001726e7
INC R15
CMP R13,R15
JNZ 0x001726cd
MOV R15,R13
LAB_001726e7:
CMP R15,R13
MOV R12,R13
CMOVC R12,R15
LAB_001726f1:
CMP R13,R15
JBE 0x0017270e
MOVSX EDI,byte ptr [RBP + R13*0x1 + -0x1]
DEC R13
CALL 0x0011b0c0
TEST EAX,EAX
JNZ 0x001726f1
INC R13
MOV R12,R13
LAB_0017270e:
SUB R12,R15
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x0011b910
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_strip(std::__cxx11::string const&) */
string * string_strip(string *param_1)
{
char *pcVar1;
long lVar2;
int iVar3;
long *in_RSI;
ulong uVar4;
ulong uVar5;
ulong uVar6;
lVar2 = *in_RSI;
uVar4 = in_RSI[1];
uVar5 = 0;
uVar6 = uVar5;
if (uVar4 != 0) {
do {
iVar3 = isspace((int)*(char *)(lVar2 + uVar5));
uVar6 = uVar5;
if (iVar3 == 0) break;
uVar5 = uVar5 + 1;
uVar6 = uVar4;
} while (uVar4 != uVar5);
}
do {
if (uVar4 <= uVar6) break;
pcVar1 = (char *)(lVar2 + -1 + uVar4);
uVar4 = uVar4 - 1;
iVar3 = isspace((int)*pcVar1);
} while (iVar3 != 0);
std::__cxx11::string::substr((ulong)param_1,(ulong)in_RSI);
return param_1;
}
| |
43,380 | my_strnxfrm_latin1_de | eloqsql/strings/ctype-latin1.c | static size_t
my_strnxfrm_latin1_de(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar* src, size_t srclen, uint flags)
{
uchar *de= dst + dstlen;
const uchar *se= src + srclen;
uchar *d0= dst;
for ( ; src < se && dst < de && nweights; src++, nweights--)
{
uchar chr= combo1map[*src];
*dst++= chr;
if ((chr= combo2map[*src]) && dst < de && nweights > 1)
{
*dst++= chr;
nweights--;
}
}
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, de, nweights, flags, 0);
} | O0 | c | my_strnxfrm_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x3efba
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x38(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x3efba
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x3efc6
jmp 0x3f057
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xff81a(%rip), %rax # 0x13e7f0
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xff8f0(%rip), %rax # 0x13e8f0
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3f03b
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x3f03b
cmpl $0x1, -0x1c(%rbp)
jbe 0x3f03b
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f03d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ef92
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x42060
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_strnxfrm_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_48], rax
loc_3EF92:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_4A], al
jnb short loc_3EFBA
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_38]
mov [rbp+var_4A], al
jnb short loc_3EFBA
cmp [rbp+var_1C], 0
setnz al
mov [rbp+var_4A], al
loc_3EFBA:
mov al, [rbp+var_4A]
test al, 1
jnz short loc_3EFC6
jmp loc_3F057
loc_3EFC6:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_49], al
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_49], al
movzx eax, al
cmp eax, 0
jz short loc_3F03B
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_3F03B
cmp [rbp+var_1C], 1
jbe short loc_3F03B
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
loc_3F03B:
jmp short $+2
loc_3F03D:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp loc_3EF92
loc_3F057:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 60h
pop rbp
retn
| long long my_strnxfrm_latin1_de(
int a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 *a5,
long long a6,
int a7)
{
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // rax
bool v10; // [rsp+16h] [rbp-4Ah]
unsigned __int8 v11; // [rsp+17h] [rbp-49h]
unsigned long long v12; // [rsp+28h] [rbp-38h]
unsigned __int8 *v13; // [rsp+38h] [rbp-28h]
unsigned __int8 *v15; // [rsp+50h] [rbp-10h]
v15 = a2;
v13 = a5;
v12 = (unsigned long long)&a2[a3];
while ( 1 )
{
v10 = 0;
if ( v13 < &a5[a6] )
{
v10 = 0;
if ( (unsigned long long)v15 < v12 )
v10 = a4 != 0;
}
if ( !v10 )
break;
v7 = v15++;
*v7 = combo1map[*v13];
v11 = combo2map[*v13];
if ( v11 && (unsigned long long)v15 < v12 && a4 > 1 )
{
v8 = v15++;
*v8 = v11;
--a4;
}
++v13;
--a4;
}
return my_strxfrm_pad_desc_and_reverse(a1, (_DWORD)a2, (_DWORD)v15, v12, a4, a7, 0);
}
| my_strnxfrm_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RAX
LAB_0013ef92:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x0013efba
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x0013efba
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_0013efba:
MOV AL,byte ptr [RBP + -0x4a]
TEST AL,0x1
JNZ 0x0013efc6
JMP 0x0013f057
LAB_0013efc6:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23e7f0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23e8f0]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013f03b
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0013f03b
CMP dword ptr [RBP + -0x1c],0x1
JBE 0x0013f03b
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_0013f03b:
JMP 0x0013f03d
LAB_0013f03d:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0013ef92
LAB_0013f057:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00142060
ADD RSP,0x60
POP RBP
RET
|
void my_strnxfrm_latin1_de
(int8 param_1,char *param_2,long param_3,uint param_4,byte *param_5,
long param_6,int4 param_7)
{
char *pcVar1;
char *pcVar2;
bool bVar3;
byte *local_30;
uint local_24;
char *local_18;
pcVar1 = param_2 + param_3;
local_30 = param_5;
local_24 = param_4;
local_18 = param_2;
while( true ) {
bVar3 = false;
if ((local_30 < param_5 + param_6) && (bVar3 = false, local_18 < pcVar1)) {
bVar3 = local_24 != 0;
}
if (!bVar3) break;
pcVar2 = local_18 + 1;
*local_18 = combo1map[*local_30];
if (((combo2map[*local_30] != '\0') && (pcVar2 < pcVar1)) && (1 < local_24)) {
*pcVar2 = combo2map[*local_30];
local_24 = local_24 - 1;
pcVar2 = local_18 + 2;
}
local_18 = pcVar2;
local_30 = local_30 + 1;
local_24 = local_24 - 1;
}
my_strxfrm_pad_desc_and_reverse(param_1,param_2,local_18,pcVar1,local_24,param_7,0);
return;
}
| |
43,381 | ggml_backend_sched_reset | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | void ggml_backend_sched_reset(ggml_backend_sched_t sched) {
// reset state for the next run
if (!sched->is_reset) {
ggml_hash_set_reset(&sched->hash_set);
memset(sched->hv_tensor_backend_ids, -1, sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
memset(sched->hv_tensor_copies, 0, sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
sched->is_reset = true;
}
sched->is_alloc = false;
} | O0 | cpp | ggml_backend_sched_reset:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
jne 0x5f6bc
movq -0x8(%rbp), %rdi
addq $0x110, %rdi # imm = 0x110
callq 0x46140
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdx
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x44050
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdx
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rax
imulq %rax, %rdx
movq -0x8(%rbp), %rax
movslq 0x1b8(%rax), %rax
imulq %rax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x44050
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| ggml_backend_sched_reset:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
test byte ptr [rax], 1
jnz short loc_5F6BC
mov rdi, [rbp+var_8]
add rdi, 110h
call _ggml_hash_set_reset
mov rax, [rbp+var_8]
mov rdi, [rax+128h]
mov rax, [rbp+var_8]
mov rdx, [rax+110h]
shl rdx, 2
mov esi, 0FFh
call _memset
mov rax, [rbp+var_8]
mov rdi, [rax+130h]
mov rax, [rbp+var_8]
mov rdx, [rax+110h]
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+4]
imul rdx, rax
mov rax, [rbp+var_8]
movsxd rax, dword ptr [rax+1B8h]
imul rdx, rax
shl rdx, 3
xor esi, esi
call _memset
mov rax, [rbp+var_8]
mov byte ptr [rax], 1
loc_5F6BC:
mov rax, [rbp+var_8]
mov byte ptr [rax+1], 0
add rsp, 10h
pop rbp
retn
| long long ggml_backend_sched_reset(long long a1)
{
long long result; // rax
if ( (*(_BYTE *)a1 & 1) == 0 )
{
ggml_hash_set_reset((long long *)(a1 + 272));
memset(*(_QWORD *)(a1 + 296), 255LL, 4LL * *(_QWORD *)(a1 + 272));
memset(*(_QWORD *)(a1 + 304), 0LL, 8 * *(int *)(a1 + 440) * *(int *)(a1 + 4) * *(_QWORD *)(a1 + 272));
*(_BYTE *)a1 = 1;
}
result = a1;
*(_BYTE *)(a1 + 1) = 0;
return result;
}
| ggml_backend_sched_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
TEST byte ptr [RAX],0x1
JNZ 0x0015f6bc
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x110
CALL 0x00146140
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x128]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x110]
SHL RDX,0x2
MOV ESI,0xff
CALL 0x00144050
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x130]
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x110]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x4]
IMUL RDX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RAX + 0x1b8]
IMUL RDX,RAX
SHL RDX,0x3
XOR ESI,ESI
CALL 0x00144050
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x1
LAB_0015f6bc:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1],0x0
ADD RSP,0x10
POP RBP
RET
|
void ggml_backend_sched_reset(byte *param_1)
{
if ((*param_1 & 1) == 0) {
ggml_hash_set_reset(param_1 + 0x110);
memset(*(void **)(param_1 + 0x128),0xff,*(long *)(param_1 + 0x110) << 2);
memset(*(void **)(param_1 + 0x130),0,
*(long *)(param_1 + 0x110) * (long)*(int *)(param_1 + 4) *
(long)*(int *)(param_1 + 0x1b8) * 8);
*param_1 = 1;
}
param_1[1] = 0;
return;
}
| |
43,382 | ggml_backend_sched_reset | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | void ggml_backend_sched_reset(ggml_backend_sched_t sched) {
// reset state for the next run
if (!sched->is_reset) {
ggml_hash_set_reset(&sched->hash_set);
memset(sched->hv_tensor_backend_ids, -1, sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
memset(sched->hv_tensor_copies, 0, sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
sched->is_reset = true;
}
sched->is_alloc = false;
} | O1 | cpp | ggml_backend_sched_reset:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x27b8b
leaq 0x110(%rbx), %rdi
callq 0x181e0
movq 0x110(%rbx), %rdx
movq 0x128(%rbx), %rdi
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x178f0
movq 0x130(%rbx), %rdi
movslq 0x4(%rbx), %rdx
movslq 0x1b8(%rbx), %rax
imulq 0x110(%rbx), %rdx
imulq %rax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x178f0
movb $0x1, (%rbx)
movb $0x0, 0x1(%rbx)
popq %rbx
retq
| ggml_backend_sched_reset:
push rbx
mov rbx, rdi
cmp byte ptr [rdi], 0
jnz short loc_27B8B
lea rdi, [rbx+110h]
call _ggml_hash_set_reset
mov rdx, [rbx+110h]
mov rdi, [rbx+128h]
shl rdx, 2
mov esi, 0FFh
call _memset
mov rdi, [rbx+130h]
movsxd rdx, dword ptr [rbx+4]
movsxd rax, dword ptr [rbx+1B8h]
imul rdx, [rbx+110h]
imul rdx, rax
shl rdx, 3
xor esi, esi
call _memset
mov byte ptr [rbx], 1
loc_27B8B:
mov byte ptr [rbx+1], 0
pop rbx
retn
| long long ggml_backend_sched_reset(long long a1)
{
long long result; // rax
if ( !*(_BYTE *)a1 )
{
ggml_hash_set_reset((_QWORD *)(a1 + 272));
memset(*(_QWORD *)(a1 + 296), 255LL, 4LL * *(_QWORD *)(a1 + 272));
result = memset(*(_QWORD *)(a1 + 304), 0LL, 8 * *(int *)(a1 + 440) * *(_QWORD *)(a1 + 272) * *(int *)(a1 + 4));
*(_BYTE *)a1 = 1;
}
*(_BYTE *)(a1 + 1) = 0;
return result;
}
| ggml_backend_sched_reset:
PUSH RBX
MOV RBX,RDI
CMP byte ptr [RDI],0x0
JNZ 0x00127b8b
LEA RDI,[RBX + 0x110]
CALL 0x001181e0
MOV RDX,qword ptr [RBX + 0x110]
MOV RDI,qword ptr [RBX + 0x128]
SHL RDX,0x2
MOV ESI,0xff
CALL 0x001178f0
MOV RDI,qword ptr [RBX + 0x130]
MOVSXD RDX,dword ptr [RBX + 0x4]
MOVSXD RAX,dword ptr [RBX + 0x1b8]
IMUL RDX,qword ptr [RBX + 0x110]
IMUL RDX,RAX
SHL RDX,0x3
XOR ESI,ESI
CALL 0x001178f0
MOV byte ptr [RBX],0x1
LAB_00127b8b:
MOV byte ptr [RBX + 0x1],0x0
POP RBX
RET
|
void ggml_backend_sched_reset(char *param_1)
{
if (*param_1 == '\0') {
ggml_hash_set_reset(param_1 + 0x110);
memset(*(void **)(param_1 + 0x128),0xff,*(long *)(param_1 + 0x110) << 2);
memset(*(void **)(param_1 + 0x130),0,
(long)*(int *)(param_1 + 4) * *(long *)(param_1 + 0x110) *
(long)*(int *)(param_1 + 0x1b8) * 8);
*param_1 = '\x01';
}
param_1[1] = '\0';
return;
}
| |
43,383 | ggml_backend_sched_reset | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp | void ggml_backend_sched_reset(ggml_backend_sched_t sched) {
// reset state for the next run
if (!sched->is_reset) {
ggml_hash_set_reset(&sched->hash_set);
memset(sched->hv_tensor_backend_ids, -1, sched->hash_set.size * sizeof(sched->hv_tensor_backend_ids[0]));
memset(sched->hv_tensor_copies, 0, sched->hash_set.size * sched->n_backends * sched->n_copies * sizeof(struct ggml_tensor *));
sched->is_reset = true;
}
sched->is_alloc = false;
} | O3 | cpp | ggml_backend_sched_reset:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x26711
leaq 0x110(%rbx), %rdi
callq 0x171d0
movq 0x110(%rbx), %rdx
movq 0x128(%rbx), %rdi
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x168f0
movq 0x130(%rbx), %rdi
movslq 0x4(%rbx), %rdx
movslq 0x1b8(%rbx), %rax
imulq 0x110(%rbx), %rdx
imulq %rax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x168f0
movb $0x1, (%rbx)
movb $0x0, 0x1(%rbx)
popq %rbx
retq
| ggml_backend_sched_reset:
push rbx
mov rbx, rdi
cmp byte ptr [rdi], 0
jnz short loc_26711
lea rdi, [rbx+110h]
call _ggml_hash_set_reset
mov rdx, [rbx+110h]
mov rdi, [rbx+128h]
shl rdx, 2
mov esi, 0FFh
call _memset
mov rdi, [rbx+130h]
movsxd rdx, dword ptr [rbx+4]
movsxd rax, dword ptr [rbx+1B8h]
imul rdx, [rbx+110h]
imul rdx, rax
shl rdx, 3
xor esi, esi
call _memset
mov byte ptr [rbx], 1
loc_26711:
mov byte ptr [rbx+1], 0
pop rbx
retn
| long long ggml_backend_sched_reset(long long a1)
{
long long result; // rax
if ( !*(_BYTE *)a1 )
{
ggml_hash_set_reset((_QWORD *)(a1 + 272));
memset(*(_QWORD *)(a1 + 296), 255LL, 4LL * *(_QWORD *)(a1 + 272));
result = memset(*(_QWORD *)(a1 + 304), 0LL, 8 * *(int *)(a1 + 440) * *(_QWORD *)(a1 + 272) * *(int *)(a1 + 4));
*(_BYTE *)a1 = 1;
}
*(_BYTE *)(a1 + 1) = 0;
return result;
}
| ggml_backend_sched_reset:
PUSH RBX
MOV RBX,RDI
CMP byte ptr [RDI],0x0
JNZ 0x00126711
LEA RDI,[RBX + 0x110]
CALL 0x001171d0
MOV RDX,qword ptr [RBX + 0x110]
MOV RDI,qword ptr [RBX + 0x128]
SHL RDX,0x2
MOV ESI,0xff
CALL 0x001168f0
MOV RDI,qword ptr [RBX + 0x130]
MOVSXD RDX,dword ptr [RBX + 0x4]
MOVSXD RAX,dword ptr [RBX + 0x1b8]
IMUL RDX,qword ptr [RBX + 0x110]
IMUL RDX,RAX
SHL RDX,0x3
XOR ESI,ESI
CALL 0x001168f0
MOV byte ptr [RBX],0x1
LAB_00126711:
MOV byte ptr [RBX + 0x1],0x0
POP RBX
RET
|
void ggml_backend_sched_reset(char *param_1)
{
if (*param_1 == '\0') {
ggml_hash_set_reset(param_1 + 0x110);
memset(*(void **)(param_1 + 0x128),0xff,*(long *)(param_1 + 0x110) << 2);
memset(*(void **)(param_1 + 0x130),0,
(long)*(int *)(param_1 + 4) * *(long *)(param_1 + 0x110) *
(long)*(int *)(param_1 + 0x1b8) * 8);
*param_1 = '\x01';
}
param_1[1] = '\0';
return;
}
| |
43,384 | uf_space_endspace_selected | eloqsql/storage/myisam/mi_packrec.c | static void uf_space_endspace_selected(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 (get_bit(bit_buff))
{
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,' ');
}
else
decode_bytes(rec,bit_buff,to,end);
}
} | O0 | c | uf_space_endspace_selected:
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 0xbc537
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 0xbc55b
jmp 0xbc579
movq -0x10(%rbp), %rdi
callq 0xbb970
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbc579
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x2a2b0
jmp 0xbc6b7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbc5ab
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 0xbc5d3
jmp 0xbc6a0
movq -0x10(%rbp), %rdi
callq 0xbb970
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbc6a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbc616
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 0x202012(%rip), %rcx # 0x2be620
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbc629
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xba120
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 0xbc64b
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbc6b7
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbc67e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
xorl %eax, %eax
subq %r8, %rax
addq %rax, %rcx
callq 0xbc080
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2b0
jmp 0xbc6b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xbc080
jmp 0xbc6b7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| uf_space_endspace_selected_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_BC537
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_BC55B
jmp short loc_BC579
loc_BC537:
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_BC579
loc_BC55B:
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_BC6B7
loc_BC579:
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BC5AB
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_BC5D3
jmp loc_BC6A0
loc_BC5AB:
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 loc_BC6A0
loc_BC5D3:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BC616
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_BC629
loc_BC616:
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_BC629:
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_BC64B
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BC6B7
loc_BC64B:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BC67E
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
xor eax, eax
sub rax, r8
add rcx, rax
call decode_bytes_0
loc_BC67E:
mov rdi, [rbp+var_20]
mov eax, [rbp+var_24]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
jmp short loc_BC6B5
loc_BC6A0:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BC6B5:
jmp short $+2
loc_BC6B7:
add rsp, 30h
pop rbp
retn
| long long uf_space_endspace_selected_0(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
int v7; // eax
int v8; // ecx
unsigned int v9; // eax
int v10; // ecx
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( !a2[1] )
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
goto LABEL_6;
return memset(a3, 32LL, a4 - a3);
}
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) != 0 )
return memset(a3, 32LL, a4 - a3);
LABEL_6:
if ( a2[1] )
{
v7 = *a2;
v8 = a2[1] - 1;
a2[1] = v8;
if ( ((1 << v8) & v7) == 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
if ( *a2 >= 0 )
return decode_bytes_0(a1, (long long)a2, a3, a4);
}
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v9 = *a2;
v10 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v10;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v9 >> v10);
}
if ( &a3[bits_0] <= a4 )
{
if ( &a3[bits_0] != a4 )
decode_bytes_0(a1, (long long)a2, a3, &a4[-bits_0]);
return memset(&a4[-bits_0], 32LL, bits_0);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_space_endspace_selected:
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 0x001bc537
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 0x001bc55b
JMP 0x001bc579
LAB_001bc537:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bb970
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 0x001bc579
LAB_001bc55b:
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 0x0012a2b0
JMP 0x001bc6b7
LAB_001bc579:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bc5ab
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 0x001bc5d3
JMP 0x001bc6a0
LAB_001bc5ab:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bb970
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 0x001bc6a0
LAB_001bc5d3:
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 0x001bc616
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,[0x3be620]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bc629
LAB_001bc616:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001ba120
MOV dword ptr [RBP + -0x28],EAX
LAB_001bc629:
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 0x001bc64b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bc6b7
LAB_001bc64b:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bc67e
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
XOR EAX,EAX
SUB RAX,R8
ADD RCX,RAX
CALL 0x001bc080
LAB_001bc67e:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2b0
JMP 0x001bc6b5
LAB_001bc6a0:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bc080
LAB_001bc6b5:
JMP 0x001bc6b7
LAB_001bc6b7:
ADD RSP,0x30
POP RBP
RET
|
void uf_space_endspace_selected(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] == 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) {
decode_bytes(param_1,param_2,param_3,param_4);
}
else {
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 {
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 - local_30);
}
memset((void *)(param_4 - local_30),0x20,(ulong)local_30);
}
}
}
else {
memset(param_3,0x20,param_4 - (long)param_3);
}
return;
}
| |
43,385 | bitmap_is_prefix | eloqsql/mysys/my_bitmap.c | my_bool bitmap_is_prefix(const MY_BITMAP *map, uint prefix_size)
{
uint prefix_mask= last_byte_mask(prefix_size);
uchar *m= (uchar*) map->bitmap;
uchar *end_prefix= m+(prefix_size-1)/8;
uchar *end;
DBUG_ASSERT(m);
DBUG_ASSERT(prefix_size <= map->n_bits);
/* Empty prefix is always true */
if (!prefix_size)
return 1;
while (m < end_prefix)
if (*m++ != 0xff)
return 0;
end= ((uchar*) map->bitmap) + no_bytes_in_map(map) - 1;
if (m == end)
return ((*m & last_byte_mask(map->n_bits)) == prefix_mask);
if (*m != prefix_mask)
return 0;
while (++m < end)
if (*m != 0)
return 0;
return ((*m & last_byte_mask(map->n_bits)) == 0);
} | O0 | c | bitmap_is_prefix:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xf1640
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0xf1530
jmp 0xf1532
jmp 0xf1534
cmpl $0x0, -0x14(%rbp)
jne 0xf1543
movb $0x1, -0x1(%rbp)
jmp 0xf1636
jmp 0xf1545
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xf1573
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xf1571
movb $0x0, -0x1(%rbp)
jmp 0xf1636
jmp 0xf1545
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xf15ce
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0xf1640
movb %al, %cl
movl -0x34(%rbp), %eax
movzbl %cl, %ecx
andl %ecx, %eax
cmpl -0x18(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0xf1636
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x18(%rbp), %eax
je 0xf15e0
movb $0x0, -0x1(%rbp)
jmp 0xf1636
jmp 0xf15e2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq -0x30(%rbp), %rax
jae 0xf1608
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xf1606
movb $0x0, -0x1(%rbp)
jmp 0xf1636
jmp 0xf15e2
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0xf1640
movb %al, %cl
movl -0x38(%rbp), %eax
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nop
| bitmap_is_prefix:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov edi, [rbp+var_14]
call last_byte_mask
movzx eax, al
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
sub ecx, 1
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short $+2
loc_F1530:
jmp short $+2
loc_F1532:
jmp short $+2
loc_F1534:
cmp [rbp+var_14], 0
jnz short loc_F1543
mov [rbp+var_1], 1
jmp loc_F1636
loc_F1543:
jmp short $+2
loc_F1545:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb short loc_F1573
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_F1571
mov [rbp+var_1], 0
jmp loc_F1636
loc_F1571:
jmp short loc_F1545
loc_F1573:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov ecx, [rcx+1Ch]
add ecx, 7
shr ecx, 3
mov ecx, ecx
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnz short loc_F15CE
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_34], eax
mov rax, [rbp+var_10]
mov edi, [rax+1Ch]
call last_byte_mask
mov cl, al
mov eax, [rbp+var_34]
movzx ecx, cl
and eax, ecx
cmp eax, [rbp+var_18]
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp short loc_F1636
loc_F15CE:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, [rbp+var_18]
jz short loc_F15E0
mov [rbp+var_1], 0
jmp short loc_F1636
loc_F15E0:
jmp short $+2
loc_F15E2:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
cmp rax, [rbp+var_30]
jnb short loc_F1608
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0
jz short loc_F1606
mov [rbp+var_1], 0
jmp short loc_F1636
loc_F1606:
jmp short loc_F15E2
loc_F1608:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov edi, [rax+1Ch]
call last_byte_mask
mov cl, al
mov eax, [rbp+var_38]
movzx ecx, cl
and eax, ecx
cmp eax, 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_F1636:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char bitmap_is_prefix(unsigned __int8 **a1, unsigned int a2)
{
unsigned __int8 *v2; // rax
unsigned __int8 v4; // [rsp+8h] [rbp-38h]
unsigned __int8 v5; // [rsp+Ch] [rbp-34h]
unsigned long long v6; // [rsp+10h] [rbp-30h]
unsigned __int8 *v7; // [rsp+20h] [rbp-20h]
int byte_mask; // [rsp+28h] [rbp-18h]
byte_mask = (unsigned __int8)last_byte_mask(a2);
v7 = *a1;
if ( !a2 )
return 1;
while ( v7 < &(*a1)[(a2 - 1) >> 3] )
{
v2 = v7++;
if ( *v2 != 255 )
return 0;
}
v6 = (unsigned long long)&(*a1)[((unsigned int)(*((_DWORD *)a1 + 7) + 7) >> 3) - 1];
if ( v7 == (unsigned __int8 *)v6 )
{
v5 = *v7;
return (unsigned __int8)(last_byte_mask(*((unsigned int *)a1 + 7)) & v5) == byte_mask;
}
else if ( *v7 == byte_mask )
{
while ( (unsigned long long)++v7 < v6 )
{
if ( *v7 )
return 0;
}
v4 = *v7;
return (unsigned __int8)(last_byte_mask(*((unsigned int *)a1 + 7)) & v4) == 0;
}
else
{
return 0;
}
}
| bitmap_is_prefix:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x001f1640
MOVZX EAX,AL
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x14]
SUB ECX,0x1
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001f1530
LAB_001f1530:
JMP 0x001f1532
LAB_001f1532:
JMP 0x001f1534
LAB_001f1534:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001f1543
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001f1636
LAB_001f1543:
JMP 0x001f1545
LAB_001f1545:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x001f1573
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x001f1571
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001f1636
LAB_001f1571:
JMP 0x001f1545
LAB_001f1573:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x1c]
ADD ECX,0x7
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001f15ce
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x1c]
CALL 0x001f1640
MOV CL,AL
MOV EAX,dword ptr [RBP + -0x34]
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,dword ptr [RBP + -0x18]
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x001f1636
LAB_001f15ce:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x18]
JZ 0x001f15e0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001f1636
LAB_001f15e0:
JMP 0x001f15e2
LAB_001f15e2:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001f1608
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001f1606
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001f1636
LAB_001f1606:
JMP 0x001f15e2
LAB_001f1608:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x1c]
CALL 0x001f1640
MOV CL,AL
MOV EAX,dword ptr [RBP + -0x38]
MOVZX ECX,CL
AND EAX,ECX
CMP EAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_001f1636:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int8 bitmap_is_prefix(long *param_1,int param_2)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte *pbVar4;
byte *pbVar5;
byte *local_28;
bool local_9;
bVar1 = last_byte_mask(param_2);
pbVar4 = (byte *)*param_1 + (param_2 - 1U >> 3);
local_28 = (byte *)*param_1;
if (param_2 == 0) {
local_9 = true;
pbVar5 = pbVar4;
}
else {
do {
if (pbVar4 <= local_28) {
pbVar4 = (byte *)(*param_1 + (ulong)(*(int *)((long)param_1 + 0x1c) + 7U >> 3) + -1);
if (local_28 == pbVar4) {
bVar3 = *local_28;
bVar2 = last_byte_mask(*(int4 *)((long)param_1 + 0x1c));
local_9 = (bVar3 & bVar2) == bVar1;
pbVar5 = (byte *)0x0;
goto LAB_001f1636;
}
pbVar5 = (byte *)0x0;
if (*local_28 == bVar1) goto LAB_001f15e2;
local_9 = false;
goto LAB_001f1636;
}
bVar3 = *local_28;
pbVar5 = (byte *)0x0;
local_28 = local_28 + 1;
} while (bVar3 == 0xff);
local_9 = false;
}
goto LAB_001f1636;
while (pbVar5 = (byte *)0x0, *local_28 == 0) {
LAB_001f15e2:
local_28 = local_28 + 1;
if (pbVar4 <= local_28) {
bVar1 = *local_28;
bVar3 = last_byte_mask(*(int4 *)((long)param_1 + 0x1c));
local_9 = (bVar1 & bVar3) == 0;
pbVar5 = (byte *)0x0;
goto LAB_001f1636;
}
}
local_9 = false;
LAB_001f1636:
return CONCAT71((int7)((ulong)pbVar5 >> 8),local_9);
}
| |
43,386 | process_dbl_arg | eloqsql/strings/my_vsnprintf.c | static char *process_dbl_arg(char *to, char *end, size_t width,
double par, char arg_type)
{
if (width == MAX_WIDTH)
width= FLT_DIG; /* width not set, use default */
else if (width >= FLOATING_POINT_DECIMALS)
width= FLOATING_POINT_DECIMALS - 1; /* max.precision for my_fcvt() */
width= MY_MIN(width, (size_t)(end-to) - 1);
if (arg_type == 'f')
to+= my_fcvt(par, (int)width , to, NULL);
else
to+= my_gcvt(par, MY_GCVT_ARG_DOUBLE, (int) width , to, NULL);
return to;
} | O3 | c | process_dbl_arg:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x1e, %rdx
movl $0x1e, %eax
cmovbq %rdx, %rax
cmpq $0xffff, %rdx # imm = 0xFFFF
movl $0x6, %edx
cmovneq %rax, %rdx
movq %rdi, %rbx
movq %rdi, %rax
notq %rax
addq %rsi, %rax
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpb $0x66, %cl
jne 0xd6aa0
movl %eax, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd202c
jmp 0xd6ab1
movl $0x1, %edi
movl %eax, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xd33ae
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| process_dbl_arg:
push rbp
mov rbp, rsp
push rbx
push rax
cmp rdx, 1Eh
mov eax, 1Eh
cmovb rax, rdx
cmp rdx, 0FFFFh
mov edx, 6
cmovnz rdx, rax
mov rbx, rdi
mov rax, rdi
not rax
add rax, rsi
cmp rdx, rax
cmovb rax, rdx
cmp cl, 66h ; 'f'
jnz short loc_D6AA0
mov edi, eax
mov rsi, rbx
xor edx, edx
call my_fcvt
jmp short loc_D6AB1
loc_D6AA0:
mov edi, 1
mov esi, eax
mov rdx, rbx
xor ecx, ecx
call my_gcvt
loc_D6AB1:
add rbx, rax
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn
| char * process_dbl_arg(unsigned long long a1, long long a2, unsigned long long a3, char a4, double a5)
{
long long v5; // rax
bool v6; // zf
unsigned long long v7; // rdx
unsigned long long v8; // rax
long long v9; // rax
v5 = 30LL;
if ( a3 < 0x1E )
v5 = a3;
v6 = a3 == 0xFFFF;
v7 = 6LL;
if ( !v6 )
v7 = v5;
v8 = a2 + ~a1;
if ( v7 < v8 )
LODWORD(v8) = v7;
if ( a4 == 102 )
v9 = (long long)my_fcvt(v8, (_WORD *)a1, 0LL);
else
v9 = my_gcvt(1, v8, (_WORD *)a1, 0LL, a5);
return (char *)(v9 + a1);
}
| process_dbl_arg:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP RDX,0x1e
MOV EAX,0x1e
CMOVC RAX,RDX
CMP RDX,0xffff
MOV EDX,0x6
CMOVNZ RDX,RAX
MOV RBX,RDI
MOV RAX,RDI
NOT RAX
ADD RAX,RSI
CMP RDX,RAX
CMOVC RAX,RDX
CMP CL,0x66
JNZ 0x001d6aa0
MOV EDI,EAX
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001d202c
JMP 0x001d6ab1
LAB_001d6aa0:
MOV EDI,0x1
MOV ESI,EAX
MOV RDX,RBX
XOR ECX,ECX
CALL 0x001d33ae
LAB_001d6ab1:
ADD RBX,RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long process_dbl_arg(ulong param_1,long param_2,ulong param_3,char param_4)
{
ulong uVar1;
long lVar2;
ulong uVar3;
uVar1 = 0x1e;
if (param_3 < 0x1e) {
uVar1 = param_3;
}
uVar3 = 6;
if (param_3 != 0xffff) {
uVar3 = uVar1;
}
uVar1 = ~param_1 + param_2;
if (uVar3 < ~param_1 + param_2) {
uVar1 = uVar3;
}
if (param_4 == 'f') {
lVar2 = my_fcvt(uVar1 & 0xffffffff,param_1,0);
}
else {
lVar2 = my_gcvt(1,uVar1 & 0xffffffff,param_1,0);
}
return param_1 + lVar2;
}
| |
43,387 | strmake_root | eloqsql/mysys/my_alloc.c | char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
{
char *pos;
if ((pos=alloc_root(root,len+1)))
{
if (len)
memcpy(pos,str,len);
pos[len]=0;
}
return pos;
} | O0 | c | strmake_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x6a660
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6af63
cmpq $0x0, -0x18(%rbp)
je 0x6af57
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x26280
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| strmake_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
add rsi, 1
call alloc_root
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_6AF63
cmp [rbp+var_18], 0
jz short loc_6AF57
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
loc_6AF57:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_6AF63:
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| char * strmake_root(_QWORD **a1, long long a2, long long a3)
{
char *v4; // [rsp+0h] [rbp-20h]
v4 = alloc_root(a1, a3 + 1);
if ( v4 )
{
if ( a3 )
memcpy(v4, a2, a3);
v4[a3] = 0;
}
return v4;
}
| strmake_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
CALL 0x0016a660
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0016af63
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0016af57
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00126280
LAB_0016af57:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0016af63:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
void * strmake_root(int8 param_1,void *param_2,size_t param_3)
{
void *__dest;
__dest = (void *)alloc_root(param_1,param_3 + 1);
if (__dest != (void *)0x0) {
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
43,388 | strmake_root | eloqsql/mysys/my_alloc.c | char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
{
char *pos;
if ((pos=alloc_root(root,len+1)))
{
if (len)
memcpy(pos,str,len);
pos[len]=0;
}
return pos;
} | O3 | c | strmake_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1(%rdx), %rsi
callq 0x4f3ab
movq %rax, %r15
testq %rax, %rax
je 0x4f7a6
testq %rbx, %rbx
je 0x4f7a1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x26290
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| strmake_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
lea rsi, [rdx+1]
call alloc_root
mov r15, rax
test rax, rax
jz short loc_4F7A6
test rbx, rbx
jz short loc_4F7A1
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _memcpy
loc_4F7A1:
mov byte ptr [r15+rbx], 0
loc_4F7A6:
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char * strmake_root(long long a1, long long a2, long long a3)
{
char *v4; // rax
char *v5; // r15
v4 = alloc_root(a1, a3 + 1);
v5 = v4;
if ( v4 )
{
if ( a3 )
memcpy(v4, a2, a3);
v5[a3] = 0;
}
return v5;
}
| strmake_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
LEA RSI,[RDX + 0x1]
CALL 0x0014f3ab
MOV R15,RAX
TEST RAX,RAX
JZ 0x0014f7a6
TEST RBX,RBX
JZ 0x0014f7a1
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00126290
LAB_0014f7a1:
MOV byte ptr [R15 + RBX*0x1],0x0
LAB_0014f7a6:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * strmake_root(int8 param_1,void *param_2,size_t param_3)
{
void *__dest;
__dest = (void *)alloc_root(param_1,param_3 + 1);
if (__dest != (void *)0x0) {
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
43,389 | my_convert_fix | eloqsql/strings/ctype.c | size_t
my_convert_fix(CHARSET_INFO *to_cs, char *to, size_t to_length,
CHARSET_INFO *from_cs, const char *from, size_t from_length,
size_t nchars,
MY_STRCOPY_STATUS *copy_status,
MY_STRCONV_STATUS *conv_status)
{
int cnvres;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
const uchar *from_end= (const uchar*) from + from_length;
uchar *to_end= (uchar*) to + to_length;
char *to_start= to;
DBUG_ASSERT(to_cs != &my_charset_bin);
DBUG_ASSERT(from_cs != &my_charset_bin);
copy_status->m_well_formed_error_pos= NULL;
conv_status->m_cannot_convert_error_pos= NULL;
for ( ; nchars; nchars--)
{
const char *from_prev= from;
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
if (!copy_status->m_well_formed_error_pos)
copy_status->m_well_formed_error_pos= from;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
if (!conv_status->m_cannot_convert_error_pos)
conv_status->m_cannot_convert_error_pos= from;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; // End of line
// Incomplete byte sequence
if (!copy_status->m_well_formed_error_pos)
copy_status->m_well_formed_error_pos= from;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
if (!conv_status->m_cannot_convert_error_pos)
conv_status->m_cannot_convert_error_pos= from_prev;
wc= '?';
goto outp;
}
else
{
from= from_prev;
break;
}
}
copy_status->m_source_end_pos= from;
return to - to_start;
} | O3 | c | my_convert_fix:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rdx, %r12
movq %rdi, %r13
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rdx
movq 0x10(%rbp), %r8
movq %rcx, -0x60(%rbp)
movq 0xb8(%rcx), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq 0xb8(%r13), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movq %rax, (%rdi)
testq %r8, %r8
movq %rsi, -0x48(%rbp)
je 0xd1eef
movq %r8, -0x50(%rbp)
addq %r14, %r9
movq %r9, -0x38(%rbp)
addq %rsi, %r12
movq %rsi, %rbx
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
callq *-0x58(%rbp)
movl %eax, %r15d
testl %eax, %eax
jle 0xd1e67
movl %r15d, %r15d
addq %r14, %r15
movq -0x30(%rbp), %rsi
jmp 0xd1e9f
je 0xd1e8a
cmpl $-0x64, %r15d
jb 0xd1e84
movq 0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd1e7c
movq %r14, (%rax)
negl %r15d
addq %r14, %r15
jmp 0xd1ec7
cmpq -0x38(%rbp), %r14
jae 0xd1eea
movq 0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd1e99
movq %r14, 0x8(%rax)
leaq 0x1(%r14), %r15
jmp 0xd1ec7
movq %r13, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq *-0x40(%rbp)
testl %eax, %eax
jg 0xd1ed6
testl %eax, %eax
jne 0xd1eea
cmpq $0x3f, -0x30(%rbp)
je 0xd1eea
movq 0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd1ec7
movq %r14, (%rax)
movq $0x3f, -0x30(%rbp)
movl $0x3f, %esi
jmp 0xd1e9f
movl %eax, %eax
addq %rax, %rbx
movq %r15, %r14
decq -0x50(%rbp)
jne 0xd1e42
jmp 0xd1ef5
movq %r14, %r15
jmp 0xd1ef5
movq %r14, %r15
movq %rsi, %rbx
movq 0x18(%rbp), %rax
movq %r15, (%rax)
subq -0x48(%rbp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_convert_fix:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, r8
mov r12, rdx
mov r13, rdi
mov rdi, [rbp+arg_10]
mov rdx, [rbp+arg_8]
mov r8, [rbp+arg_0]
mov [rbp+var_60], rcx
mov rax, [rcx+0B8h]
mov rax, [rax+28h]
mov [rbp+var_58], rax
mov rax, [r13+0B8h]
mov rax, [rax+30h]
mov [rbp+var_40], rax
xor eax, eax
mov [rdx+8], rax
mov [rdi], rax
test r8, r8
mov [rbp+var_48], rsi
jz loc_D1EEF
mov [rbp+var_50], r8
add r9, r14
mov [rbp+var_38], r9
add r12, rsi
mov rbx, rsi
loc_D1E42:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_30]
mov rdx, r14
mov rcx, [rbp+var_38]
call [rbp+var_58]
mov r15d, eax
test eax, eax
jle short loc_D1E67
mov r15d, r15d
add r15, r14
mov rsi, [rbp+var_30]
jmp short loc_D1E9F
loc_D1E67:
jz short loc_D1E8A
cmp r15d, 0FFFFFF9Ch
jb short loc_D1E84
mov rax, [rbp+arg_10]
cmp qword ptr [rax], 0
jnz short loc_D1E7C
mov [rax], r14
loc_D1E7C:
neg r15d
add r15, r14
jmp short loc_D1EC7
loc_D1E84:
cmp r14, [rbp+var_38]
jnb short loc_D1EEA
loc_D1E8A:
mov rax, [rbp+arg_8]
cmp qword ptr [rax+8], 0
jnz short loc_D1E99
mov [rax+8], r14
loc_D1E99:
lea r15, [r14+1]
jmp short loc_D1EC7
loc_D1E9F:
mov rdi, r13
mov rdx, rbx
mov rcx, r12
call [rbp+var_40]
test eax, eax
jg short loc_D1ED6
test eax, eax
jnz short loc_D1EEA
cmp [rbp+var_30], 3Fh ; '?'
jz short loc_D1EEA
mov rax, [rbp+arg_10]
cmp qword ptr [rax], 0
jnz short loc_D1EC7
mov [rax], r14
loc_D1EC7:
mov [rbp+var_30], 3Fh ; '?'
mov esi, 3Fh ; '?'
jmp short loc_D1E9F
loc_D1ED6:
mov eax, eax
add rbx, rax
mov r14, r15
dec [rbp+var_50]
jnz loc_D1E42
jmp short loc_D1EF5
loc_D1EEA:
mov r15, r14
jmp short loc_D1EF5
loc_D1EEF:
mov r15, r14
mov rbx, rsi
loc_D1EF5:
mov rax, [rbp+arg_8]
mov [rax], r15
sub rbx, [rbp+var_48]
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_convert_fix(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
long long a6,
long long a7,
unsigned long long *a8,
unsigned long long *a9)
{
unsigned long long v9; // r14
long long v10; // r12
long long v11; // rbx
int v12; // eax
unsigned long long v13; // r15
long long v14; // rsi
int v15; // eax
long long ( *v18)(long long, long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
long long v19; // [rsp+10h] [rbp-50h]
long long ( *v21)(long long, long long, long long, long long); // [rsp+20h] [rbp-40h]
unsigned long long v22; // [rsp+28h] [rbp-38h]
long long v23[6]; // [rsp+30h] [rbp-30h] BYREF
v9 = a5;
v18 = *(long long ( **)(long long, long long *, unsigned long long, unsigned long long))(*(_QWORD *)(a4 + 184) + 40LL);
v21 = *(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL);
a8[1] = 0LL;
*a9 = 0LL;
if ( a7 )
{
v19 = a7;
v22 = a5 + a6;
v10 = a2 + a3;
v11 = a2;
while ( 1 )
{
v12 = v18(a4, v23, v9, v22);
if ( v12 > 0 )
{
v13 = v9 + (unsigned int)v12;
v14 = v23[0];
goto LABEL_14;
}
if ( !v12 )
goto LABEL_11;
if ( (unsigned int)v12 < 0xFFFFFF9C )
break;
if ( !*a9 )
*a9 = v9;
v13 = v9 + (unsigned int)-v12;
LABEL_19:
while ( 1 )
{
v23[0] = 63LL;
v14 = 63LL;
LABEL_14:
v15 = v21(a1, v14, v11, v10);
if ( v15 > 0 )
break;
if ( v15 || v23[0] == 63 )
goto LABEL_22;
if ( !*a9 )
*a9 = v9;
}
v11 += (unsigned int)v15;
v9 = v13;
if ( !--v19 )
goto LABEL_24;
}
if ( v9 < v22 )
{
LABEL_11:
if ( !a8[1] )
a8[1] = v9;
v13 = v9 + 1;
goto LABEL_19;
}
LABEL_22:
v13 = v9;
}
else
{
v13 = a5;
v11 = a2;
}
LABEL_24:
*a8 = v13;
return v11 - a2;
}
| my_convert_fix:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,R8
MOV R12,RDX
MOV R13,RDI
MOV RDI,qword ptr [RBP + 0x20]
MOV RDX,qword ptr [RBP + 0x18]
MOV R8,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x60],RCX
MOV RAX,qword ptr [RCX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [R13 + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x40],RAX
XOR EAX,EAX
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RDI],RAX
TEST R8,R8
MOV qword ptr [RBP + -0x48],RSI
JZ 0x001d1eef
MOV qword ptr [RBP + -0x50],R8
ADD R9,R14
MOV qword ptr [RBP + -0x38],R9
ADD R12,RSI
MOV RBX,RSI
LAB_001d1e42:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x30]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x58]
MOV R15D,EAX
TEST EAX,EAX
JLE 0x001d1e67
MOV R15D,R15D
ADD R15,R14
MOV RSI,qword ptr [RBP + -0x30]
JMP 0x001d1e9f
LAB_001d1e67:
JZ 0x001d1e8a
CMP R15D,-0x64
JC 0x001d1e84
MOV RAX,qword ptr [RBP + 0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001d1e7c
MOV qword ptr [RAX],R14
LAB_001d1e7c:
NEG R15D
ADD R15,R14
JMP 0x001d1ec7
LAB_001d1e84:
CMP R14,qword ptr [RBP + -0x38]
JNC 0x001d1eea
LAB_001d1e8a:
MOV RAX,qword ptr [RBP + 0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x001d1e99
MOV qword ptr [RAX + 0x8],R14
LAB_001d1e99:
LEA R15,[R14 + 0x1]
JMP 0x001d1ec7
LAB_001d1e9f:
MOV RDI,R13
MOV RDX,RBX
MOV RCX,R12
CALL qword ptr [RBP + -0x40]
TEST EAX,EAX
JG 0x001d1ed6
TEST EAX,EAX
JNZ 0x001d1eea
CMP qword ptr [RBP + -0x30],0x3f
JZ 0x001d1eea
MOV RAX,qword ptr [RBP + 0x20]
CMP qword ptr [RAX],0x0
JNZ 0x001d1ec7
MOV qword ptr [RAX],R14
LAB_001d1ec7:
MOV qword ptr [RBP + -0x30],0x3f
MOV ESI,0x3f
JMP 0x001d1e9f
LAB_001d1ed6:
MOV EAX,EAX
ADD RBX,RAX
MOV R14,R15
DEC qword ptr [RBP + -0x50]
JNZ 0x001d1e42
JMP 0x001d1ef5
LAB_001d1eea:
MOV R15,R14
JMP 0x001d1ef5
LAB_001d1eef:
MOV R15,R14
MOV RBX,RSI
LAB_001d1ef5:
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RAX],R15
SUB RBX,qword ptr [RBP + -0x48]
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_convert_fix(long param_1,long param_2,long param_3,long param_4,ulong param_5,long param_6,
long param_7,ulong *param_8,ulong *param_9)
{
code *pcVar1;
code *pcVar2;
uint uVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
long local_58;
long local_38;
pcVar1 = *(code **)(*(long *)(param_4 + 0xb8) + 0x28);
pcVar2 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
param_8[1] = 0;
*param_9 = 0;
lVar4 = param_2;
uVar5 = param_5;
if (param_7 != 0) {
local_58 = param_7;
while( true ) {
uVar3 = (*pcVar1)(param_4,&local_38,uVar5,param_6 + param_5);
if ((int)uVar3 < 1) break;
uVar6 = uVar3 + uVar5;
while (uVar3 = (*pcVar2)(param_1,local_38,lVar4,param_3 + param_2), (int)uVar3 < 1) {
if ((uVar3 != 0) || (local_38 == 0x3f)) goto LAB_001d1ef5;
if (*param_9 == 0) {
*param_9 = uVar5;
}
LAB_001d1ec7:
local_38 = 0x3f;
}
lVar4 = lVar4 + (ulong)uVar3;
local_58 = local_58 + -1;
uVar5 = uVar6;
if (local_58 == 0) goto LAB_001d1ef5;
}
if (uVar3 != 0) {
if (0xffffff9b < uVar3) {
if (*param_9 == 0) {
*param_9 = uVar5;
}
uVar6 = -uVar3 + uVar5;
goto LAB_001d1ec7;
}
if (param_6 + param_5 <= uVar5) goto LAB_001d1ef5;
}
if (param_8[1] == 0) {
param_8[1] = uVar5;
}
uVar6 = uVar5 + 1;
goto LAB_001d1ec7;
}
LAB_001d1ef5:
*param_8 = uVar5;
return lVar4 - param_2;
}
| |
43,390 | testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
return user_msg_string;
}
return gtest_msg + "\n" + user_msg_string;
} | O1 | cpp | testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1cfc7
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x194c0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x194db
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
addq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rdx
callq 0x39594
leaq 0x29e59(%rip), %rsi # 0x432dd
movq %rsp, %rdi
callq 0x8a50
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0x8170
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x194f4
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x194fa
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x39594
jmp 0x19527
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x39594
jmp 0x19527
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19527
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19542
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19551
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19571
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x19571
jmp 0x1956e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1958c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
movq %rbx, %rdi
callq 0x8990
| _ZN7testing8internal17AppendUserMessageERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS_7MessageE:
push r15
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
mov rsi, [rdx]
lea r15, [rsp+58h+var_38]
mov rdi, r15
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
mov rdx, [r15+8]
test rdx, rdx
jz short loc_194C0
mov rax, [r14+8]
test rax, rax
jz short loc_194DB
lea r15, [rsp+58h+var_48]
mov [r15-10h], r15
mov rsi, [r14]
add rax, rsi
mov rdi, rsp
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aSFromSSMsTotal+19h; "\n"
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rdx, [rbx+10h]
mov [rbx], rdx
mov rsi, [rax]
mov rcx, rax
add rcx, 10h
cmp rsi, rcx
jz short loc_194F4
mov [rbx], rsi
mov rdx, [rcx]
mov [rbx+10h], rdx
jmp short loc_194FA
loc_194C0:
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_19527
loc_194DB:
lea rax, [rbx+10h]
mov [rbx], rax
mov rsi, [rsp+58h+var_38]
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_19527
loc_194F4:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
loc_194FA:
mov rdx, [rax+8]
mov [rbx+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r15
jz short loc_19527
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19527:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_19542
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_19542:
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_19551:
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_19571
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_19571
jmp short $+2
loc_1956E:
mov rbx, rax
loc_19571:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1958C
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1958C:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::AppendUserMessage(long long a1, _QWORD *a2, _QWORD *a3, int a4, int a5, int a6)
{
long long v6; // rdx
long long v7; // rax
long long v8; // rax
_OWORD *v9; // rcx
void *v11[2]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v12[2]; // [rsp+10h] [rbp-48h] BYREF
char *v13; // [rsp+20h] [rbp-38h] BYREF
long long v14; // [rsp+28h] [rbp-30h]
long long v15; // [rsp+30h] [rbp-28h] BYREF
testing::internal::StringStreamToString((unsigned int)&v13, *a3, (_DWORD)a3, a4, a5, a6);
v6 = v14;
if ( v14 )
{
v7 = a2[1];
if ( v7 )
{
v11[0] = v12;
std::string::_M_construct<char *>(v11, *a2, *a2 + v7);
std::string::append(v11, "\n");
v8 = std::string::_M_append(v11, v13);
*(_QWORD *)a1 = a1 + 16;
v9 = (_OWORD *)(v8 + 16);
if ( *(_QWORD *)v8 == v8 + 16 )
{
*(_OWORD *)(a1 + 16) = *v9;
}
else
{
*(_QWORD *)a1 = *(_QWORD *)v8;
*(_QWORD *)(a1 + 16) = *(_QWORD *)v9;
}
*(_QWORD *)(a1 + 8) = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = v9;
*(_QWORD *)(v8 + 8) = 0LL;
*(_BYTE *)(v8 + 16) = 0;
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
}
else
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, v13, &v13[v6]);
}
}
else
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char *>(a1, *a2, *a2 + a2[1]);
}
if ( v13 != (char *)&v15 )
operator delete(v13, v15 + 1);
return a1;
}
| AppendUserMessage:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDX]
LEA R15,[RSP + 0x20]
MOV RDI,R15
CALL 0x0011cfc7
MOV RDX,qword ptr [R15 + 0x8]
TEST RDX,RDX
JZ 0x001194c0
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x001194db
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [R14]
ADD RAX,RSI
LAB_00119472:
MOV RDI,RSP
MOV RDX,RAX
CALL 0x00139594
LAB_0011947d:
LEA RSI,[0x1432dd]
MOV RDI,RSP
CALL 0x00108a50
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_00119496:
MOV RDI,RSP
CALL 0x00108170
LEA RDX,[RBX + 0x10]
MOV qword ptr [RBX],RDX
MOV RSI,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RSI,RCX
JZ 0x001194f4
MOV qword ptr [RBX],RSI
MOV RDX,qword ptr [RCX]
MOV qword ptr [RBX + 0x10],RDX
JMP 0x001194fa
LAB_001194c0:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LAB_001194d1:
MOV RDI,RBX
CALL 0x00139594
JMP 0x00119527
LAB_001194db:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [RSP + 0x20]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x00139594
LAB_001194f2:
JMP 0x00119527
LAB_001194f4:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
LAB_001194fa:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x00119527
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001084e0
LAB_00119527:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00119542
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001084e0
LAB_00119542:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::AppendUserMessage(std::__cxx11::string const&, testing::Message const&) */
string * testing::internal::AppendUserMessage(string *param_1,Message *param_2)
{
long lVar1;
long *plVar2;
long *plVar3;
long *local_58 [2];
long local_48 [2];
long *local_38;
long local_30;
long local_28 [2];
StringStreamToString((stringstream *)&local_38);
if (local_30 == 0) {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 001194d1 to 001194f1 has its CatchHandler @ 0011956e */
std::__cxx11::string::_M_construct<char*>
(param_1,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
}
else if (*(long *)(param_2 + 8) == 0) {
*(string **)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct<char*>(param_1,local_38,local_30 + (long)local_38);
}
else {
local_58[0] = local_48;
/* try { // try from 00119472 to 0011947c has its CatchHandler @ 0011956c */
std::__cxx11::string::_M_construct<char*>
(local_58,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
/* try { // try from 0011947d to 0011948b has its CatchHandler @ 00119551 */
std::__cxx11::string::append((char *)local_58);
/* try { // try from 00119496 to 0011949d has its CatchHandler @ 0011954f */
plVar2 = (long *)std::__cxx11::string::_M_append((char *)local_58,(ulong)local_38);
*(string **)param_1 = param_1 + 0x10;
plVar3 = plVar2 + 2;
if ((long *)*plVar2 == plVar3) {
lVar1 = plVar2[3];
*(long *)(param_1 + 0x10) = *plVar3;
*(long *)(param_1 + 0x18) = lVar1;
}
else {
*(long **)param_1 = (long *)*plVar2;
*(long *)(param_1 + 0x10) = *plVar3;
}
*(long *)(param_1 + 8) = plVar2[1];
*plVar2 = (long)plVar3;
plVar2[1] = 0;
*(int1 *)(plVar2 + 2) = 0;
if (local_58[0] != local_48) {
operator_delete(local_58[0],local_48[0] + 1);
}
}
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return param_1;
}
| |
43,391 | ma_dynstr_realloc | eloqsql/libmariadb/libmariadb/ma_string.c | my_bool ma_dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size)
{
if (!additional_size) return(FALSE);
if (str->length + additional_size > str->max_length)
{
str->max_length=((str->length + additional_size+str->alloc_increment-1)/
str->alloc_increment)*str->alloc_increment;
if (!(str->str=(char*) realloc(str->str,str->max_length)))
return(TRUE);
}
return(FALSE);
} | O0 | c | ma_dynstr_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4c30d
movb $0x0, -0x1(%rbp)
jmp 0x4c386
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x4c382
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x18(%rcx), %rax
subq $0x1, %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq %rax, %rcx
movq -0x10(%rbp), %rax
imulq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14710
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4c380
movb $0x1, -0x1(%rbp)
jmp 0x4c386
jmp 0x4c382
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
| ma_dynstr_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_18], 0
jnz short loc_4C30D
mov [rbp+var_1], 0
jmp short loc_4C386
loc_4C30D:
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jbe short loc_4C382
mov rax, [rbp+var_10]
mov rax, [rax+8]
add rax, [rbp+var_18]
mov rcx, [rbp+var_10]
add rax, [rcx+18h]
sub rax, 1
mov rcx, [rbp+var_10]
xor edx, edx
div qword ptr [rcx+18h]
mov rcx, rax
mov rax, [rbp+var_10]
imul rcx, [rax+18h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
call _realloc
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_4C380
mov [rbp+var_1], 1
jmp short loc_4C386
loc_4C380:
jmp short $+2
loc_4C382:
mov [rbp+var_1], 0
loc_4C386:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| bool ma_dynstr_realloc(long long *a1, long long a2)
{
long long v2; // rax
char v4; // [rsp+1Fh] [rbp-1h]
if ( a2 )
{
v4 = 0;
if ( a2 + a1[1] > (unsigned long long)a1[2] )
{
a1[2] = a1[3] * ((a1[3] + a2 + a1[1] - 1) / (unsigned long long)a1[3]);
v2 = realloc(*a1, a1[2]);
*a1 = v2;
if ( !v2 )
return 1;
}
}
else
{
return 0;
}
return v4;
}
| ma_dynstr_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0014c30d
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0014c386
LAB_0014c30d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JBE 0x0014c382
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0x18]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV qword ptr [RCX + 0x18]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00114710
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x0014c380
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014c386
LAB_0014c380:
JMP 0x0014c382
LAB_0014c382:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014c386:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 ma_dynstr_realloc(int8 *param_1,long param_2)
{
void *pvVar1;
if ((param_2 != 0) && ((ulong)param_1[2] < (ulong)(param_1[1] + param_2))) {
param_1[2] = (((param_1[1] + param_2 + param_1[3]) - 1U) / (ulong)param_1[3]) * param_1[3];
pvVar1 = realloc((void *)*param_1,param_1[2]);
*param_1 = pvVar1;
if (pvVar1 == (void *)0x0) {
return 1;
}
}
return 0;
}
| |
43,392 | my_caseup_str_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_caseup_str_utf8mb4(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->caseup_multiply == 1);
while (*src &&
(srcres= my_mb_wc_utf8mb4_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_toupper_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
*dst= '\0';
return (size_t) (dst - dst0);
} | O3 | c | my_caseup_str_utf8mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x0, (%rsi)
movq %rsi, %r14
je 0xd6e1b
movq 0x78(%rdi), %r15
movq %rbx, %r12
movq %rbx, %r14
leaq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0xda15f
testl %eax, %eax
je 0xd6e1b
movl %eax, %r13d
movq -0x30(%rbp), %rdi
cmpq (%r15), %rdi
ja 0xd6dfc
movq 0x8(%r15), %rax
movq %rdi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0xd6dfc
movzbl %dil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %edi
movq %rdi, -0x30(%rbp)
movq %r14, %rsi
callq 0xda27b
testl %eax, %eax
je 0xd6e1b
movl %r13d, %ecx
movl %eax, %eax
addq %rax, %r14
cmpb $0x0, (%r12,%rcx)
leaq (%r12,%rcx), %r12
jne 0xd6dbd
movb $0x0, (%r14)
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_caseup_str_utf8mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp byte ptr [rsi], 0
mov r14, rsi
jz short loc_D6E1B
mov r15, [rdi+78h]
mov r12, rbx
mov r14, rbx
loc_D6DBD:
lea rdi, [rbp+var_30]
mov rsi, r12
call my_mb_wc_utf8mb4_no_range
test eax, eax
jz short loc_D6E1B
mov r13d, eax
mov rdi, [rbp+var_30]
cmp rdi, [r15]
ja short loc_D6DFC
mov rax, [r15+8]
mov rcx, rdi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_D6DFC
movzx ecx, dil
lea rcx, [rcx+rcx*2]
mov edi, [rax+rcx*4]
mov [rbp+var_30], rdi
loc_D6DFC:
mov rsi, r14
call my_wc_mb_utf8mb4_no_range
test eax, eax
jz short loc_D6E1B
mov ecx, r13d
mov eax, eax
add r14, rax
cmp byte ptr [r12+rcx], 0
lea r12, [r12+rcx]
jnz short loc_D6DBD
loc_D6E1B:
mov byte ptr [r14], 0
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_caseup_str_utf8mb4(long long a1, _BYTE *a2)
{
long long v2; // rax
_BYTE *v3; // r14
_QWORD *v4; // r15
_BYTE *v5; // r12
unsigned int v6; // eax
unsigned int v7; // r13d
long long v8; // rdi
long long v9; // rax
unsigned int v10; // eax
bool v11; // zf
_QWORD v13[6]; // [rsp+0h] [rbp-30h] BYREF
v13[0] = v2;
v3 = a2;
if ( *a2 )
{
v4 = *(_QWORD **)(a1 + 120);
v5 = a2;
v3 = a2;
do
{
v6 = my_mb_wc_utf8mb4_no_range(v13, v5);
if ( !v6 )
break;
v7 = v6;
v8 = v13[0];
if ( v13[0] <= *v4 )
{
v9 = *(_QWORD *)(v4[1] + 8LL * (v13[0] >> 8));
if ( v9 )
{
v8 = *(unsigned int *)(v9 + 12LL * LOBYTE(v13[0]));
v13[0] = v8;
}
}
v10 = my_wc_mb_utf8mb4_no_range(v8, v3);
if ( !v10 )
break;
v3 += v10;
v11 = v5[v7] == 0;
v5 += v7;
}
while ( !v11 );
}
*v3 = 0;
return v3 - a2;
}
| my_caseup_str_utf8mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP byte ptr [RSI],0x0
MOV R14,RSI
JZ 0x001d6e1b
MOV R15,qword ptr [RDI + 0x78]
MOV R12,RBX
MOV R14,RBX
LAB_001d6dbd:
LEA RDI,[RBP + -0x30]
MOV RSI,R12
CALL 0x001da15f
TEST EAX,EAX
JZ 0x001d6e1b
MOV R13D,EAX
MOV RDI,qword ptr [RBP + -0x30]
CMP RDI,qword ptr [R15]
JA 0x001d6dfc
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,RDI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x001d6dfc
MOVZX ECX,DIL
LEA RCX,[RCX + RCX*0x2]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x30],RDI
LAB_001d6dfc:
MOV RSI,R14
CALL 0x001da27b
TEST EAX,EAX
JZ 0x001d6e1b
MOV ECX,R13D
MOV EAX,EAX
ADD R14,RAX
CMP byte ptr [R12 + RCX*0x1],0x0
LEA R12,[R12 + RCX*0x1]
JNZ 0x001d6dbd
LAB_001d6e1b:
MOV byte ptr [R14],0x0
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_str_utf8mb4(long param_1,char *param_2)
{
char *pcVar1;
ulong *puVar2;
long lVar3;
uint uVar4;
uint uVar5;
ulong in_RAX;
char *pcVar6;
char *pcVar7;
ulong local_38;
pcVar7 = param_2;
if (*param_2 != '\0') {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar6 = param_2;
local_38 = in_RAX;
do {
uVar4 = my_mb_wc_utf8mb4_no_range(&local_38,pcVar6);
if (uVar4 == 0) break;
if ((local_38 <= *puVar2) && (lVar3 = *(long *)(puVar2[1] + (local_38 >> 8) * 8), lVar3 != 0))
{
local_38 = (ulong)*(uint *)(lVar3 + (local_38 & 0xff) * 0xc);
}
uVar5 = my_wc_mb_utf8mb4_no_range(local_38,pcVar7);
if (uVar5 == 0) break;
pcVar7 = pcVar7 + uVar5;
pcVar1 = pcVar6 + uVar4;
pcVar6 = pcVar6 + uVar4;
} while (*pcVar1 != '\0');
}
*pcVar7 = '\0';
return (long)pcVar7 - (long)param_2;
}
| |
43,393 | testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | O3 | c | testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5e3fe
movq (%r14), %rsi
movq %r15, %rdi
callq 0x5e44e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x251ee
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7cc2c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7cc4c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x11760
| _ZN7testing15AssertionResultlsIPKwEERS0_RKT_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+28h+var_20]
mov rdi, r15; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rsi, [r14]
mov rdi, r15
call _ZN7testing7MessagelsEPKw; testing::Message::operator<<(wchar_t const*)
lea rsi, [rsp+28h+var_20]; testing::Message *
mov rdi, rbx; this
call _ZN7testing15AssertionResult13AppendMessageERKNS_7MessageE; testing::AssertionResult::AppendMessage(testing::Message const&)
mov rdi, [rsp+28h+var_20]
test rdi, rdi
jz short loc_7CC2C
mov rax, [rdi]
call qword ptr [rax+8]
loc_7CC2C:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_7CC4C
mov rax, [rdi]
call qword ptr [rax+8]
loc_7CC4C:
mov rdi, rbx
call __Unwind_Resume
| testing::AssertionResult * testing::AssertionResult::operator<<<wchar_t const*>(
testing::AssertionResult *this)
{
_QWORD v2[4]; // [rsp+8h] [rbp-20h] BYREF
testing::Message::Message((testing::Message *)v2);
testing::Message::operator<<(v2);
testing::AssertionResult::AppendMessage(this, (const testing::Message *)v2);
if ( v2[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v2[0] + 8LL))(v2[0]);
return this;
}
| operator<<:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x0015e3fe
MOV RSI,qword ptr [R14]
LAB_0017cc07:
MOV RDI,R15
CALL 0x0015e44e
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001251ee
LAB_0017cc1c:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0017cc2c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0017cc2c:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* testing::AssertionResult& testing::AssertionResult::TEMPNAMEPLACEHOLDERVALUE(wchar_t const*
const&) */
AssertionResult * __thiscall
testing::AssertionResult::operator<<(AssertionResult *this,wchar_t **param_1)
{
long *local_20;
Message::Message((Message *)&local_20);
/* try { // try from 0017cc07 to 0017cc1b has its CatchHandler @ 0017cc39 */
Message::operator<<((Message *)&local_20,*param_1);
AppendMessage((Message *)this);
if (local_20 != (long *)0x0) {
(**(code **)(*local_20 + 8))();
}
return this;
}
| |
43,394 | minja::Parser::parseMathPlusMinus() | llama.cpp/common/minja/minja.hpp | std::shared_ptr<Expression> parseMathPlusMinus() {
static std::regex plus_minus_tok(R"(\+|-(?![}%#]\}))");
auto left = parseMathMulDiv();
if (!left) throw std::runtime_error("Expected left side of 'math plus/minus' expression");
std::string op_str;
while (!(op_str = consumeToken(plus_minus_tok)).empty()) {
auto right = parseMathMulDiv();
if (!right) throw std::runtime_error("Expected right side of 'math plus/minus' expression");
auto op = op_str == "+" ? BinaryOpExpr::Op::Add : BinaryOpExpr::Op::Sub;
left = std::make_shared<BinaryOpExpr>(get_location(), std::move(left), std::move(right), op);
}
return left;
} | O3 | cpp | minja::Parser::parseMathPlusMinus():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x819e8(%rip), %rax # 0x163560
movb (%rax), %al
testb %al, %al
movq %rdi, (%rsp)
je 0xe1d80
movq %rbp, %rdi
movq %r14, %rsi
callq 0xe1e92
cmpq $0x0, (%rbp)
je 0xe1ddb
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x7f34f(%rip), %rax # 0x160f10
addq $0x10, %rax
movq %rax, 0x58(%rsp)
movq %r12, %rdi
movq %r14, %rsi
leaq 0x81969(%rip), %rdx # 0x163540
movl $0x1, %ecx
callq 0xdedb2
movq %r13, %rdi
movq %r12, %rsi
callq 0x208c0
movq 0x8(%rax), %r15
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xe1c0c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x20180
testq %r15, %r15
je 0xe1d18
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xe1e92
cmpq $0x0, 0x8(%rsp)
je 0xe1d49
movq %r13, %rdi
leaq 0x3e226(%rip), %rsi # 0x11fe5e
callq 0x20f50
cmpl $0x1, %eax
movl $0x2, %r15d
sbbl $0x0, %r15d
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xe1c75
movq 0x80331(%rip), %rcx # 0x161f98
cmpb $0x0, (%rcx)
je 0xe1c71
incl 0x8(%rax)
jmp 0xe1c75
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
movq %r14, %rbx
subq 0x10(%r14), %rax
movq %rax, 0x28(%rsp)
movl $0x58, %edi
callq 0x20210
movq %rax, %r13
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r13)
movq 0x58(%rsp), %rax
movq %rax, (%r13)
movq %r13, %r14
addq $0x10, %r14
movq %r14, %rdi
movq %r12, %rsi
movq (%rsp), %rbp
movq %rbp, %rdx
leaq 0x8(%rsp), %rcx
movl %r15d, %r8d
callq 0xec4ca
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movups (%rbp), %xmm0
movq %r14, (%rbp)
movq %r13, 0x8(%rbp)
movaps %xmm0, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x70a5a
leaq 0x68(%rsp), %rdi
callq 0x70a5a
leaq 0x20(%rsp), %rdi
callq 0x70a5a
leaq 0x10(%rsp), %rdi
callq 0x70a5a
leaq 0x38(%rsp), %r13
movq %rbx, %r14
jmp 0xe1bca
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xe1d34
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x20180
movq %rbp, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20650
movq %rax, %r15
leaq 0x3f417(%rip), %rsi # 0x121174
movq %rax, %rdi
callq 0x20430
movq 0x80254(%rip), %rsi # 0x161fc0
movq 0x8020d(%rip), %rdx # 0x161f80
movq %r15, %rdi
callq 0x20a50
jmp 0xe1e0d
leaq 0x817d9(%rip), %rdi # 0x163560
callq 0x205a0
testl %eax, %eax
je 0xe1b86
leaq 0x817a5(%rip), %rdi # 0x163540
leaq 0x3f38f(%rip), %rsi # 0x121131
movl $0x10, %edx
callq 0x66374
leaq -0x7b993(%rip), %rdi # 0x66420
leaq 0x81786(%rip), %rsi # 0x163540
leaq 0x80cb7(%rip), %rdx # 0x162a78
callq 0x20ed0
leaq 0x81793(%rip), %rdi # 0x163560
callq 0x20960
movq (%rsp), %rbp
jmp 0xe1b86
movl $0x10, %edi
callq 0x20650
movq %rax, %r15
leaq 0x3f352(%rip), %rsi # 0x121141
movq %rax, %rdi
callq 0x20430
movq 0x801c2(%rip), %rsi # 0x161fc0
movq 0x8017b(%rip), %rdx # 0x161f80
movq %r15, %rdi
callq 0x20a50
movq %rax, %r14
leaq 0x81749(%rip), %rdi # 0x163560
callq 0x206d0
jmp 0xe1e89
movq %rax, %r14
jmp 0xe1e7c
movq %rax, %r14
movq %r15, %rdi
callq 0x20ef0
jmp 0xe1e7c
movq %rax, %r14
jmp 0xe1e51
movq %rax, %r14
movq %r15, %rdi
callq 0x20ef0
jmp 0xe1e51
jmp 0xe1e5d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x70a5a
leaq 0x10(%rsp), %rdi
callq 0x70a5a
jmp 0xe1e60
movq %rax, %r14
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xe1e7c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x20180
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x70a5a
movq %r14, %rdi
callq 0x20af0
nop
| _ZN5minja6Parser18parseMathPlusMinusEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rsi
mov rbp, rdi
lea rax, _ZGVZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; `guard variable for'minja::Parser::parseMathPlusMinus(void)::plus_minus_tok
mov al, [rax]
test al, al
mov qword ptr [rsp+0B8h+var_B8], rdi; int
jz loc_E1D80
loc_E1B86:
mov rdi, rbp; this
mov rsi, r14
call _ZN5minja6Parser15parseMathMulDivEv; minja::Parser::parseMathMulDiv(void)
cmp qword ptr [rbp+0], 0
jz loc_E1DDB
lea rax, [rsp+0B8h+var_70]
mov [rax-10h], rax
mov qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea r12, [rsp+0B8h+var_A0]
lea r13, [rsp+0B8h+var_80]
lea rax, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja12BinaryOpExprESaIvELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
add rax, 10h
mov [rsp+0B8h+var_60], rax
loc_E1BCA:
mov rdi, r12; int
mov rsi, r14; int
lea rdx, _ZZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rdi, r13
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov r15, [rax+8]
mov rdi, [rsp+0B8h+var_A0]; void *
lea rax, [rsp+0B8h+var_90]
cmp rdi, rax
jz short loc_E1C0C
mov rsi, [rsp+0B8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E1C0C:
test r15, r15
jz loc_E1D18
lea rdi, [rsp+0B8h+var_B0]; this
mov rsi, r14
call _ZN5minja6Parser15parseMathMulDivEv; minja::Parser::parseMathMulDiv(void)
cmp [rsp+0B8h+var_B0], 0
jz loc_E1D49
mov rdi, r13
lea rsi, asc_11FE5D+1; "+"
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
cmp eax, 1
mov r15d, 2
sbb r15d, 0
mov rax, [r14]
mov [rsp+0B8h+var_A0], rax
mov rax, [r14+8]
mov [rsp+0B8h+var_98], rax
test rax, rax
jz short loc_E1C75
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_E1C71
inc dword ptr [rax+8]
jmp short loc_E1C75
loc_E1C71:
lock inc dword ptr [rax+8]
loc_E1C75:
mov rax, [r14+20h]
mov rbx, r14
sub rax, [r14+10h]
mov [rsp+0B8h+var_90], rax
mov edi, 58h ; 'X'; unsigned __int64
call __Znwm; operator new(ulong)
mov r13, rax
mov rax, 100000001h
mov [r13+8], rax
mov rax, [rsp+0B8h+var_60]
mov [r13+0], rax
mov r14, r13
add r14, 10h
mov rdi, r14
mov rsi, r12
mov rbp, qword ptr [rsp+0B8h+var_B8]
mov rdx, rbp
lea rcx, [rsp+0B8h+var_B0]
mov r8d, r15d
call _ZN5minja12BinaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_NS0_2OpE; minja::BinaryOpExpr::BinaryOpExpr(minja::Location const&,std::shared_ptr<minja::Expression> &&,std::shared_ptr<minja::Expression> &,minja::BinaryOpExpr::Op)
xorps xmm0, xmm0
movaps [rsp+0B8h+var_58], xmm0
movups xmm0, xmmword ptr [rbp+0]
mov [rbp+0], r14
mov [rbp+8], r13
movaps [rsp+0B8h+var_48], xmm0
lea rdi, [rsp+0B8h+var_48+8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_58+8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_98]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_A8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea r13, [rsp+0B8h+var_80]
mov r14, rbx
jmp loc_E1BCA
loc_E1D18:
mov rdi, [rsp+0B8h+var_80]; void *
lea rax, [rsp+0B8h+var_70]
cmp rdi, rax
jz short loc_E1D34
mov rsi, [rsp+0B8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E1D34:
mov rax, rbp
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E1D49:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_4; "Expected right side of 'math plus/minus"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp loc_E1E0D
loc_E1D80:
lea rdi, _ZGVZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_E1B86
lea rdi, _ZZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; minja::Parser::parseMathPlusMinus(void)::plus_minus_tok
lea rsi, asc_121131; "\\+|-(?![}%#]\\})"
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)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_release
mov rbp, qword ptr [rsp+0B8h+var_B8]
jmp loc_E1B86
loc_E1DDB:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_4; "Expected left side of 'math plus/minus'"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_E1E0D:
mov r14, rax
lea rdi, _ZGVZN5minja6Parser18parseMathPlusMinusEvE14plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_E1E89
mov r14, rax
jmp short loc_E1E7C
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_E1E7C
mov r14, rax
jmp short loc_E1E51
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_E1E51
jmp short loc_E1E5D
mov r14, rax
lea rdi, [rsp+0B8h+var_98]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_E1E51:
lea rdi, [rsp+0B8h+var_A8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_E1E60
loc_E1E5D:
mov r14, rax
loc_E1E60:
mov rdi, [rsp+0B8h+var_80]; void *
lea rax, [rsp+0B8h+var_70]
cmp rdi, rax
jz short loc_E1E7C
mov rsi, [rsp+0B8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E1E7C:
mov rdi, qword ptr [rsp+0B8h+var_B8]
add rdi, 8
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_E1E89:
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseMathPlusMinus(minja::Parser *this, long long a2)
{
minja::Parser *v2; // rbp
long long v3; // r15
unsigned int v4; // r15d
volatile signed __int32 *v5; // rax
long long **v6; // r13
__int128 v7; // xmm0
std::runtime_error *v9; // r15
std::runtime_error *exception; // r15
long long v11; // [rsp+8h] [rbp-B0h] BYREF
volatile signed __int32 *v12; // [rsp+10h] [rbp-A8h] BYREF
void *v13; // [rsp+18h] [rbp-A0h] BYREF
volatile signed __int32 *v14; // [rsp+20h] [rbp-98h] BYREF
long long v15; // [rsp+28h] [rbp-90h] BYREF
void *v16[2]; // [rsp+38h] [rbp-80h] BYREF
_QWORD v17[2]; // [rsp+48h] [rbp-70h] BYREF
long long *v18; // [rsp+58h] [rbp-60h]
__int128 v19; // [rsp+60h] [rbp-58h] BYREF
__int128 v20; // [rsp+70h] [rbp-48h] BYREF
v2 = this;
if ( !(_BYTE)`guard variable for'minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11],
(long long)"\\+|-(?![}%#]\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11]);
v2 = this;
}
minja::Parser::parseMathMulDiv(v2);
if ( !*(_QWORD *)v2 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'math plus/minus' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v16[0] = v17;
v16[1] = 0LL;
LOBYTE(v17[0]) = 0;
v18 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::BinaryOpExpr,std::allocator<void>,(__gnu_cxx::_Lock_policy)2>
+ 2;
while ( 1 )
{
minja::Parser::consumeToken(
&v13,
a2,
(long long)&minja::Parser::parseMathPlusMinus(void)::plus_minus_tok[abi:cxx11],
1u);
v3 = *(_QWORD *)(std::string::operator=(v16, &v13) + 8);
if ( v13 != &v15 )
operator delete(v13, v15 + 1);
if ( !v3 )
break;
minja::Parser::parseMathMulDiv((minja::Parser *)&v11);
if ( !v11 )
{
v9 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v9, "Expected right side of 'math plus/minus' expression");
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = (((unsigned int)std::string::compare(v16, "+") | 0x200000000uLL) - 1) >> 32;
v13 = *(void **)a2;
v5 = *(volatile signed __int32 **)(a2 + 8);
v14 = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v5 + 2);
else
_InterlockedIncrement(v5 + 2);
}
v15 = *(_QWORD *)(a2 + 32) - *(_QWORD *)(a2 + 16);
v6 = (long long **)operator new(0x58uLL);
v6[1] = (long long *)0x100000001LL;
*v6 = v18;
v2 = this;
minja::BinaryOpExpr::BinaryOpExpr(v6 + 2, &v13, this, &v11, v4);
v19 = 0LL;
v7 = *(_OWORD *)this;
*(_QWORD *)this = v6 + 2;
*((_QWORD *)this + 1) = v6;
v20 = v7;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v20 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((volatile signed __int32 **)&v19 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v14);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v12);
}
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
return v2;
}
| parseMathPlusMinus:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RSI
MOV RBP,RDI
LEA RAX,[0x263560]
MOV AL,byte ptr [RAX]
TEST AL,AL
MOV qword ptr [RSP],RDI
JZ 0x001e1d80
LAB_001e1b86:
MOV RDI,RBP
MOV RSI,R14
CALL 0x001e1e92
CMP qword ptr [RBP],0x0
JZ 0x001e1ddb
LEA RAX,[RSP + 0x48]
MOV qword ptr [RAX + -0x10],RAX
MOV qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA R12,[RSP + 0x18]
LEA R13,[RSP + 0x38]
LEA RAX,[0x260f10]
ADD RAX,0x10
MOV qword ptr [RSP + 0x58],RAX
LAB_001e1bca:
MOV RDI,R12
MOV RSI,R14
LEA RDX,[0x263540]
MOV ECX,0x1
CALL 0x001dedb2
MOV RDI,R13
MOV RSI,R12
CALL 0x001208c0
MOV R15,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x001e1c0c
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x00120180
LAB_001e1c0c:
TEST R15,R15
JZ 0x001e1d18
LAB_001e1c15:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x001e1e92
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001e1d49
MOV RDI,R13
LEA RSI,[0x21fe5e]
CALL 0x00120f50
CMP EAX,0x1
MOV R15D,0x2
SBB R15D,0x0
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x001e1c75
MOV RCX,qword ptr [0x00261f98]
CMP byte ptr [RCX],0x0
JZ 0x001e1c71
INC dword ptr [RAX + 0x8]
JMP 0x001e1c75
LAB_001e1c71:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001e1c75:
MOV RAX,qword ptr [R14 + 0x20]
MOV RBX,R14
SUB RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x28],RAX
LAB_001e1c85:
MOV EDI,0x58
CALL 0x00120210
LAB_001e1c8f:
MOV R13,RAX
MOV RAX,0x100000001
MOV qword ptr [R13 + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [R13],RAX
MOV R14,R13
ADD R14,0x10
MOV RDI,R14
MOV RSI,R12
MOV RBP,qword ptr [RSP]
MOV RDX,RBP
LEA RCX,[RSP + 0x8]
MOV R8D,R15D
CALL 0x001ec4ca
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVUPS XMM0,xmmword ptr [RBP]
MOV qword ptr [RBP],R14
MOV qword ptr [RBP + 0x8],R13
MOVAPS xmmword ptr [RSP + 0x70],XMM0
LEA RDI,[RSP + 0x78]
CALL 0x00170a5a
LEA RDI,[RSP + 0x68]
CALL 0x00170a5a
LEA RDI,[RSP + 0x20]
CALL 0x00170a5a
LEA RDI,[RSP + 0x10]
CALL 0x00170a5a
LEA R13,[RSP + 0x38]
MOV R14,RBX
JMP 0x001e1bca
LAB_001e1d18:
MOV RDI,qword ptr [RSP + 0x38]
LEA RAX,[RSP + 0x48]
CMP RDI,RAX
JZ 0x001e1d34
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x00120180
LAB_001e1d34:
MOV RAX,RBP
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e1d49:
MOV EDI,0x10
CALL 0x00120650
MOV R15,RAX
LAB_001e1d56:
LEA RSI,[0x221174]
MOV RDI,RAX
CALL 0x00120430
LAB_001e1d65:
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,R15
CALL 0x00120a50
LAB_001e1d80:
LEA RDI,[0x263560]
CALL 0x001205a0
TEST EAX,EAX
JZ 0x001e1b86
LAB_001e1d94:
LEA RDI,[0x263540]
LEA RSI,[0x221131]
MOV EDX,0x10
CALL 0x00166374
LAB_001e1dac:
LEA RDI,[0x166420]
LEA RSI,[0x263540]
LEA RDX,[0x262a78]
CALL 0x00120ed0
LEA RDI,[0x263560]
CALL 0x00120960
MOV RBP,qword ptr [RSP]
JMP 0x001e1b86
LAB_001e1ddb:
MOV EDI,0x10
CALL 0x00120650
MOV R15,RAX
LAB_001e1de8:
LEA RSI,[0x221141]
MOV RDI,RAX
CALL 0x00120430
LAB_001e1df7:
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,R15
CALL 0x00120a50
|
/* minja::Parser::parseMathPlusMinus() */
long * minja::Parser::parseMathPlusMinus(void)
{
int iVar1;
long lVar2;
int8 *puVar3;
runtime_error *prVar4;
int8 *in_RSI;
long *in_RDI;
long local_b0;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_a8 [8];
long *local_a0;
long local_98;
long local_90 [2];
int1 *local_80;
int8 local_78;
int1 local_70;
int7 uStack_6f;
int **local_60;
int8 local_58;
int8 uStack_50;
long local_48;
long alStack_40 [2];
if (parseMathPlusMinus()::plus_minus_tok_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseMathPlusMinus()::plus_minus_tok_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 001e1d94 to 001e1dab has its CatchHandler @ 001e1e0d */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseMathPlusMinus()::plus_minus_tok_abi_cxx11_,"\\+|-(?![}%#]\\})",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseMathPlusMinus()::plus_minus_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseMathPlusMinus()::plus_minus_tok_abi_cxx11_);
}
}
parseMathMulDiv();
if (*in_RDI != 0) {
local_80 = &local_70;
local_78 = 0;
local_70 = 0;
local_60 = &PTR___Sp_counted_base_00260f20;
while( true ) {
/* try { // try from 001e1bca to 001e1be0 has its CatchHandler @ 001e1e5d */
consumeToken((string *)&local_a0,in_RSI,parseMathPlusMinus()::plus_minus_tok_abi_cxx11_,1);
lVar2 = std::__cxx11::string::operator=((string *)&local_80,(string *)&local_a0);
lVar2 = *(long *)(lVar2 + 8);
if (local_a0 != local_90) {
operator_delete(local_a0,local_90[0] + 1);
}
if (lVar2 == 0) break;
/* try { // try from 001e1c15 to 001e1c21 has its CatchHandler @ 001e1e42 */
parseMathMulDiv();
if (local_b0 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001e1d56 to 001e1d64 has its CatchHandler @ 001e1e35 */
std::runtime_error::runtime_error
(prVar4,"Expected right side of \'math plus/minus\' expression");
/* try { // try from 001e1d65 to 001e1d7a has its CatchHandler @ 001e1e30 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
iVar1 = std::__cxx11::string::compare((char *)&local_80);
local_a0 = (long *)*in_RSI;
local_98 = in_RSI[1];
if (local_98 != 0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
*(int *)(local_98 + 8) = *(int *)(local_98 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_98 + 8) = *(int *)(local_98 + 8) + 1;
}
}
local_90[0] = in_RSI[4] - in_RSI[2];
/* try { // try from 001e1c85 to 001e1c8e has its CatchHandler @ 001e1e44 */
puVar3 = (int8 *)operator_new(0x58);
puVar3[1] = 0x100000001;
*puVar3 = local_60;
BinaryOpExpr::BinaryOpExpr
((BinaryOpExpr *)(puVar3 + 2),(string *)&local_a0,in_RDI,&local_b0,
2 - (uint)(iVar1 == 0));
local_58 = 0;
uStack_50 = 0;
local_48 = *in_RDI;
alStack_40[0] = in_RDI[1];
*in_RDI = (long)(puVar3 + 2);
in_RDI[1] = (long)puVar3;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)alStack_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_50);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_98);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_a8);
}
if (local_80 != &local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
return in_RDI;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001e1de8 to 001e1df6 has its CatchHandler @ 001e1e23 */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'math plus/minus\' expression");
/* try { // try from 001e1df7 to 001e1e0c has its CatchHandler @ 001e1e1e */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
| |
43,395 | testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(
premature_exit_filepath ? premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the file with a single "0" character in it. I/O
// errors are ignored as there's nothing better we can do and we
// don't want to fail the test because of this.
FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");
fwrite("0", 1, 1, pfile);
fclose(pfile);
}
} | O1 | cpp | testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xe69e(%rip), %rax # 0x432de
cmoveq %rax, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x8200
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39504
cmpq $0x0, 0x8(%rbx)
je 0x34c97
movq (%rbx), %rdi
leaq 0xecf9(%rip), %rsi # 0x4396c
callq 0x8610
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0x8690
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN7testing8internal23ScopedPrematureExitFileC2EPKc:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
test rsi, rsi
lea rax, aSFromSSMsTotal+1Ah; ""
cmovz r14, rax
lea rax, [rdi+10h]
mov [rdi], rax
mov rdi, r14
call _strlen
lea rdx, [rax+r14]
mov rdi, rbx
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
cmp qword ptr [rbx+8], 0
jz short loc_34C97
mov rdi, [rbx]
lea rsi, aW; "w"
call _fopen
mov rbx, rax
mov edi, 30h ; '0'
mov rsi, rax
call _fputc
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _fclose
loc_34C97:
add rsp, 8
pop rbx
pop r14
retn
| long long testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(
testing::internal::ScopedPrematureExitFile *this,
char *a2)
{
char *v2; // r14
long long v3; // rax
long long result; // rax
long long v5; // rbx
v2 = a2;
if ( !a2 )
v2 = "";
*(_QWORD *)this = (char *)this + 16;
v3 = strlen(v2);
result = std::string::_M_construct<char const*>(this, v2, &v2[v3]);
if ( *((_QWORD *)this + 1) )
{
v5 = fopen(*(_QWORD *)this, "w");
fputc(48LL, v5);
return fclose(v5);
}
return result;
}
| ScopedPrematureExitFile:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
TEST RSI,RSI
LEA RAX,[0x1432de]
CMOVZ R14,RAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV RDI,R14
CALL 0x00108200
LEA RDX,[RAX + R14*0x1]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00139504
CMP qword ptr [RBX + 0x8],0x0
JZ 0x00134c97
MOV RDI,qword ptr [RBX]
LEA RSI,[0x14396c]
CALL 0x00108610
MOV RBX,RAX
MOV EDI,0x30
MOV RSI,RAX
CALL 0x00108690
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001084a0
LAB_00134c97:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) */
void __thiscall
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile
(ScopedPrematureExitFile *this,char *param_1)
{
size_t sVar1;
FILE *__stream;
if (param_1 == (char *)0x0) {
param_1 = "";
}
*(ScopedPrematureExitFile **)this = this + 0x10;
sVar1 = strlen(param_1);
std::__cxx11::string::_M_construct<char_const*>(this,param_1,param_1 + sVar1);
if (*(long *)(this + 8) != 0) {
__stream = fopen(*(char **)this,"w");
fputc(0x30,__stream);
fclose(__stream);
return;
}
return;
}
| |
43,396 | Dimension::~Dimension() | untodesu[P]voxelius/game/shared/dimension.cc | Dimension::~Dimension(void)
{
for(const auto it : m_chunkmap)
delete it.second;
entities.clear();
chunks.clear();
} | O0 | cpp | Dimension::~Dimension():
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x228df5(%rip), %rcx # 0x2cabb0
movq %rcx, (%rax)
addq $0x2c8, %rax # imm = 0x2C8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa2710
movq %rax, -0x40(%rbp)
jmp 0xa1dd7
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa2740
movq %rax, -0x50(%rbp)
jmp 0xa1dee
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xa2770
movb %al, -0x51(%rbp)
jmp 0xa1e08
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xa1e11
jmp 0xa1e6f
leaq -0x18(%rbp), %rdi
callq 0xa27a0
movq %rax, -0x60(%rbp)
jmp 0xa1e20
movq -0x60(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xa1e60
movq -0x68(%rbp), %rdi
callq 0x92120
movq -0x68(%rbp), %rdi
movl $0x2020, %esi # imm = 0x2020
callq 0x1a940
jmp 0xa1e62
leaq -0x18(%rbp), %rdi
callq 0xa27c0
jmp 0xa1e6d
jmp 0xa1df6
movq -0x48(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0xa27e0
jmp 0xa1e81
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0xa27e0
jmp 0xa1e90
movq -0x48(%rbp), %rdi
addq $0x2c8, %rdi # imm = 0x2C8
callq 0xa26b0
movq -0x48(%rbp), %rdi
addq $0x2a8, %rdi # imm = 0x2A8
callq 0x1b238
movq -0x48(%rbp), %rdi
addq $0x158, %rdi # imm = 0x158
callq 0x49e20
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x49e20
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1da70
nopl (%rax,%rax)
| _ZN9DimensionD2Ev:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
lea rcx, off_2CABB0
mov [rax], rcx
add rax, 2C8h
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
call _ZN7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE5beginEv; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::begin(void)
mov [rbp+var_40], rax
jmp short $+2
loc_A1DD7:
mov rax, [rbp+var_40]
mov [rbp+var_18], rax
mov rdi, [rbp+var_10]
call _ZN7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE3endEv; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::end(void)
mov [rbp+var_50], rax
jmp short $+2
loc_A1DEE:
mov rax, [rbp+var_50]
mov [rbp+var_20], rax
loc_A1DF6:
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_20]
call _ZNK7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE8iteratorneERKSC_; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator!=(emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator const&)
mov [rbp+var_51], al
jmp short $+2
loc_A1E08:
mov al, [rbp+var_51]
test al, 1
jnz short loc_A1E11
jmp short loc_A1E6F
loc_A1E11:
lea rdi, [rbp+var_18]
call _ZNK7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE8iteratordeEv; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator*(void)
mov [rbp+var_60], rax
jmp short $+2
loc_A1E20:
mov rax, [rbp+var_60]
mov rcx, [rax]
mov [rbp+var_38], rcx
mov rcx, [rax+8]
mov [rbp+var_30], rcx
mov rax, [rax+10h]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_68], rax
cmp rax, 0
jz short loc_A1E60
mov rdi, [rbp+var_68]; this
call _ZN5ChunkD2Ev; Chunk::~Chunk()
mov rdi, [rbp+var_68]; void *
mov esi, 2020h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A1E60:
jmp short $+2
loc_A1E62:
lea rdi, [rbp+var_18]
call _ZN7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EE8iteratorppEv; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator++(void)
jmp short $+2
loc_A1E6D:
jmp short loc_A1DF6
loc_A1E6F:
mov rdi, [rbp+var_48]
add rdi, 158h
call _ZN4entt14basic_registryINS_6entityESaIS1_EE5clearIJEEEvv; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>(void)
jmp short $+2
loc_A1E81:
mov rdi, [rbp+var_48]
add rdi, 8
call _ZN4entt14basic_registryINS_6entityESaIS1_EE5clearIJEEEvv; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>(void)
jmp short $+2
loc_A1E90:
mov rdi, [rbp+var_48]
add rdi, 2C8h
call _ZN7emhash87HashMapIN3glm3vecILi3EiLNS1_9qualifierE0EEEP5ChunkSt4hashIS4_ESt8equal_toIS4_EED2Ev; emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::~HashMap()
mov rdi, [rbp+var_48]
add rdi, 2A8h; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rbp+var_48]
add rdi, 158h
call _ZN4entt14basic_registryINS_6entityESaIS1_EED2Ev; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry()
mov rdi, [rbp+var_48]
add rdi, 8
call _ZN4entt14basic_registryINS_6entityESaIS1_EED2Ev; entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry()
add rsp, 70h
pop rbp
retn
mov rdi, rax
call __clang_call_terminate
| void Dimension::~Dimension(Dimension *this)
{
Chunk *v1; // [rsp+8h] [rbp-68h]
long long v2; // [rsp+50h] [rbp-20h] BYREF
_QWORD v3[3]; // [rsp+58h] [rbp-18h] BYREF
v3[2] = this;
*(_QWORD *)this = off_2CABB0;
v3[1] = (char *)this + 712;
v3[0] = emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::begin((char *)this + 712);
v2 = emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::end((char *)this + 712);
while ( (emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator!=(
v3,
&v2) & 1) != 0 )
{
v1 = *(Chunk **)(emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator*(v3)
+ 16);
if ( v1 )
{
Chunk::~Chunk(v1);
operator delete(v1, 0x2020uLL);
}
emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::iterator::operator++(v3);
}
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>((char *)this + 344);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>((char *)this + 8);
emhash8::HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk *,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>::~HashMap((char *)this + 712);
std::string::~string((char *)this + 680);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry((long long)this + 344);
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry((long long)this + 8);
}
| ~Dimension:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
LEA RCX,[0x3cabb0]
MOV qword ptr [RAX],RCX
ADD RAX,0x2c8
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
LAB_001a1dcc:
CALL 0x001a2710
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001a1dd7
LAB_001a1dd7:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001a2740
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001a1dee
LAB_001a1dee:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x20],RAX
LAB_001a1df6:
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x20]
CALL 0x001a2770
MOV byte ptr [RBP + -0x51],AL
JMP 0x001a1e08
LAB_001a1e08:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001a1e11
JMP 0x001a1e6f
LAB_001a1e11:
LEA RDI,[RBP + -0x18]
CALL 0x001a27a0
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001a1e20
LAB_001a1e20:
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x68],RAX
CMP RAX,0x0
JZ 0x001a1e60
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x00192120
MOV RDI,qword ptr [RBP + -0x68]
MOV ESI,0x2020
CALL 0x0011a940
LAB_001a1e60:
JMP 0x001a1e62
LAB_001a1e62:
LEA RDI,[RBP + -0x18]
CALL 0x001a27c0
JMP 0x001a1e6d
LAB_001a1e6d:
JMP 0x001a1df6
LAB_001a1e6f:
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x158
CALL 0x001a27e0
JMP 0x001a1e81
LAB_001a1e81:
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x8
CALL 0x001a27e0
JMP 0x001a1e90
LAB_001a1e90:
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x2c8
CALL 0x001a26b0
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x2a8
CALL 0x0011b238
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x158
CALL 0x00149e20
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x8
CALL 0x00149e20
ADD RSP,0x70
POP RBP
RET
|
/* Dimension::~Dimension() */
void __thiscall Dimension::~Dimension(Dimension *this)
{
Chunk *this_00;
byte bVar1;
long lVar2;
int8 local_28;
int8 local_20;
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
*local_18;
Dimension *local_10;
*(int ***)this = &PTR__Dimension_003cabb0;
local_18 = (HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
*)(this + 0x2c8);
local_10 = this;
/* try { // try from 001a1dcc to 001a1e8d has its CatchHandler @ 001a1ed3 */
local_20 = emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::begin(local_18);
local_28 = emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::end(local_18);
while( true ) {
bVar1 = emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::iterator::operator!=((iterator *)&local_20,(iterator *)&local_28);
if ((bVar1 & 1) == 0) break;
lVar2 = emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::iterator::operator*((iterator *)&local_20);
this_00 = *(Chunk **)(lVar2 + 0x10);
if (this_00 != (Chunk *)0x0) {
Chunk::~Chunk(this_00);
operator_delete(this_00,0x2020);
}
emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::iterator::operator++((iterator *)&local_20);
}
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 0x158));
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::clear<>
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 8));
emhash8::
HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
::~HashMap((HashMap<glm::vec<3,int,(glm::qualifier)0>,Chunk*,std::hash<glm::vec<3,int,(glm::qualifier)0>>,std::equal_to<glm::vec<3,int,(glm::qualifier)0>>>
*)(this + 0x2c8));
std::__cxx11::string::~string((string *)(this + 0x2a8));
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 0x158));
entt::basic_registry<entt::entity,std::allocator<entt::entity>>::~basic_registry
((basic_registry<entt::entity,std::allocator<entt::entity>> *)(this + 8));
return;
}
| |
43,397 | my_hash_delete | eloqsql/mysys/hash.c | my_bool my_hash_delete(HASH *hash, uchar *record)
{
uint pos2,idx,empty_index;
my_hash_value_type pos_hashnr, lastpos_hashnr;
size_t blength;
HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
DBUG_ENTER("my_hash_delete");
if (!hash->records)
DBUG_RETURN(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,HASH_LINK*);
/* Search after record with key */
pos= data + my_hash_mask(rec_hashnr(hash, record), blength, hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
DBUG_RETURN(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos[0]= empty[0];
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr= lastpos->hash_nr;
/* pos is where lastpos should be */
pos= data + my_hash_mask(lastpos_hashnr, hash->blength, hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr= pos->hash_nr;
/* pos3 is where the pos should be */
pos3= data + my_hash_mask(pos_hashnr, hash->blength, hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= my_hash_mask(lastpos_hashnr, blength, hash->records + 1);
if (pos2 == my_hash_mask(pos_hashnr, blength, hash->records + 1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);
} | O0 | c | my_hash_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xde9b9
jmp 0xde9b0
movb $0x1, -0x1(%rbp)
jmp 0xded32
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xded40
movl %eax, %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde1c0
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0xdea55
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0xdea3e
jmp 0xdea35
movb $0x1, -0x1(%rbp)
jmp 0xded32
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0xdea14
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0xdea84
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xdeaca
movq -0x58(%rbp), %rax
movl (%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
jmp 0xdeb05
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xdeb03
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xdeb05
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0xdeb14
jmp 0xded06
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde1c0
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0xdeb76
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xded06
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde1c0
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0xdec1c
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x60(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0xde950
jmp 0xded06
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0xde1c0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x28(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0xde1c0
movl %eax, %ecx
movl -0x84(%rbp), %eax
cmpl %ecx, %eax
jne 0xdeccb
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0xdecb7
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0xde950
jmp 0xded06
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x20(%rbp)
jmp 0xdecd2
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x58(%rbp), %rax
movl (%rax), %ecx
callq 0xde950
movl -0x24(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xdaa50
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0xded2c
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0xded2e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x90, %rsp
popq %rbp
retq
nop
| my_hash_delete:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jnz short loc_DE9B9
jmp short $+2
loc_DE9B0:
mov [rbp+var_1], 1
jmp loc_DED32
loc_DE9B9:
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rec_hashnr
mov edi, eax
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_70]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov [rbp+var_50], 0
loc_DEA14:
mov rax, [rbp+var_58]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jz short loc_DEA55
mov rax, [rbp+var_58]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jnz short loc_DEA3E
jmp short $+2
loc_DEA35:
mov [rbp+var_1], 1
jmp loc_DED32
loc_DEA3E:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
jmp short loc_DEA14
loc_DEA55:
mov rcx, [rbp+var_10]
mov rax, [rcx+18h]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rcx+18h], rax
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
shr rcx, 1
cmp rax, rcx
jnb short loc_DEA84
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
shr rcx, 1
mov [rax+10h], rcx
loc_DEA84:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
shl rcx, 4
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_24], eax
cmp [rbp+var_50], 0
jz short loc_DEACA
mov rax, [rbp+var_58]
mov ecx, [rax]
mov rax, [rbp+var_50]
mov [rax], ecx
jmp short loc_DEB05
loc_DEACA:
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_DEB03
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
mov [rbp+var_24], ecx
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_68]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_DEB03:
jmp short $+2
loc_DEB05:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_48]
jnz short loc_DEB14
jmp loc_DED06
loc_DEB14:
mov rax, [rbp+var_48]
mov eax, [rax+4]
mov [rbp+var_2C], eax
mov rax, [rbp+var_40]
mov [rbp+var_78], rax
mov edi, [rbp+var_2C]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_78]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_68]
jnz short loc_DEB76
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
jmp loc_DED06
loc_DEB76:
mov rax, [rbp+var_58]
mov eax, [rax+4]
mov [rbp+var_28], eax
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov edi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_80]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_60]
jz short loc_DEC1C
mov rax, [rbp+var_68]
mov rcx, [rbp+var_58]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rax, [rbp+var_58]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink
jmp loc_DED06
loc_DEC1C:
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_84], eax
mov edi, [rbp+var_28]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov ecx, eax
mov eax, [rbp+var_84]
cmp eax, ecx
jnz short loc_DECCB
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jz short loc_DECB7
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_48]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink
jmp short loc_DED06
loc_DECB7:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_20], eax
jmp short loc_DECD2
loc_DECCB:
mov [rbp+var_20], 0FFFFFFFFh
loc_DECD2:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov esi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rax, [rbp+var_58]
mov ecx, [rax]
call movelink
mov ecx, [rbp+var_24]
mov rax, [rbp+var_58]
mov [rax], ecx
loc_DED06:
mov rdi, [rbp+var_10]
add rdi, 28h ; '('
call pop_dynamic
mov rax, [rbp+var_10]
cmp qword ptr [rax+60h], 0
jz short loc_DED2C
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov rdi, [rbp+var_18]
call rax
loc_DED2C:
jmp short $+2
loc_DED2E:
mov [rbp+var_1], 0
loc_DED32:
mov al, [rbp+var_1]
add rsp, 90h
pop rbp
retn
| char my_hash_delete(long long a1, long long a2)
{
unsigned int v2; // eax
unsigned long long v3; // rax
_QWORD *v5; // [rsp+28h] [rbp-68h]
long long v6; // [rsp+30h] [rbp-60h]
unsigned int *v7; // [rsp+38h] [rbp-58h]
long long v8; // [rsp+38h] [rbp-58h]
_DWORD *v9; // [rsp+40h] [rbp-50h]
long long v10; // [rsp+48h] [rbp-48h]
long long v11; // [rsp+50h] [rbp-40h]
unsigned long long v12; // [rsp+58h] [rbp-38h]
unsigned int v13; // [rsp+64h] [rbp-2Ch]
unsigned int v14; // [rsp+68h] [rbp-28h]
unsigned int v15; // [rsp+6Ch] [rbp-24h]
int v16; // [rsp+70h] [rbp-20h]
int v17; // [rsp+74h] [rbp-1Ch]
if ( !*(_QWORD *)(a1 + 24) )
return 1;
v12 = *(_QWORD *)(a1 + 16);
v11 = *(_QWORD *)(a1 + 40);
v2 = rec_hashnr(a1, a2);
v7 = (unsigned int *)(16LL * (unsigned int)my_hash_mask(v2, v12, *(_QWORD *)(a1 + 24)) + v11);
v9 = 0LL;
while ( *((_QWORD *)v7 + 1) != a2 )
{
v9 = v7;
if ( *v7 == -1 )
return 1;
v7 = (unsigned int *)(16LL * *v7 + v11);
}
v3 = *(_QWORD *)(a1 + 24) - 1LL;
*(_QWORD *)(a1 + 24) = v3;
if ( v3 < *(_QWORD *)(a1 + 16) >> 1 )
*(_QWORD *)(a1 + 16) >>= 1;
v10 = 16LL * *(_QWORD *)(a1 + 24) + v11;
v5 = v7;
v15 = ((long long)v7 - v11) >> 4;
if ( v9 )
{
*v9 = *v7;
}
else if ( *v7 != -1 )
{
v15 = *v7;
v5 = (_QWORD *)(16LL * *v7 + v11);
*(_QWORD *)v7 = *v5;
*((_QWORD *)v7 + 1) = v5[1];
}
if ( v5 != (_QWORD *)v10 )
{
v13 = *(_DWORD *)(v10 + 4);
v8 = 16LL * (unsigned int)my_hash_mask(v13, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( (_QWORD *)v8 == v5 )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
}
else
{
v14 = *(_DWORD *)(v8 + 4);
v6 = 16LL * (unsigned int)my_hash_mask(v14, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( v8 == v6 )
{
v17 = my_hash_mask(v13, v12, *(_QWORD *)(a1 + 24) + 1LL);
if ( v17 == (unsigned int)my_hash_mask(v14, v12, *(_QWORD *)(a1 + 24) + 1LL) )
{
if ( v17 != *(_QWORD *)(a1 + 24) )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink(v11, (v10 - v11) >> 4, (v8 - v11) >> 4, v15);
goto LABEL_25;
}
v16 = (v8 - v11) >> 4;
}
else
{
v16 = -1;
}
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink(v11, v16, v15, *(_DWORD *)v8);
*(_DWORD *)v8 = v15;
goto LABEL_25;
}
*v5 = *(_QWORD *)v8;
v5[1] = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = *(_QWORD *)v10;
*(_QWORD *)(v8 + 8) = *(_QWORD *)(v10 + 8);
movelink(v11, (v8 - v11) >> 4, (v6 - v11) >> 4, v15);
}
}
LABEL_25:
pop_dynamic((long long *)(a1 + 40));
if ( *(_QWORD *)(a1 + 96) )
(*(void ( **)(long long))(a1 + 96))(a2);
return 0;
}
| my_hash_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x001de9b9
JMP 0x001de9b0
LAB_001de9b0:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001ded32
LAB_001de9b9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001ded40
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de1c0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x50],0x0
LAB_001dea14:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x001dea55
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JNZ 0x001dea3e
JMP 0x001dea35
LAB_001dea35:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001ded32
LAB_001dea3e:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001dea14
LAB_001dea55:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RCX + 0x18]
ADD RAX,-0x1
MOV qword ptr [RCX + 0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
SHR RCX,0x1
CMP RAX,RCX
JNC 0x001dea84
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SHR RCX,0x1
MOV qword ptr [RAX + 0x10],RCX
LAB_001dea84:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x24],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001deaca
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
JMP 0x001deb05
LAB_001deaca:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JZ 0x001deb03
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RBP + -0x24],ECX
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_001deb03:
JMP 0x001deb05
LAB_001deb05:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x001deb14
JMP 0x001ded06
LAB_001deb14:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x78],RAX
MOV EDI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de1c0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x001deb76
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001ded06
LAB_001deb76:
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de1c0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x60]
JZ 0x001dec1c
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x001de950
JMP 0x001ded06
LAB_001dec1c:
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x001de1c0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x84],EAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x001de1c0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x84]
CMP EAX,ECX
JNZ 0x001deccb
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JZ 0x001decb7
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x001de950
JMP 0x001ded06
LAB_001decb7:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001decd2
LAB_001deccb:
MOV dword ptr [RBP + -0x20],0xffffffff
LAB_001decd2:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
CALL 0x001de950
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX],ECX
LAB_001ded06:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x28
CALL 0x001daa50
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x001ded2c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
LAB_001ded2c:
JMP 0x001ded2e
LAB_001ded2e:
MOV byte ptr [RBP + -0x1],0x0
LAB_001ded32:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x90
POP RBP
RET
|
int1 my_hash_delete(long param_1,long param_2)
{
int8 uVar1;
long lVar2;
int4 uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uint *puVar8;
uint *puVar9;
uint *puVar10;
uint *local_70;
uint *local_60;
uint *local_58;
uint local_2c;
int4 local_28;
if (*(long *)(param_1 + 0x18) == 0) {
return 1;
}
uVar1 = *(int8 *)(param_1 + 0x10);
lVar2 = *(long *)(param_1 + 0x28);
uVar3 = rec_hashnr(param_1,param_2);
uVar4 = my_hash_mask(uVar3,uVar1,*(int8 *)(param_1 + 0x18));
local_58 = (uint *)0x0;
while (local_60 = (uint *)(lVar2 + (ulong)uVar4 * 0x10), *(long *)(local_60 + 2) != param_2) {
local_58 = local_60;
if (*local_60 == 0xffffffff) {
return 1;
}
uVar4 = *local_60;
}
uVar7 = *(long *)(param_1 + 0x18) - 1;
*(ulong *)(param_1 + 0x18) = uVar7;
if (uVar7 < *(ulong *)(param_1 + 0x10) >> 1) {
*(ulong *)(param_1 + 0x10) = *(ulong *)(param_1 + 0x10) >> 1;
}
puVar8 = (uint *)(lVar2 + *(long *)(param_1 + 0x18) * 0x10);
local_70 = local_60;
local_2c = (uint)((long)local_60 - lVar2 >> 4);
if (local_58 == (uint *)0x0) {
if (*local_60 != 0xffffffff) {
local_2c = *local_60;
local_70 = (uint *)(lVar2 + (ulong)local_2c * 0x10);
*(int8 *)local_60 = *(int8 *)local_70;
*(int8 *)(local_60 + 2) = *(int8 *)(local_70 + 2);
}
}
else {
*local_58 = *local_60;
}
if (local_70 != puVar8) {
uVar4 = puVar8[1];
uVar5 = my_hash_mask(uVar4,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar9 = (uint *)(lVar2 + (ulong)uVar5 * 0x10);
if (puVar9 == local_70) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
}
else {
uVar5 = puVar9[1];
uVar6 = my_hash_mask(uVar5,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar10 = (uint *)(lVar2 + (ulong)uVar6 * 0x10);
if (puVar9 == puVar10) {
uVar4 = my_hash_mask(uVar4,uVar1,*(long *)(param_1 + 0x18) + 1);
uVar5 = my_hash_mask(uVar5,uVar1,*(long *)(param_1 + 0x18) + 1);
if (uVar4 == uVar5) {
if ((ulong)uVar4 != *(ulong *)(param_1 + 0x18)) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar8 - lVar2 >> 4 & 0xffffffff,
(long)puVar9 - lVar2 >> 4 & 0xffffffff,local_2c);
goto LAB_001ded06;
}
local_28 = (int4)((long)puVar9 - lVar2 >> 4);
}
else {
local_28 = 0xffffffff;
}
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,local_28,local_2c,*puVar9);
*puVar9 = local_2c;
}
else {
*(int8 *)local_70 = *(int8 *)puVar9;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar9 + 2);
*(int8 *)puVar9 = *(int8 *)puVar8;
*(int8 *)(puVar9 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar9 - lVar2 >> 4 & 0xffffffff,
(long)puVar10 - lVar2 >> 4 & 0xffffffff,local_2c);
}
}
}
LAB_001ded06:
pop_dynamic(param_1 + 0x28);
if (*(long *)(param_1 + 0x60) != 0) {
(**(code **)(param_1 + 0x60))(param_2);
}
return 0;
}
| |
43,398 | update_light_client_update | corpus-core[P]colibri-stateless/src/chains/eth/verifier/sync_committee.c | static bool update_light_client_update(verify_ctx_t* ctx, ssz_ob_t* update, bytes32_t trusted_blockhash) {
bytes32_t sync_root = {0};
bytes32_t merkle_root = {0};
bytes32_t blockhash = {0};
ssz_ob_t attested = ssz_get(update, "attestedHeader");
ssz_ob_t header = ssz_get(&attested, "beacon");
ssz_ob_t sync_aggregate = ssz_get(update, "syncAggregate");
ssz_ob_t signature = ssz_get(&sync_aggregate, "syncCommitteeSignature");
ssz_ob_t sync_bits = ssz_get(&sync_aggregate, "syncCommitteeBits");
ssz_ob_t merkle_proof = ssz_get(update, "nextSyncCommitteeBranch");
ssz_ob_t sync_committee = ssz_get(update, "nextSyncCommittee");
ssz_ob_t state_root = ssz_get(&header, "stateRoot");
uint64_t slot = ssz_get_uint64(&header, "slot");
if (ssz_is_error(header) || ssz_is_error(state_root) || ssz_is_error(signature) || ssz_is_error(sync_bits) || ssz_is_error(merkle_proof) || ssz_is_error(sync_committee))
RETURN_VERIFY_ERROR(ctx, "invalid light client update!");
// calculate the blockhash
ssz_hash_tree_root(header, blockhash);
// verify the signature of the old sync committee for the next sync committee
if (trusted_blockhash) {
if (!bytes_all_zero(bytes(trusted_blockhash, 32)) && memcmp(trusted_blockhash, blockhash, 32)) RETURN_VERIFY_ERROR(ctx, "invalid blockhash!");
}
else {
if (c4_verify_blockroot_signature(ctx, &header, &sync_bits, &signature, slot) != C4_SUCCESS) return false;
}
// create merkle root from proof
ssz_hash_tree_root(sync_committee, sync_root);
ssz_verify_single_merkle_proof(merkle_proof.bytes, sync_root, NEXT_SYNC_COMMITTEE_GINDEX, merkle_root);
// verify the merkle root
if (memcmp(merkle_root, state_root.bytes.data, 32)) RETURN_VERIFY_ERROR(ctx, "invalid merkle root in light client update!");
return c4_set_sync_period(slot, blockhash, ssz_get(&sync_committee, "pubkeys").bytes, ctx->chain_id);
} | O2 | c | update_light_client_update:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
leaq 0x4b79a(%rip), %rdx # 0x73b0f
leaq 0x140(%rsp), %r13
movq %r13, %rdi
callq 0x4c201
leaq 0x4b80d(%rip), %rdx # 0x73b99
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x4c201
leaq 0x4b7c4(%rip), %rdx # 0x73b67
leaq 0x128(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4c201
leaq 0x4b49a(%rip), %rdx # 0x73857
leaq 0x98(%rsp), %rdi
movq %r13, %rsi
callq 0x4c201
leaq 0x4b471(%rip), %rdx # 0x73845
leaq 0x80(%rsp), %rdi
movq %r13, %rsi
callq 0x4c201
leaq 0x4b745(%rip), %rdx # 0x73b30
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x4c201
leaq 0x4b71f(%rip), %rdx # 0x73b1e
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x4c201
leaq 0x4b677(%rip), %rdx # 0x73a8a
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x4c201
leaq 0x4b44c(%rip), %rdx # 0x73873
leaq 0x158(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c201
movl (%r15), %edi
movq 0x8(%r15), %rsi
callq 0x4ac9d
cmpq $0x0, 0x10(%r12)
je 0x2852b
cmpq $0x0, 0x58(%rsp)
je 0x2852b
cmpq $0x0, 0x78(%rsp)
je 0x2852b
cmpq $0x0, 0x70(%rsp)
je 0x2852b
cmpq $0x0, 0xa8(%rsp)
je 0x2852b
cmpq $0x0, 0xa0(%rsp)
je 0x2852b
cmpq $0x0, 0x90(%rsp)
je 0x2852b
cmpq $0x0, 0x88(%rsp)
je 0x2852b
cmpq $0x0, 0x48(%rsp)
je 0x2852b
cmpq $0x0, 0x40(%rsp)
je 0x2852b
cmpq $0x0, 0x30(%rsp)
je 0x2852b
cmpq $0x0, 0x28(%rsp)
je 0x2852b
movq %rax, %r15
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x4c4d9
testq %r14, %r14
je 0x28552
pushq $0x20
popq %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4a2f6
testb %al, %al
jne 0x28576
leaq 0xb0(%rsp), %rsi
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x22230
testl %eax, %eax
je 0x28576
leaq 0x70(%rbx), %rdi
leaq 0x4bf86(%rip), %rsi # 0x744af
jmp 0x28536
leaq 0x70(%rbx), %rdi
leaq 0x4bf5c(%rip), %rsi # 0x74492
callq 0x4f75d
movb $0x0, 0x68(%rbx)
xorl %eax, %eax
addq $0x170, %rsp # imm = 0x170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x50(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0x98(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %r8
callq 0x293cc
testl %eax, %eax
jne 0x2853f
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x4c4d9
movl 0x38(%rsp), %edi
movq 0x40(%rsp), %rsi
pushq $0x37
popq %rcx
leaq 0xd0(%rsp), %r12
movq %r14, %rdx
movq %r12, %r8
callq 0x4cc62
movq 0x70(%rsp), %rsi
pushq $0x20
popq %rdx
movq %r12, %rdi
callq 0x22230
testl %eax, %eax
je 0x285dc
leaq 0x70(%rbx), %rdi
leaq 0x4beeb(%rip), %rsi # 0x744c2
jmp 0x28536
leaq 0x4b5d7(%rip), %rdx # 0x73bba
leaq 0x110(%rsp), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x4c201
movl (%r14), %edx
movq 0x8(%r14), %rcx
movl 0x80(%rbx), %r8d
leaq 0xb0(%rsp), %rsi
movq %r15, %rdi
callq 0x2889c
jmp 0x28541
| update_light_client_update:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 170h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+198h+var_98], xmm0
movaps [rsp+198h+var_A8], xmm0
movaps [rsp+198h+var_B8], xmm0
movaps [rsp+198h+var_C8], xmm0
movaps [rsp+198h+var_D8], xmm0
movaps [rsp+198h+var_E8], xmm0
lea rdx, aAttestedheader; "attestedHeader"
lea r13, [rsp+198h+var_58]
mov rdi, r13
call ssz_get
lea rdx, aBeacon; "beacon"
lea r12, [rsp+198h+var_148]
mov rdi, r12
mov rsi, r13
call ssz_get
lea rdx, aSyncaggregate; "syncAggregate"
lea r13, [rsp+198h+var_70]
mov rdi, r13
mov rsi, r15
call ssz_get
lea rdx, aSynccommittees; "syncCommitteeSignature"
lea rdi, [rsp+198h+var_100]
mov rsi, r13
call ssz_get
lea rdx, aSynccommitteeb; "syncCommitteeBits"
lea rdi, [rsp+198h+var_118]
mov rsi, r13
call ssz_get
lea rdx, aNextsynccommit; "nextSyncCommitteeBranch"
lea rdi, [rsp+198h+var_160]
mov rsi, r15
call ssz_get
lea rdx, aNextsynccommit_0; "nextSyncCommittee"
lea rdi, [rsp+198h+var_178]
mov rsi, r15
call ssz_get
lea rdx, aStateroot; "stateRoot"
lea rdi, [rsp+198h+var_130]
mov rsi, r12
call ssz_get
lea rdx, aSlot; "slot"
lea r15, [rsp+198h+var_40]
mov rdi, r15
mov rsi, r12
call ssz_get
mov edi, [r15]
mov rsi, [r15+8]
call bytes_as_le
cmp qword ptr [r12+10h], 0
jz loc_2852B
cmp qword ptr [rsp+198h+var_148+8], 0
jz loc_2852B
cmp [rsp+198h+var_120], 0
jz loc_2852B
cmp [rsp+198h+var_128], 0
jz loc_2852B
cmp [rsp+198h+var_F0], 0
jz loc_2852B
cmp [rsp+198h+var_F8], 0
jz loc_2852B
cmp [rsp+198h+var_108], 0
jz loc_2852B
cmp [rsp+198h+var_110], 0
jz short loc_2852B
cmp [rsp+198h+var_150], 0
jz short loc_2852B
cmp [rsp+198h+var_158], 0
jz short loc_2852B
cmp [rsp+198h+var_168], 0
jz short loc_2852B
cmp qword ptr [rsp+198h+var_178+8], 0
jz short loc_2852B
mov r15, rax
mov rax, [rsp+198h+var_138]
mov [rsp+198h+var_188], rax
movups xmm0, [rsp+198h+var_148]
movups [rsp+198h+var_198], xmm0
lea rdi, [rsp+198h+var_E8]
call ssz_hash_tree_root
test r14, r14
jz short loc_28552
push 20h ; ' '
pop rdi
mov rsi, r14
xor edx, edx
call bytes_all_equal
test al, al
jnz short loc_28576
lea rsi, [rsp+198h+var_E8]
push 20h ; ' '
pop rdx
mov rdi, r14
call _bcmp
test eax, eax
jz short loc_28576
lea rdi, [rbx+70h]
lea rsi, aInvalidBlockha; "invalid blockhash!"
jmp short loc_28536
loc_2852B:
lea rdi, [rbx+70h]
lea rsi, aInvalidLightCl; "invalid light client update!"
loc_28536:
call c4_state_add_error
mov byte ptr [rbx+68h], 0
loc_2853F:
xor eax, eax
loc_28541:
add rsp, 170h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_28552:
lea rsi, [rsp+198h+var_148]
lea rdx, [rsp+198h+var_118]
lea rcx, [rsp+198h+var_100]
mov rdi, rbx
mov r8, r15
call c4_verify_blockroot_signature
test eax, eax
jnz short loc_2853F
loc_28576:
mov rax, [rsp+198h+var_168]
mov [rsp+198h+var_188], rax
movups xmm0, [rsp+198h+var_178]
movups [rsp+198h+var_198], xmm0
lea r14, [rsp+198h+var_A8]
mov rdi, r14
call ssz_hash_tree_root
mov edi, [rsp+198h+var_160]
mov rsi, [rsp+198h+var_158]
push 37h ; '7'
pop rcx
lea r12, [rsp+198h+var_C8]
mov rdx, r14
mov r8, r12
call ssz_verify_single_merkle_proof
mov rsi, [rsp+198h+var_128]
push 20h ; ' '
pop rdx
mov rdi, r12
call _bcmp
test eax, eax
jz short loc_285DC
lea rdi, [rbx+70h]
lea rsi, aInvalidMerkleR; "invalid merkle root in light client upd"...
jmp loc_28536
loc_285DC:
lea rdx, aPubkeys; "pubkeys"
lea r14, [rsp+198h+var_88]
lea rsi, [rsp+198h+var_178]
mov rdi, r14
call ssz_get
mov edx, [r14]
mov rcx, [r14+8]
mov r8d, [rbx+80h]
lea rsi, [rsp+198h+var_E8]
mov rdi, r15
call c4_set_sync_period
jmp loc_28541
| long long update_light_client_update(long long a1, long long a2, long long *a3)
{
long long v5; // rsi
long long v6; // rax
long long v7; // rdx
long long v8; // rcx
long long v9; // r8
long long v10; // r9
long long v11; // r15
long long *v12; // rsi
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
long long v17; // rdi
const char *v18; // rsi
long long v20; // [rsp+20h] [rbp-178h] BYREF
long long v21; // [rsp+28h] [rbp-170h]
long long v22; // [rsp+30h] [rbp-168h]
unsigned int v23; // [rsp+38h] [rbp-160h] BYREF
long long v24; // [rsp+40h] [rbp-158h]
long long v25; // [rsp+48h] [rbp-150h]
long long v26; // [rsp+50h] [rbp-148h] BYREF
long long v27; // [rsp+58h] [rbp-140h]
long long v28; // [rsp+60h] [rbp-138h]
_BYTE v29[8]; // [rsp+68h] [rbp-130h] BYREF
long long v30; // [rsp+70h] [rbp-128h]
long long v31; // [rsp+78h] [rbp-120h]
_BYTE v32[8]; // [rsp+80h] [rbp-118h] BYREF
long long v33; // [rsp+88h] [rbp-110h]
long long v34; // [rsp+90h] [rbp-108h]
_BYTE v35[8]; // [rsp+98h] [rbp-100h] BYREF
long long v36; // [rsp+A0h] [rbp-F8h]
long long v37; // [rsp+A8h] [rbp-F0h]
_OWORD v38[2]; // [rsp+B0h] [rbp-E8h] BYREF
_OWORD v39[2]; // [rsp+D0h] [rbp-C8h] BYREF
_OWORD v40[2]; // [rsp+F0h] [rbp-A8h] BYREF
unsigned int v41; // [rsp+110h] [rbp-88h] BYREF
long long v42; // [rsp+118h] [rbp-80h]
_BYTE v43[24]; // [rsp+128h] [rbp-70h] BYREF
_BYTE v44[24]; // [rsp+140h] [rbp-58h] BYREF
unsigned int v45; // [rsp+158h] [rbp-40h] BYREF
long long v46; // [rsp+160h] [rbp-38h]
memset(v40, 0, sizeof(v40));
memset(v39, 0, sizeof(v39));
memset(v38, 0, sizeof(v38));
ssz_get(v44, a2);
ssz_get(&v26, v44);
ssz_get(v43, a2);
ssz_get(v35, v43);
ssz_get(v32, v43);
ssz_get(&v23, a2);
ssz_get(&v20, a2);
ssz_get(v29, &v26);
ssz_get(&v45, &v26);
v5 = v46;
v6 = bytes_as_le(v45);
if ( !v28 || !v27 || !v31 || !v30 || !v37 || !v36 || !v34 || !v33 || !v25 || !v24 || !v22 || !v21 )
{
v17 = a1 + 112;
v18 = "invalid light client update!";
goto LABEL_18;
}
v11 = v6;
ssz_hash_tree_root(v38, v5, v7, v8, v9, v10, v26, v27, v28);
if ( a3 )
{
v12 = a3;
if ( !(unsigned __int8)bytes_all_equal(32LL, a3, 0LL) )
{
v12 = (long long *)v38;
if ( (unsigned int)bcmp(a3, v38, 32LL) )
{
v17 = a1 + 112;
v18 = "invalid blockhash!";
LABEL_18:
c4_state_add_error(v17, v18);
*(_BYTE *)(a1 + 104) = 0;
return 0LL;
}
}
}
else
{
v12 = &v26;
if ( (unsigned int)c4_verify_blockroot_signature(a1, &v26, v32, v35, v11) )
return 0LL;
}
ssz_hash_tree_root(v40, v12, v13, v14, v15, v16, v20, v21, v22);
ssz_verify_single_merkle_proof(v23, v24, v40, 55LL, v39);
if ( (unsigned int)bcmp(v39, v30, 32LL) )
{
v17 = a1 + 112;
v18 = "invalid merkle root in light client update!";
goto LABEL_18;
}
ssz_get(&v41, &v20);
return c4_set_sync_period(v11, v38, v41, v42, *(unsigned int *)(a1 + 128));
}
| update_light_client_update:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x170
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
LEA RDX,[0x173b0f]
LEA R13,[RSP + 0x140]
MOV RDI,R13
CALL 0x0014c201
LEA RDX,[0x173b99]
LEA R12,[RSP + 0x50]
MOV RDI,R12
MOV RSI,R13
CALL 0x0014c201
LEA RDX,[0x173b67]
LEA R13,[RSP + 0x128]
MOV RDI,R13
MOV RSI,R15
CALL 0x0014c201
LEA RDX,[0x173857]
LEA RDI,[RSP + 0x98]
MOV RSI,R13
CALL 0x0014c201
LEA RDX,[0x173845]
LEA RDI,[RSP + 0x80]
MOV RSI,R13
CALL 0x0014c201
LEA RDX,[0x173b30]
LEA RDI,[RSP + 0x38]
MOV RSI,R15
CALL 0x0014c201
LEA RDX,[0x173b1e]
LEA RDI,[RSP + 0x20]
MOV RSI,R15
CALL 0x0014c201
LEA RDX,[0x173a8a]
LEA RDI,[RSP + 0x68]
MOV RSI,R12
CALL 0x0014c201
LEA RDX,[0x173873]
LEA R15,[RSP + 0x158]
MOV RDI,R15
MOV RSI,R12
CALL 0x0014c201
MOV EDI,dword ptr [R15]
MOV RSI,qword ptr [R15 + 0x8]
CALL 0x0014ac9d
CMP qword ptr [R12 + 0x10],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x58],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x78],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x70],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0xa8],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0xa0],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x90],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x88],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x48],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x40],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x30],0x0
JZ 0x0012852b
CMP qword ptr [RSP + 0x28],0x0
JZ 0x0012852b
MOV R15,RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0xb0]
CALL 0x0014c4d9
TEST R14,R14
JZ 0x00128552
PUSH 0x20
POP RDI
MOV RSI,R14
XOR EDX,EDX
CALL 0x0014a2f6
TEST AL,AL
JNZ 0x00128576
LEA RSI,[RSP + 0xb0]
PUSH 0x20
POP RDX
MOV RDI,R14
CALL 0x00122230
TEST EAX,EAX
JZ 0x00128576
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1744af]
JMP 0x00128536
LAB_0012852b:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x174492]
LAB_00128536:
CALL 0x0014f75d
MOV byte ptr [RBX + 0x68],0x0
LAB_0012853f:
XOR EAX,EAX
LAB_00128541:
ADD RSP,0x170
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00128552:
LEA RSI,[RSP + 0x50]
LEA RDX,[RSP + 0x80]
LEA RCX,[RSP + 0x98]
MOV RDI,RBX
MOV R8,R15
CALL 0x001293cc
TEST EAX,EAX
JNZ 0x0012853f
LAB_00128576:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0xf0]
MOV RDI,R14
CALL 0x0014c4d9
MOV EDI,dword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x40]
PUSH 0x37
POP RCX
LEA R12,[RSP + 0xd0]
MOV RDX,R14
MOV R8,R12
CALL 0x0014cc62
MOV RSI,qword ptr [RSP + 0x70]
PUSH 0x20
POP RDX
MOV RDI,R12
CALL 0x00122230
TEST EAX,EAX
JZ 0x001285dc
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1744c2]
JMP 0x00128536
LAB_001285dc:
LEA RDX,[0x173bba]
LEA R14,[RSP + 0x110]
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x0014c201
MOV EDX,dword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
MOV R8D,dword ptr [RBX + 0x80]
LEA RSI,[RSP + 0xb0]
MOV RDI,R15
CALL 0x0012889c
JMP 0x00128541
|
int8
update_light_client_update
(long param_1,int8 param_2,void *param_3,int8 param_4,int8 param_5,
int8 param_6)
{
char cVar1;
int iVar2;
int8 uVar3;
char *pcVar4;
int4 local_178 [2];
int4 uStack_170;
int4 uStack_16c;
long local_168;
int4 local_160 [2];
long local_158;
long local_150;
int4 local_148 [2];
int4 uStack_140;
int4 uStack_13c;
long local_138;
int1 local_130 [8];
void *local_128;
long local_120;
int1 local_118 [8];
long local_110;
long local_108;
int1 local_100 [8];
long local_f8;
long local_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int4 local_88 [2];
int8 local_80;
int1 local_70 [24];
int1 local_58 [24];
int4 local_40 [2];
int8 local_38;
local_98 = 0;
uStack_90 = 0;
local_a8 = 0;
uStack_a0 = 0;
local_b8 = 0;
uStack_b0 = 0;
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
local_e8 = 0;
uStack_e0 = 0;
ssz_get(local_58,param_2,"attestedHeader");
ssz_get(local_148,local_58,"beacon");
ssz_get(local_70,param_2,"syncAggregate");
ssz_get(local_100,local_70,"syncCommitteeSignature");
ssz_get(local_118,local_70,"syncCommitteeBits");
ssz_get(local_160,param_2,"nextSyncCommitteeBranch");
ssz_get(local_178,param_2,"nextSyncCommittee");
ssz_get(local_130,local_148,"stateRoot");
ssz_get(local_40,local_148,&DAT_00173873);
uVar3 = bytes_as_le(local_40[0],local_38);
if ((((((local_138 == 0) || (CONCAT44(uStack_13c,uStack_140) == 0)) || (local_120 == 0)) ||
(((local_128 == (void *)0x0 || (local_f0 == 0)) ||
((local_f8 == 0 || ((local_108 == 0 || (local_110 == 0)))))))) || (local_150 == 0)) ||
(((local_158 == 0 || (local_168 == 0)) || (CONCAT44(uStack_16c,uStack_170) == 0)))) {
pcVar4 = "invalid light client update!";
}
else {
ssz_hash_tree_root(&local_e8);
if (param_3 == (void *)0x0) {
iVar2 = c4_verify_blockroot_signature
(param_1,local_148,local_118,local_100,uVar3,param_6,local_148[0],uStack_140
,local_138);
if (iVar2 != 0) {
return 0;
}
}
else {
cVar1 = bytes_all_equal(0x20,param_3,0);
if ((cVar1 == '\0') && (iVar2 = bcmp(param_3,&local_e8,0x20), iVar2 != 0)) {
pcVar4 = "invalid blockhash!";
goto LAB_00128536;
}
}
ssz_hash_tree_root(&local_a8);
ssz_verify_single_merkle_proof
(local_160[0],local_158,&local_a8,0x37,&local_c8,param_6,local_178[0],uStack_170,
local_168);
iVar2 = bcmp(&local_c8,local_128,0x20);
if (iVar2 == 0) {
ssz_get(local_88,local_178,"pubkeys");
uVar3 = c4_set_sync_period(uVar3,&local_e8,local_88[0],local_80,
*(int4 *)(param_1 + 0x80));
return uVar3;
}
pcVar4 = "invalid merkle root in light client update!";
}
LAB_00128536:
c4_state_add_error(param_1 + 0x70,pcVar4);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
| |
43,399 | update_light_client_update | corpus-core[P]colibri-stateless/src/chains/eth/verifier/sync_committee.c | static bool update_light_client_update(verify_ctx_t* ctx, ssz_ob_t* update, bytes32_t trusted_blockhash) {
bytes32_t sync_root = {0};
bytes32_t merkle_root = {0};
bytes32_t blockhash = {0};
ssz_ob_t attested = ssz_get(update, "attestedHeader");
ssz_ob_t header = ssz_get(&attested, "beacon");
ssz_ob_t sync_aggregate = ssz_get(update, "syncAggregate");
ssz_ob_t signature = ssz_get(&sync_aggregate, "syncCommitteeSignature");
ssz_ob_t sync_bits = ssz_get(&sync_aggregate, "syncCommitteeBits");
ssz_ob_t merkle_proof = ssz_get(update, "nextSyncCommitteeBranch");
ssz_ob_t sync_committee = ssz_get(update, "nextSyncCommittee");
ssz_ob_t state_root = ssz_get(&header, "stateRoot");
uint64_t slot = ssz_get_uint64(&header, "slot");
if (ssz_is_error(header) || ssz_is_error(state_root) || ssz_is_error(signature) || ssz_is_error(sync_bits) || ssz_is_error(merkle_proof) || ssz_is_error(sync_committee))
RETURN_VERIFY_ERROR(ctx, "invalid light client update!");
// calculate the blockhash
ssz_hash_tree_root(header, blockhash);
// verify the signature of the old sync committee for the next sync committee
if (trusted_blockhash) {
if (!bytes_all_zero(bytes(trusted_blockhash, 32)) && memcmp(trusted_blockhash, blockhash, 32)) RETURN_VERIFY_ERROR(ctx, "invalid blockhash!");
}
else {
if (c4_verify_blockroot_signature(ctx, &header, &sync_bits, &signature, slot) != C4_SUCCESS) return false;
}
// create merkle root from proof
ssz_hash_tree_root(sync_committee, sync_root);
ssz_verify_single_merkle_proof(merkle_proof.bytes, sync_root, NEXT_SYNC_COMMITTEE_GINDEX, merkle_root);
// verify the merkle root
if (memcmp(merkle_root, state_root.bytes.data, 32)) RETURN_VERIFY_ERROR(ctx, "invalid merkle root in light client update!");
return c4_set_sync_period(slot, blockhash, ssz_get(&sync_committee, "pubkeys").bytes, ctx->chain_id);
} | O3 | c | update_light_client_update:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqa %xmm0, 0x100(%rsp)
movdqa %xmm0, 0xf0(%rsp)
movdqa %xmm0, 0xe0(%rsp)
movdqa %xmm0, 0xd0(%rsp)
movdqa %xmm0, 0x70(%rsp)
movdqa %xmm0, 0x60(%rsp)
leaq 0x57632(%rip), %rdx # 0x7fb0f
leaq 0x140(%rsp), %r13
movq %r13, %rdi
callq 0x53211
leaq 0x576a5(%rip), %rdx # 0x7fb99
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x53211
leaq 0x5765c(%rip), %rdx # 0x7fb67
leaq 0x128(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x53211
leaq 0x57332(%rip), %rdx # 0x7f857
leaq 0xb8(%rsp), %rdi
movq %r13, %rsi
callq 0x53211
leaq 0x57309(%rip), %rdx # 0x7f845
leaq 0xa0(%rsp), %rdi
movq %r13, %rsi
callq 0x53211
leaq 0x575dd(%rip), %rdx # 0x7fb30
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x53211
leaq 0x575b7(%rip), %rdx # 0x7fb1e
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x53211
leaq 0x5750f(%rip), %rdx # 0x7fa8a
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
callq 0x53211
leaq 0x572e1(%rip), %rdx # 0x7f873
leaq 0x158(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x53211
movl (%r15), %edi
movq 0x8(%r15), %rsi
callq 0x51c2a
cmpq $0x0, 0x10(%r12)
je 0x286b4
cmpq $0x0, 0x50(%rsp)
je 0x286b4
cmpq $0x0, 0x98(%rsp)
je 0x286b4
cmpq $0x0, 0x90(%rsp)
je 0x286b4
cmpq $0x0, 0xc8(%rsp)
je 0x286b4
cmpq $0x0, 0xc0(%rsp)
je 0x286b4
cmpq $0x0, 0xb0(%rsp)
je 0x286b4
cmpq $0x0, 0xa8(%rsp)
je 0x286b4
cmpq $0x0, 0x40(%rsp)
je 0x286b4
cmpq $0x0, 0x38(%rsp)
je 0x286b4
cmpq $0x0, 0x28(%rsp)
je 0x286b4
cmpq $0x0, 0x20(%rsp)
je 0x286b4
movq %rax, %r15
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqu 0x48(%rsp), %xmm0
movdqu %xmm0, (%rsp)
leaq 0x60(%rsp), %rdi
callq 0x53496
testq %r14, %r14
je 0x286db
movl $0x20, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x51165
testb %al, %al
jne 0x286ff
movdqu (%r14), %xmm0
movdqu 0x10(%r14), %xmm1
pcmpeqb 0x70(%rsp), %xmm1
pcmpeqb 0x60(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x286ff
leaq 0x70(%rbx), %rdi
leaq 0x57dfd(%rip), %rsi # 0x804af
jmp 0x286bf
leaq 0x70(%rbx), %rdi
leaq 0x57dd3(%rip), %rsi # 0x80492
callq 0x56981
movb $0x0, 0x68(%rbx)
xorl %eax, %eax
addq $0x170, %rsp # imm = 0x170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x48(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %r8
callq 0x2960f
testl %eax, %eax
jne 0x286c8
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x53496
movl 0x30(%rsp), %edi
movq 0x38(%rsp), %rsi
leaq 0xd0(%rsp), %r12
movl $0x37, %ecx
movq %r14, %rdx
movq %r12, %r8
callq 0x53c4e
movq 0x90(%rsp), %rax
movdqu (%rax), %xmm0
movdqu 0x10(%rax), %xmm1
pcmpeqb 0x10(%r12), %xmm1
pcmpeqb (%r12), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x28780
leaq 0x70(%rbx), %rdi
leaq 0x57d47(%rip), %rsi # 0x804c2
jmp 0x286bf
leaq 0x57433(%rip), %rdx # 0x7fbba
leaq 0x110(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x53211
movl (%r14), %edx
movq 0x8(%r14), %rcx
movl 0x80(%rbx), %r8d
leaq 0x60(%rsp), %rsi
movq %r15, %rdi
callq 0x28a63
jmp 0x286ca
| update_light_client_update:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 170h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
pxor xmm0, xmm0
movdqa [rsp+198h+var_98], xmm0
movdqa [rsp+198h+var_A8], xmm0
movdqa [rsp+198h+var_B8], xmm0
movdqa [rsp+198h+var_C8], xmm0
movdqa [rsp+198h+var_128], xmm0
movdqa [rsp+198h+var_138], xmm0
lea rdx, aAttestedheader; "attestedHeader"
lea r13, [rsp+198h+var_58]
mov rdi, r13
call ssz_get
lea rdx, aBeacon; "beacon"
lea r12, [rsp+198h+var_150]
mov rdi, r12
mov rsi, r13
call ssz_get
lea rdx, aSyncaggregate; "syncAggregate"
lea r13, [rsp+198h+var_70]
mov rdi, r13
mov rsi, r15
call ssz_get
lea rdx, aSynccommittees; "syncCommitteeSignature"
lea rdi, [rsp+198h+var_E0]
mov rsi, r13
call ssz_get
lea rdx, aSynccommitteeb; "syncCommitteeBits"
lea rdi, [rsp+198h+var_F8]
mov rsi, r13
call ssz_get
lea rdx, aNextsynccommit; "nextSyncCommitteeBranch"
lea rdi, [rsp+198h+var_168]
mov rsi, r15
call ssz_get
lea rdx, aNextsynccommit_0; "nextSyncCommittee"
lea rdi, [rsp+198h+var_180]
mov rsi, r15
call ssz_get
lea rdx, aStateroot; "stateRoot"
lea rdi, [rsp+198h+var_110]
mov rsi, r12
call ssz_get
lea rdx, aSlot; "slot"
lea r15, [rsp+198h+var_40]
mov rdi, r15
mov rsi, r12
call ssz_get
mov edi, [r15]
mov rsi, [r15+8]
call bytes_as_le
cmp qword ptr [r12+10h], 0
jz loc_286B4
cmp qword ptr [rsp+198h+var_150+8], 0
jz loc_286B4
cmp [rsp+198h+var_100], 0
jz loc_286B4
cmp [rsp+198h+var_108], 0
jz loc_286B4
cmp [rsp+198h+var_D0], 0
jz loc_286B4
cmp [rsp+198h+var_D8], 0
jz loc_286B4
cmp [rsp+198h+var_E8], 0
jz loc_286B4
cmp [rsp+198h+var_F0], 0
jz loc_286B4
cmp [rsp+198h+var_158], 0
jz loc_286B4
cmp [rsp+198h+var_160], 0
jz short loc_286B4
cmp [rsp+198h+var_170], 0
jz short loc_286B4
cmp qword ptr [rsp+198h+var_180+8], 0
jz short loc_286B4
mov r15, rax
mov rax, [rsp+198h+var_140]
mov [rsp+198h+var_188], rax
movdqu xmm0, [rsp+198h+var_150]
movdqu [rsp+198h+var_198], xmm0
lea rdi, [rsp+198h+var_138]
call ssz_hash_tree_root
test r14, r14
jz short loc_286DB
mov edi, 20h ; ' '
mov rsi, r14
xor edx, edx
call bytes_all_equal
test al, al
jnz short loc_286FF
movdqu xmm0, xmmword ptr [r14]
movdqu xmm1, xmmword ptr [r14+10h]
pcmpeqb xmm1, [rsp+198h+var_128]
pcmpeqb xmm0, [rsp+198h+var_138]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
jz short loc_286FF
lea rdi, [rbx+70h]
lea rsi, aInvalidBlockha; "invalid blockhash!"
jmp short loc_286BF
loc_286B4:
lea rdi, [rbx+70h]
lea rsi, aInvalidLightCl; "invalid light client update!"
loc_286BF:
call c4_state_add_error
mov byte ptr [rbx+68h], 0
loc_286C8:
xor eax, eax
loc_286CA:
add rsp, 170h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_286DB:
lea rsi, [rsp+198h+var_150]
lea rdx, [rsp+198h+var_F8]
lea rcx, [rsp+198h+var_E0]
mov rdi, rbx
mov r8, r15
call c4_verify_blockroot_signature
test eax, eax
jnz short loc_286C8
loc_286FF:
mov rax, [rsp+198h+var_170]
mov [rsp+198h+var_188], rax
movups xmm0, [rsp+198h+var_180]
movups [rsp+198h+var_198], xmm0
lea r14, [rsp+198h+var_A8]
mov rdi, r14
call ssz_hash_tree_root
mov edi, [rsp+198h+var_168]
mov rsi, [rsp+198h+var_160]
lea r12, [rsp+198h+var_C8]
mov ecx, 37h ; '7'
mov rdx, r14
mov r8, r12
call ssz_verify_single_merkle_proof
mov rax, [rsp+198h+var_108]
movdqu xmm0, xmmword ptr [rax]
movdqu xmm1, xmmword ptr [rax+10h]
pcmpeqb xmm1, xmmword ptr [r12+10h]
pcmpeqb xmm0, xmmword ptr [r12]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
jz short loc_28780
lea rdi, [rbx+70h]
lea rsi, aInvalidMerkleR; "invalid merkle root in light client upd"...
jmp loc_286BF
loc_28780:
lea rdx, aPubkeys; "pubkeys"
lea r14, [rsp+198h+var_88]
lea rsi, [rsp+198h+var_180]
mov rdi, r14
call ssz_get
mov edx, [r14]
mov rcx, [r14+8]
mov r8d, [rbx+80h]
lea rsi, [rsp+198h+var_138]
mov rdi, r15
call c4_set_sync_period
jmp loc_286CA
| long long update_light_client_update(long long a1, long long a2, const __m128i *a3)
{
long long v5; // rsi
long long v6; // rax
long long v7; // rdx
long long v8; // rcx
long long v9; // r8
long long v10; // r9
long long v11; // r15
__m128i v12; // xmm0
__m128i *v13; // rsi
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // rdi
const char *v19; // rsi
long long v21; // [rsp+18h] [rbp-180h] BYREF
long long v22; // [rsp+20h] [rbp-178h]
long long v23; // [rsp+28h] [rbp-170h]
unsigned int v24; // [rsp+30h] [rbp-168h] BYREF
long long v25; // [rsp+38h] [rbp-160h]
long long v26; // [rsp+40h] [rbp-158h]
__m128i v27; // [rsp+48h] [rbp-150h] BYREF
long long v28; // [rsp+58h] [rbp-140h]
__m128i v29; // [rsp+60h] [rbp-138h] BYREF
__m128i v30; // [rsp+70h] [rbp-128h]
_BYTE v31[8]; // [rsp+88h] [rbp-110h] BYREF
const __m128i *v32; // [rsp+90h] [rbp-108h]
long long v33; // [rsp+98h] [rbp-100h]
_BYTE v34[8]; // [rsp+A0h] [rbp-F8h] BYREF
long long v35; // [rsp+A8h] [rbp-F0h]
long long v36; // [rsp+B0h] [rbp-E8h]
_BYTE v37[8]; // [rsp+B8h] [rbp-E0h] BYREF
long long v38; // [rsp+C0h] [rbp-D8h]
long long v39; // [rsp+C8h] [rbp-D0h]
__m128i v40; // [rsp+D0h] [rbp-C8h] BYREF
__m128i v41; // [rsp+E0h] [rbp-B8h]
_OWORD v42[2]; // [rsp+F0h] [rbp-A8h] BYREF
unsigned int v43; // [rsp+110h] [rbp-88h] BYREF
long long v44; // [rsp+118h] [rbp-80h]
_BYTE v45[24]; // [rsp+128h] [rbp-70h] BYREF
_BYTE v46[24]; // [rsp+140h] [rbp-58h] BYREF
unsigned int v47; // [rsp+158h] [rbp-40h] BYREF
long long v48; // [rsp+160h] [rbp-38h]
memset(v42, 0, sizeof(v42));
v41 = 0LL;
v40 = 0LL;
v30 = 0LL;
v29 = 0LL;
ssz_get(v46, a2);
ssz_get(&v27, v46);
ssz_get(v45, a2);
ssz_get(v37, v45);
ssz_get(v34, v45);
ssz_get(&v24, a2);
ssz_get(&v21, a2);
ssz_get(v31, &v27);
ssz_get(&v47, &v27);
v5 = v48;
v6 = bytes_as_le(v47, v48);
if ( !v28 || !v27.m128i_i64[1] || !v33 || !v32 || !v39 || !v38 || !v36 || !v35 || !v26 || !v25 || !v23 || !v22 )
{
v18 = a1 + 112;
v19 = "invalid light client update!";
goto LABEL_18;
}
v11 = v6;
v12 = _mm_loadu_si128(&v27);
ssz_hash_tree_root(&v29, v5, v7, v8, v9, v10, v12.m128i_i64[0], v12.m128i_i64[1], v28);
if ( a3 )
{
v13 = (__m128i *)a3;
if ( !(unsigned __int8)bytes_all_equal(32LL, a3, 0LL)
&& _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_loadu_si128(a3), v29), _mm_cmpeq_epi8(_mm_loadu_si128(a3 + 1), v30))) != 0xFFFF )
{
v18 = a1 + 112;
v19 = "invalid blockhash!";
LABEL_18:
c4_state_add_error(v18, v19);
*(_BYTE *)(a1 + 104) = 0;
return 0LL;
}
}
else
{
v13 = &v27;
if ( (unsigned int)c4_verify_blockroot_signature(a1, &v27, v34, v37, v11) )
return 0LL;
}
ssz_hash_tree_root(v42, v13, v14, v15, v16, v17, v21, v22, v23);
ssz_verify_single_merkle_proof(v24, v25, v42, 55LL, &v40);
if ( _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_loadu_si128(v32), v40), _mm_cmpeq_epi8(_mm_loadu_si128(v32 + 1), v41))) != 0xFFFF )
{
v18 = a1 + 112;
v19 = "invalid merkle root in light client update!";
goto LABEL_18;
}
ssz_get(&v43, &v21);
return c4_set_sync_period(v11, &v29, v43, v44, *(unsigned int *)(a1 + 128));
}
| update_light_client_update:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x170
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
PXOR XMM0,XMM0
MOVDQA xmmword ptr [RSP + 0x100],XMM0
MOVDQA xmmword ptr [RSP + 0xf0],XMM0
MOVDQA xmmword ptr [RSP + 0xe0],XMM0
MOVDQA xmmword ptr [RSP + 0xd0],XMM0
MOVDQA xmmword ptr [RSP + 0x70],XMM0
MOVDQA xmmword ptr [RSP + 0x60],XMM0
LEA RDX,[0x17fb0f]
LEA R13,[RSP + 0x140]
MOV RDI,R13
CALL 0x00153211
LEA RDX,[0x17fb99]
LEA R12,[RSP + 0x48]
MOV RDI,R12
MOV RSI,R13
CALL 0x00153211
LEA RDX,[0x17fb67]
LEA R13,[RSP + 0x128]
MOV RDI,R13
MOV RSI,R15
CALL 0x00153211
LEA RDX,[0x17f857]
LEA RDI,[RSP + 0xb8]
MOV RSI,R13
CALL 0x00153211
LEA RDX,[0x17f845]
LEA RDI,[RSP + 0xa0]
MOV RSI,R13
CALL 0x00153211
LEA RDX,[0x17fb30]
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x00153211
LEA RDX,[0x17fb1e]
LEA RDI,[RSP + 0x18]
MOV RSI,R15
CALL 0x00153211
LEA RDX,[0x17fa8a]
LEA RDI,[RSP + 0x88]
MOV RSI,R12
CALL 0x00153211
LEA RDX,[0x17f873]
LEA R15,[RSP + 0x158]
MOV RDI,R15
MOV RSI,R12
CALL 0x00153211
MOV EDI,dword ptr [R15]
MOV RSI,qword ptr [R15 + 0x8]
CALL 0x00151c2a
CMP qword ptr [R12 + 0x10],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x50],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x98],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x90],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0xc8],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0xc0],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0xb0],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0xa8],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x40],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x38],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x28],0x0
JZ 0x001286b4
CMP qword ptr [RSP + 0x20],0x0
JZ 0x001286b4
MOV R15,RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x10],RAX
MOVDQU XMM0,xmmword ptr [RSP + 0x48]
MOVDQU xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x60]
CALL 0x00153496
TEST R14,R14
JZ 0x001286db
MOV EDI,0x20
MOV RSI,R14
XOR EDX,EDX
CALL 0x00151165
TEST AL,AL
JNZ 0x001286ff
MOVDQU XMM0,xmmword ptr [R14]
MOVDQU XMM1,xmmword ptr [R14 + 0x10]
PCMPEQB XMM1,xmmword ptr [RSP + 0x70]
PCMPEQB XMM0,xmmword ptr [RSP + 0x60]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
JZ 0x001286ff
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1804af]
JMP 0x001286bf
LAB_001286b4:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x180492]
LAB_001286bf:
CALL 0x00156981
MOV byte ptr [RBX + 0x68],0x0
LAB_001286c8:
XOR EAX,EAX
LAB_001286ca:
ADD RSP,0x170
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_001286db:
LEA RSI,[RSP + 0x48]
LEA RDX,[RSP + 0xa0]
LEA RCX,[RSP + 0xb8]
MOV RDI,RBX
MOV R8,R15
CALL 0x0012960f
TEST EAX,EAX
JNZ 0x001286c8
LAB_001286ff:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x18]
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0xf0]
MOV RDI,R14
CALL 0x00153496
MOV EDI,dword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
LEA R12,[RSP + 0xd0]
MOV ECX,0x37
MOV RDX,R14
MOV R8,R12
CALL 0x00153c4e
MOV RAX,qword ptr [RSP + 0x90]
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM1,xmmword ptr [RAX + 0x10]
PCMPEQB XMM1,xmmword ptr [R12 + 0x10]
PCMPEQB XMM0,xmmword ptr [R12]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
JZ 0x00128780
LEA RDI,[RBX + 0x70]
LEA RSI,[0x1804c2]
JMP 0x001286bf
LAB_00128780:
LEA RDX,[0x17fbba]
LEA R14,[RSP + 0x110]
LEA RSI,[RSP + 0x18]
MOV RDI,R14
CALL 0x00153211
MOV EDX,dword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
MOV R8D,dword ptr [RBX + 0x80]
LEA RSI,[RSP + 0x60]
MOV RDI,R15
CALL 0x00128a63
JMP 0x001286ca
|
int8
update_light_client_update
(long param_1,int8 param_2,char *param_3,int8 param_4,int8 param_5,
int8 param_6)
{
char cVar1;
int iVar2;
int8 uVar3;
char *pcVar4;
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int8 local_180;
long lStack_178;
long local_170;
int4 local_168 [2];
long local_160;
long local_158;
int8 local_150;
long lStack_148;
long local_140;
int1 local_138 [16];
int1 local_128 [16];
int1 local_110 [8];
char *local_108;
long local_100;
int1 local_f8 [8];
long local_f0;
long local_e8;
int1 local_e0 [8];
long local_d8;
long local_d0;
int1 local_c8 [16];
int1 local_b8 [16];
int1 local_a8 [16];
int1 local_98 [16];
int4 local_88 [2];
int8 local_80;
int1 local_70 [24];
int1 local_58 [24];
int4 local_40 [2];
int8 local_38;
local_98 = (int1 [16])0x0;
local_a8 = (int1 [16])0x0;
local_b8 = (int1 [16])0x0;
local_c8 = (int1 [16])0x0;
local_128 = (int1 [16])0x0;
local_138 = (int1 [16])0x0;
ssz_get(local_58,param_2,"attestedHeader");
ssz_get(&local_150,local_58,"beacon");
ssz_get(local_70,param_2,"syncAggregate");
ssz_get(local_e0,local_70,"syncCommitteeSignature");
ssz_get(local_f8,local_70,"syncCommitteeBits");
ssz_get(local_168,param_2,"nextSyncCommitteeBranch");
ssz_get(&local_180,param_2,"nextSyncCommittee");
ssz_get(local_110,&local_150,"stateRoot");
ssz_get(local_40,&local_150,&DAT_0017f873);
uVar3 = bytes_as_le(local_40[0],local_38);
if (((((local_140 == 0) || (lStack_148 == 0)) || (local_100 == 0)) ||
((((local_108 == (char *)0x0 || (local_d0 == 0)) ||
((local_d8 == 0 || ((local_e8 == 0 || (local_f0 == 0)))))) || (local_158 == 0)))) ||
(((local_160 == 0 || (local_170 == 0)) || (lStack_178 == 0)))) {
pcVar4 = "invalid light client update!";
}
else {
ssz_hash_tree_root(local_138);
if (param_3 == (char *)0x0) {
iVar2 = c4_verify_blockroot_signature
(param_1,&local_150,local_f8,local_e0,uVar3,param_6,local_150,lStack_148,
local_140);
if (iVar2 != 0) {
return 0;
}
}
else {
cVar1 = bytes_all_equal(0x20,param_3,0);
if (cVar1 == '\0') {
auVar7[0] = -(param_3[0x10] == local_128[0]);
auVar7[1] = -(param_3[0x11] == local_128[1]);
auVar7[2] = -(param_3[0x12] == local_128[2]);
auVar7[3] = -(param_3[0x13] == local_128[3]);
auVar7[4] = -(param_3[0x14] == local_128[4]);
auVar7[5] = -(param_3[0x15] == local_128[5]);
auVar7[6] = -(param_3[0x16] == local_128[6]);
auVar7[7] = -(param_3[0x17] == local_128[7]);
auVar7[8] = -(param_3[0x18] == local_128[8]);
auVar7[9] = -(param_3[0x19] == local_128[9]);
auVar7[10] = -(param_3[0x1a] == local_128[10]);
auVar7[0xb] = -(param_3[0x1b] == local_128[0xb]);
auVar7[0xc] = -(param_3[0x1c] == local_128[0xc]);
auVar7[0xd] = -(param_3[0x1d] == local_128[0xd]);
auVar7[0xe] = -(param_3[0x1e] == local_128[0xe]);
auVar7[0xf] = -(param_3[0x1f] == local_128[0xf]);
auVar5[0] = -(*param_3 == local_138[0]);
auVar5[1] = -(param_3[1] == local_138[1]);
auVar5[2] = -(param_3[2] == local_138[2]);
auVar5[3] = -(param_3[3] == local_138[3]);
auVar5[4] = -(param_3[4] == local_138[4]);
auVar5[5] = -(param_3[5] == local_138[5]);
auVar5[6] = -(param_3[6] == local_138[6]);
auVar5[7] = -(param_3[7] == local_138[7]);
auVar5[8] = -(param_3[8] == local_138[8]);
auVar5[9] = -(param_3[9] == local_138[9]);
auVar5[10] = -(param_3[10] == local_138[10]);
auVar5[0xb] = -(param_3[0xb] == local_138[0xb]);
auVar5[0xc] = -(param_3[0xc] == local_138[0xc]);
auVar5[0xd] = -(param_3[0xd] == local_138[0xd]);
auVar5[0xe] = -(param_3[0xe] == local_138[0xe]);
auVar5[0xf] = -(param_3[0xf] == local_138[0xf]);
auVar5 = auVar5 & auVar7;
if ((ushort)((ushort)(SUB161(auVar5 >> 7,0) & 1) |
(ushort)(SUB161(auVar5 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar5 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar5 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar5 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar5 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar5 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar5 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar5 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar5 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar5 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar5 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar5 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar5 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar5 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar5[0xf] >> 7) << 0xf) != 0xffff) {
pcVar4 = "invalid blockhash!";
goto LAB_001286bf;
}
}
}
ssz_hash_tree_root(local_a8);
ssz_verify_single_merkle_proof
(local_168[0],local_160,local_a8,0x37,local_c8,param_6,local_180,lStack_178,local_170)
;
auVar8[0] = -(local_108[0x10] == local_b8[0]);
auVar8[1] = -(local_108[0x11] == local_b8[1]);
auVar8[2] = -(local_108[0x12] == local_b8[2]);
auVar8[3] = -(local_108[0x13] == local_b8[3]);
auVar8[4] = -(local_108[0x14] == local_b8[4]);
auVar8[5] = -(local_108[0x15] == local_b8[5]);
auVar8[6] = -(local_108[0x16] == local_b8[6]);
auVar8[7] = -(local_108[0x17] == local_b8[7]);
auVar8[8] = -(local_108[0x18] == local_b8[8]);
auVar8[9] = -(local_108[0x19] == local_b8[9]);
auVar8[10] = -(local_108[0x1a] == local_b8[10]);
auVar8[0xb] = -(local_108[0x1b] == local_b8[0xb]);
auVar8[0xc] = -(local_108[0x1c] == local_b8[0xc]);
auVar8[0xd] = -(local_108[0x1d] == local_b8[0xd]);
auVar8[0xe] = -(local_108[0x1e] == local_b8[0xe]);
auVar8[0xf] = -(local_108[0x1f] == local_b8[0xf]);
auVar6[0] = -(*local_108 == local_c8[0]);
auVar6[1] = -(local_108[1] == local_c8[1]);
auVar6[2] = -(local_108[2] == local_c8[2]);
auVar6[3] = -(local_108[3] == local_c8[3]);
auVar6[4] = -(local_108[4] == local_c8[4]);
auVar6[5] = -(local_108[5] == local_c8[5]);
auVar6[6] = -(local_108[6] == local_c8[6]);
auVar6[7] = -(local_108[7] == local_c8[7]);
auVar6[8] = -(local_108[8] == local_c8[8]);
auVar6[9] = -(local_108[9] == local_c8[9]);
auVar6[10] = -(local_108[10] == local_c8[10]);
auVar6[0xb] = -(local_108[0xb] == local_c8[0xb]);
auVar6[0xc] = -(local_108[0xc] == local_c8[0xc]);
auVar6[0xd] = -(local_108[0xd] == local_c8[0xd]);
auVar6[0xe] = -(local_108[0xe] == local_c8[0xe]);
auVar6[0xf] = -(local_108[0xf] == local_c8[0xf]);
auVar6 = auVar6 & auVar8;
if ((ushort)((ushort)(SUB161(auVar6 >> 7,0) & 1) | (ushort)(SUB161(auVar6 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar6 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar6 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar6 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar6 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar6 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar6 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar6 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar6 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar6 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar6 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar6 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar6 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar6 >> 0x77,0) & 1) << 0xe |
(ushort)(byte)(auVar6[0xf] >> 7) << 0xf) == 0xffff) {
ssz_get(local_88,&local_180,"pubkeys");
uVar3 = c4_set_sync_period(uVar3,local_138,local_88[0],local_80,
*(int4 *)(param_1 + 0x80));
return uVar3;
}
pcVar4 = "invalid merkle root in light client update!";
}
LAB_001286bf:
c4_state_add_error(param_1 + 0x70,pcVar4);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
|
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.