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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
58,500
|
my_coll_parser_scan_shift
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_shift(MY_COLL_RULE_PARSER *p)
{
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_SHIFT)
{
my_coll_rule_shift_at_level(&p->rule, my_coll_parser_curr(p)->diff);
return my_coll_parser_scan(p);
}
return 0;
}
|
O3
|
c
|
my_coll_parser_scan_shift:
xorl %eax, %eax
cmpl $0x1, (%rdi)
jne 0x44ce6
movl 0x20(%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x44cb9
leaq 0x1a64f8(%rip), %rcx # 0x1eb160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xd0(%rdi)
movl $0x0, 0xdc(%rdi)
movq $0x0, 0xd4(%rdi)
jmp 0x44cb9
incl 0xd8(%rdi)
movl $0x0, 0xdc(%rdi)
jmp 0x44cb9
incl 0xdc(%rdi)
jmp 0x44cb9
incl 0xd4(%rdi)
movq $0x0, 0xd8(%rdi)
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movups 0x28(%rdi), %xmm0
movups 0x38(%rdi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, %rdi
callq 0x449b3
movl $0x1, %eax
popq %rbp
retq
|
my_coll_parser_scan_shift:
xor eax, eax
cmp dword ptr [rdi], 1
jnz locret_44CE6
mov eax, [rdi+20h]
dec eax; switch 4 cases
cmp eax, 3
ja short def_44C6F; jumptable 0000000000044C6F default case
lea rcx, jpt_44C6F
movsxd rax, ds:(jpt_44C6F - 1EB160h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_44C71:
inc dword ptr [rdi+0D0h]; jumptable 0000000000044C6F case 1
mov dword ptr [rdi+0DCh], 0
mov qword ptr [rdi+0D4h], 0
jmp short def_44C6F; jumptable 0000000000044C6F default case
loc_44C8E:
inc dword ptr [rdi+0D8h]; jumptable 0000000000044C6F case 3
mov dword ptr [rdi+0DCh], 0
jmp short def_44C6F; jumptable 0000000000044C6F default case
loc_44CA0:
inc dword ptr [rdi+0DCh]; jumptable 0000000000044C6F case 4
jmp short def_44C6F; jumptable 0000000000044C6F default case
loc_44CA8:
inc dword ptr [rdi+0D4h]; jumptable 0000000000044C6F case 2
mov qword ptr [rdi+0D8h], 0
def_44C6F:
push rbp; jumptable 0000000000044C6F default case
mov rbp, rsp
lea rax, [rdi+28h]
mov rcx, [rdi+48h]
mov [rdi+20h], rcx
movups xmm0, xmmword ptr [rdi+28h]
movups xmm1, xmmword ptr [rdi+38h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov rdi, rax
call my_coll_lexem_next
mov eax, 1
pop rbp
locret_44CE6:
retn
|
long long my_coll_parser_scan_shift(long long a1)
{
long long result; // rax
__int128 v2; // xmm0
result = 0LL;
if ( *(_DWORD *)a1 == 1 )
{
switch ( *(_DWORD *)(a1 + 32) )
{
case 1:
++*(_DWORD *)(a1 + 208);
*(_DWORD *)(a1 + 220) = 0;
*(_QWORD *)(a1 + 212) = 0LL;
break;
case 2:
++*(_DWORD *)(a1 + 212);
*(_QWORD *)(a1 + 216) = 0LL;
break;
case 3:
++*(_DWORD *)(a1 + 216);
*(_DWORD *)(a1 + 220) = 0;
break;
case 4:
++*(_DWORD *)(a1 + 220);
break;
default:
break;
}
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v2 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v2;
my_coll_lexem_next(a1 + 40);
return 1LL;
}
return result;
}
|
my_coll_parser_scan_shift:
XOR EAX,EAX
CMP dword ptr [RDI],0x1
JNZ 0x00144ce6
MOV EAX,dword ptr [RDI + 0x20]
DEC EAX
CMP EAX,0x3
JA 0x00144cb9
LEA RCX,[0x2eb160]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
INC dword ptr [RDI + 0xd0]
MOV dword ptr [RDI + 0xdc],0x0
MOV qword ptr [RDI + 0xd4],0x0
JMP 0x00144cb9
caseD_3:
INC dword ptr [RDI + 0xd8]
MOV dword ptr [RDI + 0xdc],0x0
JMP 0x00144cb9
caseD_4:
INC dword ptr [RDI + 0xdc]
JMP 0x00144cb9
caseD_2:
INC dword ptr [RDI + 0xd4]
MOV qword ptr [RDI + 0xd8],0x0
default:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x28]
MOV RCX,qword ptr [RDI + 0x48]
MOV qword ptr [RDI + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RDI + 0x28]
MOVUPS XMM1,xmmword ptr [RDI + 0x38]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
CALL 0x001449b3
MOV EAX,0x1
POP RBP
LAB_00144ce6:
RET
|
int8 my_coll_parser_scan_shift(int *param_1)
{
int8 uVar1;
uVar1 = 0;
if (*param_1 == 1) {
switch(param_1[8]) {
case 1:
param_1[0x34] = param_1[0x34] + 1;
param_1[0x37] = 0;
param_1[0x35] = 0;
param_1[0x36] = 0;
break;
case 2:
param_1[0x35] = param_1[0x35] + 1;
param_1[0x36] = 0;
param_1[0x37] = 0;
break;
case 3:
param_1[0x36] = param_1[0x36] + 1;
param_1[0x37] = 0;
break;
case 4:
param_1[0x37] = param_1[0x37] + 1;
}
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
uVar1 = 1;
}
return uVar1;
}
|
|
58,501
|
ma_log_suffix
|
eloqsql/storage/maria/ma_key_recover.c
|
my_bool _ma_log_suffix(MARIA_PAGE *ma_page, uint org_length, uint new_length)
{
LSN lsn;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 4];
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 10 + 7 + 2], *log_pos;
uchar *buff= ma_page->buff;
int diff;
uint translog_parts, extra_length;
MARIA_HA *info= ma_page->info;
pgcache_page_no_t page= ma_page->pos / info->s->block_size;
DBUG_ENTER("_ma_log_suffix");
DBUG_PRINT("enter", ("page: %lu org_length: %u new_length: %u",
(ulong) page, org_length, new_length));
DBUG_ASSERT(ma_page->size == new_length);
DBUG_ASSERT(ma_page->org_size == org_length);
log_pos= log_data + FILEID_STORE_SIZE;
page_store(log_pos, page);
log_pos+= PAGE_STORE_SIZE;
/* Store keypage_flag */
*log_pos++= KEY_OP_SET_PAGEFLAG;
*log_pos++= _ma_get_keypage_flag(info->s, buff);
if ((diff= (int) (new_length - org_length)) < 0)
{
log_pos[0]= KEY_OP_DEL_SUFFIX;
int2store(log_pos+1, -diff);
log_pos+= 3;
translog_parts= 1;
extra_length= 0;
}
else
{
log_pos[0]= KEY_OP_ADD_SUFFIX;
int2store(log_pos+1, diff);
log_pos+= 3;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= buff + org_length;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= (uint) diff;
translog_parts= 2;
extra_length= (uint) diff;
}
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= (uint) (log_pos -
log_data);
_ma_log_key_changes(ma_page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
DBUG_RETURN(translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t)
log_array[TRANSLOG_INTERNAL_PARTS +
0].length + extra_length,
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL));
}
|
O3
|
c
|
ma_log_suffix:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movl %edx, %r10d
movq %fs:0x28, %rax
movq %rax, -0x10(%rbp)
movq (%rdi), %rcx
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %rax
movq (%rcx), %r11
movl 0x7bc(%r11), %ebx
xorl %r8d, %r8d
xorl %edx, %edx
divq %rbx
movl %eax, -0x2e(%rbp)
shrq $0x20, %rax
movb %al, -0x2a(%rbp)
movb $0xa, -0x29(%rbp)
movl 0x744(%r11), %eax
addl $-0x3, %eax
movb (%r9,%rax), %al
movb %al, -0x28(%rbp)
subl %esi, %r10d
js 0x3e29b
leaq -0x24(%rbp), %rax
movl %esi, %edx
addq %rdx, %r9
movq %r9, -0x70(%rbp)
movl %r10d, %edx
movq %rdx, -0x68(%rbp)
movl $0x4, %r9d
movb $0x6, %dl
movl %r10d, %r8d
jmp 0x3e2aa
negl %r10d
movl $0x3, %r9d
movb $0x7, %dl
leaq -0x24(%rbp), %rax
leaq -0x30(%rbp), %r11
movb %dl, 0x9(%r11)
movw %r10w, 0xa(%r11)
leaq -0xa0(%rbp), %r10
movq %r11, 0x20(%r10)
subq %r11, %rax
movl %eax, %edx
movq %rdx, 0x28(%r10)
movl 0x20(%rdi), %edx
movl %edx, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl %eax, %r8d
subq $0x8, %rsp
leaq -0x38(%rbp), %rdi
movl $0xc, %esi
pushq $0x0
pushq %r11
pushq %r10
callq 0x2bde9
addq $0x20, %rsp
movq %fs:0x28, %rcx
cmpq -0x10(%rbp), %rcx
jne 0x3e30d
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
callq 0x2a240
|
_ma_log_suffix:
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov r10d, edx
mov rax, fs:28h
mov [rbp+var_10], rax
mov rcx, [rdi]
mov r9, [rdi+10h]
mov rax, [rdi+18h]
mov r11, [rcx]
mov ebx, [r11+7BCh]
xor r8d, r8d
xor edx, edx
div rbx
mov [rbp+var_2E], eax
shr rax, 20h
mov [rbp+var_2A], al
mov [rbp+var_29], 0Ah
mov eax, [r11+744h]
add eax, 0FFFFFFFDh
mov al, [r9+rax]
mov [rbp+var_28], al
sub r10d, esi
js short loc_3E29B
lea rax, [rbp+var_24]
mov edx, esi
add r9, rdx
mov [rbp+var_70], r9
mov edx, r10d
mov [rbp+var_68], rdx
mov r9d, 4
mov dl, 6
mov r8d, r10d
jmp short loc_3E2AA
loc_3E29B:
neg r10d
mov r9d, 3
mov dl, 7
lea rax, [rbp+var_24]
loc_3E2AA:
lea r11, [rbp+var_30]
mov [r11+9], dl
mov [r11+0Ah], r10w
lea r10, [rbp+var_A0]
mov [r10+20h], r11
sub rax, r11
mov edx, eax
mov [r10+28h], rdx
mov edx, [rdi+20h]
mov [rdi+24h], edx
mov rdx, [rcx+8]
add r8d, eax
sub rsp, 8
lea rdi, [rbp+var_38]
mov esi, 0Ch
push 0
push r11
push r10
call translog_write_record
add rsp, 20h
mov rcx, fs:28h
cmp rcx, [rbp+var_10]
jnz short loc_3E30D
add rsp, 98h
pop rbx
pop rbp
retn
loc_3E30D:
call ___stack_chk_fail
|
long long ma_log_suffix(long long **a1, unsigned int a2, int a3)
{
long long *v3; // rcx
long long *v4; // r9
long long v5; // r11
unsigned int v6; // r8d
unsigned long long v7; // rax
unsigned int v8; // r10d
int v9; // r9d
char v10; // dl
__int128 v12; // [rsp+0h] [rbp-A0h] BYREF
__int16 *v13; // [rsp+20h] [rbp-80h]
long long v14; // [rsp+28h] [rbp-78h]
long long v15; // [rsp+30h] [rbp-70h]
long long v16; // [rsp+38h] [rbp-68h]
_BYTE v17[8]; // [rsp+68h] [rbp-38h] BYREF
__int16 v18; // [rsp+70h] [rbp-30h] BYREF
int v19; // [rsp+72h] [rbp-2Eh]
char v20; // [rsp+76h] [rbp-2Ah]
char v21; // [rsp+77h] [rbp-29h]
char v22; // [rsp+78h] [rbp-28h]
char v23; // [rsp+79h] [rbp-27h]
__int16 v24; // [rsp+7Ah] [rbp-26h]
_BYTE v25[20]; // [rsp+7Ch] [rbp-24h] BYREF
unsigned long long v26; // [rsp+90h] [rbp-10h]
v26 = __readfsqword(0x28u);
v3 = *a1;
v4 = a1[2];
v5 = **a1;
v6 = 0;
v7 = (unsigned long long)a1[3] / *(unsigned int *)(v5 + 1980);
v19 = v7;
v20 = BYTE4(v7);
v21 = 10;
v22 = *((_BYTE *)v4 + (unsigned int)(*(_DWORD *)(v5 + 1860) - 3));
v8 = a3 - a2;
if ( (int)(a3 - a2) < 0 )
{
LOWORD(v8) = a2 - a3;
v9 = 3;
v10 = 7;
}
else
{
v15 = (long long)v4 + a2;
v16 = v8;
v9 = 4;
v10 = 6;
v6 = v8;
}
v23 = v10;
v24 = v8;
v13 = &v18;
v14 = (unsigned int)(v25 - (_BYTE *)&v18);
*((_DWORD *)a1 + 9) = *((_DWORD *)a1 + 8);
return translog_write_record(
(unsigned long long)v17,
&byte_9[3],
v3[1],
v3,
(unsigned int)(v25 - (_BYTE *)&v18) + v6,
v9,
&v12,
&v18,
0LL);
}
|
_ma_log_suffix:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV R10D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV RCX,qword ptr [RDI]
MOV R9,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI + 0x18]
MOV R11,qword ptr [RCX]
MOV EBX,dword ptr [R11 + 0x7bc]
XOR R8D,R8D
XOR EDX,EDX
DIV RBX
MOV dword ptr [RBP + -0x2e],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x2a],AL
MOV byte ptr [RBP + -0x29],0xa
MOV EAX,dword ptr [R11 + 0x744]
ADD EAX,-0x3
MOV AL,byte ptr [R9 + RAX*0x1]
MOV byte ptr [RBP + -0x28],AL
SUB R10D,ESI
JS 0x0013e29b
LEA RAX,[RBP + -0x24]
MOV EDX,ESI
ADD R9,RDX
MOV qword ptr [RBP + -0x70],R9
MOV EDX,R10D
MOV qword ptr [RBP + -0x68],RDX
MOV R9D,0x4
MOV DL,0x6
MOV R8D,R10D
JMP 0x0013e2aa
LAB_0013e29b:
NEG R10D
MOV R9D,0x3
MOV DL,0x7
LEA RAX,[RBP + -0x24]
LAB_0013e2aa:
LEA R11,[RBP + -0x30]
MOV byte ptr [R11 + 0x9],DL
MOV word ptr [R11 + 0xa],R10W
LEA R10,[RBP + -0xa0]
MOV qword ptr [R10 + 0x20],R11
SUB RAX,R11
MOV EDX,EAX
MOV qword ptr [R10 + 0x28],RDX
MOV EDX,dword ptr [RDI + 0x20]
MOV dword ptr [RDI + 0x24],EDX
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,EAX
SUB RSP,0x8
LEA RDI,[RBP + -0x38]
MOV ESI,0xc
PUSH 0x0
PUSH R11
PUSH R10
CALL 0x0012bde9
ADD RSP,0x20
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x10]
JNZ 0x0013e30d
ADD RSP,0x98
POP RBX
POP RBP
RET
LAB_0013e30d:
CALL 0x0012a240
|
void _ma_log_suffix(long *param_1,uint param_2,int param_3)
{
long *plVar1;
int1 auVar2 [16];
int iVar3;
uint uVar4;
int8 uVar5;
uint uVar6;
long in_FS_OFFSET;
int1 local_a8 [32];
int1 *local_88;
ulong local_80;
long local_78;
ulong local_70;
int1 local_40 [8];
int1 local_38 [2];
int4 local_36;
int1 local_32;
int1 local_31;
int1 local_30;
int1 local_2f;
int2 local_2e;
int1 local_2c [20];
long local_18;
local_18 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)*param_1;
uVar4 = 0;
auVar2._8_8_ = 0;
auVar2._0_8_ = param_1[3];
auVar2 = auVar2 / ZEXT416(*(uint *)(*plVar1 + 0x7bc));
local_36 = auVar2._0_4_;
local_32 = auVar2[4];
local_31 = 10;
local_30 = *(int1 *)(param_1[2] + (ulong)(*(int *)(*plVar1 + 0x744) - 3));
uVar6 = param_3 - param_2;
if ((int)uVar6 < 0) {
uVar6 = -uVar6;
uVar5 = 3;
local_2f = 7;
iVar3 = (int)local_2c;
}
else {
iVar3 = (int)local_2c;
local_78 = param_1[2] + (ulong)param_2;
local_70 = (ulong)uVar6;
uVar5 = 4;
local_2f = 6;
uVar4 = uVar6;
}
local_88 = local_38;
local_2e = (int2)uVar6;
uVar6 = iVar3 - (int)local_88;
local_80 = (ulong)uVar6;
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
translog_write_record(local_40,0xc,plVar1[1],plVar1,uVar4 + uVar6,uVar5,local_a8,local_88,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_18) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
58,502
|
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const
|
monkey531[P]llama/common/json.hpp
|
bool operator==(const IterImpl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
}
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
return (m_it.object_iterator == other.m_it.object_iterator);
case value_t::array:
return (m_it.array_iterator == other.m_it.array_iterator);
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:
return (m_it.primitive_iterator == other.m_it.primitive_iterator);
}
}
|
O2
|
cpp
|
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x43b2d
testq %rax, %rax
je 0x43b7e
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x43b0f
cmpl $0x1, %eax
jne 0x43b19
movq 0x8(%r14), %rax
cmpq 0x8(%rsi), %rax
jmp 0x43b21
movq 0x10(%r14), %rax
cmpq 0x10(%rsi), %rax
jmp 0x43b21
movq 0x18(%r14), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x6f131(%rip), %rsi # 0xb2c70
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x27fde
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xd4, %esi
callq 0x43bc6
xorl %ebp, %ebp
leaq 0xbb389(%rip), %rsi # 0xfeef8
leaq -0x3140(%rip), %rdx # 0x40a36
movq %rbx, %rdi
callq 0x24ef0
leaq 0x6e0b7(%rip), %rdi # 0xb1c3c
leaq 0x6e0fa(%rip), %rdx # 0xb1c86
leaq 0x7338a(%rip), %rcx # 0xb6f1d
movl $0x3422, %esi # imm = 0x3422
xorl %eax, %eax
callq 0x24ea0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x251d8
testb %bpl, %bpl
jne 0x43bb6
jmp 0x43bbe
movq %rax, %r14
movq %rbx, %rdi
callq 0x24680
movq %r14, %rdi
callq 0x24f80
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
mov rax, [rdi]
cmp rax, [rsi]
jnz short loc_43B2D
test rax, rax
jz loc_43B7E
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_43B0F
cmp eax, 1
jnz short loc_43B19
mov rax, [r14+8]
cmp rax, [rsi+8]
jmp short loc_43B21
loc_43B0F:
mov rax, [r14+10h]
cmp rax, [rsi+10h]
jmp short loc_43B21
loc_43B19:
mov rax, [r14+18h]
cmp rax, [rsi+18h]
loc_43B21:
setz al
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_43B2D:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aCannotCompareI; "cannot compare iterators of different c"...
lea rdi, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_39]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 0D4h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_43B7E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3422h
xor eax, eax
call _ggml_abort
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_43BB6
jmp short loc_43BBE
mov r14, rax
loc_43BB6:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_43BBE:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CMP RAX,qword ptr [RSI]
JNZ 0x00143b2d
TEST RAX,RAX
JZ 0x00143b7e
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x00143b0f
CMP EAX,0x1
JNZ 0x00143b19
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RSI + 0x8]
JMP 0x00143b21
LAB_00143b0f:
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JMP 0x00143b21
LAB_00143b19:
MOV RAX,qword ptr [R14 + 0x18]
CMP RAX,qword ptr [RSI + 0x18]
LAB_00143b21:
SETZ AL
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00143b2d:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_00143b38:
LEA RSI,[0x1b2c70]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
CALL 0x00127fde
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_00143b54:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0xd4
CALL 0x00143bc6
XOR EBP,EBP
LEA RSI,[0x1feef8]
LEA RDX,[0x140a36]
MOV RDI,RBX
CALL 0x00124ef0
LAB_00143b7e:
LEA RDI,[0x1b1c3c]
LEA RDX,[0x1b1c86]
LEA RCX,[0x1b6f1d]
MOV ESI,0x3422
XOR EAX,EAX
CALL 0x00124ea0
|
int8
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(int8 *param_1,int8 *param_2)
{
char *pcVar1;
long lVar2;
int8 uVar3;
bool bVar4;
allocator local_39;
string local_38 [32];
pcVar1 = (char *)*param_1;
if (pcVar1 != (char *)*param_2) {
uVar3 = __cxa_allocate_exception(0x20);
/* try { // try from 00143b38 to 00143b4d has its CatchHandler @ 00143bb3 */
std::__cxx11::string::string<std::allocator<char>>
(local_38,"cannot compare iterators of different containers",&local_39);
/* try { // try from 00143b54 to 00143b7d has its CatchHandler @ 00143b9f */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd4,local_38,*param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\x02') {
lVar2 = param_1[2];
bVar4 = lVar2 == param_2[2];
}
else if (*pcVar1 == '\x01') {
lVar2 = param_1[1];
bVar4 = lVar2 == param_2[1];
}
else {
lVar2 = param_1[3];
bVar4 = lVar2 == param_2[3];
}
return CONCAT71((int7)((ulong)lVar2 >> 8),bVar4);
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x3422,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
|
||
58,503
|
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const
|
monkey531[P]llama/common/json.hpp
|
bool operator==(const IterImpl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
}
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
return (m_it.object_iterator == other.m_it.object_iterator);
case value_t::array:
return (m_it.array_iterator == other.m_it.array_iterator);
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:
return (m_it.primitive_iterator == other.m_it.primitive_iterator);
}
}
|
O3
|
cpp
|
bool nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator==<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, nullptr>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x5f089
testq %rax, %rax
je 0x5f0e7
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x5f069
cmpl $0x1, %eax
jne 0x5f073
movq 0x8(%r14), %rax
cmpq 0x8(%rsi), %rax
jmp 0x5f07b
movq 0x10(%r14), %rax
cmpq 0x10(%rsi), %rax
jmp 0x5f07b
movq 0x18(%r14), %rax
cmpq 0x18(%rsi), %rax
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8fbb8(%rip), %rsi # 0xeec5e
leaq 0x8fbe1(%rip), %rdx # 0xeec8e
leaq 0x8(%rsp), %rdi
callq 0x225b4
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd4, %esi
callq 0x5f13c
xorl %ebp, %ebp
leaq 0xcce20(%rip), %rsi # 0x12bef8
leaq -0x38ad(%rip), %rdx # 0x5b832
movq %rbx, %rdi
callq 0x1bf00
leaq 0x8eb4b(%rip), %rdi # 0xedc39
leaq 0x8eb8e(%rip), %rdx # 0xedc83
leaq 0x93e31(%rip), %rcx # 0xf2f2d
movl $0x3422, %esi # imm = 0x3422
xorl %eax, %eax
callq 0x1be90
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5f122
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8c0
testb %bpl, %bpl
jne 0x5f12c
jmp 0x5f134
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b660
movq %r14, %rdi
callq 0x1bf90
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
push rbp; char
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov r14, rdi
mov rax, [rdi]
cmp rax, [rsi]
jnz short loc_5F089
test rax, rax
jz loc_5F0E7
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_5F069
cmp eax, 1
jnz short loc_5F073
mov rax, [r14+8]
cmp rax, [rsi+8]
jmp short loc_5F07B
loc_5F069:
mov rax, [r14+10h]
cmp rax, [rsi+10h]
jmp short loc_5F07B
loc_5F073:
mov rax, [r14+18h]
cmp rax, [rsi+18h]
loc_5F07B:
setz al
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5F089:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotCompareI; "cannot compare iterators of different c"...
lea rdx, aCannotCompareI+30h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D4h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_5F0E7:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3422h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_5F122
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5F122:
test bpl, bpl
jnz short loc_5F12C
jmp short loc_5F134
mov r14, rax
loc_5F12C:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5F134:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RDI
MOV RAX,qword ptr [RDI]
CMP RAX,qword ptr [RSI]
JNZ 0x0015f089
TEST RAX,RAX
JZ 0x0015f0e7
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0015f069
CMP EAX,0x1
JNZ 0x0015f073
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RSI + 0x8]
JMP 0x0015f07b
LAB_0015f069:
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JMP 0x0015f07b
LAB_0015f073:
MOV RAX,qword ptr [R14 + 0x18]
CMP RAX,qword ptr [RSI + 0x18]
LAB_0015f07b:
SETZ AL
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015f089:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0015f09f:
LEA RSI,[0x1eec5e]
LEA RDX,[0x1eec8e]
LEA RDI,[RSP + 0x8]
CALL 0x001225b4
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_0015f0bd:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd4
CALL 0x0015f13c
XOR EBP,EBP
LEA RSI,[0x22bef8]
LEA RDX,[0x15b832]
MOV RDI,RBX
CALL 0x0011bf00
LAB_0015f0e7:
LEA RDI,[0x1edc39]
LEA RDX,[0x1edc83]
LEA RCX,[0x1f2f2d]
MOV ESI,0x3422
XOR EAX,EAX
CALL 0x0011be90
|
int8
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(int8 *param_1,int8 *param_2)
{
char *pcVar1;
long lVar2;
int8 uVar3;
bool bVar4;
int1 *local_40 [2];
int1 local_30 [16];
pcVar1 = (char *)*param_1;
if (pcVar1 != (char *)*param_2) {
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0015f09f to 0015f0b6 has its CatchHandler @ 0015f129 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot compare iterators of different containers","");
/* try { // try from 0015f0bd to 0015f0e6 has its CatchHandler @ 0015f108 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd4,local_40,*param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\x02') {
lVar2 = param_1[2];
bVar4 = lVar2 == param_2[2];
}
else if (*pcVar1 == '\x01') {
lVar2 = param_1[1];
bVar4 = lVar2 == param_2[1];
}
else {
lVar2 = param_1[3];
bVar4 = lVar2 == param_2[3];
}
return CONCAT71((int7)((ulong)lVar2 >> 8),bVar4);
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x3422,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
|
||
58,504
|
js_array_fill
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_fill(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
int64_t len, start, end;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
start = 0;
if (argc > 1 && !JS_IsUndefined(argv[1])) {
if (JS_ToInt64Clamp(ctx, &start, argv[1], 0, len, len))
goto exception;
}
end = len;
if (argc > 2 && !JS_IsUndefined(argv[2])) {
if (JS_ToInt64Clamp(ctx, &end, argv[2], 0, len, len))
goto exception;
}
/* XXX: should special case fast arrays */
while (start < end) {
if (JS_SetPropertyInt64(ctx, obj, start, js_dup(argv[0])) < 0)
goto exception;
start++;
}
return obj;
exception:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_array_fill:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r12
callq 0x2ae39
movq %rax, %r14
movq %rdx, %rbx
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x26b38
testl %eax, %eax
je 0x79755
movq 0x18(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21922
movl $0x6, %ebx
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x8(%rsp)
cmpl $0x2, %ebp
jl 0x7978d
movq 0x18(%r15), %rcx
cmpl $0x3, %ecx
je 0x7978d
movq 0x18(%rsp), %r9
movq 0x10(%r15), %rdx
movq %r9, (%rsp)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
xorl %r8d, %r8d
callq 0x2b8b4
testl %eax, %eax
jne 0x79728
movq 0x18(%rsp), %r9
movq %r9, 0x10(%rsp)
cmpl $0x3, %ebp
jl 0x797c5
movq 0x28(%r15), %rcx
cmpl $0x3, %ecx
je 0x797c5
movq 0x20(%r15), %rdx
movq %r9, (%rsp)
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
xorl %r8d, %r8d
callq 0x2b8b4
testl %eax, %eax
jne 0x79728
movq 0x10(%rsp), %rbp
movq 0x8(%rsp), %r13
cmpq %rbp, %r13
jge 0x7980d
movq (%r15), %r8
movq 0x8(%r15), %r9
movq %r8, 0x20(%rsp)
cmpl $-0x9, %r9d
jb 0x797ed
movq 0x20(%rsp), %rax
incl (%rax)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x293b2
testl %eax, %eax
js 0x79817
incq %r13
cmpq %r13, %rbp
jne 0x797d4
movq %rbp, %r13
movq %r13, 0x8(%rsp)
jmp 0x79740
movq %r13, 0x8(%rsp)
jmp 0x79728
|
js_array_fill:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, r8
mov ebp, ecx
mov r12, rdi
call JS_ToObject
mov r14, rax
mov rbx, rdx
lea rsi, [rsp+58h+var_40]
mov rdi, r12
mov rdx, rax
mov rcx, rbx
call js_get_length64
test eax, eax
jz short loc_79755
loc_79728:
mov rdi, [r12+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r14d, r14d
loc_79740:
mov rax, r14
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_79755:
mov [rsp+58h+var_50], 0
cmp ebp, 2
jl short loc_7978D
mov rcx, [r15+18h]
cmp ecx, 3
jz short loc_7978D
mov r9, [rsp+58h+var_40]
mov rdx, [r15+10h]
mov [rsp+58h+var_58], r9
lea rsi, [rsp+58h+var_50]
mov rdi, r12
xor r8d, r8d
call JS_ToInt64Clamp
test eax, eax
jnz short loc_79728
loc_7978D:
mov r9, [rsp+58h+var_40]
mov [rsp+58h+var_48], r9
cmp ebp, 3
jl short loc_797C5
mov rcx, [r15+28h]
cmp ecx, 3
jz short loc_797C5
mov rdx, [r15+20h]
mov [rsp+58h+var_58], r9
lea rsi, [rsp+58h+var_48]
mov rdi, r12
xor r8d, r8d
call JS_ToInt64Clamp
test eax, eax
jnz loc_79728
loc_797C5:
mov rbp, [rsp+58h+var_48]
mov r13, [rsp+58h+var_50]
cmp r13, rbp
jge short loc_7980D
loc_797D4:
mov r8, [r15]
mov r9, [r15+8]
mov [rsp+58h+var_38], r8
cmp r9d, 0FFFFFFF7h
jb short loc_797ED
mov rax, [rsp+58h+var_38]
inc dword ptr [rax]
loc_797ED:
mov rdi, r12
mov rsi, r14
mov rdx, rbx
mov rcx, r13
call JS_SetPropertyInt64
test eax, eax
js short loc_79817
inc r13
cmp rbp, r13
jnz short loc_797D4
mov r13, rbp
loc_7980D:
mov [rsp+58h+var_50], r13
jmp loc_79740
loc_79817:
mov [rsp+58h+var_50], r13
jmp loc_79728
|
_DWORD * js_array_fill(
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)
{
int v15; // ebp
_DWORD *v16; // r14
unsigned long long v17; // rdx
unsigned long long v18; // rbx
double v19; // xmm4_8
double v20; // xmm5_8
long long v22; // rcx
long long v23; // rcx
long long v24; // rbp
_DWORD *v25; // r13
_DWORD *v26; // r8
long long v27; // r9
long long v28; // [rsp+8h] [rbp-50h] BYREF
long long v29; // [rsp+10h] [rbp-48h] BYREF
long long v30; // [rsp+18h] [rbp-40h] BYREF
_DWORD *v31; // [rsp+20h] [rbp-38h]
v15 = a4;
v16 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v18 = v17;
if ( !(unsigned int)js_get_length64(a1, &v30, (int)v16, v17) )
{
v28 = 0LL;
if ( v15 < 2
|| (v22 = *(_QWORD *)(a5 + 24), (_DWORD)v22 == 3)
|| !(unsigned int)JS_ToInt64Clamp(a1, (unsigned long long *)&v28, *(_DWORD **)(a5 + 16), v22, 0LL, v30, v30) )
{
v29 = v30;
if ( v15 < 3
|| (v23 = *(_QWORD *)(a5 + 40), (_DWORD)v23 == 3)
|| !(unsigned int)JS_ToInt64Clamp(a1, (unsigned long long *)&v29, *(_DWORD **)(a5 + 32), v23, 0LL, v30, v30) )
{
v24 = v29;
v25 = (_DWORD *)v28;
if ( v28 >= v29 )
{
LABEL_16:
v28 = (long long)v25;
return v16;
}
while ( 1 )
{
v26 = *(_DWORD **)a5;
v27 = *(_QWORD *)(a5 + 8);
v31 = *(_DWORD **)a5;
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
++*v31;
if ( (int)JS_SetPropertyInt64(
a1,
(unsigned long long)v16,
v18,
v25,
v26,
v27,
*(double *)a7.m128_u64,
a8,
a9,
a10,
v19,
v20,
a13,
a14) < 0 )
break;
v25 = (_DWORD *)((char *)v25 + 1);
if ( (_DWORD *)v24 == v25 )
{
v25 = (_DWORD *)v24;
goto LABEL_16;
}
}
v28 = (long long)v25;
}
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v16, v18);
return 0LL;
}
|
js_array_fill:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,R8
MOV EBP,ECX
MOV R12,RDI
CALL 0x0012ae39
MOV R14,RAX
MOV RBX,RDX
LEA RSI,[RSP + 0x18]
MOV RDI,R12
MOV RDX,RAX
MOV RCX,RBX
CALL 0x00126b38
TEST EAX,EAX
JZ 0x00179755
LAB_00179728:
MOV RDI,qword ptr [R12 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x00121922
MOV EBX,0x6
XOR R14D,R14D
LAB_00179740:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00179755:
MOV qword ptr [RSP + 0x8],0x0
CMP EBP,0x2
JL 0x0017978d
MOV RCX,qword ptr [R15 + 0x18]
CMP ECX,0x3
JZ 0x0017978d
MOV R9,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP],R9
LEA RSI,[RSP + 0x8]
MOV RDI,R12
XOR R8D,R8D
CALL 0x0012b8b4
TEST EAX,EAX
JNZ 0x00179728
LAB_0017978d:
MOV R9,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x10],R9
CMP EBP,0x3
JL 0x001797c5
MOV RCX,qword ptr [R15 + 0x28]
CMP ECX,0x3
JZ 0x001797c5
MOV RDX,qword ptr [R15 + 0x20]
MOV qword ptr [RSP],R9
LEA RSI,[RSP + 0x10]
MOV RDI,R12
XOR R8D,R8D
CALL 0x0012b8b4
TEST EAX,EAX
JNZ 0x00179728
LAB_001797c5:
MOV RBP,qword ptr [RSP + 0x10]
MOV R13,qword ptr [RSP + 0x8]
CMP R13,RBP
JGE 0x0017980d
LAB_001797d4:
MOV R8,qword ptr [R15]
MOV R9,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x20],R8
CMP R9D,-0x9
JC 0x001797ed
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_001797ed:
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R13
CALL 0x001293b2
TEST EAX,EAX
JS 0x00179817
INC R13
CMP RBP,R13
JNZ 0x001797d4
MOV R13,RBP
LAB_0017980d:
MOV qword ptr [RSP + 0x8],R13
JMP 0x00179740
LAB_00179817:
MOV qword ptr [RSP + 0x8],R13
JMP 0x00179728
|
int1 [16]
js_array_fill(long param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
long lVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
long lVar5;
int1 auVar6 [16];
long local_50;
long local_48;
long local_40;
int *local_38;
auVar6 = JS_ToObject();
uVar4 = auVar6._8_8_;
uVar3 = auVar6._0_8_;
iVar2 = js_get_length64(param_1,&local_40,uVar3,uVar4);
lVar5 = local_50;
if (((iVar2 == 0) &&
(((local_50 = 0, param_4 < 2 || ((int)param_5[3] == 3)) ||
(iVar2 = JS_ToInt64Clamp(param_1,&local_50,param_5[2],param_5[3],0,local_40,local_40),
lVar5 = local_50, iVar2 == 0)))) &&
(((local_48 = local_40, param_4 < 3 || ((int)param_5[5] == 3)) ||
(iVar2 = JS_ToInt64Clamp(param_1,&local_48,param_5[4],param_5[5],0,local_40,local_40),
lVar5 = local_50, iVar2 == 0)))) {
lVar1 = local_48;
lVar5 = local_50;
if (local_50 < local_48) {
do {
local_38 = (int *)*param_5;
if (0xfffffff6 < (uint)param_5[1]) {
*local_38 = *local_38 + 1;
}
iVar2 = JS_SetPropertyInt64(param_1,uVar3,uVar4,lVar5);
if (iVar2 < 0) goto LAB_00179728;
lVar5 = lVar5 + 1;
} while (lVar1 != lVar5);
}
}
else {
LAB_00179728:
local_50 = lVar5;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar3,uVar4);
auVar6 = ZEXT816(6) << 0x40;
}
return auVar6;
}
|
|
58,505
|
GASymbolTable::symbolhash()
|
goodasm/gasymboltable.cpp
|
QByteArray GASymbolTable::symbolhash(){
QCryptographicHash hash(QCryptographicHash::Sha1);
hash.reset();
for (auto i = table.begin(), end = table.end(); i != end; i++){
QString name=i.key();
uint64_t adr=i.value()->absval;
hash.addData((name+"="+QString::number(adr)).toUtf8());
}
return hash.result();
}
|
O0
|
cpp
|
GASymbolTable::symbolhash():
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x2, %esi
callq 0x73c0
movq -0xc8(%rbp), %rdi
callq 0x7740
jmp 0x23b42
movq -0xd0(%rbp), %rdi
addq $0x8, %rdi
callq 0x246e0
movq %rax, -0xe8(%rbp)
jmp 0x23b5b
movq -0xd0(%rbp), %rdi
movq -0xe8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x24730
movq %rax, -0xf0(%rbp)
jmp 0x23b7f
movq -0xf0(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24780
movb %al, -0xf1(%rbp)
jmp 0x23b9f
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x23bae
jmp 0x23d4b
leaq -0x30(%rbp), %rdi
callq 0x247b0
movq %rax, -0x100(%rbp)
jmp 0x23bc0
movq -0x100(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xe8f0
leaq -0x30(%rbp), %rdi
callq 0x247d0
movq %rax, -0x108(%rbp)
jmp 0x23be2
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
leaq 0xed78d(%rip), %rdx # 0x111388
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x178b0
jmp 0x23c0d
movq -0x58(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0xa, %edx
callq 0x7350
jmp 0x23c24
leaq -0x88(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x17ab0
jmp 0x23c40
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xf4d0
jmp 0x23c52
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x75e0
jmp 0x23c61
leaq -0x70(%rbp), %rdi
callq 0xebc0
leaq -0x88(%rbp), %rdi
callq 0xe770
leaq -0xb8(%rbp), %rdi
callq 0xe770
leaq -0xa0(%rbp), %rdi
callq 0xe770
leaq -0x50(%rbp), %rdi
callq 0xe770
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x247f0
movq %rax, -0x110(%rbp)
jmp 0x23cab
movq -0x110(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x23b8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x23d76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x23d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x23d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x23d28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x23d1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xebc0
leaq -0x88(%rbp), %rdi
callq 0xe770
leaq -0xb8(%rbp), %rdi
callq 0xe770
leaq -0xa0(%rbp), %rdi
callq 0xe770
leaq -0x50(%rbp), %rdi
callq 0xe770
jmp 0x23d76
movq -0xe0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7410
jmp 0x23d5d
leaq -0x18(%rbp), %rdi
callq 0x7200
movq -0xd8(%rbp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x7200
movq -0x20(%rbp), %rdi
callq 0x7210
nopl (%rax,%rax)
|
_ZN13GASymbolTable10symbolhashEv:
push rbp
mov rbp, rsp
sub rsp, 110h
mov [rbp+var_E0], rdi
mov rax, rdi
mov [rbp+var_D8], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_D0], rax
lea rdi, [rbp+var_18]
mov [rbp+var_C8], rdi
mov esi, 2
call __ZN18QCryptographicHashC1ENS_9AlgorithmE; QCryptographicHash::QCryptographicHash(QCryptographicHash::Algorithm)
mov rdi, [rbp+var_C8]; this
call __ZN18QCryptographicHash5resetEv; QCryptographicHash::reset(void)
jmp short $+2
loc_23B42:
mov rdi, [rbp+var_D0]
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolE5beginEv; QMap<QString,GASymbol *>::begin(void)
mov [rbp+var_E8], rax
jmp short $+2
loc_23B5B:
mov rdi, [rbp+var_D0]
mov rax, [rbp+var_E8]
mov [rbp+var_30], rax
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolE3endEv; QMap<QString,GASymbol *>::end(void)
mov [rbp+var_F0], rax
jmp short $+2
loc_23B7F:
mov rax, [rbp+var_F0]
mov [rbp+var_38], rax
loc_23B8A:
lea rdi, [rbp+var_30]
lea rsi, [rbp+var_38]
call _ZneRKN4QMapI7QStringP8GASymbolE8iteratorES6_; operator!=(QMap<QString,GASymbol *>::iterator const&,QMap<QString,GASymbol *>::iterator const&)
mov [rbp+var_F1], al
jmp short $+2
loc_23B9F:
mov al, [rbp+var_F1]
test al, 1
jnz short loc_23BAE
jmp loc_23D4B
loc_23BAE:
lea rdi, [rbp+var_30]
call _ZNK4QMapI7QStringP8GASymbolE8iterator3keyEv; QMap<QString,GASymbol *>::iterator::key(void)
mov [rbp+var_100], rax
jmp short $+2
loc_23BC0:
mov rsi, [rbp+var_100]; QString *
lea rdi, [rbp+var_50]; this
call _ZN7QStringC2ERKS_; QString::QString(QString const&)
lea rdi, [rbp+var_30]
call _ZNK4QMapI7QStringP8GASymbolE8iterator5valueEv; QMap<QString,GASymbol *>::iterator::value(void)
mov [rbp+var_108], rax
jmp short $+2
loc_23BE2:
mov rax, [rbp+var_108]
mov rax, [rax]
mov rax, [rax+18h]
mov [rbp+var_58], rax
lea rdx, aType+4; "="
lea rdi, [rbp+var_A0]
lea rsi, [rbp+var_50]
call _ZplRK7QStringPKc; operator+(QString const&,char const*)
jmp short $+2
loc_23C0D:
mov rsi, [rbp+var_58]; unsigned __int64
lea rdi, [rbp+var_B8]; this
mov edx, 0Ah; int
call __ZN7QString6numberEmi; QString::number(ulong,int)
jmp short $+2
loc_23C24:
lea rdi, [rbp+var_88]
lea rsi, [rbp+var_A0]
lea rdx, [rbp+var_B8]
call _ZplRK7QStringS1_; operator+(QString const&,QString const&)
jmp short $+2
loc_23C40:
lea rdi, [rbp+var_70]
lea rsi, [rbp+var_88]
call _ZNKR7QString6toUtf8Ev; QString::toUtf8(void)
jmp short $+2
loc_23C52:
lea rdi, [rbp+var_18]; this
lea rsi, [rbp+var_70]; QByteArray *
call __ZN18QCryptographicHash7addDataERK10QByteArray; QCryptographicHash::addData(QByteArray const&)
jmp short $+2
loc_23C61:
lea rdi, [rbp+var_70]; this
call _ZN10QByteArrayD2Ev; QByteArray::~QByteArray()
lea rdi, [rbp+var_88]; this
call _ZN7QStringD2Ev; QString::~QString()
lea rdi, [rbp+var_B8]; this
call _ZN7QStringD2Ev; QString::~QString()
lea rdi, [rbp+var_A0]; this
call _ZN7QStringD2Ev; QString::~QString()
lea rdi, [rbp+var_50]; this
call _ZN7QStringD2Ev; QString::~QString()
lea rdi, [rbp+var_30]
xor esi, esi
call _ZN4QMapI7QStringP8GASymbolE8iteratorppEi; QMap<QString,GASymbol *>::iterator::operator++(int)
mov [rbp+var_110], rax
jmp short $+2
loc_23CAB:
mov rax, [rbp+var_110]
mov [rbp+var_C0], rax
jmp loc_23B8A
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
jmp loc_23D76
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
jmp short loc_23D40
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
jmp short loc_23D34
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
jmp short loc_23D28
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
jmp short loc_23D1C
mov rcx, rax
mov eax, edx
mov [rbp+var_20], rcx
mov [rbp+var_24], eax
lea rdi, [rbp+var_70]; this
call _ZN10QByteArrayD2Ev; QByteArray::~QByteArray()
loc_23D1C:
lea rdi, [rbp+var_88]; this
call _ZN7QStringD2Ev; QString::~QString()
loc_23D28:
lea rdi, [rbp+var_B8]; this
call _ZN7QStringD2Ev; QString::~QString()
loc_23D34:
lea rdi, [rbp+var_A0]; this
call _ZN7QStringD2Ev; QString::~QString()
loc_23D40:
lea rdi, [rbp+var_50]; this
call _ZN7QStringD2Ev; QString::~QString()
jmp short loc_23D76
loc_23D4B:
mov rdi, [rbp+var_E0]; this
lea rsi, [rbp+var_18]
call __ZNK18QCryptographicHash6resultEv; QCryptographicHash::result(void)
jmp short $+2
loc_23D5D:
lea rdi, [rbp+var_18]; this
call __ZN18QCryptographicHashD1Ev; QCryptographicHash::~QCryptographicHash()
mov rax, [rbp+var_D8]
add rsp, 110h
pop rbp
retn
loc_23D76:
lea rdi, [rbp+var_18]; this
call __ZN18QCryptographicHashD1Ev; QCryptographicHash::~QCryptographicHash()
mov rdi, [rbp+var_20]
call __Unwind_Resume
|
GASymbolTable * GASymbolTable::symbolhash(GASymbolTable *this, long long a2)
{
QString *v3; // [rsp+10h] [rbp-100h]
_BYTE v4[24]; // [rsp+58h] [rbp-B8h] BYREF
_BYTE v5[24]; // [rsp+70h] [rbp-A0h] BYREF
_BYTE v6[24]; // [rsp+88h] [rbp-88h] BYREF
_BYTE v7[24]; // [rsp+A0h] [rbp-70h] BYREF
unsigned long long v8; // [rsp+B8h] [rbp-58h]
_BYTE v9[24]; // [rsp+C0h] [rbp-50h] BYREF
long long v10; // [rsp+D8h] [rbp-38h] BYREF
long long v11; // [rsp+E0h] [rbp-30h] BYREF
_BYTE v12[8]; // [rsp+F8h] [rbp-18h] BYREF
long long v13; // [rsp+100h] [rbp-10h]
GASymbolTable *v14; // [rsp+108h] [rbp-8h]
v14 = this;
v13 = a2;
QCryptographicHash::QCryptographicHash(v12, 2LL);
QCryptographicHash::reset((QCryptographicHash *)v12);
v11 = QMap<QString,GASymbol *>::begin(a2 + 8);
v10 = QMap<QString,GASymbol *>::end(a2 + 8);
while ( (operator!=(&v11, &v10) & 1) != 0 )
{
v3 = (QString *)QMap<QString,GASymbol *>::iterator::key(&v11);
QString::QString((QString *)v9, v3);
v8 = *(_QWORD *)(*(_QWORD *)QMap<QString,GASymbol *>::iterator::value(&v11) + 24LL);
operator+((QString *)v5, (const QString *)v9, (long long)"=");
QString::number((QString *)v4, v8, 10);
operator+((QString *)v6, (const QString *)v5, (const QString *)v4);
QString::toUtf8((QString *)v7, (const QString *)v6);
QCryptographicHash::addData((QCryptographicHash *)v12, (const QByteArray *)v7);
QByteArray::~QByteArray((QByteArray *)v7);
QString::~QString((QString *)v6);
QString::~QString((QString *)v4);
QString::~QString((QString *)v5);
QString::~QString((QString *)v9);
QMap<QString,GASymbol *>::iterator::operator++(&v11, 0LL);
}
QCryptographicHash::result(this);
QCryptographicHash::~QCryptographicHash((QCryptographicHash *)v12);
return this;
}
|
symbolhash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
MOV qword ptr [RBP + -0xe0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xd8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xd0],RAX
LEA RDI,[RBP + -0x18]
MOV qword ptr [RBP + -0xc8],RDI
MOV ESI,0x2
CALL 0x001073c0
MOV RDI,qword ptr [RBP + -0xc8]
LAB_00123b3b:
CALL 0x00107740
JMP 0x00123b42
LAB_00123b42:
MOV RDI,qword ptr [RBP + -0xd0]
ADD RDI,0x8
CALL 0x001246e0
MOV qword ptr [RBP + -0xe8],RAX
JMP 0x00123b5b
LAB_00123b5b:
MOV RDI,qword ptr [RBP + -0xd0]
MOV RAX,qword ptr [RBP + -0xe8]
MOV qword ptr [RBP + -0x30],RAX
ADD RDI,0x8
CALL 0x00124730
MOV qword ptr [RBP + -0xf0],RAX
JMP 0x00123b7f
LAB_00123b7f:
MOV RAX,qword ptr [RBP + -0xf0]
MOV qword ptr [RBP + -0x38],RAX
LAB_00123b8a:
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x38]
CALL 0x00124780
MOV byte ptr [RBP + -0xf1],AL
JMP 0x00123b9f
LAB_00123b9f:
MOV AL,byte ptr [RBP + -0xf1]
TEST AL,0x1
JNZ 0x00123bae
JMP 0x00123d4b
LAB_00123bae:
LEA RDI,[RBP + -0x30]
CALL 0x001247b0
MOV qword ptr [RBP + -0x100],RAX
JMP 0x00123bc0
LAB_00123bc0:
MOV RSI,qword ptr [RBP + -0x100]
LEA RDI,[RBP + -0x50]
CALL 0x0010e8f0
LAB_00123bd0:
LEA RDI,[RBP + -0x30]
CALL 0x001247d0
MOV qword ptr [RBP + -0x108],RAX
JMP 0x00123be2
LAB_00123be2:
MOV RAX,qword ptr [RBP + -0x108]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x58],RAX
LEA RDX,[0x211388]
LEA RDI,[RBP + -0xa0]
LEA RSI,[RBP + -0x50]
CALL 0x001178b0
JMP 0x00123c0d
LAB_00123c0d:
MOV RSI,qword ptr [RBP + -0x58]
LAB_00123c11:
LEA RDI,[RBP + -0xb8]
MOV EDX,0xa
CALL 0x00107350
JMP 0x00123c24
LAB_00123c24:
LEA RDI,[RBP + -0x88]
LEA RSI,[RBP + -0xa0]
LEA RDX,[RBP + -0xb8]
CALL 0x00117ab0
JMP 0x00123c40
LAB_00123c40:
LEA RDI,[RBP + -0x70]
LEA RSI,[RBP + -0x88]
CALL 0x0010f4d0
JMP 0x00123c52
LAB_00123c52:
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x70]
CALL 0x001075e0
JMP 0x00123c61
LAB_00123c61:
LEA RDI,[RBP + -0x70]
CALL 0x0010ebc0
LEA RDI,[RBP + -0x88]
CALL 0x0010e770
LEA RDI,[RBP + -0xb8]
CALL 0x0010e770
LEA RDI,[RBP + -0xa0]
CALL 0x0010e770
LEA RDI,[RBP + -0x50]
CALL 0x0010e770
LAB_00123c97:
LEA RDI,[RBP + -0x30]
XOR ESI,ESI
CALL 0x001247f0
MOV qword ptr [RBP + -0x110],RAX
JMP 0x00123cab
LAB_00123cab:
MOV RAX,qword ptr [RBP + -0x110]
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x00123b8a
LAB_00123d4b:
MOV RDI,qword ptr [RBP + -0xe0]
LEA RSI,[RBP + -0x18]
CALL 0x00107410
LAB_00123d5b:
JMP 0x00123d5d
LAB_00123d5d:
LEA RDI,[RBP + -0x18]
CALL 0x00107200
MOV RAX,qword ptr [RBP + -0xd8]
ADD RSP,0x110
POP RBP
RET
|
/* GASymbolTable::symbolhash() */
int8 GASymbolTable::symbolhash(void)
{
byte bVar1;
QString *pQVar2;
long *plVar3;
long in_RSI;
int8 in_RDI;
QString local_c0 [24];
QString local_a8 [24];
QString local_90 [24];
QString local_78 [24];
int8 local_60;
QString local_58 [24];
int8 local_40;
int8 local_38 [3];
QCryptographicHash local_20 [24];
QCryptographicHash::QCryptographicHash(local_20,2);
/* try { // try from 00123b3b to 00123bb6 has its CatchHandler @ 00123cbe */
QCryptographicHash::reset();
local_38[0] = QMap<QString,GASymbol*>::begin((QMap<QString,GASymbol*> *)(in_RSI + 8));
local_40 = QMap<QString,GASymbol*>::end((QMap<QString,GASymbol*> *)(in_RSI + 8));
while( true ) {
bVar1 = ::operator!=((iterator *)local_38,(iterator *)&local_40);
if ((bVar1 & 1) == 0) break;
pQVar2 = (QString *)QMap<QString,GASymbol*>::iterator::key((iterator *)local_38);
QString::QString(local_58,pQVar2);
/* try { // try from 00123bd0 to 00123c0a has its CatchHandler @ 00123ccf */
plVar3 = (long *)QMap<QString,GASymbol*>::iterator::value((iterator *)local_38);
local_60 = *(int8 *)(*plVar3 + 0x18);
operator+(local_a8,(char *)local_58);
/* try { // try from 00123c11 to 00123c21 has its CatchHandler @ 00123cdd */
QString::number((ulong)local_c0,(int)local_60);
/* try { // try from 00123c24 to 00123c3d has its CatchHandler @ 00123ceb */
operator+(local_90,local_a8);
/* try { // try from 00123c40 to 00123c4f has its CatchHandler @ 00123cf9 */
QString::toUtf8(local_78);
/* try { // try from 00123c52 to 00123c5e has its CatchHandler @ 00123d07 */
QCryptographicHash::addData((QByteArray *)local_20);
QByteArray::~QByteArray((QByteArray *)local_78);
QString::~QString(local_90);
QString::~QString(local_c0);
QString::~QString(local_a8);
QString::~QString(local_58);
/* try { // try from 00123c97 to 00123d5a has its CatchHandler @ 00123cbe */
QMap<QString,GASymbol*>::iterator::operator++((iterator *)local_38,0);
}
QCryptographicHash::result();
QCryptographicHash::~QCryptographicHash(local_20);
return in_RDI;
}
|
|
58,506
|
ft_parse
|
eloqsql/storage/myisam/ft_parser.c
|
int ft_parse(TREE *wtree, uchar *doc, int doclen,
struct st_mysql_ftparser *parser,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
MY_FT_PARSER_PARAM my_param;
DBUG_ENTER("ft_parse");
DBUG_ASSERT(parser);
my_param.wtree= wtree;
my_param.mem_root= mem_root;
param->mysql_parse= ft_parse_internal;
param->mysql_add_word= ft_add_word;
param->mysql_ftparam= &my_param;
param->cs= wtree->custom_arg;
param->doc= (char*) doc;
param->length= doclen;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
DBUG_RETURN(parser->parse(param));
}
|
O0
|
c
|
ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0xa7571
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
leaq 0x74(%rip), %rcx # 0xa7600
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x116(%rip), %rcx # 0xa76b0
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x230(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ft_parse:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_A7571:
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
lea rcx, ft_parse_internal
mov [rax], rcx
mov rax, [rbp+var_28]
lea rcx, ft_add_word
mov [rax+8], rcx
mov rax, [rbp+var_28]
lea rcx, [rbp+var_40]
mov [rax+18h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+230h]
mov rax, [rbp+var_28]
mov [rax+20h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax+28h], rcx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+30h], ecx
mov rax, [rbp+var_28]
mov dword ptr [rax+38h], 0
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rdi, [rbp+var_28]
call rax
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long ft_parse(long long a1, long long a2, int a3, long long a4, _QWORD *a5, long long a6)
{
_QWORD v7[3]; // [rsp+10h] [rbp-40h] BYREF
_QWORD *v8; // [rsp+28h] [rbp-28h]
long long v9; // [rsp+30h] [rbp-20h]
int v10; // [rsp+3Ch] [rbp-14h]
long long v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v8 = a5;
v7[2] = a6;
v7[0] = a1;
v7[1] = a6;
*a5 = ft_parse_internal;
v8[1] = ft_add_word;
v8[3] = v7;
v8[4] = *(_QWORD *)(v12 + 560);
v8[5] = v11;
*((_DWORD *)v8 + 12) = v10;
*((_DWORD *)v8 + 14) = 0;
return (*(unsigned int ( **)(_QWORD *))(v9 + 8))(v8);
}
|
ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x001a7571
LAB_001a7571:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a7600]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[0x1a76b0]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x230]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4
ft_parse(long param_1,int8 param_2,int4 param_3,long param_4,int8 *param_5,
int8 param_6)
{
int4 uVar1;
long local_48;
int8 local_40;
int8 local_38;
int8 *local_30;
long local_28;
int4 local_1c;
int8 local_18;
long local_10;
*param_5 = ft_parse_internal;
param_5[1] = ft_add_word;
param_5[3] = &local_48;
param_5[4] = *(int8 *)(param_1 + 0x230);
param_5[5] = param_2;
*(int4 *)(param_5 + 6) = param_3;
*(int4 *)(param_5 + 7) = 0;
local_48 = param_1;
local_40 = param_6;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = (**(code **)(param_4 + 8))(param_5);
return uVar1;
}
|
|
58,507
|
add_compiled_collation
|
eloqsql/mysys/charset.c
|
void add_compiled_collation(struct charset_info_st *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
#ifndef DBUG_OFF
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->cs_name.str,
cs->cs_name.length);
DBUG_ASSERT(org);
DBUG_ASSERT(org->cs_name.str == cs->cs_name.str);
DBUG_ASSERT(org->cs_name.length == strlen(cs->cs_name.str));
#endif
}
}
|
O0
|
c
|
add_compiled_collation:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2995e
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x35ccff(%rip), %rax # 0x386670
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x200, %ecx # imm = 0x200
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rsi
leaq 0x360ce0(%rip), %rdi # 0x38a670
callq 0x2c700
cmpb $0x0, %al
je 0x2999b
jmp 0x2999b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
add_compiled_collation:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_2995E:
mov rdx, [rbp+var_8]
mov rax, [rbp+var_8]
mov eax, [rax]
mov ecx, eax
lea rax, all_charsets
mov [rax+rcx*8], rdx
mov rax, [rbp+var_8]
mov ecx, [rax+0Ch]
or ecx, 200h
mov [rax+0Ch], ecx
mov rsi, [rbp+var_8]
lea rdi, charset_name_hash
call my_hash_insert
cmp al, 0
jz short loc_2999B
jmp short $+2
loc_2999B:
add rsp, 10h
pop rbp
retn
|
long long add_compiled_collation(unsigned int *a1)
{
all_charsets[*a1] = a1;
a1[3] |= 0x200u;
return my_hash_insert(&charset_name_hash, a1);
}
|
add_compiled_collation:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0012995e
LAB_0012995e:
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x486670]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x200
MOV dword ptr [RAX + 0xc],ECX
MOV RSI,qword ptr [RBP + -0x8]
LEA RDI,[0x48a670]
CALL 0x0012c700
CMP AL,0x0
JZ 0x0012999b
JMP 0x0012999b
LAB_0012999b:
ADD RSP,0x10
POP RBP
RET
|
void add_compiled_collation(uint *param_1)
{
(&all_charsets)[*param_1] = param_1;
param_1[3] = param_1[3] | 0x200;
my_hash_insert(charset_name_hash,param_1);
return;
}
|
|
58,508
|
add_compiled_collation
|
eloqsql/mysys/charset.c
|
void add_compiled_collation(struct charset_info_st *cs)
{
DBUG_ASSERT(cs->number < array_elements(all_charsets));
all_charsets[cs->number]= cs;
cs->state|= MY_CS_AVAILABLE;
if ((my_hash_insert(&charset_name_hash, (uchar*) cs)))
{
#ifndef DBUG_OFF
CHARSET_INFO *org= (CHARSET_INFO*) my_hash_search(&charset_name_hash,
(uchar*) cs->cs_name.str,
cs->cs_name.length);
DBUG_ASSERT(org);
DBUG_ASSERT(org->cs_name.str == cs->cs_name.str);
DBUG_ASSERT(org->cs_name.length == strlen(cs->cs_name.str));
#endif
}
}
|
O3
|
c
|
add_compiled_collation:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movl (%rdi), %eax
leaq 0x33e93b(%rip), %rcx # 0x366a50
movq %rdi, (%rcx,%rax,8)
orb $0x2, 0xd(%rdi)
leaq 0x34292c(%rip), %rdi # 0x36aa50
popq %rbp
jmp 0x29ada
|
add_compiled_collation:
push rbp
mov rbp, rsp
mov rsi, rdi
mov eax, [rdi]
lea rcx, all_charsets
mov [rcx+rax*8], rdi
or byte ptr [rdi+0Dh], 2
lea rdi, charset_name_hash
pop rbp
jmp my_hash_insert
|
long long add_compiled_collation(unsigned int *a1)
{
all_charsets[*a1] = a1;
*((_BYTE *)a1 + 13) |= 2u;
return my_hash_insert(&charset_name_hash, a1);
}
|
add_compiled_collation:
PUSH RBP
MOV RBP,RSP
MOV RSI,RDI
MOV EAX,dword ptr [RDI]
LEA RCX,[0x466a50]
MOV qword ptr [RCX + RAX*0x8],RDI
OR byte ptr [RDI + 0xd],0x2
LEA RDI,[0x46aa50]
POP RBP
JMP 0x00129ada
|
void add_compiled_collation(uint *param_1)
{
(&all_charsets)[*param_1] = param_1;
*(byte *)((long)param_1 + 0xd) = *(byte *)((long)param_1 + 0xd) | 2;
my_hash_insert(charset_name_hash,param_1);
return;
}
|
|
58,509
|
promise_reaction_job
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue promise_reaction_job(JSContext *ctx, int argc,
JSValue *argv)
{
JSValue handler, arg, func;
JSValue res, res2;
BOOL is_reject;
assert(argc == 5);
handler = argv[2];
is_reject = JS_ToBool(ctx, argv[3]);
arg = argv[4];
promise_trace(ctx, "promise_reaction_job: is_reject=%d\n", is_reject);
if (JS_IsUndefined(handler)) {
if (is_reject) {
res = JS_Throw(ctx, js_dup(arg));
} else {
res = js_dup(arg);
}
} else {
res = JS_Call(ctx, handler, JS_UNDEFINED, 1, &arg);
}
is_reject = JS_IsException(res);
if (is_reject)
res = JS_GetException(ctx);
func = argv[is_reject];
/* as an extension, we support undefined as value to avoid
creating a dummy promise in the 'await' implementation of async
functions */
if (!JS_IsUndefined(func)) {
res2 = JS_Call(ctx, func, JS_UNDEFINED,
1, &res);
} else {
res2 = JS_UNDEFINED;
}
JS_FreeValue(ctx, res);
return res2;
}
|
O0
|
c
|
promise_reaction_job:
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x100(%rsp)
movl %esi, 0xfc(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0xe0(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x38530
movl %eax, 0xac(%rsp)
movq 0xf0(%rsp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0xd0(%rsp)
movq 0x48(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
je 0x75109
cmpl $0x0, 0xac(%rsp)
je 0x750c8
movq 0x100(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x216d0
movq 0x10(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x2cf00
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0x75107
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x216d0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0x75177
movq 0x100(%rsp), %rdi
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %r8
movl $0x1, %r9d
leaq 0xd0(%rsp), %rax
movq %rax, (%rsp)
callq 0x3a050
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x23cc0
movl %eax, 0xac(%rsp)
cmpl $0x0, 0xac(%rsp)
je 0x751ce
movq 0x100(%rsp), %rdi
callq 0x2cf70
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rax
movslq 0xac(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
jne 0x75286
movq 0x100(%rsp), %rdi
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movl $0x1, %r9d
leaq 0xb0(%rsp), %rax
movq %rax, (%rsp)
callq 0x3a050
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x110(%rsp)
jmp 0x752b1
movl $0x0, 0x18(%rsp)
movq $0x3, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x23c90
movq 0x108(%rsp), %rax
movq 0x110(%rsp), %rdx
addq $0x118, %rsp # imm = 0x118
retq
nopw %cs:(%rax,%rax)
|
promise_reaction_job:
sub rsp, 118h
mov [rsp+118h+var_18], rdi
mov [rsp+118h+var_1C], esi
mov [rsp+118h+var_28], rdx
mov rax, [rsp+118h+var_28]
mov rcx, [rax+20h]
mov [rsp+118h+var_38], rcx
mov rax, [rax+28h]
mov [rsp+118h+var_30], rax
mov rdi, [rsp+118h+var_18]
mov rax, [rsp+118h+var_28]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_ToBool
mov [rsp+118h+var_6C], eax
mov rax, [rsp+118h+var_28]
mov rcx, [rax+40h]
mov [rsp+118h+var_48], rcx
mov rax, [rax+48h]
mov [rsp+118h+var_40], rax
mov rdi, [rsp+118h+var_38]
mov rsi, [rsp+118h+var_30]
call JS_IsUndefined_0
cmp eax, 0
jz loc_75109
cmp [rsp+118h+var_6C], 0
jz short loc_750C8
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_108], rax
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov rdi, [rsp+118h+var_108]
mov [rsp+118h+var_90], rax
mov [rsp+118h+var_88], rdx
mov rsi, [rsp+118h+var_90]
mov rdx, [rsp+118h+var_88]
call JS_Throw
mov [rsp+118h+var_80], rax
mov [rsp+118h+var_78], rdx
mov rax, [rsp+118h+var_80]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_78]
mov [rsp+118h+var_60], rax
jmp short loc_75107
loc_750C8:
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov [rsp+118h+var_A0], rax
mov [rsp+118h+var_98], rdx
mov rax, [rsp+118h+var_A0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_98]
mov [rsp+118h+var_60], rax
loc_75107:
jmp short loc_75177
loc_75109:
mov rdi, [rsp+118h+var_18]
mov dword ptr [rsp+118h+var_C0], 0
mov [rsp+118h+var_B8], 3
mov rsi, [rsp+118h+var_38]
mov rdx, [rsp+118h+var_30]
mov rcx, [rsp+118h+var_C0]
mov r8, [rsp+118h+var_B8]
mov r9d, 1
lea rax, [rsp+118h+var_48]
mov [rsp+118h+var_118], rax
call JS_Call
mov [rsp+118h+var_B0], rax
mov [rsp+118h+var_A8], rdx
mov rax, [rsp+118h+var_B0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_A8]
mov [rsp+118h+var_60], rax
loc_75177:
mov rdi, [rsp+118h+var_68]
mov rsi, [rsp+118h+var_60]
call JS_IsException_1
mov [rsp+118h+var_6C], eax
cmp [rsp+118h+var_6C], 0
jz short loc_751CE
mov rdi, [rsp+118h+var_18]
call JS_GetException
mov [rsp+118h+var_D0], rax
mov [rsp+118h+var_C8], rdx
mov rax, [rsp+118h+var_D0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_C8]
mov [rsp+118h+var_60], rax
loc_751CE:
mov rax, [rsp+118h+var_28]
movsxd rcx, [rsp+118h+var_6C]
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov [rsp+118h+var_58], rcx
mov rax, [rax+8]
mov [rsp+118h+var_50], rax
mov rdi, [rsp+118h+var_58]
mov rsi, [rsp+118h+var_50]
call JS_IsUndefined_0
cmp eax, 0
jnz short loc_75286
mov rdi, [rsp+118h+var_18]
mov dword ptr [rsp+118h+var_F0], 0
mov [rsp+118h+var_E8], 3
mov rsi, [rsp+118h+var_58]
mov rdx, [rsp+118h+var_50]
mov rcx, [rsp+118h+var_F0]
mov r8, [rsp+118h+var_E8]
mov r9d, 1
lea rax, [rsp+118h+var_68]
mov [rsp+118h+var_118], rax
call JS_Call
mov [rsp+118h+var_E0], rax
mov [rsp+118h+var_D8], rdx
mov rax, [rsp+118h+var_E0]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_D8]
mov [rsp+118h+var_8], rax
jmp short loc_752B1
loc_75286:
mov dword ptr [rsp+118h+var_100], 0
mov [rsp+118h+var_F8], 3
mov rax, [rsp+118h+var_100]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_F8]
mov [rsp+118h+var_8], rax
loc_752B1:
mov rdi, [rsp+118h+var_18]
mov rsi, [rsp+118h+var_68]
mov rdx, [rsp+118h+var_60]
call JS_FreeValue
mov rax, [rsp+118h+var_10]
mov rdx, [rsp+118h+var_8]
add rsp, 118h
retn
|
long long promise_reaction_job(long long a1, int a2, long long a3)
{
long long v3; // rdx
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
long long *v7; // rax
long long v8; // rdx
long long v10; // [rsp+18h] [rbp-100h]
_DWORD *v11; // [rsp+88h] [rbp-90h]
int v12; // [rsp+ACh] [rbp-6Ch]
BOOL IsException_1; // [rsp+ACh] [rbp-6Ch]
long long Exception; // [rsp+B0h] [rbp-68h] BYREF
long long v15; // [rsp+B8h] [rbp-60h]
long long v16; // [rsp+C0h] [rbp-58h]
long long v17; // [rsp+C8h] [rbp-50h]
_DWORD *v18; // [rsp+D0h] [rbp-48h] BYREF
long long v19; // [rsp+D8h] [rbp-40h]
long long v20; // [rsp+E0h] [rbp-38h]
long long v21; // [rsp+E8h] [rbp-30h]
long long v22; // [rsp+F0h] [rbp-28h]
int v23; // [rsp+FCh] [rbp-1Ch]
long long v24; // [rsp+100h] [rbp-18h]
long long v25; // [rsp+108h] [rbp-10h]
long long v26; // [rsp+110h] [rbp-8h]
v24 = a1;
v23 = a2;
v22 = a3;
v20 = *(_QWORD *)(a3 + 32);
v21 = *(_QWORD *)(a3 + 40);
v12 = JS_ToBool(a1, *(_DWORD **)(a3 + 48), *(_QWORD *)(a3 + 56));
v18 = *(_DWORD **)(v22 + 64);
v19 = *(_QWORD *)(v22 + 72);
if ( JS_IsUndefined_0(v20, v21) )
{
if ( v12 )
{
v11 = js_dup(v18, v19);
Exception = JS_Throw(v24, (long long)v11, v3);
}
else
{
Exception = (long long)js_dup(v18, v19);
}
v15 = v4;
}
else
{
Exception = JS_Call(v24, v20, v21, 0, 3, 1, (long long)&v18);
v15 = v5;
}
IsException_1 = JS_IsException_1(Exception, v15);
if ( IsException_1 )
{
Exception = JS_GetException(v24);
v15 = v6;
}
v7 = (long long *)(16LL * IsException_1 + v22);
v16 = *v7;
v17 = v7[1];
if ( JS_IsUndefined_0(v16, v17) )
{
LODWORD(v10) = 0;
v25 = v10;
v26 = 3LL;
}
else
{
v25 = JS_Call(v24, v16, v17, 0, 3, 1, (long long)&Exception);
v26 = v8;
}
JS_FreeValue(v24, Exception, v15);
return v25;
}
|
promise_reaction_job:
SUB RSP,0x118
MOV qword ptr [RSP + 0x100],RDI
MOV dword ptr [RSP + 0xfc],ESI
MOV qword ptr [RSP + 0xf0],RDX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0xe0],RCX
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x00138530
MOV dword ptr [RSP + 0xac],EAX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0xd0],RCX
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
CALL 0x0012e260
CMP EAX,0x0
JZ 0x00175109
CMP dword ptr [RSP + 0xac],0x0
JZ 0x001750c8
MOV RAX,qword ptr [RSP + 0x100]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x001216d0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x0012cf00
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x00175107
LAB_001750c8:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x001216d0
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xb8],RAX
LAB_00175107:
JMP 0x00175177
LAB_00175109:
MOV RDI,qword ptr [RSP + 0x100]
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
MOV RCX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x60]
MOV R9D,0x1
LEA RAX,[RSP + 0xd0]
MOV qword ptr [RSP],RAX
CALL 0x0013a050
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xb8],RAX
LAB_00175177:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xb8]
CALL 0x00123cc0
MOV dword ptr [RSP + 0xac],EAX
CMP dword ptr [RSP + 0xac],0x0
JZ 0x001751ce
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0012cf70
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xb8],RAX
LAB_001751ce:
MOV RAX,qword ptr [RSP + 0xf0]
MOVSXD RCX,dword ptr [RSP + 0xac]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xc0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x0012e260
CMP EAX,0x0
JNZ 0x00175286
MOV RDI,qword ptr [RSP + 0x100]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV R9D,0x1
LEA RAX,[RSP + 0xb0]
MOV qword ptr [RSP],RAX
CALL 0x0013a050
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x110],RAX
JMP 0x001752b1
LAB_00175286:
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x3
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x110],RAX
LAB_001752b1:
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x108]
MOV RDX,qword ptr [RSP + 0x110]
ADD RSP,0x118
RET
|
int1 [16] promise_reaction_job(int8 param_1,int4 param_2,long param_3)
{
int8 uVar1;
int iVar2;
int iVar3;
int8 *puVar4;
int1 auVar5 [16];
uint uStack_fc;
uint uStack_ec;
uint uStack_bc;
int1 local_68 [16];
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
long local_28;
int4 local_1c;
int8 local_18;
int1 local_10 [16];
local_38 = *(int8 *)(param_3 + 0x20);
local_30 = *(int8 *)(param_3 + 0x28);
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
iVar2 = JS_ToBool(param_1,*(int8 *)(param_3 + 0x30),*(int8 *)(param_3 + 0x38));
local_48 = *(int8 *)(local_28 + 0x40);
local_40 = *(int8 *)(local_28 + 0x48);
iVar3 = JS_IsUndefined(local_38,local_30);
uVar1 = local_18;
if (iVar3 == 0) {
local_68 = JS_Call(local_18,local_38,local_30,(ulong)uStack_bc << 0x20,3,1,&local_48);
}
else if (iVar2 == 0) {
local_68 = js_dup(local_48,local_40);
}
else {
auVar5 = js_dup(local_48,local_40);
local_68 = JS_Throw(uVar1,auVar5._0_8_,auVar5._8_8_);
}
iVar2 = JS_IsException(local_68._0_8_,local_68._8_8_);
auVar5 = local_68;
if (iVar2 != 0) {
auVar5 = JS_GetException(local_18);
}
puVar4 = (int8 *)(local_28 + (long)iVar2 * 0x10);
local_58 = *puVar4;
local_50 = puVar4[1];
local_68 = auVar5;
iVar2 = JS_IsUndefined(local_58,local_50);
if (iVar2 == 0) {
local_10 = JS_Call(local_18,local_58,local_50,(ulong)uStack_ec << 0x20,3,1,local_68);
}
else {
local_10._8_8_ = 3;
local_10._0_8_ = (ulong)uStack_fc << 0x20;
}
JS_FreeValue(local_18,local_68._0_8_,local_68._8_8_);
return local_10;
}
|
|
58,510
|
promise_reaction_job
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue promise_reaction_job(JSContext *ctx, int argc,
JSValue *argv)
{
JSValue handler, arg, func;
JSValue res, res2;
BOOL is_reject;
assert(argc == 5);
handler = argv[2];
is_reject = JS_ToBool(ctx, argv[3]);
arg = argv[4];
promise_trace(ctx, "promise_reaction_job: is_reject=%d\n", is_reject);
if (JS_IsUndefined(handler)) {
if (is_reject) {
res = JS_Throw(ctx, js_dup(arg));
} else {
res = js_dup(arg);
}
} else {
res = JS_Call(ctx, handler, JS_UNDEFINED, 1, &arg);
}
is_reject = JS_IsException(res);
if (is_reject)
res = JS_GetException(ctx);
func = argv[is_reject];
/* as an extension, we support undefined as value to avoid
creating a dummy promise in the 'await' implementation of async
functions */
if (!JS_IsUndefined(func)) {
res2 = JS_Call(ctx, func, JS_UNDEFINED,
1, &res);
} else {
res2 = JS_UNDEFINED;
}
JS_FreeValue(ctx, res);
return res2;
}
|
O1
|
c
|
promise_reaction_job:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x20(%rdx), %r15
movq 0x28(%rdx), %r12
movq 0x30(%rdx), %rsi
movq 0x38(%rdx), %rdx
movq %rsi, 0x20(%rsp)
cmpl $-0x9, %edx
jb 0x4428f
movq 0x20(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
callq 0x22d0d
movups 0x40(%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
cmpl $0x3, %r12d
jne 0x44308
movq 0x40(%rsp), %r13
movq 0x48(%rsp), %r15
testl %eax, %eax
je 0x4435a
movq %r13, 0x20(%rsp)
cmpl $-0x9, %r15d
jb 0x442cb
movq 0x20(%rsp), %rax
incl (%rax)
movq 0x18(%rbx), %r12
movq 0xf0(%r12), %rsi
movq 0xf8(%r12), %rdx
movq %r12, %rdi
callq 0x1d8c6
movq %r13, 0xf0(%r12)
movq %r15, 0xf8(%r12)
movq $0x0, 0x30(%rsp)
movl $0x6, %r15d
jmp 0x44371
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x284ca
movq %rdx, %r15
movq %rax, 0x30(%rsp)
jmp 0x44371
movq %r13, 0x20(%rsp)
cmpl $-0x9, %r15d
jb 0x4436c
movq 0x20(%rsp), %rax
incl (%rax)
movq %r13, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movl %r15d, %eax
cmpq $0x6, %rax
jne 0x443a4
movq 0x18(%rbx), %rcx
movups 0xf0(%rcx), %xmm0
movl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movaps %xmm0, 0x30(%rsp)
xorl %ecx, %ecx
cmpl $0x6, %eax
sete %cl
shll $0x4, %ecx
movq 0x8(%r14,%rcx), %rdx
cmpl $0x3, %edx
jne 0x443c6
movl $0x3, %r14d
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x44421
addq %rcx, %r14
movq (%r14), %rsi
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x284ca
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r15d
orq %rcx, %r15
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1d8c6
movq %r15, %rax
movq %r14, %rdx
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
promise_reaction_job:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 50h
mov r14, rdx
mov rbx, rdi
mov r15, [rdx+20h]
mov r12, [rdx+28h]
mov rsi, [rdx+30h]
mov rdx, [rdx+38h]
mov qword ptr [rsp+78h+var_58], rsi
cmp edx, 0FFFFFFF7h
jb short loc_4428F
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_4428F:
mov rdi, rbx
call JS_ToBoolFree
movups xmm0, xmmword ptr [r14+40h]
movaps [rsp+78h+var_38], xmm0
cmp r12d, 3
jnz short loc_44308
mov r13, qword ptr [rsp+78h+var_38]
mov r15, qword ptr [rsp+78h+var_38+8]
test eax, eax
jz loc_4435A
mov qword ptr [rsp+78h+var_58], r13
cmp r15d, 0FFFFFFF7h
jb short loc_442CB
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_442CB:
mov r12, [rbx+18h]
mov rsi, [r12+0F0h]
mov rdx, [r12+0F8h]
mov rdi, r12
call JS_FreeValueRT
mov [r12+0F0h], r13
mov [r12+0F8h], r15
mov qword ptr [rsp+78h+var_48], 0
mov r15d, 6
jmp short loc_44371
loc_44308:
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
lea rax, [rsp+78h+var_38]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
mov rsi, r15
mov rdx, r12
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov r15, rdx
mov qword ptr [rsp+78h+var_48], rax
jmp short loc_44371
loc_4435A:
mov qword ptr [rsp+78h+var_58], r13
cmp r15d, 0FFFFFFF7h
jb short loc_4436C
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_4436C:
mov qword ptr [rsp+78h+var_48], r13
loc_44371:
mov qword ptr [rsp+78h+var_48+8], r15
mov eax, r15d
cmp rax, 6
jnz short loc_443A4
mov rcx, [rbx+18h]
movups xmm0, xmmword ptr [rcx+0F0h]
mov dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
movaps [rsp+78h+var_48], xmm0
loc_443A4:
xor ecx, ecx
cmp eax, 6
setz cl
shl ecx, 4
mov rdx, [r14+rcx+8]
cmp edx, 3
jnz short loc_443C6
mov r14d, 3
xor r15d, r15d
xor ecx, ecx
jmp short loc_44421
loc_443C6:
add r14, rcx
mov rsi, [r14]
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
lea rax, [rsp+78h+var_48]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r15d, eax
loc_44421:
or r15, rcx
mov rsi, qword ptr [rsp+78h+var_48]
mov rdx, qword ptr [rsp+78h+var_48+8]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rax, r15
mov rdx, r14
add rsp, 50h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
unsigned long long promise_reaction_job(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11)
{
long long v12; // r15
long long v13; // r12
_DWORD *v14; // rsi
long long v15; // rdx
int v16; // eax
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // r13
long long v20; // r15
long long v21; // r12
unsigned long long v22; // rax
long long v23; // rdx
long long v24; // rcx
__int128 v25; // xmm0
long long v26; // rcx
long long v27; // rdx
long long v28; // r15
unsigned long long v29; // rcx
unsigned long long v30; // rax
unsigned long long v31; // r15
__m128 v33; // [rsp+20h] [rbp-58h]
__int128 v34; // [rsp+30h] [rbp-48h] BYREF
__int128 v35; // [rsp+40h] [rbp-38h] BYREF
v12 = *(_QWORD *)(a11 + 32);
v13 = *(_QWORD *)(a11 + 40);
v14 = *(_DWORD **)(a11 + 48);
v15 = *(_QWORD *)(a11 + 56);
v33.m128_i32[1] = HIDWORD(v14);
if ( (unsigned int)v15 >= 0xFFFFFFF7 )
++*v14;
v16 = JS_ToBoolFree(a1, (long long)v14, v15);
v35 = *(_OWORD *)(a11 + 64);
if ( (_DWORD)v13 == 3 )
{
v20 = *((_QWORD *)&v35 + 1);
v19 = v35;
if ( v16 )
{
v33.m128_i32[1] = DWORD1(v35);
if ( DWORD2(v35) >= 0xFFFFFFF7 )
++*(_DWORD *)v35;
v21 = *(_QWORD *)(a1 + 24);
JS_FreeValueRT(v21, *(_DWORD **)(v21 + 240), *(_QWORD *)(v21 + 248));
*(_QWORD *)(v21 + 240) = v19;
*(_QWORD *)(v21 + 248) = v20;
*(_QWORD *)&v34 = 0LL;
v20 = 6LL;
}
else
{
v33.m128_i32[1] = DWORD1(v35);
if ( DWORD2(v35) >= 0xFFFFFFF7 )
++*(_DWORD *)v35;
*(_QWORD *)&v34 = v19;
}
}
else
{
v33.m128_i32[0] = 0;
v33.m128_u64[1] = 3LL;
v22 = JS_CallInternal(
a1,
v12,
v13,
0LL,
3LL,
1LL,
v33,
a3,
a4,
a5,
v17,
v18,
a8,
a9,
v33.m128_i8[0],
3,
(long long)&v35,
2u);
v20 = v23;
*(_QWORD *)&v34 = v22;
}
*((_QWORD *)&v34 + 1) = v20;
if ( (unsigned int)v20 == 6LL )
{
v24 = *(_QWORD *)(a1 + 24);
v25 = *(_OWORD *)(v24 + 240);
*(_DWORD *)(v24 + 240) = 0;
*(_QWORD *)(v24 + 248) = 4LL;
v34 = v25;
}
v26 = 16 * (unsigned int)((_DWORD)v20 == 6);
v27 = *(_QWORD *)(a11 + v26 + 8);
if ( (_DWORD)v27 == 3 )
{
v28 = 0LL;
v29 = 0LL;
}
else
{
v33.m128_i32[0] = 0;
v33.m128_u64[1] = 3LL;
v30 = JS_CallInternal(
a1,
*(_QWORD *)(v26 + a11),
v27,
0LL,
3LL,
1LL,
v33,
a3,
a4,
a5,
v17,
v18,
a8,
a9,
v33.m128_i8[0],
3,
(long long)&v34,
2u);
v29 = v30 & 0xFFFFFFFF00000000LL;
v28 = (unsigned int)v30;
}
v31 = v29 | v28;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v34, *((long long *)&v34 + 1));
return v31;
}
|
promise_reaction_job:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RDX
MOV RBX,RDI
MOV R15,qword ptr [RDX + 0x20]
MOV R12,qword ptr [RDX + 0x28]
MOV RSI,qword ptr [RDX + 0x30]
MOV RDX,qword ptr [RDX + 0x38]
MOV qword ptr [RSP + 0x20],RSI
CMP EDX,-0x9
JC 0x0014428f
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_0014428f:
MOV RDI,RBX
CALL 0x00122d0d
MOVUPS XMM0,xmmword ptr [R14 + 0x40]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CMP R12D,0x3
JNZ 0x00144308
MOV R13,qword ptr [RSP + 0x40]
MOV R15,qword ptr [RSP + 0x48]
TEST EAX,EAX
JZ 0x0014435a
MOV qword ptr [RSP + 0x20],R13
CMP R15D,-0x9
JC 0x001442cb
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_001442cb:
MOV R12,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [R12 + 0xf0]
MOV RDX,qword ptr [R12 + 0xf8]
MOV RDI,R12
CALL 0x0011d8c6
MOV qword ptr [R12 + 0xf0],R13
MOV qword ptr [R12 + 0xf8],R15
MOV qword ptr [RSP + 0x30],0x0
MOV R15D,0x6
JMP 0x00144371
LAB_00144308:
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV R8D,0x3
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
XOR ECX,ECX
MOV R9D,0x1
CALL 0x001284ca
MOV R15,RDX
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00144371
LAB_0014435a:
MOV qword ptr [RSP + 0x20],R13
CMP R15D,-0x9
JC 0x0014436c
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_0014436c:
MOV qword ptr [RSP + 0x30],R13
LAB_00144371:
MOV qword ptr [RSP + 0x38],R15
MOV EAX,R15D
CMP RAX,0x6
JNZ 0x001443a4
MOV RCX,qword ptr [RBX + 0x18]
MOVUPS XMM0,xmmword ptr [RCX + 0xf0]
MOV dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LAB_001443a4:
XOR ECX,ECX
CMP EAX,0x6
SETZ CL
SHL ECX,0x4
MOV RDX,qword ptr [R14 + RCX*0x1 + 0x8]
CMP EDX,0x3
JNZ 0x001443c6
MOV R14D,0x3
XOR R15D,R15D
XOR ECX,ECX
JMP 0x00144421
LAB_001443c6:
ADD R14,RCX
MOV RSI,qword ptr [R14]
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV R8D,0x3
MOV RDI,RBX
XOR ECX,ECX
MOV R9D,0x1
CALL 0x001284ca
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV R15D,EAX
LAB_00144421:
OR R15,RCX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x0011d8c6
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x50
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] promise_reaction_job(long param_1,int8 param_2,long param_3)
{
int1 (*pauVar1) [16];
int8 uVar2;
int *piVar3;
int8 uVar4;
int iVar5;
long lVar6;
ulong uVar7;
int8 uVar8;
ulong uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int1 local_48 [16];
int4 local_38;
int4 uStack_34;
uint uStack_30;
int4 uStack_2c;
uVar8 = *(int8 *)(param_3 + 0x20);
uVar2 = *(int8 *)(param_3 + 0x28);
if (0xfffffff6 < (uint)*(int8 *)(param_3 + 0x38)) {
**(int **)(param_3 + 0x30) = **(int **)(param_3 + 0x30) + 1;
}
iVar5 = JS_ToBoolFree(param_1);
pauVar1 = (int1 (*) [16])(param_3 + 0x40);
local_38 = *(int4 *)*pauVar1;
uStack_34 = *(int4 *)(param_3 + 0x44);
piVar3 = *(int **)*pauVar1;
uStack_30 = *(uint *)(param_3 + 0x48);
uStack_2c = *(int4 *)(param_3 + 0x4c);
uVar4 = *(int8 *)(param_3 + 0x48);
auVar11 = *pauVar1;
if ((int)uVar2 == 3) {
if (iVar5 == 0) {
auVar10 = *pauVar1;
if (0xfffffff6 < uStack_30) {
*piVar3 = *piVar3 + 1;
auVar10 = auVar11;
}
}
else {
if (0xfffffff6 < uStack_30) {
*piVar3 = *piVar3 + 1;
}
lVar6 = *(long *)(param_1 + 0x18);
JS_FreeValueRT(lVar6,*(int8 *)(lVar6 + 0xf0),*(int8 *)(lVar6 + 0xf8));
*(int **)(lVar6 + 0xf0) = piVar3;
*(int8 *)(lVar6 + 0xf8) = uVar4;
auVar10 = ZEXT816(6) << 0x40;
}
}
else {
auVar10 = JS_CallInternal(param_1,uVar8,uVar2,0,3,1,0,3,&local_38,2);
}
local_48 = auVar10;
if ((auVar10._8_8_ & 0xffffffff) == 6) {
lVar6 = *(long *)(param_1 + 0x18);
local_48 = *(int1 (*) [16])(lVar6 + 0xf0);
*(int4 *)(lVar6 + 0xf0) = 0;
*(int8 *)(lVar6 + 0xf8) = 4;
}
lVar6 = (ulong)(auVar10._8_4_ == 6) * 0x10;
uVar8 = *(int8 *)(param_3 + 8 + lVar6);
if ((int)uVar8 == 3) {
uVar8 = 3;
uVar9 = 0;
uVar7 = 0;
}
else {
auVar11 = JS_CallInternal(param_1,*(int8 *)(param_3 + lVar6),uVar8,0,3,1,0,3,local_48,2);
uVar8 = auVar11._8_8_;
uVar7 = auVar11._0_8_ & 0xffffffff00000000;
uVar9 = auVar11._0_8_ & 0xffffffff;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_48._0_8_,local_48._8_8_);
auVar11._8_8_ = uVar8;
auVar11._0_8_ = uVar9 | uVar7;
return auVar11;
}
|
|
58,511
|
postprocess_cpu_params(cpu_params&, cpu_params const*)
|
llama.cpp/common/common.cpp
|
void postprocess_cpu_params(cpu_params& cpuparams, const cpu_params* role_model) {
int32_t n_set = 0;
if (cpuparams.n_threads < 0) {
// Assuming everything about cpuparams is invalid
if (role_model != nullptr) {
cpuparams = *role_model;
} else {
cpuparams.n_threads = cpu_get_num_math();
}
}
for (int32_t i = 0; i < GGML_MAX_N_THREADS; i++) {
if (cpuparams.cpumask[i]) {
n_set++;
}
}
if (n_set && n_set < cpuparams.n_threads) {
// Not enough set bits, may experience performance issues.
LOG_WRN("Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n", n_set, cpuparams.n_threads);
}
}
|
O3
|
cpp
|
postprocess_cpu_params(cpu_params&, cpu_params const*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jns 0xf6332
testq %rsi, %rsi
je 0xf632b
movl $0x214, %edx # imm = 0x214
movq %rbx, %rdi
callq 0x200f0
jmp 0xf6332
callq 0xf611e
movl %eax, (%rbx)
pxor %xmm1, %xmm1
movl $0x4, %eax
pxor %xmm0, %xmm0
movd (%rbx,%rax), %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm2, %xmm0
addq $0x4, %rax
cmpq $0x204, %rax # imm = 0x204
jne 0xf633f
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0xf63ac
cmpl (%rbx), %ebp
jge 0xf63ac
leaq 0x6d55f(%rip), %rax # 0x1638e0
cmpl $0x0, (%rax)
js 0xf63ac
callq 0x10d343
movl (%rbx), %r8d
leaq 0x2df52(%rip), %rdx # 0x1242e7
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10d3e0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_Z22postprocess_cpu_paramsR10cpu_paramsPKS_:
push rbp
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 0
jns short loc_F6332
test rsi, rsi
jz short loc_F632B
mov edx, 214h
mov rdi, rbx
call _memcpy
jmp short loc_F6332
loc_F632B:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov [rbx], eax
loc_F6332:
pxor xmm1, xmm1
mov eax, 4
pxor xmm0, xmm0
loc_F633F:
movd xmm2, dword ptr [rbx+rax]
punpcklbw xmm2, xmm1
punpcklwd xmm2, xmm1
paddd xmm0, xmm2
add rax, 4
cmp rax, 204h
jnz short loc_F633F
pshufd xmm1, xmm0, 0EEh
paddd xmm1, xmm0
pshufd xmm0, xmm1, 55h ; 'U'
paddd xmm0, xmm1
movd ebp, xmm0
test ebp, ebp
jz short loc_F63AC
cmp ebp, [rbx]
jge short loc_F63AC
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_F63AC
call _Z15common_log_mainv; common_log_main(void)
mov r8d, [rbx]
lea rdx, aNotEnoughSetBi; "Not enough set bits in CPU mask (%d) to"...
mov rdi, rax
mov esi, 3
mov ecx, ebp
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_F63AC:
add rsp, 8
pop rbx
pop rbp
retn
|
int * postprocess_cpu_params(int *a1, long long a2)
{
int *result; // rax
__m128i v3; // xmm0
__m128i v4; // xmm1
int v5; // ebp
int v6; // eax
int v7; // r9d
if ( *a1 < 0 )
{
if ( a2 )
memcpy(a1, a2, 532LL);
else
*a1 = cpu_get_num_math();
}
result = (_DWORD *)&byte_4;
v3 = 0LL;
do
v3 = _mm_add_epi32(
v3,
_mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(int *)((char *)result++ + (_QWORD)a1)), (__m128i)0LL),
(__m128i)0LL));
while ( result != &dword_204 );
v4 = _mm_add_epi32(_mm_shuffle_epi32(v3, 238), v3);
v5 = _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v4, 85), v4));
if ( v5 && v5 < *a1 )
{
result = (int *)&common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
return (int *)common_log_add(
v6,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v5,
*a1,
v7);
}
}
return result;
}
|
postprocess_cpu_params:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x0
JNS 0x001f6332
TEST RSI,RSI
JZ 0x001f632b
MOV EDX,0x214
MOV RDI,RBX
CALL 0x001200f0
JMP 0x001f6332
LAB_001f632b:
CALL 0x001f611e
MOV dword ptr [RBX],EAX
LAB_001f6332:
PXOR XMM1,XMM1
MOV EAX,0x4
PXOR XMM0,XMM0
LAB_001f633f:
MOVD XMM2,dword ptr [RBX + RAX*0x1]
PUNPCKLBW XMM2,XMM1
PUNPCKLWD XMM2,XMM1
PADDD XMM0,XMM2
ADD RAX,0x4
CMP RAX,0x204
JNZ 0x001f633f
PSHUFD XMM1,XMM0,0xee
PADDD XMM1,XMM0
PSHUFD XMM0,XMM1,0x55
PADDD XMM0,XMM1
MOVD EBP,XMM0
TEST EBP,EBP
JZ 0x001f63ac
CMP EBP,dword ptr [RBX]
JGE 0x001f63ac
LEA RAX,[0x2638e0]
CMP dword ptr [RAX],0x0
JS 0x001f63ac
CALL 0x0020d343
MOV R8D,dword ptr [RBX]
LEA RDX,[0x2242e7]
MOV RDI,RAX
MOV ESI,0x3
MOV ECX,EBP
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0020d3e0
LAB_001f63ac:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* postprocess_cpu_params(cpu_params&, cpu_params const*) */
void postprocess_cpu_params(cpu_params *param_1,cpu_params *param_2)
{
int1 auVar1 [13];
int1 auVar2 [13];
int1 auVar3 [13];
ulong uVar4;
int1 auVar5 [13];
int4 uVar6;
long lVar7;
int8 uVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (*(int *)param_1 < 0) {
if (param_2 == (cpu_params *)0x0) {
uVar6 = cpu_get_num_math();
*(int4 *)param_1 = uVar6;
}
else {
memcpy(param_1,param_2,0x214);
}
}
lVar7 = 4;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
do {
uVar6 = *(int4 *)(param_1 + lVar7);
uVar4 = (ulong)(ushort)uVar6 & 0xffffffffffff00ff;
auVar1._8_4_ = 0;
auVar1._0_8_ = uVar4;
auVar1[0xc] = (char)((uint)uVar6 >> 0x18);
auVar2[8] = (char)((uint)uVar6 >> 0x10);
auVar2._0_8_ = uVar4;
auVar2[9] = 0;
auVar2._10_3_ = auVar1._10_3_;
auVar5._5_8_ = 0;
auVar5._0_5_ = auVar2._8_5_;
auVar3[4] = (char)((uint)uVar6 >> 8);
auVar3._0_4_ = (int)uVar4;
auVar3[5] = 0;
auVar3._6_7_ = SUB137(auVar5 << 0x40,6);
iVar9 = iVar9 + (int)uVar4;
iVar10 = iVar10 + auVar3._4_4_;
iVar11 = iVar11 + auVar2._8_4_;
iVar12 = iVar12 + (uint)(uint3)(auVar1._10_3_ >> 0x10);
lVar7 = lVar7 + 4;
} while (lVar7 != 0x204);
iVar9 = iVar12 + iVar10 + iVar11 + iVar9;
if (((iVar9 != 0) && (iVar9 < *(int *)param_1)) && (-1 < common_log_verbosity_thold)) {
uVar8 = common_log_main();
common_log_add(uVar8,3,
"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
iVar9,*(int4 *)param_1);
return;
}
return;
}
|
|
58,512
|
my_casedn_utf8mb3
|
eloqsql/strings/ctype-utf8.c
|
static size_t my_casedn_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar*) src, (uchar*)srcend)) > 0)
{
my_tolower_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
}
|
O3
|
c
|
my_casedn_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x52a86
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq -0x30(%rbp), %r13
addq %r13, %r14
movq 0x78(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5261b
testl %eax, %eax
jle 0x52a86
movl %eax, %ebx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movzbl %ah, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x52a65
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
movl 0x4(%rcx,%rax,4), %eax
movq %rax, -0x38(%rbp)
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x526e0
testl %eax, %eax
jle 0x52a86
movl %ebx, %ecx
addq %rcx, %r12
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r12
jb 0x52a29
subq -0x30(%rbp), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_casedn_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle short loc_52A86
mov r14, r8
mov r15, rdx
mov r12, rsi
add r15, rsi
mov r13, [rbp+var_30]
add r14, r13
mov rax, [rdi+78h]
mov [rbp+var_40], rax
loc_52A29:
lea rsi, [rbp+var_38]
mov rdx, r12
mov rcx, r15
call my_utf8mb3_uni
test eax, eax
jle short loc_52A86
mov ebx, eax
mov rax, [rbp+var_40]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
movzx edx, ah
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_52A65
movzx eax, al
lea rax, [rax+rax*2]
mov eax, [rcx+rax*4+4]
mov [rbp+var_38], rax
loc_52A65:
mov rsi, rax
mov rdx, r13
mov rcx, r14
call my_uni_utf8mb3
test eax, eax
jle short loc_52A86
mov ecx, ebx
add r12, rcx
mov eax, eax
add r13, rax
cmp r12, r15
jb short loc_52A29
loc_52A86:
sub r13, [rbp+var_30]
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_BYTE * my_casedn_utf8mb3(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4, long long a5)
{
_BYTE *v5; // r13
unsigned __int8 *v6; // r12
unsigned long long v7; // r15
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rax
long long v12; // rcx
int v13; // eax
long long v15; // [rsp+0h] [rbp-40h]
unsigned long long v16; // [rsp+8h] [rbp-38h] BYREF
_BYTE *v17; // [rsp+10h] [rbp-30h]
v5 = a4;
v17 = a4;
if ( a3 > 0 )
{
v6 = a2;
v7 = (unsigned long long)&a2[a3];
v5 = v17;
v8 = (unsigned long long)&v17[a5];
v15 = *(_QWORD *)(a1 + 120);
do
{
v9 = my_utf8mb3_uni(a1, &v16, v6, v7);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v16;
v12 = *(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * BYTE1(v16));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v16 + 4);
v16 = v11;
}
v13 = my_uni_utf8mb3(a1, v11, v5, v8);
if ( v13 <= 0 )
break;
v6 += v10;
v5 += (unsigned int)v13;
}
while ( (unsigned long long)v6 < v7 );
}
return (_BYTE *)(v5 - v17);
}
|
my_casedn_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x00152a86
MOV R14,R8
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV R13,qword ptr [RBP + -0x30]
ADD R14,R13
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x40],RAX
LAB_00152a29:
LEA RSI,[RBP + -0x38]
MOV RDX,R12
MOV RCX,R15
CALL 0x0015261b
TEST EAX,EAX
JLE 0x00152a86
MOV EBX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EDX,AH
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x00152a65
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
MOV EAX,dword ptr [RCX + RAX*0x4 + 0x4]
MOV qword ptr [RBP + -0x38],RAX
LAB_00152a65:
MOV RSI,RAX
MOV RDX,R13
MOV RCX,R14
CALL 0x001526e0
TEST EAX,EAX
JLE 0x00152a86
MOV ECX,EBX
ADD R12,RCX
MOV EAX,EAX
ADD R13,RAX
CMP R12,R15
JC 0x00152a29
LAB_00152a86:
SUB R13,qword ptr [RBP + -0x30]
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_utf8mb3(long param_1,ulong param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
uint uVar3;
uint uVar4;
long lVar5;
ulong uVar6;
int8 local_40;
lVar5 = param_4;
if (0 < param_3) {
uVar6 = param_3 + param_2;
lVar1 = *(long *)(param_1 + 0x78);
do {
uVar3 = my_utf8mb3_uni();
if ((int)uVar3 < 1) break;
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (local_40 >> 8 & 0xff) * 8);
if (lVar2 != 0) {
local_40 = (ulong)*(uint *)(lVar2 + 4 + (local_40 & 0xff) * 0xc);
}
uVar4 = my_uni_utf8mb3();
if ((int)uVar4 < 1) break;
param_2 = param_2 + uVar3;
lVar5 = lVar5 + (ulong)uVar4;
} while (param_2 < uVar6);
}
return lVar5 - param_4;
}
|
|
58,513
|
nglog::InstallFailureSignalHandler()
|
ng-log[P]ng-log/src/signalhandler.cc
|
void InstallFailureSignalHandler() {
#ifdef HAVE_SIGACTION
// Build the sigaction struct.
struct sigaction sig_action;
memset(&sig_action, 0, sizeof(sig_action));
sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags |= SA_SIGINFO;
sig_action.sa_sigaction = &FailureSignalHandler;
for (auto kFailureSignal : kFailureSignals) {
CHECK_ERR(sigaction(kFailureSignal.number, &sig_action, nullptr));
}
kFailureSignalHandlerInstalled = true;
#elif defined(NGLOG_OS_WINDOWS)
for (size_t i = 0; i < ARRAYSIZE(kFailureSignals); ++i) {
CHECK_NE(signal(kFailureSignals[i].number, &FailureSignalHandler), SIG_ERR);
}
kFailureSignalHandlerInstalled = true;
#endif // HAVE_SIGACTION
}
|
O1
|
cpp
|
nglog::InstallFailureSignalHandler():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
leaq 0x80(%rsp), %rbx
xorl %r13d, %r13d
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72a0
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x76d0
orb $0x4, 0x80(%r14)
leaq -0x88(%rip), %rax # 0x209fd
movq %rax, -0x8(%r14)
leaq 0x101f0(%rip), %rbp # 0x30c80
leaq 0x448b(%rip), %r14 # 0x24f22
leaq 0x20(%rsp), %r15
leaq 0x44cc(%rip), %r12 # 0x24f6f
movl (%r13,%rbp), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x76e0
cmpl $-0x1, %eax
je 0x20ac3
addq $0x10, %r13
cmpq $0x60, %r13
jne 0x20aa3
jmp 0x20b1b
leaq -0x157c0(%rip), %rax # 0xb30a
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movl $0x18b, %edx # imm = 0x18B
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0xc3ae
movq %r15, %rdi
callq 0xb7ce
movl $0x36, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7600
movq %r15, %rdi
callq 0xc418
jmp 0x20ab7
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc418
movq %rbx, %rdi
callq 0x79b0
movq %rax, %rdi
callq 0x9923
|
_ZN5nglog27InstallFailureSignalHandlerEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
lea rbx, [rsp+148h+var_C8]
xor r13d, r13d
mov edx, 98h
mov rdi, rbx
xor esi, esi
call _memset
lea r14, [rsp+148h+var_C0]
mov rdi, r14
call _sigemptyset
or byte ptr [r14+80h], 4
lea rax, _ZN5nglog12_GLOBAL__N_120FailureSignalHandlerEiP9siginfo_tPv; nglog::`anonymous namespace'::FailureSignalHandler(int,siginfo_t *,void *)
mov [r14-8], rax
lea rbp, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
lea r14, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea r15, [rsp+148h+var_128]
lea r12, aSigactionKfail; "sigaction(kFailureSignal.number, &sig_a"...
loc_20AA3:
mov edi, [r13+rbp+0]
mov rsi, rbx
xor edx, edx
call _sigaction
cmp eax, 0FFFFFFFFh
jz short loc_20AC3
loc_20AB7:
add r13, 10h
cmp r13, 60h ; '`'
jnz short loc_20AA3
jmp short loc_20B1B
loc_20AC3:
lea rax, _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
mov qword ptr [rsp+148h+var_138], rax
mov qword ptr [rsp+148h+var_138+8], 0
movups xmm0, [rsp+148h+var_138]
movups [rsp+148h+var_148], xmm0
mov rdi, r15
mov rsi, r14
mov edx, 18Bh
mov ecx, 3
xor r8d, r8d
call _ZN5nglog15ErrnoLogMessageC2EPKciNS_11LogSeverityElMNS_10LogMessageEFvvE; nglog::ErrnoLogMessage::ErrnoLogMessage(char const*,int,nglog::LogSeverity,long,void (nglog::LogMessage::*)(void))
mov rdi, r15; this
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov edx, 36h ; '6'
mov rdi, rax
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r15; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
jmp short loc_20AB7
loc_20B1B:
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
void nglog::InstallFailureSignalHandler(nglog *this)
{
long long v1; // r13
long long v2; // r9
long long v3; // rax
_QWORD v4[12]; // [rsp+20h] [rbp-128h] BYREF
long long ( *v5)(int, long long, long long); // [rsp+80h] [rbp-C8h] BYREF
_BYTE v6[128]; // [rsp+88h] [rbp-C0h] BYREF
char v7; // [rsp+108h] [rbp-40h]
v1 = 0LL;
memset(&v5, 0LL, 152LL);
sigemptyset(v6);
v7 |= 4u;
v5 = nglog::`anonymous namespace'::FailureSignalHandler;
do
{
if ( (unsigned int)sigaction(
*(unsigned int *)((char *)&nglog::`anonymous namespace'::kFailureSignals + v1),
&v5,
0LL) == -1 )
{
nglog::ErrnoLogMessage::ErrnoLogMessage(
v4,
(nglog::tools *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
395,
3,
0LL,
v2,
(long long)nglog::LogMessage::SendToLog,
0LL);
v3 = nglog::LogMessage::stream((nglog::LogMessage *)v4);
std::__ostream_insert<char,std::char_traits<char>>(
v3,
"sigaction(kFailureSignal.number, &sig_action, nullptr)",
54LL);
nglog::ErrnoLogMessage::~ErrnoLogMessage((nglog::ErrnoLogMessage *)v4);
}
v1 += 16LL;
}
while ( v1 != 96 );
}
|
InstallFailureSignalHandler:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
LEA RBX,[RSP + 0x80]
XOR R13D,R13D
MOV EDX,0x98
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001072a0
LEA R14,[RSP + 0x88]
MOV RDI,R14
CALL 0x001076d0
OR byte ptr [R14 + 0x80],0x4
LEA RAX,[0x1209fd]
MOV qword ptr [R14 + -0x8],RAX
LEA RBP,[0x130c80]
LEA R14,[0x124f22]
LEA R15,[RSP + 0x20]
LEA R12,[0x124f6f]
LAB_00120aa3:
MOV EDI,dword ptr [R13 + RBP*0x1]
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001076e0
CMP EAX,-0x1
JZ 0x00120ac3
LAB_00120ab7:
ADD R13,0x10
CMP R13,0x60
JNZ 0x00120aa3
JMP 0x00120b1b
LAB_00120ac3:
LEA RAX,[0x10b30a]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x0
MOVUPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x18b
MOV ECX,0x3
XOR R8D,R8D
CALL 0x0010c3ae
LAB_00120af9:
MOV RDI,R15
CALL 0x0010b7ce
MOV EDX,0x36
MOV RDI,RAX
MOV RSI,R12
CALL 0x00107600
LAB_00120b11:
MOV RDI,R15
CALL 0x0010c418
JMP 0x00120ab7
LAB_00120b1b:
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::InstallFailureSignalHandler() */
void nglog::InstallFailureSignalHandler(void)
{
int iVar1;
ostream *poVar2;
int8 in_R9;
long lVar3;
LogMessage local_128 [96];
sigaction local_c8;
lVar3 = 0;
memset(&local_c8,0,0x98);
sigemptyset(&local_c8.sa_mask);
local_c8.sa_flags._0_1_ = (byte)local_c8.sa_flags | 4;
local_c8.__sigaction_handler.sa_handler = (anonymous_namespace)::FailureSignalHandler;
do {
iVar1 = sigaction(*(int *)((long)&(anonymous_namespace)::kFailureSignals + lVar3),&local_c8,
(sigaction *)0x0);
if (iVar1 == -1) {
ErrnoLogMessage::ErrnoLogMessage
((ErrnoLogMessage *)local_128,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
0x18b,3,0,in_R9,0x10b30a,0);
/* try { // try from 00120af9 to 00120b10 has its CatchHandler @ 00120b2d */
poVar2 = (ostream *)LogMessage::stream(local_128);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"sigaction(kFailureSignal.number, &sig_action, nullptr)",0x36);
ErrnoLogMessage::~ErrnoLogMessage((ErrnoLogMessage *)local_128);
}
lVar3 = lVar3 + 0x10;
} while (lVar3 != 0x60);
return;
}
|
|
58,514
|
nglog::InstallFailureSignalHandler()
|
ng-log[P]ng-log/src/signalhandler.cc
|
void InstallFailureSignalHandler() {
#ifdef HAVE_SIGACTION
// Build the sigaction struct.
struct sigaction sig_action;
memset(&sig_action, 0, sizeof(sig_action));
sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags |= SA_SIGINFO;
sig_action.sa_sigaction = &FailureSignalHandler;
for (auto kFailureSignal : kFailureSignals) {
CHECK_ERR(sigaction(kFailureSignal.number, &sig_action, nullptr));
}
kFailureSignalHandlerInstalled = true;
#elif defined(NGLOG_OS_WINDOWS)
for (size_t i = 0; i < ARRAYSIZE(kFailureSignals); ++i) {
CHECK_NE(signal(kFailureSignals[i].number, &FailureSignalHandler), SIG_ERR);
}
kFailureSignalHandlerInstalled = true;
#endif // HAVE_SIGACTION
}
|
O2
|
cpp
|
nglog::InstallFailureSignalHandler():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
leaq 0x80(%rsp), %rbx
xorl %r13d, %r13d
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8300
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x8740
orb $0x4, 0x80(%r14)
leaq -0x88(%rip), %rax # 0x1d4fb
movq %rax, -0x8(%r14)
leaq 0x13712(%rip), %r14 # 0x30ca0
leaq 0x20(%rsp), %r15
pushq $0x3
popq %rbp
leaq 0x49d2(%rip), %r12 # 0x21f6f
cmpq $0x60, %r13
je 0x1d60e
movl (%r13,%r14), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8750
cmpl $-0x1, %eax
je 0x1d5bd
addq $0x10, %r13
jmp 0x1d59d
leaq -0x11aa0(%rip), %rax # 0xbb24
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
leaq 0x4940(%rip), %rsi # 0x21f22
movl $0x18b, %edx # imm = 0x18B
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xc81e
movq %r15, %rdi
callq 0xbdd2
movq %rax, %rdi
movq %r12, %rsi
callq 0x8590
movq %r15, %rdi
callq 0xc840
jmp 0x1d5b7
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc840
movq %rbx, %rdi
callq 0x8a40
movq %rax, %rdi
callq 0xa2c5
|
_ZN5nglog27InstallFailureSignalHandlerEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
lea rbx, [rsp+148h+var_C8]
xor r13d, r13d
mov edx, 98h
mov rdi, rbx
xor esi, esi
call _memset
lea r14, [rsp+148h+var_C0]
mov rdi, r14
call _sigemptyset
or byte ptr [r14+80h], 4
lea rax, _ZN5nglog12_GLOBAL__N_120FailureSignalHandlerEiP9siginfo_tPv; nglog::`anonymous namespace'::FailureSignalHandler(int,siginfo_t *,void *)
mov [r14-8], rax
lea r14, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
lea r15, [rsp+148h+var_128]
push 3
pop rbp
lea r12, aSigactionKfail; "sigaction(kFailureSignal.number, &sig_a"...
loc_1D59D:
cmp r13, 60h ; '`'
jz short loc_1D60E
mov edi, [r13+r14+0]
mov rsi, rbx
xor edx, edx
call _sigaction
cmp eax, 0FFFFFFFFh
jz short loc_1D5BD
loc_1D5B7:
add r13, 10h
jmp short loc_1D59D
loc_1D5BD:
lea rax, _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
mov qword ptr [rsp+148h+var_138], rax
and qword ptr [rsp+148h+var_138+8], 0
movups xmm0, [rsp+148h+var_138]
movups [rsp+148h+var_148], xmm0
mov rdi, r15
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov edx, 18Bh
mov ecx, ebp
xor r8d, r8d
call _ZN5nglog15ErrnoLogMessageC2EPKciNS_11LogSeverityElMNS_10LogMessageEFvvE; nglog::ErrnoLogMessage::ErrnoLogMessage(char const*,int,nglog::LogSeverity,long,void (nglog::LogMessage::*)(void))
mov rdi, r15; this
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov rdi, rax
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rdi, r15; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
jmp short loc_1D5B7
loc_1D60E:
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
void nglog::InstallFailureSignalHandler(nglog *this)
{
long long v1; // r13
long long v2; // r9
long long v3; // rax
_QWORD v4[12]; // [rsp+20h] [rbp-128h] BYREF
long long ( *v5)(int, long long, long long); // [rsp+80h] [rbp-C8h] BYREF
_BYTE v6[128]; // [rsp+88h] [rbp-C0h] BYREF
char v7; // [rsp+108h] [rbp-40h]
v1 = 0LL;
memset(&v5, 0LL, 152LL);
sigemptyset(v6);
v7 |= 4u;
v5 = nglog::`anonymous namespace'::FailureSignalHandler;
while ( v1 != 96 )
{
if ( (unsigned int)sigaction(
*(unsigned int *)((char *)&nglog::`anonymous namespace'::kFailureSignals + v1),
&v5,
0LL) == -1 )
{
nglog::ErrnoLogMessage::ErrnoLogMessage(
v4,
(long long)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
0x18Bu,
3u,
0LL,
v2,
(unsigned long long)nglog::LogMessage::SendToLog);
v3 = nglog::LogMessage::stream((nglog::LogMessage *)v4);
std::operator<<<std::char_traits<char>>(v3, "sigaction(kFailureSignal.number, &sig_action, nullptr)");
nglog::ErrnoLogMessage::~ErrnoLogMessage((nglog::ErrnoLogMessage *)v4);
}
v1 += 16LL;
}
}
|
InstallFailureSignalHandler:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
LEA RBX,[RSP + 0x80]
XOR R13D,R13D
MOV EDX,0x98
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00108300
LEA R14,[RSP + 0x88]
MOV RDI,R14
CALL 0x00108740
OR byte ptr [R14 + 0x80],0x4
LEA RAX,[0x11d4fb]
MOV qword ptr [R14 + -0x8],RAX
LEA R14,[0x130ca0]
LEA R15,[RSP + 0x20]
PUSH 0x3
POP RBP
LEA R12,[0x121f6f]
LAB_0011d59d:
CMP R13,0x60
JZ 0x0011d60e
MOV EDI,dword ptr [R13 + R14*0x1]
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00108750
CMP EAX,-0x1
JZ 0x0011d5bd
LAB_0011d5b7:
ADD R13,0x10
JMP 0x0011d59d
LAB_0011d5bd:
LEA RAX,[0x10bb24]
MOV qword ptr [RSP + 0x10],RAX
AND qword ptr [RSP + 0x18],0x0
MOVUPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
LEA RSI,[0x121f22]
MOV EDX,0x18b
MOV ECX,EBP
XOR R8D,R8D
CALL 0x0010c81e
LAB_0011d5f1:
MOV RDI,R15
CALL 0x0010bdd2
MOV RDI,RAX
MOV RSI,R12
CALL 0x00108590
LAB_0011d604:
MOV RDI,R15
CALL 0x0010c840
JMP 0x0011d5b7
LAB_0011d60e:
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::InstallFailureSignalHandler() */
void nglog::InstallFailureSignalHandler(void)
{
int iVar1;
ostream *poVar2;
int8 in_R9;
long lVar3;
LogMessage local_128 [96];
sigaction local_c8;
memset(&local_c8,0,0x98);
sigemptyset(&local_c8.sa_mask);
local_c8.sa_flags._0_1_ = (byte)local_c8.sa_flags | 4;
local_c8.__sigaction_handler.sa_handler = (anonymous_namespace)::FailureSignalHandler;
for (lVar3 = 0; lVar3 != 0x60; lVar3 = lVar3 + 0x10) {
iVar1 = sigaction(*(int *)((long)&(anonymous_namespace)::kFailureSignals + lVar3),&local_c8,
(sigaction *)0x0);
if (iVar1 == -1) {
ErrnoLogMessage::ErrnoLogMessage
((ErrnoLogMessage *)local_128,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
0x18b,3,0,in_R9,0x10bb24,0);
/* try { // try from 0011d5f1 to 0011d603 has its CatchHandler @ 0011d620 */
poVar2 = (ostream *)LogMessage::stream(local_128);
std::operator<<(poVar2,"sigaction(kFailureSignal.number, &sig_action, nullptr)");
ErrnoLogMessage::~ErrnoLogMessage((ErrnoLogMessage *)local_128);
}
}
return;
}
|
|
58,515
|
my_casedn_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
}
|
O3
|
c
|
my_casedn_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x3bd28
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x3bd12
popq %rbp
retq
|
my_casedn_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_3BD28
push rbp
mov rbp, rsp
mov rdx, [rdi+48h]
xor edi, edi
loc_3BD12:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_3BD12
pop rbp
locret_3BD28:
retn
|
long long my_casedn_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 72);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
|
my_casedn_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x0013bd28
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x48]
XOR EDI,EDI
LAB_0013bd12:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x0013bd12
POP RBP
LAB_0013bd28:
RET
|
void my_casedn_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x48);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
|
|
58,516
|
my_gethwaddr
|
eloqsql/mysys/my_gethwaddr.c
|
my_bool my_gethwaddr(uchar *to)
{
int fd, res= 1;
#ifdef _AIX
struct ifhwaddr_req ifr[32];
#else
struct ifreq ifr[32];
#endif
struct ifconf ifc;
DBUG_ENTER("my_gethwaddr");
ifc.ifc_req= (struct ifreq *) ifr;
ifc.ifc_len= sizeof(ifr);
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0)
{
DBUG_PRINT("error", ("socket() call failed with %d", errno));
goto err;
}
if (ioctl(fd, SIOCGIFCONF, (char*)&ifc) >= 0)
{
uint i;
for (i= 0; res && i < ifc.ifc_len / sizeof(ifr[0]); i++)
{
#if !defined(_AIX) || !defined(__linux__)
#if defined(__linux__)
#define HWADDR_DATA ifr[i].ifr_hwaddr.sa_data
#else
#define HWADDR_DATA ifr[i].ifr_hwaddr
#endif
if (ioctl(fd, SIOCGIFHWADDR, &ifr[i]) >= 0)
res= memcpy_and_test(to, (uchar *)&HWADDR_DATA,
ETHER_ADDR_LEN);
#else
/*
A bug in OpenSolaris used to prevent non-root from getting a mac
address: {no url. Oracle killed the old OpenSolaris bug database}
Thus, we'll use an alternative method and extract the address from the
arp table.
*/
struct arpreq arpr;
arpr.arp_pa= ifr[i].ifr_addr;
if (ioctl(fd, SIOCGARP, (char*)&arpr) >= 0)
res= memcpy_and_test(to, (uchar *)&arpr.arp_ha.sa_data,
ETHER_ADDR_LEN);
#endif
}
}
close(fd);
err:
DBUG_RETURN(res);
}
|
O0
|
c
|
my_gethwaddr:
pushq %rbp
movq %rsp, %rbp
subq $0x540, %rsp # imm = 0x540
movq %rdi, -0x8(%rbp)
movl $0x1, -0x10(%rbp)
leaq -0x510(%rbp), %rax
movq %rax, -0x518(%rbp)
movl $0x500, -0x520(%rbp) # imm = 0x500
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x27430
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xcfd9e
jmp 0xcfd97
jmp 0xcfd99
jmp 0xcfe8d
movl -0xc(%rbp), %edi
movl $0x8912, %esi # imm = 0x8912
leaq -0x520(%rbp), %rdx
movb $0x0, %al
callq 0x27140
cmpl $0x0, %eax
jl 0xcfe85
movl $0x0, -0x524(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x525(%rbp)
je 0xcfe09
movl -0x524(%rbp), %eax
movq %rax, -0x530(%rbp)
movslq -0x520(%rbp), %rax
movl $0x28, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x530(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x525(%rbp)
movb -0x525(%rbp), %al
testb $0x1, %al
jne 0xcfe15
jmp 0xcfe83
movl -0xc(%rbp), %edi
movl -0x524(%rbp), %eax
leaq -0x510(%rbp), %rdx
imulq $0x28, %rax, %rax
addq %rax, %rdx
movl $0x8927, %esi # imm = 0x8927
movb $0x0, %al
callq 0x27140
cmpl $0x0, %eax
jl 0xcfe6d
movq -0x8(%rbp), %rdi
movl -0x524(%rbp), %eax
leaq -0x510(%rbp), %rsi
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
addq $0x2, %rsi
movl $0x6, %edx
callq 0xcfeb0
movsbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0xcfe6f
movl -0x524(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x524(%rbp)
jmp 0xcfdc7
jmp 0xcfe85
movl -0xc(%rbp), %edi
callq 0x27210
jmp 0xcfe8f
movl -0x10(%rbp), %eax
movb %al, -0x531(%rbp)
movb -0x531(%rbp), %al
addq $0x540, %rsp # imm = 0x540
popq %rbp
retq
nopw (%rax,%rax)
|
my_gethwaddr:
push rbp
mov rbp, rsp
sub rsp, 540h
mov [rbp+var_8], rdi
mov [rbp+var_10], 1
lea rax, [rbp+var_510]
mov [rbp+var_518], rax
mov [rbp+var_520], 500h
mov esi, 2
xor edx, edx
mov edi, esi
call _socket
mov [rbp+var_C], eax
cmp [rbp+var_C], 0
jge short loc_CFD9E
jmp short $+2
loc_CFD97:
jmp short $+2
loc_CFD99:
jmp loc_CFE8D
loc_CFD9E:
mov edi, [rbp+var_C]
mov esi, 8912h
lea rdx, [rbp+var_520]
mov al, 0
call _ioctl
cmp eax, 0
jl loc_CFE85
mov [rbp+var_524], 0
loc_CFDC7:
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_525], al
jz short loc_CFE09
mov eax, [rbp+var_524]
mov [rbp+var_530], rax
movsxd rax, [rbp+var_520]
mov ecx, 28h ; '('
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_530]
cmp rax, rcx
setb al
mov [rbp+var_525], al
loc_CFE09:
mov al, [rbp+var_525]
test al, 1
jnz short loc_CFE15
jmp short loc_CFE83
loc_CFE15:
mov edi, [rbp+var_C]
mov eax, [rbp+var_524]
lea rdx, [rbp+var_510]
imul rax, 28h ; '('
add rdx, rax
mov esi, 8927h
mov al, 0
call _ioctl
cmp eax, 0
jl short loc_CFE6D
mov rdi, [rbp+var_8]
mov eax, [rbp+var_524]
lea rsi, [rbp+var_510]
imul rax, 28h ; '('
add rsi, rax
add rsi, 10h
add rsi, 2
mov edx, 6
call memcpy_and_test
movsx eax, al
mov [rbp+var_10], eax
loc_CFE6D:
jmp short $+2
loc_CFE6F:
mov eax, [rbp+var_524]
add eax, 1
mov [rbp+var_524], eax
jmp loc_CFDC7
loc_CFE83:
jmp short $+2
loc_CFE85:
mov edi, [rbp+var_C]
call _close
loc_CFE8D:
jmp short $+2
loc_CFE8F:
mov eax, [rbp+var_10]
mov [rbp+var_531], al
mov al, [rbp+var_531]
add rsp, 540h
pop rbp
retn
|
char my_gethwaddr(long long a1)
{
bool v2; // [rsp+1Bh] [rbp-525h]
unsigned int i; // [rsp+1Ch] [rbp-524h]
int v4; // [rsp+20h] [rbp-520h] BYREF
_QWORD *v5; // [rsp+28h] [rbp-518h]
_QWORD v6[160]; // [rsp+30h] [rbp-510h] BYREF
int v7; // [rsp+530h] [rbp-10h]
unsigned int v8; // [rsp+534h] [rbp-Ch]
long long v9; // [rsp+538h] [rbp-8h]
v9 = a1;
v7 = 1;
v5 = v6;
v4 = 1280;
v8 = socket(2LL, 2LL, 0LL);
if ( (v8 & 0x80000000) == 0 )
{
if ( (int)ioctl(v8, 35090LL, &v4) >= 0 )
{
for ( i = 0; ; ++i )
{
v2 = 0;
if ( v7 )
v2 = i < v4 / 0x28uLL;
if ( !v2 )
break;
if ( (int)ioctl(v8, 35111LL, &v6[5 * i]) >= 0 )
v7 = (char)memcpy_and_test(v9, (char *)&v6[5 * i + 2] + 2, 6LL);
}
}
close(v8);
}
return v7;
}
|
my_gethwaddr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x540
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0x10],0x1
LEA RAX,[RBP + -0x510]
MOV qword ptr [RBP + -0x518],RAX
MOV dword ptr [RBP + -0x520],0x500
MOV ESI,0x2
XOR EDX,EDX
MOV EDI,ESI
CALL 0x00127430
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x0
JGE 0x001cfd9e
JMP 0x001cfd97
LAB_001cfd97:
JMP 0x001cfd99
LAB_001cfd99:
JMP 0x001cfe8d
LAB_001cfd9e:
MOV EDI,dword ptr [RBP + -0xc]
MOV ESI,0x8912
LEA RDX,[RBP + -0x520]
MOV AL,0x0
CALL 0x00127140
CMP EAX,0x0
JL 0x001cfe85
MOV dword ptr [RBP + -0x524],0x0
LAB_001cfdc7:
XOR EAX,EAX
CMP dword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x525],AL
JZ 0x001cfe09
MOV EAX,dword ptr [RBP + -0x524]
MOV qword ptr [RBP + -0x530],RAX
MOVSXD RAX,dword ptr [RBP + -0x520]
MOV ECX,0x28
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x530]
CMP RAX,RCX
SETC AL
MOV byte ptr [RBP + -0x525],AL
LAB_001cfe09:
MOV AL,byte ptr [RBP + -0x525]
TEST AL,0x1
JNZ 0x001cfe15
JMP 0x001cfe83
LAB_001cfe15:
MOV EDI,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x524]
LEA RDX,[RBP + -0x510]
IMUL RAX,RAX,0x28
ADD RDX,RAX
MOV ESI,0x8927
MOV AL,0x0
CALL 0x00127140
CMP EAX,0x0
JL 0x001cfe6d
MOV RDI,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x524]
LEA RSI,[RBP + -0x510]
IMUL RAX,RAX,0x28
ADD RSI,RAX
ADD RSI,0x10
ADD RSI,0x2
MOV EDX,0x6
CALL 0x001cfeb0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x10],EAX
LAB_001cfe6d:
JMP 0x001cfe6f
LAB_001cfe6f:
MOV EAX,dword ptr [RBP + -0x524]
ADD EAX,0x1
MOV dword ptr [RBP + -0x524],EAX
JMP 0x001cfdc7
LAB_001cfe83:
JMP 0x001cfe85
LAB_001cfe85:
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x00127210
LAB_001cfe8d:
JMP 0x001cfe8f
LAB_001cfe8f:
MOV EAX,dword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x531],AL
MOV AL,byte ptr [RBP + -0x531]
ADD RSP,0x540
POP RBP
RET
|
int my_gethwaddr(int8 param_1)
{
char cVar1;
int iVar2;
uint local_52c;
int local_528 [2];
int1 *local_520;
int1 local_518 [18];
int1 auStack_506 [1262];
int local_18;
int local_14;
int8 local_10;
local_18 = 1;
local_520 = local_518;
local_528[0] = 0x500;
local_10 = param_1;
local_14 = socket(2,2,0);
if (-1 < local_14) {
iVar2 = ioctl(local_14,0x8912,local_528);
if (-1 < iVar2) {
for (local_52c = 0; local_18 != 0 && (ulong)local_52c < (ulong)(long)local_528[0] / 0x28;
local_52c = local_52c + 1) {
iVar2 = ioctl(local_14,0x8927,local_518 + (ulong)local_52c * 0x28);
if (-1 < iVar2) {
cVar1 = memcpy_and_test(local_10,auStack_506 + (ulong)local_52c * 0x28,6);
local_18 = (int)cVar1;
}
}
}
close(local_14);
}
return local_18;
}
|
|
58,517
|
resize_queue
|
eloqsql/mysys/queues.c
|
int resize_queue(QUEUE *queue, uint max_elements)
{
uchar **new_root;
DBUG_ENTER("resize_queue");
if (queue->max_elements == max_elements)
DBUG_RETURN(0);
if ((new_root= (uchar **) my_realloc(key_memory_QUEUE, (void *)queue->root,
(max_elements + 1)* sizeof(void*),
MYF(MY_WME))) == 0)
DBUG_RETURN(1);
set_if_smaller(queue->elements, max_elements);
queue->max_elements= max_elements;
queue->root= new_root;
DBUG_RETURN(0);
}
|
O0
|
c
|
resize_queue:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x833d6
jmp 0x833cd
movl $0x0, -0x4(%rbp)
jmp 0x83449
leaq 0x375793(%rip), %rax # 0x3f8b70
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
movl $0x10, %ecx
callq 0x7fdc0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x83413
jmp 0x8340a
movl $0x1, -0x4(%rbp)
jmp 0x83449
jmp 0x83415
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x8342b
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x8342d
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
resize_queue:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov eax, [rax+14h]
cmp eax, [rbp+var_14]
jnz short loc_833D6
jmp short $+2
loc_833CD:
mov [rbp+var_4], 0
jmp short loc_83449
loc_833D6:
lea rax, key_memory_QUEUE
mov edi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_14]
add eax, 1
mov eax, eax
mov edx, eax
shl rdx, 3
mov ecx, 10h
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_83413
jmp short $+2
loc_8340A:
mov [rbp+var_4], 1
jmp short loc_83449
loc_83413:
jmp short $+2
loc_83415:
mov rax, [rbp+var_10]
mov eax, [rax+10h]
cmp eax, [rbp+var_14]
jbe short loc_8342B
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+10h], ecx
loc_8342B:
jmp short $+2
loc_8342D:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+14h], ecx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 0
loc_83449:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long resize_queue(long long a1, unsigned int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
if ( *(_DWORD *)(a1 + 20) == a2 )
{
return 0;
}
else
{
v3 = my_realloc(key_memory_QUEUE, *(_QWORD *)a1, (const char *)(8LL * (a2 + 1)), 16);
if ( v3 )
{
if ( *(_DWORD *)(a1 + 16) > a2 )
*(_DWORD *)(a1 + 16) = a2;
*(_DWORD *)(a1 + 20) = a2;
*(_QWORD *)a1 = v3;
return 0;
}
else
{
return 1;
}
}
}
|
resize_queue:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x001833d6
JMP 0x001833cd
LAB_001833cd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00183449
LAB_001833d6:
LEA RAX,[0x4f8b70]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV EAX,EAX
MOV EDX,EAX
SHL RDX,0x3
MOV ECX,0x10
CALL 0x0017fdc0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x00183413
JMP 0x0018340a
LAB_0018340a:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00183449
LAB_00183413:
JMP 0x00183415
LAB_00183415:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RBP + -0x14]
JBE 0x0018342b
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x10],ECX
LAB_0018342b:
JMP 0x0018342d
LAB_0018342d:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x14],ECX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_00183449:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 resize_queue(long *param_1,uint param_2)
{
long lVar1;
int4 local_c;
if (*(uint *)((long)param_1 + 0x14) == param_2) {
local_c = 0;
}
else {
lVar1 = my_realloc(key_memory_QUEUE,*param_1,(ulong)(param_2 + 1) << 3,0x10);
if (lVar1 == 0) {
local_c = 1;
}
else {
if (param_2 < *(uint *)(param_1 + 2)) {
*(uint *)(param_1 + 2) = param_2;
}
*(uint *)((long)param_1 + 0x14) = param_2;
*param_1 = lVar1;
local_c = 0;
}
}
return local_c;
}
|
|
58,518
|
ggml_gallocr_alloc_graph
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c
|
bool ggml_gallocr_alloc_graph(ggml_gallocr_t galloc, struct ggml_cgraph * graph) {
if (ggml_gallocr_needs_realloc(galloc, graph)) {
if (galloc->n_buffers == 1) {
#ifndef NDEBUG
GGML_LOG_DEBUG("%s: reallocating buffers automatically\n", __func__);
#endif
if (!ggml_gallocr_reserve(galloc, graph)) {
return false;
}
} else {
#ifndef NDEBUG
GGML_LOG_DEBUG("%s: cannot reallocate multi buffer graph automatically, call reserve\n", __func__);
#endif
return false;
}
}
// reset buffers
for (int i = 0; i < galloc->n_buffers; i++) {
if (galloc->buffers[i] != NULL) {
ggml_backend_buffer_reset(galloc->buffers[i]);
}
}
// allocate the graph tensors from the previous assignments
// leafs
for (int i = 0; i < graph->n_leafs; i++) {
struct ggml_tensor * leaf = graph->leafs[i];
struct leaf_alloc * leaf_alloc = &galloc->leaf_allocs[i];
ggml_gallocr_init_tensor(galloc, leaf, &leaf_alloc->leaf);
}
// nodes
for (int i = 0; i < graph->n_nodes; i++) {
struct ggml_tensor * node = graph->nodes[i];
struct node_alloc * node_alloc = &galloc->node_allocs[i];
for (int j = 0; j < GGML_MAX_SRC; j++) {
struct ggml_tensor * src = node->src[j];
if (src == NULL) {
continue;
}
ggml_gallocr_init_tensor(galloc, src, &node_alloc->src[j]);
}
ggml_gallocr_init_tensor(galloc, node, &node_alloc->dst);
}
return true;
}
|
O3
|
c
|
ggml_gallocr_alloc_graph:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r14
movl 0x48(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x24b36
movl 0x58(%r14), %ecx
cmpl 0x8(%r13), %ecx
jne 0x24b3f
testl %eax, %eax
jle 0x24b97
movl $0x18, %ebp
xorl %ebx, %ebx
movq %r13, 0x8(%rsp)
movq 0x10(%r13), %rax
movq (%rax,%rbx,8), %r15
movq 0x40(%r14), %r12
movq %rbx, %rax
shlq $0x8, %rax
leaq (%rax,%rbx,8), %rdx
addq %r12, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x255e0
testb %al, %al
je 0x24ce9
movq %rbp, 0x10(%rsp)
addq %rbp, %r12
xorl %r13d, %r13d
movq 0x98(%r15,%r13,8), %rbp
testq %rbp, %rbp
je 0x24b06
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x255e0
testb %al, %al
je 0x24cb1
incq %r13
addq $0x18, %r12
cmpq $0xa, %r13
jne 0x24ae3
incq %rbx
movq 0x8(%rsp), %r13
movslq 0x4(%r13), %rax
movq 0x10(%rsp), %rbp
addq $0x108, %rbp # imm = 0x108
cmpq %rax, %rbx
jl 0x24aab
jmp 0x24b97
leaq 0x2aabf(%rip), %rsi # 0x4f5fc
jmp 0x24b46
leaq 0x2aafa(%rip), %rsi # 0x4f640
leaq 0x2aad8(%rip), %rdx # 0x4f625
movl $0x1, %edi
xorl %eax, %eax
callq 0x16810
cmpl $0x1, 0x18(%r14)
jne 0x24c84
leaq 0x2a76f(%rip), %rsi # 0x4f2da
leaq 0x2a790(%rip), %rdx # 0x4f302
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x16810
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x174c0
testb %al, %al
je 0x24ca0
movl 0x18(%r14), %eax
testl %eax, %eax
jle 0x24bc2
xorl %ebx, %ebx
movq 0x8(%r14), %rcx
movq (%rcx,%rbx,8), %rdi
testq %rdi, %rdi
je 0x24bb7
callq 0x17370
movl 0x18(%r14), %eax
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x24ba1
cmpl $0x0, 0x8(%r13)
jle 0x24bf5
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x28(%r13), %rax
movq (%rax,%r15,8), %rsi
movq 0x50(%r14), %rdx
addq %rbx, %rdx
movq %r14, %rdi
callq 0x24d12
incq %r15
movslq 0x8(%r13), %rax
addq $0x18, %rbx
cmpq %rax, %r15
jl 0x24bce
movb $0x1, %bl
cmpl $0x0, 0x4(%r13)
jle 0x24ca0
movl $0x18, %r15d
xorl %ebx, %ebx
movq %r13, 0x8(%rsp)
movq 0x10(%r13), %rax
movq (%rax,%rbx,8), %r12
movq 0x40(%r14), %rbp
movq %rbx, %rax
shlq $0x8, %rax
leaq (%rax,%rbx,8), %rax
addq %rbp, %rax
movq %rax, 0x10(%rsp)
addq %r15, %rbp
movl $0x13, %r13d
movq (%r12,%r13,8), %rsi
testq %rsi, %rsi
je 0x24c4b
movq %r14, %rdi
movq %rbp, %rdx
callq 0x24d12
addq $0x18, %rbp
incq %r13
cmpq $0x1d, %r13
jne 0x24c37
movq %r14, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0x24d12
incq %rbx
movq 0x8(%rsp), %r13
movslq 0x4(%r13), %rax
addq $0x108, %r15 # imm = 0x108
cmpq %rax, %rbx
jl 0x24c0f
movb $0x1, %bl
jmp 0x24ca0
leaq 0x2a690(%rip), %rsi # 0x4f31b
leaq 0x2a670(%rip), %rdx # 0x4f302
xorl %ebx, %ebx
movl $0x1, %edi
xorl %eax, %eax
callq 0x16810
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x100, %eax # imm = 0x100
addq %rax, %rbp
addq %rax, %r15
leaq 0x2a9c0(%rip), %rsi # 0x4f683
leaq 0x2a95b(%rip), %rdx # 0x4f625
movl $0x1, %edi
movl %r13d, %ecx
movq %rbp, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x16810
movq 0x8(%rsp), %r13
jmp 0x24b59
addq $0x100, %r15 # imm = 0x100
leaq 0x2a972(%rip), %rsi # 0x4f669
leaq 0x2a927(%rip), %rdx # 0x4f625
movl $0x1, %edi
movq %r15, %rcx
xorl %eax, %eax
callq 0x16810
jmp 0x24b59
|
ggml_gallocr_alloc_graph:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rsi
mov r14, rdi
mov eax, [rdi+48h]
cmp eax, [rsi+4]
jnz loc_24B36
mov ecx, [r14+58h]
cmp ecx, [r13+8]
jnz loc_24B3F
test eax, eax
jle loc_24B97
mov ebp, 18h
xor ebx, ebx
mov [rsp+48h+var_40], r13
loc_24AAB:
mov rax, [r13+10h]
mov r15, [rax+rbx*8]
mov r12, [r14+40h]
mov rax, rbx
shl rax, 8
lea rdx, [rax+rbx*8]
add rdx, r12
mov rdi, r14
mov rsi, r15
call ggml_gallocr_node_needs_realloc
test al, al
jz loc_24CE9
mov [rsp+48h+var_38], rbp
add r12, rbp
xor r13d, r13d
loc_24AE3:
mov rbp, [r15+r13*8+98h]
test rbp, rbp
jz short loc_24B06
mov rdi, r14
mov rsi, rbp
mov rdx, r12
call ggml_gallocr_node_needs_realloc
test al, al
jz loc_24CB1
loc_24B06:
inc r13
add r12, 18h
cmp r13, 0Ah
jnz short loc_24AE3
inc rbx
mov r13, [rsp+48h+var_40]
movsxd rax, dword ptr [r13+4]
mov rbp, [rsp+48h+var_38]
add rbp, 108h
cmp rbx, rax
jl loc_24AAB
jmp short loc_24B97
loc_24B36:
lea rsi, aSGraphHasDiffe; "%s: graph has different number of nodes"...
jmp short loc_24B46
loc_24B3F:
lea rsi, aSGraphHasDiffe_0; "%s: graph has different number of leafs"...
loc_24B46:
lea rdx, aGgmlGallocrNee; "ggml_gallocr_needs_realloc"
mov edi, 1
xor eax, eax
call _ggml_log_internal
loc_24B59:
cmp dword ptr [r14+18h], 1
jnz loc_24C84
lea rsi, aSReallocatingB; "%s: reallocating buffers automatically"...
lea rdx, aGgmlGallocrAll_0; "ggml_gallocr_alloc_graph"
xor ebx, ebx
mov edi, 1
xor eax, eax
call _ggml_log_internal
mov rdi, r14
mov rsi, r13
xor edx, edx
xor ecx, ecx
call _ggml_gallocr_reserve_n
test al, al
jz loc_24CA0
loc_24B97:
mov eax, [r14+18h]
test eax, eax
jle short loc_24BC2
xor ebx, ebx
loc_24BA1:
mov rcx, [r14+8]
mov rdi, [rcx+rbx*8]
test rdi, rdi
jz short loc_24BB7
call _ggml_backend_buffer_reset
mov eax, [r14+18h]
loc_24BB7:
inc rbx
movsxd rcx, eax
cmp rbx, rcx
jl short loc_24BA1
loc_24BC2:
cmp dword ptr [r13+8], 0
jle short loc_24BF5
xor ebx, ebx
xor r15d, r15d
loc_24BCE:
mov rax, [r13+28h]
mov rsi, [rax+r15*8]
mov rdx, [r14+50h]
add rdx, rbx
mov rdi, r14
call ggml_gallocr_init_tensor
inc r15
movsxd rax, dword ptr [r13+8]
add rbx, 18h
cmp r15, rax
jl short loc_24BCE
loc_24BF5:
mov bl, 1
cmp dword ptr [r13+4], 0
jle loc_24CA0
mov r15d, 18h
xor ebx, ebx
mov [rsp+48h+var_40], r13
loc_24C0F:
mov rax, [r13+10h]
mov r12, [rax+rbx*8]
mov rbp, [r14+40h]
mov rax, rbx
shl rax, 8
lea rax, [rax+rbx*8]
add rax, rbp
mov [rsp+48h+var_38], rax
add rbp, r15
mov r13d, 13h
loc_24C37:
mov rsi, [r12+r13*8]
test rsi, rsi
jz short loc_24C4B
mov rdi, r14
mov rdx, rbp
call ggml_gallocr_init_tensor
loc_24C4B:
add rbp, 18h
inc r13
cmp r13, 1Dh
jnz short loc_24C37
mov rdi, r14
mov rsi, r12
mov rdx, [rsp+48h+var_38]
call ggml_gallocr_init_tensor
inc rbx
mov r13, [rsp+48h+var_40]
movsxd rax, dword ptr [r13+4]
add r15, 108h
cmp rbx, rax
jl short loc_24C0F
mov bl, 1
jmp short loc_24CA0
loc_24C84:
lea rsi, aSCannotRealloc; "%s: cannot reallocate multi buffer grap"...
lea rdx, aGgmlGallocrAll_0; "ggml_gallocr_alloc_graph"
xor ebx, ebx
mov edi, 1
xor eax, eax
call _ggml_log_internal
loc_24CA0:
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_24CB1:
mov eax, 100h
add rbp, rax
add r15, rax
lea rsi, aSSrcDSOfNodeSI; "%s: src %d (%s) of node %s is not valid"...
lea rdx, aGgmlGallocrNee; "ggml_gallocr_needs_realloc"
mov edi, 1
mov ecx, r13d
mov r8, rbp
mov r9, r15
xor eax, eax
call _ggml_log_internal
mov r13, [rsp+48h+var_40]
jmp loc_24B59
loc_24CE9:
add r15, 100h
lea rsi, aSNodeSIsNotVal; "%s: node %s is not valid\n"
lea rdx, aGgmlGallocrNee; "ggml_gallocr_needs_realloc"
mov edi, 1
mov rcx, r15
xor eax, eax
call _ggml_log_internal
jmp loc_24B59
|
long long ggml_gallocr_alloc_graph(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long i; // rbx
long long v15; // r13
int v16; // eax
long long v17; // rbp
long long v18; // r15
long long v19; // r12
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // r12
long long k; // r13
long long v26; // rbp
__m128 v27; // xmm4
__m128 v28; // xmm5
const char *v29; // rsi
long long v30; // rcx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
double v35; // xmm4_8
double v36; // xmm5_8
int v37; // eax
long long v38; // r15
long long v39; // r15
long long v40; // r12
long long v41; // rbp
long long v42; // rbp
long long j; // r13
long long v44; // rsi
long long v46; // [rsp+8h] [rbp-40h]
long long v47; // [rsp+10h] [rbp-38h]
long long v48; // [rsp+10h] [rbp-38h]
v15 = a2;
v16 = *(_DWORD *)(a1 + 72);
if ( v16 != *(_DWORD *)(a2 + 4) )
{
v29 = "%s: graph has different number of nodes\n";
LABEL_14:
ggml_log_internal(
1u,
(long long)v29,
(long long)"ggml_gallocr_needs_realloc",
a12,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10);
goto LABEL_15;
}
a12 = *(unsigned int *)(a1 + 88);
if ( (_DWORD)a12 != *(_DWORD *)(a2 + 8) )
{
v29 = "%s: graph has different number of leafs\n";
goto LABEL_14;
}
if ( v16 <= 0 )
{
LABEL_17:
v37 = *(_DWORD *)(a1 + 24);
if ( v37 > 0 )
{
for ( i = 0LL; i < v37; ++i )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8 * i) )
{
ggml_backend_buffer_reset();
v37 = *(_DWORD *)(a1 + 24);
}
}
}
if ( *(int *)(v15 + 8) > 0 )
{
i = 0LL;
v38 = 0LL;
do
{
ggml_gallocr_init_tensor(a1, *(_QWORD *)(*(_QWORD *)(v15 + 40) + 8 * v38++), i + *(_QWORD *)(a1 + 80));
i += 24LL;
}
while ( v38 < *(int *)(v15 + 8) );
}
LOBYTE(i) = 1;
if ( *(int *)(v15 + 4) > 0 )
{
v39 = 24LL;
i = 0LL;
v46 = v15;
do
{
v40 = *(_QWORD *)(*(_QWORD *)(v15 + 16) + 8 * i);
v41 = *(_QWORD *)(a1 + 64);
v48 = v41 + 264 * i;
v42 = v39 + v41;
for ( j = 19LL; j != 29; ++j )
{
v44 = *(_QWORD *)(v40 + 8 * j);
if ( v44 )
ggml_gallocr_init_tensor(a1, v44, v42);
v42 += 24LL;
}
ggml_gallocr_init_tensor(a1, v40, v48);
++i;
v15 = v46;
v39 += 264LL;
}
while ( i < *(int *)(v46 + 4) );
LOBYTE(i) = 1;
}
return (unsigned int)i;
}
v17 = 24LL;
i = 0LL;
while ( 2 )
{
v18 = *(_QWORD *)(*(_QWORD *)(v15 + 16) + 8 * i);
v19 = *(_QWORD *)(a1 + 64);
if ( (unsigned __int8)ggml_gallocr_node_needs_realloc(a1, v18, v19 + 264 * i) )
{
v47 = v17;
v24 = v17 + v19;
for ( k = 0LL; k != 10; ++k )
{
v26 = *(_QWORD *)(v18 + 8 * k + 152);
if ( v26 && !(unsigned __int8)ggml_gallocr_node_needs_realloc(a1, *(_QWORD *)(v18 + 8 * k + 152), v24) )
{
ggml_log_internal(
1u,
(long long)"%s: src %d (%s) of node %s is not valid\n",
(long long)"ggml_gallocr_needs_realloc",
(unsigned int)k,
v26 + 256,
v18 + 256,
a3,
a4,
a5,
a6,
v27,
v28,
a9,
a10);
v15 = a2;
goto LABEL_15;
}
v24 += 24LL;
}
++i;
v15 = a2;
v17 = v47 + 264;
if ( i < *(int *)(a2 + 4) )
continue;
goto LABEL_17;
}
break;
}
ggml_log_internal(
1u,
(long long)"%s: node %s is not valid\n",
(long long)"ggml_gallocr_needs_realloc",
v18 + 256,
v20,
v21,
a3,
a4,
a5,
a6,
v22,
v23,
a9,
a10);
LABEL_15:
if ( *(_DWORD *)(a1 + 24) != 1 )
{
LODWORD(i) = 0;
ggml_log_internal(
1u,
(long long)"%s: cannot reallocate multi buffer graph automatically, call reserve\n",
(long long)"ggml_gallocr_alloc_graph",
v30,
v31,
v32,
a3,
a4,
a5,
a6,
v33,
v34,
a9,
a10);
return (unsigned int)i;
}
LODWORD(i) = 0;
ggml_log_internal(
1u,
(long long)"%s: reallocating buffers automatically\n",
(long long)"ggml_gallocr_alloc_graph",
v30,
v31,
v32,
a3,
a4,
a5,
a6,
v33,
v34,
a9,
a10);
if ( (unsigned __int8)ggml_gallocr_reserve_n(a1, v15, 0LL, 0LL, a3, a4, a5, a6, v35, v36, a9, a10) )
goto LABEL_17;
return (unsigned int)i;
}
|
ggml_gallocr_alloc_graph:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RSI
MOV R14,RDI
MOV EAX,dword ptr [RDI + 0x48]
CMP EAX,dword ptr [RSI + 0x4]
JNZ 0x00124b36
MOV ECX,dword ptr [R14 + 0x58]
CMP ECX,dword ptr [R13 + 0x8]
JNZ 0x00124b3f
TEST EAX,EAX
JLE 0x00124b97
MOV EBP,0x18
XOR EBX,EBX
MOV qword ptr [RSP + 0x8],R13
LAB_00124aab:
MOV RAX,qword ptr [R13 + 0x10]
MOV R15,qword ptr [RAX + RBX*0x8]
MOV R12,qword ptr [R14 + 0x40]
MOV RAX,RBX
SHL RAX,0x8
LEA RDX,[RAX + RBX*0x8]
ADD RDX,R12
MOV RDI,R14
MOV RSI,R15
CALL 0x001255e0
TEST AL,AL
JZ 0x00124ce9
MOV qword ptr [RSP + 0x10],RBP
ADD R12,RBP
XOR R13D,R13D
LAB_00124ae3:
MOV RBP,qword ptr [R15 + R13*0x8 + 0x98]
TEST RBP,RBP
JZ 0x00124b06
MOV RDI,R14
MOV RSI,RBP
MOV RDX,R12
CALL 0x001255e0
TEST AL,AL
JZ 0x00124cb1
LAB_00124b06:
INC R13
ADD R12,0x18
CMP R13,0xa
JNZ 0x00124ae3
INC RBX
MOV R13,qword ptr [RSP + 0x8]
MOVSXD RAX,dword ptr [R13 + 0x4]
MOV RBP,qword ptr [RSP + 0x10]
ADD RBP,0x108
CMP RBX,RAX
JL 0x00124aab
JMP 0x00124b97
LAB_00124b36:
LEA RSI,[0x14f5fc]
JMP 0x00124b46
LAB_00124b3f:
LEA RSI,[0x14f640]
LAB_00124b46:
LEA RDX,[0x14f625]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00116810
LAB_00124b59:
CMP dword ptr [R14 + 0x18],0x1
JNZ 0x00124c84
LEA RSI,[0x14f2da]
LEA RDX,[0x14f302]
XOR EBX,EBX
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00116810
MOV RDI,R14
MOV RSI,R13
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001174c0
TEST AL,AL
JZ 0x00124ca0
LAB_00124b97:
MOV EAX,dword ptr [R14 + 0x18]
TEST EAX,EAX
JLE 0x00124bc2
XOR EBX,EBX
LAB_00124ba1:
MOV RCX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RCX + RBX*0x8]
TEST RDI,RDI
JZ 0x00124bb7
CALL 0x00117370
MOV EAX,dword ptr [R14 + 0x18]
LAB_00124bb7:
INC RBX
MOVSXD RCX,EAX
CMP RBX,RCX
JL 0x00124ba1
LAB_00124bc2:
CMP dword ptr [R13 + 0x8],0x0
JLE 0x00124bf5
XOR EBX,EBX
XOR R15D,R15D
LAB_00124bce:
MOV RAX,qword ptr [R13 + 0x28]
MOV RSI,qword ptr [RAX + R15*0x8]
MOV RDX,qword ptr [R14 + 0x50]
ADD RDX,RBX
MOV RDI,R14
CALL 0x00124d12
INC R15
MOVSXD RAX,dword ptr [R13 + 0x8]
ADD RBX,0x18
CMP R15,RAX
JL 0x00124bce
LAB_00124bf5:
MOV BL,0x1
CMP dword ptr [R13 + 0x4],0x0
JLE 0x00124ca0
MOV R15D,0x18
XOR EBX,EBX
MOV qword ptr [RSP + 0x8],R13
LAB_00124c0f:
MOV RAX,qword ptr [R13 + 0x10]
MOV R12,qword ptr [RAX + RBX*0x8]
MOV RBP,qword ptr [R14 + 0x40]
MOV RAX,RBX
SHL RAX,0x8
LEA RAX,[RAX + RBX*0x8]
ADD RAX,RBP
MOV qword ptr [RSP + 0x10],RAX
ADD RBP,R15
MOV R13D,0x13
LAB_00124c37:
MOV RSI,qword ptr [R12 + R13*0x8]
TEST RSI,RSI
JZ 0x00124c4b
MOV RDI,R14
MOV RDX,RBP
CALL 0x00124d12
LAB_00124c4b:
ADD RBP,0x18
INC R13
CMP R13,0x1d
JNZ 0x00124c37
MOV RDI,R14
MOV RSI,R12
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x00124d12
INC RBX
MOV R13,qword ptr [RSP + 0x8]
MOVSXD RAX,dword ptr [R13 + 0x4]
ADD R15,0x108
CMP RBX,RAX
JL 0x00124c0f
MOV BL,0x1
JMP 0x00124ca0
LAB_00124c84:
LEA RSI,[0x14f31b]
LEA RDX,[0x14f302]
XOR EBX,EBX
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00116810
LAB_00124ca0:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00124cb1:
MOV EAX,0x100
ADD RBP,RAX
ADD R15,RAX
LEA RSI,[0x14f683]
LEA RDX,[0x14f625]
MOV EDI,0x1
MOV ECX,R13D
MOV R8,RBP
MOV R9,R15
XOR EAX,EAX
CALL 0x00116810
MOV R13,qword ptr [RSP + 0x8]
JMP 0x00124b59
LAB_00124ce9:
ADD R15,0x100
LEA RSI,[0x14f669]
LEA RDX,[0x14f625]
MOV EDI,0x1
MOV RCX,R15
XOR EAX,EAX
CALL 0x00116810
JMP 0x00124b59
|
ulong ggml_gallocr_alloc_graph(long param_1,long param_2)
{
long lVar1;
long lVar2;
char cVar3;
int iVar4;
ulong unaff_RBX;
long lVar5;
long lVar6;
char *pcVar7;
long lVar8;
ulong uVar9;
long lVar10;
long lVar11;
if (*(int *)(param_1 + 0x48) == *(int *)(param_2 + 4)) {
if (*(int *)(param_1 + 0x58) != *(int *)(param_2 + 8)) {
pcVar7 = "%s: graph has different number of leafs\n";
goto LAB_00124b46;
}
if (0 < *(int *)(param_1 + 0x48)) {
lVar5 = 0x18;
unaff_RBX = 0;
do {
lVar11 = *(long *)(*(long *)(param_2 + 0x10) + unaff_RBX * 8);
lVar8 = *(long *)(param_1 + 0x40);
cVar3 = ggml_gallocr_node_needs_realloc(param_1,lVar11,unaff_RBX * 0x108 + lVar8);
if (cVar3 == '\0') {
ggml_log_internal(1,"%s: node %s is not valid\n","ggml_gallocr_needs_realloc",
lVar11 + 0x100);
goto LAB_00124b59;
}
lVar8 = lVar8 + lVar5;
uVar9 = 0;
do {
lVar1 = *(long *)(lVar11 + 0x98 + uVar9 * 8);
if ((lVar1 != 0) &&
(cVar3 = ggml_gallocr_node_needs_realloc(param_1,lVar1,lVar8), cVar3 == '\0')) {
ggml_log_internal(1,"%s: src %d (%s) of node %s is not valid\n",
"ggml_gallocr_needs_realloc",uVar9 & 0xffffffff,lVar1 + 0x100,
lVar11 + 0x100);
goto LAB_00124b59;
}
uVar9 = uVar9 + 1;
lVar8 = lVar8 + 0x18;
} while (uVar9 != 10);
unaff_RBX = unaff_RBX + 1;
lVar5 = lVar5 + 0x108;
} while ((long)unaff_RBX < (long)*(int *)(param_2 + 4));
}
}
else {
pcVar7 = "%s: graph has different number of nodes\n";
LAB_00124b46:
ggml_log_internal(1,pcVar7,"ggml_gallocr_needs_realloc");
LAB_00124b59:
if (*(int *)(param_1 + 0x18) != 1) {
unaff_RBX = 0;
ggml_log_internal(1,"%s: cannot reallocate multi buffer graph automatically, call reserve\n",
"ggml_gallocr_alloc_graph");
goto LAB_00124ca0;
}
unaff_RBX = 0;
ggml_log_internal(1,"%s: reallocating buffers automatically\n","ggml_gallocr_alloc_graph");
cVar3 = ggml_gallocr_reserve_n(param_1,param_2,0,0);
if (cVar3 == '\0') goto LAB_00124ca0;
}
iVar4 = *(int *)(param_1 + 0x18);
if (0 < iVar4) {
unaff_RBX = 0;
do {
if (*(long *)(*(long *)(param_1 + 8) + unaff_RBX * 8) != 0) {
ggml_backend_buffer_reset();
iVar4 = *(int *)(param_1 + 0x18);
}
unaff_RBX = unaff_RBX + 1;
} while ((long)unaff_RBX < (long)iVar4);
}
if (0 < *(int *)(param_2 + 8)) {
unaff_RBX = 0;
lVar5 = 0;
do {
ggml_gallocr_init_tensor
(param_1,*(int8 *)(*(long *)(param_2 + 0x28) + lVar5 * 8),
*(long *)(param_1 + 0x50) + unaff_RBX);
lVar5 = lVar5 + 1;
unaff_RBX = unaff_RBX + 0x18;
} while (lVar5 < *(int *)(param_2 + 8));
}
unaff_RBX = CONCAT71((int7)(unaff_RBX >> 8),1);
if (0 < *(int *)(param_2 + 4)) {
lVar11 = 0x18;
lVar5 = 0;
do {
lVar8 = *(long *)(*(long *)(param_2 + 0x10) + lVar5 * 8);
lVar1 = *(long *)(param_1 + 0x40);
lVar6 = lVar1 + lVar11;
lVar10 = 0x13;
do {
lVar2 = *(long *)(lVar8 + lVar10 * 8);
if (lVar2 != 0) {
ggml_gallocr_init_tensor(param_1,lVar2,lVar6);
}
lVar6 = lVar6 + 0x18;
lVar10 = lVar10 + 1;
} while (lVar10 != 0x1d);
ggml_gallocr_init_tensor(param_1,lVar8,lVar5 * 0x108 + lVar1);
lVar5 = lVar5 + 1;
lVar11 = lVar11 + 0x108;
} while (lVar5 < *(int *)(param_2 + 4));
unaff_RBX = CONCAT71((int7)((ulong)lVar5 >> 8),1);
}
LAB_00124ca0:
return unaff_RBX & 0xffffffff;
}
|
|
58,519
|
google::protobuf::DescriptorProto_ExtensionRange::_internal_has_options() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.h
|
inline bool DescriptorProto_ExtensionRange::_internal_has_options() const {
bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
PROTOBUF_ASSUME(!value || _impl_.options_ != nullptr);
return value;
}
|
O0
|
c
|
google::protobuf::DescriptorProto_ExtensionRange::_internal_has_options() const:
subq $0x98, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x10, %rax
movq %rax, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movq 0x90(%rsp), %rax
movslq 0x8c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x7f(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x87c20
jmp 0x87cc6
movb 0x7f(%rsp), %al
movb $0x0, 0x3f(%rsp)
testb $0x1, %al
je 0x87c39
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x87c3b
jmp 0x87c8b
leaq 0x168307(%rip), %rdx # 0x1eff49
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x248e, %ecx # imm = 0x248E
callq 0x237e0
movq 0x10(%rsp), %rdi
movb $0x1, 0x3f(%rsp)
leaq 0x168384(%rip), %rsi # 0x1efff0
callq 0x230a0
movq %rax, 0x18(%rsp)
jmp 0x87c78
movq 0x18(%rsp), %rsi
leaq 0x2b(%rsp), %rdi
callq 0x23250
jmp 0x87c89
jmp 0x87c8b
testb $0x1, 0x3f(%rsp)
jne 0x87c94
jmp 0x87c9e
leaq 0x40(%rsp), %rdi
callq 0x23820
jmp 0x87c15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x87cba
jmp 0x87cc4
leaq 0x40(%rsp), %rdi
callq 0x23820
jmp 0x87cf6
movb $0x1, %al
testb $0x1, 0x7f(%rsp)
movb %al, 0xf(%rsp)
je 0x87ce4
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb 0x7f(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x13750
|
_ZNK6google8protobuf30DescriptorProto_ExtensionRange21_internal_has_optionsEv:
sub rsp, 98h
mov [rsp+98h+var_18], rdi
mov rax, [rsp+98h+var_18]
mov [rsp+98h+var_78], rax
add rax, 10h
mov [rsp+98h+var_8], rax
mov [rsp+98h+var_C], 0
mov rax, [rsp+98h+var_8]
movsxd rcx, [rsp+98h+var_C]
mov eax, [rax+rcx*4]
and eax, 1
cmp eax, 0
setnz al
and al, 1
mov [rsp+98h+var_19], al
loc_87C15:
xor eax, eax
test al, 1
jnz short loc_87C20
jmp loc_87CC6
loc_87C20:
mov al, [rsp+98h+var_19]
mov [rsp+98h+var_59], 0
test al, 1
jz short loc_87C39
mov rax, [rsp+98h+var_78]
cmp qword ptr [rax+18h], 0
jz short loc_87C3B
loc_87C39:
jmp short loc_87C8B
loc_87C3B:
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+98h+var_58]
mov [rsp+98h+var_88], rdi
mov esi, 3
mov ecx, 248Eh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+98h+var_88]
mov [rsp+98h+var_59], 1
lea rsi, aCheckFailedVal_2; "CHECK failed: !value || _impl_.options_"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_80], rax
jmp short $+2
loc_87C78:
mov rsi, [rsp+98h+var_80]
lea rdi, [rsp+98h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_87C89:
jmp short $+2
loc_87C8B:
test [rsp+98h+var_59], 1
jnz short loc_87C94
jmp short loc_87C9E
loc_87C94:
lea rdi, [rsp+98h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_87C9E:
jmp loc_87C15
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
test [rsp+arg_37], 1
jnz short loc_87CBA
jmp short loc_87CC4
loc_87CBA:
lea rdi, [rsp+arg_38]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_87CC4:
jmp short loc_87CF6
loc_87CC6:
mov al, 1
test [rsp+98h+var_19], 1
mov [rsp+98h+var_89], al
jz short loc_87CE4
mov rax, [rsp+98h+var_78]
cmp qword ptr [rax+18h], 0
setnz al
mov [rsp+98h+var_89], al
loc_87CE4:
mov al, [rsp+98h+var_89]
mov al, [rsp+98h+var_19]
and al, 1
add rsp, 98h
retn
loc_87CF6:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
bool google::protobuf::DescriptorProto_ExtensionRange::_internal_has_options(
google::protobuf::DescriptorProto_ExtensionRange *this)
{
return (*((_DWORD *)this + 4) & 1) != 0;
}
|
_internal_has_options:
SUB RSP,0x98
MOV qword ptr [RSP + 0x80],RDI
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x20],RAX
ADD RAX,0x10
MOV qword ptr [RSP + 0x90],RAX
MOV dword ptr [RSP + 0x8c],0x0
MOV RAX,qword ptr [RSP + 0x90]
MOVSXD RCX,dword ptr [RSP + 0x8c]
MOV EAX,dword ptr [RAX + RCX*0x4]
AND EAX,0x1
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x7f],AL
LAB_00187c15:
XOR EAX,EAX
TEST AL,0x1
JNZ 0x00187c20
JMP 0x00187cc6
LAB_00187c20:
MOV AL,byte ptr [RSP + 0x7f]
MOV byte ptr [RSP + 0x3f],0x0
TEST AL,0x1
JZ 0x00187c39
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x00187c3b
LAB_00187c39:
JMP 0x00187c8b
LAB_00187c3b:
LEA RDX,[0x2eff49]
LEA RDI,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RDI
MOV ESI,0x3
MOV ECX,0x248e
CALL 0x001237e0
MOV RDI,qword ptr [RSP + 0x10]
MOV byte ptr [RSP + 0x3f],0x1
LAB_00187c65:
LEA RSI,[0x2efff0]
CALL 0x001230a0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00187c78
LAB_00187c78:
MOV RSI,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x2b]
CALL 0x00123250
LAB_00187c87:
JMP 0x00187c89
LAB_00187c89:
JMP 0x00187c8b
LAB_00187c8b:
TEST byte ptr [RSP + 0x3f],0x1
JNZ 0x00187c94
JMP 0x00187c9e
LAB_00187c94:
LEA RDI,[RSP + 0x40]
CALL 0x00123820
LAB_00187c9e:
JMP 0x00187c15
LAB_00187cc6:
MOV AL,0x1
TEST byte ptr [RSP + 0x7f],0x1
MOV byte ptr [RSP + 0xf],AL
JZ 0x00187ce4
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RAX + 0x18],0x0
SETNZ AL
MOV byte ptr [RSP + 0xf],AL
LAB_00187ce4:
MOV AL,byte ptr [RSP + 0xf]
MOV AL,byte ptr [RSP + 0x7f]
AND AL,0x1
ADD RSP,0x98
RET
|
/* WARNING: Removing unreachable block (ram,0x00187c20) */
/* WARNING: Removing unreachable block (ram,0x00187c2d) */
/* WARNING: Removing unreachable block (ram,0x00187c39) */
/* WARNING: Removing unreachable block (ram,0x00187c3b) */
/* WARNING: Removing unreachable block (ram,0x00187c8b) */
/* WARNING: Removing unreachable block (ram,0x00187c94) */
/* WARNING: Removing unreachable block (ram,0x00187c92) */
/* WARNING: Removing unreachable block (ram,0x00187c9e) */
/* google::protobuf::DescriptorProto_ExtensionRange::_internal_has_options() const */
int8 __thiscall
google::protobuf::DescriptorProto_ExtensionRange::_internal_has_options
(DescriptorProto_ExtensionRange *this)
{
int7 uVar1;
bool bVar2;
bVar2 = (*(uint *)(this + 0x10) & 1) != 0;
uVar1 = 0;
if (bVar2) {
uVar1 = (int7)((ulong)this >> 8);
}
return CONCAT71(uVar1,bVar2);
}
|
|
58,520
|
rlp_get_uint64
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/rlp.c
|
INTERNAL uint64_t rlp_get_uint64(bytes_t data, int index) {
uint64_t value = 0;
rlp_decode(&data, index, &data);
if (data.len > 8 || !data.len) return 0;
for (int i = 0; i < data.len; i++)
value |= ((uint64_t) data.data[i]) << ((data.len - i - 1) << 3);
return value;
}
|
O0
|
c
|
rlp_get_uint64:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdx
movq %rdx, %rdi
callq 0x15f10
cmpl $0x8, -0x18(%rbp)
ja 0x16695
cmpl $0x0, -0x18(%rbp)
jne 0x1669f
movq $0x0, -0x8(%rbp)
jmp 0x166e6
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x166de
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl -0x18(%rbp), %ecx
subl -0x2c(%rbp), %ecx
subl $0x1, %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x166a6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
|
rlp_get_uint64:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], edi
mov [rbp+var_10], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], 0
mov esi, [rbp+var_1C]
lea rdx, [rbp+var_18]
mov rdi, rdx
call rlp_decode
cmp [rbp+var_18], 8
ja short loc_16695
cmp [rbp+var_18], 0
jnz short loc_1669F
loc_16695:
mov [rbp+var_8], 0
jmp short loc_166E6
loc_1669F:
mov [rbp+var_2C], 0
loc_166A6:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_18]
jnb short loc_166DE
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
movzx eax, byte ptr [rax+rcx]
mov ecx, [rbp+var_18]
sub ecx, [rbp+var_2C]
sub ecx, 1
shl ecx, 3
mov ecx, ecx
shl rax, cl
or rax, [rbp+var_28]
mov [rbp+var_28], rax
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_166A6
loc_166DE:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_166E6:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long rlp_get_uint64(unsigned int a1, long long a2, int a3)
{
unsigned int i; // [rsp+4h] [rbp-2Ch]
long long v5; // [rsp+8h] [rbp-28h]
unsigned int v6; // [rsp+18h] [rbp-18h] BYREF
long long v7; // [rsp+20h] [rbp-10h]
v6 = a1;
v7 = a2;
v5 = 0LL;
rlp_decode(&v6, a3, (long long)&v6);
if ( v6 > 8 || !v6 )
return 0LL;
for ( i = 0; i < v6; ++i )
v5 |= (unsigned long long)*(unsigned __int8 *)(v7 + (int)i) << (8 * ((unsigned __int8)v6 - (unsigned __int8)i - 1));
return v5;
}
|
rlp_get_uint64:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x18],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],0x0
MOV ESI,dword ptr [RBP + -0x1c]
LEA RDX,[RBP + -0x18]
MOV RDI,RDX
CALL 0x00115f10
CMP dword ptr [RBP + -0x18],0x8
JA 0x00116695
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x0011669f
LAB_00116695:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001166e6
LAB_0011669f:
MOV dword ptr [RBP + -0x2c],0x0
LAB_001166a6:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x18]
JNC 0x001166de
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV ECX,dword ptr [RBP + -0x18]
SUB ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x1
SHL ECX,0x3
MOV ECX,ECX
SHL RAX,CL
OR RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001166a6
LAB_001166de:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_001166e6:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
ulong rlp_get_uint64(uint param_1,long param_2,int4 param_3)
{
uint local_34;
ulong local_30;
uint local_20 [2];
long local_18;
ulong local_10;
local_30 = 0;
local_20[0] = param_1;
local_18 = param_2;
rlp_decode(local_20,param_3);
if ((local_20[0] < 9) && (local_20[0] != 0)) {
for (local_34 = 0; local_34 < local_20[0]; local_34 = local_34 + 1) {
local_30 = (ulong)*(byte *)(local_18 + (int)local_34) <<
((((char)local_20[0] - (char)local_34) + -1) * '\b' & 0x3fU) | local_30;
}
local_10 = local_30;
}
else {
local_10 = 0;
}
return local_10;
}
|
|
58,521
|
rlp_get_uint64
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/rlp.c
|
INTERNAL uint64_t rlp_get_uint64(bytes_t data, int index) {
uint64_t value = 0;
rlp_decode(&data, index, &data);
if (data.len > 8 || !data.len) return 0;
for (int i = 0; i < data.len; i++)
value |= ((uint64_t) data.data[i]) << ((data.len - i - 1) << 3);
return value;
}
|
O1
|
c
|
rlp_get_uint64:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movl %edi, (%rbx)
movq %rsi, 0x8(%rbx)
movq %rbx, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x10ef0
movl (%rbx), %edx
leal -0x1(%rdx), %eax
cmpl $0x7, %eax
ja 0x113cb
movq 0x8(%rsp), %rsi
leal -0x8(,%rdx,8), %ecx
xorl %edi, %edi
xorl %eax, %eax
movzbl (%rsi,%rdi), %r8d
shlq %cl, %r8
orq %r8, %rax
incq %rdi
addl $-0x8, %ecx
cmpq %rdi, %rdx
jne 0x113b3
jmp 0x113cd
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
|
rlp_get_uint64:
push rbx
sub rsp, 10h
mov rbx, rsp
mov [rbx], edi
mov [rbx+8], rsi
mov rdi, rbx
mov esi, edx
mov rdx, rbx
call rlp_decode
mov edx, [rbx]
lea eax, [rdx-1]
cmp eax, 7
ja short loc_113CB
mov rsi, [rsp+18h+var_10]
lea ecx, ds:0FFFFFFFFFFFFFFF8h[rdx*8]
xor edi, edi
xor eax, eax
loc_113B3:
movzx r8d, byte ptr [rsi+rdi]
shl r8, cl
or rax, r8
inc rdi
add ecx, 0FFFFFFF8h
cmp rdx, rdi
jnz short loc_113B3
jmp short loc_113CD
loc_113CB:
xor eax, eax
loc_113CD:
add rsp, 10h
pop rbx
retn
|
long long rlp_get_uint64(unsigned int a1, long long a2, int a3)
{
unsigned int v3; // ecx
long long v4; // rdi
long long result; // rax
unsigned int v6; // [rsp+0h] [rbp-18h] BYREF
long long v7; // [rsp+8h] [rbp-10h]
v6 = a1;
v7 = a2;
rlp_decode(&v6, a3, (long long)&v6);
if ( v6 - 1 > 7 )
return 0LL;
v3 = 8 * v6 - 8;
v4 = 0LL;
result = 0LL;
do
{
result |= (unsigned long long)*(unsigned __int8 *)(v7 + v4++) << v3;
v3 -= 8;
}
while ( v6 != v4 );
return result;
}
|
rlp_get_uint64:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSP
MOV dword ptr [RBX],EDI
MOV qword ptr [RBX + 0x8],RSI
MOV RDI,RBX
MOV ESI,EDX
MOV RDX,RBX
CALL 0x00110ef0
MOV EDX,dword ptr [RBX]
LEA EAX,[RDX + -0x1]
CMP EAX,0x7
JA 0x001113cb
MOV RSI,qword ptr [RSP + 0x8]
LEA ECX,[-0x8 + RDX*0x8]
XOR EDI,EDI
XOR EAX,EAX
LAB_001113b3:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
SHL R8,CL
OR RAX,R8
INC RDI
ADD ECX,-0x8
CMP RDX,RDI
JNZ 0x001113b3
JMP 0x001113cd
LAB_001113cb:
XOR EAX,EAX
LAB_001113cd:
ADD RSP,0x10
POP RBX
RET
|
ulong rlp_get_uint64(uint param_1,long param_2,int4 param_3)
{
ulong uVar1;
int iVar2;
ulong uVar3;
uint local_18 [2];
long local_10;
local_18[0] = param_1;
local_10 = param_2;
rlp_decode(local_18,param_3,local_18);
if (local_18[0] - 1 < 8) {
iVar2 = local_18[0] * 8;
uVar3 = 0;
uVar1 = 0;
do {
iVar2 = iVar2 + -8;
uVar1 = uVar1 | (ulong)*(byte *)(local_10 + uVar3) << ((byte)iVar2 & 0x3f);
uVar3 = uVar3 + 1;
} while (local_18[0] != uVar3);
}
else {
uVar1 = 0;
}
return uVar1;
}
|
|
58,522
|
rlp_get_uint64
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/rlp.c
|
INTERNAL uint64_t rlp_get_uint64(bytes_t data, int index) {
uint64_t value = 0;
rlp_decode(&data, index, &data);
if (data.len > 8 || !data.len) return 0;
for (int i = 0; i < data.len; i++)
value |= ((uint64_t) data.data[i]) << ((data.len - i - 1) << 3);
return value;
}
|
O3
|
c
|
rlp_get_uint64:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movl %edi, (%rbx)
movq %rsi, 0x8(%rbx)
movq %rbx, %rdi
movl %edx, %esi
movq %rbx, %rdx
callq 0x10c40
movl (%rbx), %edx
leal -0x1(%rdx), %eax
cmpl $0x7, %eax
ja 0x11121
movq 0x8(%rsp), %rsi
leal -0x8(,%rdx,8), %ecx
xorl %edi, %edi
xorl %eax, %eax
movzbl (%rsi,%rdi), %r8d
shlq %cl, %r8
orq %r8, %rax
incq %rdi
addl $-0x8, %ecx
cmpq %rdi, %rdx
jne 0x11109
jmp 0x11123
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
|
rlp_get_uint64:
push rbx
sub rsp, 10h
mov rbx, rsp
mov [rbx], edi
mov [rbx+8], rsi
mov rdi, rbx
mov esi, edx
mov rdx, rbx
call rlp_decode
mov edx, [rbx]
lea eax, [rdx-1]
cmp eax, 7
ja short loc_11121
mov rsi, [rsp+18h+var_10]
lea ecx, ds:0FFFFFFFFFFFFFFF8h[rdx*8]
xor edi, edi
xor eax, eax
loc_11109:
movzx r8d, byte ptr [rsi+rdi]
shl r8, cl
or rax, r8
inc rdi
add ecx, 0FFFFFFF8h
cmp rdx, rdi
jnz short loc_11109
jmp short loc_11123
loc_11121:
xor eax, eax
loc_11123:
add rsp, 10h
pop rbx
retn
|
long long rlp_get_uint64(unsigned int a1, long long a2, int a3)
{
unsigned int v3; // ecx
long long v4; // rdi
long long result; // rax
unsigned int v6; // [rsp+0h] [rbp-18h] BYREF
long long v7; // [rsp+8h] [rbp-10h]
v6 = a1;
v7 = a2;
rlp_decode(&v6, a3, (long long)&v6);
if ( v6 - 1 > 7 )
return 0LL;
v3 = 8 * v6 - 8;
v4 = 0LL;
result = 0LL;
do
{
result |= (unsigned long long)*(unsigned __int8 *)(v7 + v4++) << v3;
v3 -= 8;
}
while ( v6 != v4 );
return result;
}
|
rlp_get_uint64:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSP
MOV dword ptr [RBX],EDI
MOV qword ptr [RBX + 0x8],RSI
MOV RDI,RBX
MOV ESI,EDX
MOV RDX,RBX
CALL 0x00110c40
MOV EDX,dword ptr [RBX]
LEA EAX,[RDX + -0x1]
CMP EAX,0x7
JA 0x00111121
MOV RSI,qword ptr [RSP + 0x8]
LEA ECX,[-0x8 + RDX*0x8]
XOR EDI,EDI
XOR EAX,EAX
LAB_00111109:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
SHL R8,CL
OR RAX,R8
INC RDI
ADD ECX,-0x8
CMP RDX,RDI
JNZ 0x00111109
JMP 0x00111123
LAB_00111121:
XOR EAX,EAX
LAB_00111123:
ADD RSP,0x10
POP RBX
RET
|
ulong rlp_get_uint64(uint param_1,long param_2,int4 param_3)
{
ulong uVar1;
int iVar2;
ulong uVar3;
uint local_18 [2];
long local_10;
local_18[0] = param_1;
local_10 = param_2;
rlp_decode(local_18,param_3,local_18);
if (local_18[0] - 1 < 8) {
iVar2 = local_18[0] * 8;
uVar3 = 0;
uVar1 = 0;
do {
iVar2 = iVar2 + -8;
uVar1 = uVar1 | (ulong)*(byte *)(local_10 + uVar3) << ((byte)iVar2 & 0x3f);
uVar3 = uVar3 + 1;
} while (local_18[0] != uVar3);
}
else {
uVar1 = 0;
}
return uVar1;
}
|
|
58,523
|
check_and_set_lsn
|
eloqsql/storage/maria/ma_pagecache.c
|
static void check_and_set_lsn(PAGECACHE *pagecache,
LSN lsn, PAGECACHE_BLOCK_LINK *block)
{
LSN old;
DBUG_ENTER("check_and_set_lsn");
/*
In recovery, we can _ma_unpin_all_pages() to put a LSN on page, though
page would be PAGECACHE_PLAIN_PAGE (transactionality temporarily disabled
to not log REDOs).
*/
DBUG_ASSERT((block->type == PAGECACHE_LSN_PAGE) || maria_in_recovery);
old= lsn_korr(block->buffer);
DBUG_PRINT("info", ("old lsn: " LSN_FMT " new lsn: " LSN_FMT,
LSN_IN_PARTS(old), LSN_IN_PARTS(lsn)));
if (cmp_translog_addr(lsn, old) > 0)
{
DBUG_ASSERT(block->type != PAGECACHE_READ_UNKNOWN_PAGE);
lsn_store(block->buffer, lsn);
/* we stored LSN in page so we dirtied it */
if (!(block->status & PCBLOCK_CHANGED))
link_to_changed_list(pagecache, block);
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
check_and_set_lsn:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdx), %rax
movzwl (%rax), %ecx
shlq $0x20, %rcx
movzbl 0x2(%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movl 0x3(%rax), %ecx
orq %r8, %rcx
cmpq %rsi, %rcx
jge 0x32eb1
movq %rsi, %rcx
shrq $0x20, %rcx
movb %cl, (%rax)
movq %rsi, %rax
shrq $0x28, %rax
movq 0x30(%rdx), %rcx
movb %al, 0x1(%rcx)
movq %rsi, %rax
shrq $0x30, %rax
movq 0x30(%rdx), %rcx
movb %al, 0x2(%rcx)
movq 0x30(%rdx), %rax
movl %esi, 0x3(%rax)
testb $0x20, 0x74(%rdx)
jne 0x32eb1
leaq 0x10(%rdx), %rax
movq 0x10(%rdx), %rsi
movq 0x18(%rdx), %rcx
testq %rsi, %rsi
je 0x32e6c
movq %rcx, 0x18(%rsi)
movq (%rax), %rsi
jmp 0x32e6e
xorl %esi, %esi
movq %rsi, (%rcx)
movq 0x128(%rdi), %rcx
movq 0x20(%rdx), %rsi
movl 0x28(%rdi), %r8d
decl %r8d
andl 0x28(%rsi), %r8d
leaq (%rcx,%r8,8), %rcx
movq %rcx, 0x18(%rdx)
movq (%rcx), %rsi
movq %rsi, 0x10(%rdx)
testq %rsi, %rsi
je 0x32e9f
movq %rax, 0x18(%rsi)
movq %rdx, (%rcx)
orb $0x20, 0x74(%rdx)
incq 0x58(%rdi)
incq 0x168(%rdi)
popq %rbp
retq
|
check_and_set_lsn:
push rbp
mov rbp, rsp
mov rax, [rdx+30h]
movzx ecx, word ptr [rax]
shl rcx, 20h
movzx r8d, byte ptr [rax+2]
shl r8, 30h
or r8, rcx
mov ecx, [rax+3]
or rcx, r8
cmp rcx, rsi
jge loc_32EB1
mov rcx, rsi
shr rcx, 20h
mov [rax], cl
mov rax, rsi
shr rax, 28h
mov rcx, [rdx+30h]
mov [rcx+1], al
mov rax, rsi
shr rax, 30h
mov rcx, [rdx+30h]
mov [rcx+2], al
mov rax, [rdx+30h]
mov [rax+3], esi
test byte ptr [rdx+74h], 20h
jnz short loc_32EB1
lea rax, [rdx+10h]
mov rsi, [rdx+10h]
mov rcx, [rdx+18h]
test rsi, rsi
jz short loc_32E6C
mov [rsi+18h], rcx
mov rsi, [rax]
jmp short loc_32E6E
loc_32E6C:
xor esi, esi
loc_32E6E:
mov [rcx], rsi
mov rcx, [rdi+128h]
mov rsi, [rdx+20h]
mov r8d, [rdi+28h]
dec r8d
and r8d, [rsi+28h]
lea rcx, [rcx+r8*8]
mov [rdx+18h], rcx
mov rsi, [rcx]
mov [rdx+10h], rsi
test rsi, rsi
jz short loc_32E9F
mov [rsi+18h], rax
loc_32E9F:
mov [rcx], rdx
or byte ptr [rdx+74h], 20h
inc qword ptr [rdi+58h]
inc qword ptr [rdi+168h]
loc_32EB1:
pop rbp
retn
|
unsigned __int16 * check_and_set_lsn(long long a1, signed long long a2, long long a3)
{
unsigned __int16 *result; // rax
long long v4; // rsi
_QWORD *v5; // rcx
long long v6; // rsi
long long *v7; // rcx
long long v8; // rsi
result = *(unsigned __int16 **)(a3 + 48);
if ( (long long)(((unsigned long long)*result << 32) | ((unsigned long long)*((unsigned __int8 *)result + 2) << 48) | *(unsigned int *)((char *)result + 3)) < a2 )
{
*(_BYTE *)result = BYTE4(a2);
*(_BYTE *)(*(_QWORD *)(a3 + 48) + 1LL) = BYTE5(a2);
*(_BYTE *)(*(_QWORD *)(a3 + 48) + 2LL) = BYTE6(a2);
result = *(unsigned __int16 **)(a3 + 48);
*(_DWORD *)((char *)result + 3) = a2;
if ( (*(_BYTE *)(a3 + 116) & 0x20) == 0 )
{
result = (unsigned __int16 *)(a3 + 16);
v4 = *(_QWORD *)(a3 + 16);
v5 = *(_QWORD **)(a3 + 24);
if ( v4 )
{
*(_QWORD *)(v4 + 24) = v5;
v6 = *(_QWORD *)result;
}
else
{
v6 = 0LL;
}
*v5 = v6;
v7 = (long long *)(*(_QWORD *)(a1 + 296)
+ 8LL * (*(_DWORD *)(*(_QWORD *)(a3 + 32) + 40LL) & (unsigned int)(*(_DWORD *)(a1 + 40) - 1)));
*(_QWORD *)(a3 + 24) = v7;
v8 = *v7;
*(_QWORD *)(a3 + 16) = *v7;
if ( v8 )
*(_QWORD *)(v8 + 24) = result;
*v7 = a3;
*(_BYTE *)(a3 + 116) |= 0x20u;
++*(_QWORD *)(a1 + 88);
++*(_QWORD *)(a1 + 360);
}
}
return result;
}
|
check_and_set_lsn:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDX + 0x30]
MOVZX ECX,word ptr [RAX]
SHL RCX,0x20
MOVZX R8D,byte ptr [RAX + 0x2]
SHL R8,0x30
OR R8,RCX
MOV ECX,dword ptr [RAX + 0x3]
OR RCX,R8
CMP RCX,RSI
JGE 0x00132eb1
MOV RCX,RSI
SHR RCX,0x20
MOV byte ptr [RAX],CL
MOV RAX,RSI
SHR RAX,0x28
MOV RCX,qword ptr [RDX + 0x30]
MOV byte ptr [RCX + 0x1],AL
MOV RAX,RSI
SHR RAX,0x30
MOV RCX,qword ptr [RDX + 0x30]
MOV byte ptr [RCX + 0x2],AL
MOV RAX,qword ptr [RDX + 0x30]
MOV dword ptr [RAX + 0x3],ESI
TEST byte ptr [RDX + 0x74],0x20
JNZ 0x00132eb1
LEA RAX,[RDX + 0x10]
MOV RSI,qword ptr [RDX + 0x10]
MOV RCX,qword ptr [RDX + 0x18]
TEST RSI,RSI
JZ 0x00132e6c
MOV qword ptr [RSI + 0x18],RCX
MOV RSI,qword ptr [RAX]
JMP 0x00132e6e
LAB_00132e6c:
XOR ESI,ESI
LAB_00132e6e:
MOV qword ptr [RCX],RSI
MOV RCX,qword ptr [RDI + 0x128]
MOV RSI,qword ptr [RDX + 0x20]
MOV R8D,dword ptr [RDI + 0x28]
DEC R8D
AND R8D,dword ptr [RSI + 0x28]
LEA RCX,[RCX + R8*0x8]
MOV qword ptr [RDX + 0x18],RCX
MOV RSI,qword ptr [RCX]
MOV qword ptr [RDX + 0x10],RSI
TEST RSI,RSI
JZ 0x00132e9f
MOV qword ptr [RSI + 0x18],RAX
LAB_00132e9f:
MOV qword ptr [RCX],RDX
OR byte ptr [RDX + 0x74],0x20
INC qword ptr [RDI + 0x58]
INC qword ptr [RDI + 0x168]
LAB_00132eb1:
POP RBP
RET
|
void check_and_set_lsn(long param_1,long param_2,long param_3)
{
long *plVar1;
ushort *puVar2;
int8 *puVar3;
long lVar4;
int8 uVar5;
puVar2 = *(ushort **)(param_3 + 0x30);
if ((long)((ulong)*(uint *)((long)puVar2 + 3) |
(ulong)(byte)puVar2[1] << 0x30 | (ulong)*puVar2 << 0x20) < param_2) {
*(char *)puVar2 = (char)((ulong)param_2 >> 0x20);
*(char *)(*(long *)(param_3 + 0x30) + 1) = (char)((ulong)param_2 >> 0x28);
*(char *)(*(long *)(param_3 + 0x30) + 2) = (char)((ulong)param_2 >> 0x30);
*(int *)(*(long *)(param_3 + 0x30) + 3) = (int)param_2;
if ((*(byte *)(param_3 + 0x74) & 0x20) == 0) {
puVar3 = *(int8 **)(param_3 + 0x18);
if (*(long *)(param_3 + 0x10) == 0) {
uVar5 = 0;
}
else {
*(int8 **)(*(long *)(param_3 + 0x10) + 0x18) = puVar3;
uVar5 = *(int8 *)(param_3 + 0x10);
}
*puVar3 = uVar5;
plVar1 = (long *)(*(long *)(param_1 + 0x128) +
(ulong)(*(int *)(param_1 + 0x28) - 1U &
*(uint *)(*(long *)(param_3 + 0x20) + 0x28)) * 8);
*(long **)(param_3 + 0x18) = plVar1;
lVar4 = *plVar1;
*(long *)(param_3 + 0x10) = lVar4;
if (lVar4 != 0) {
*(int8 **)(lVar4 + 0x18) = (int8 *)(param_3 + 0x10);
}
*plVar1 = param_3;
*(byte *)(param_3 + 0x74) = *(byte *)(param_3 + 0x74) | 0x20;
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + 1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + 1;
}
}
return;
}
|
|
58,524
|
mysql_client_plugin_init
|
eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c
|
int mysql_client_plugin_init()
{
MYSQL mysql;
struct st_mysql_client_plugin **builtin;
va_list unused;
LINT_INIT_STRUCT(unused);
if (initialized)
return 0;
memset(&mysql, 0, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
pthread_mutex_init(&LOCK_load_client_plugin, NULL);
ma_init_alloc_root(&mem_root, 128, 128);
memset(&plugin_list, 0, sizeof(plugin_list));
initialized= 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
for (builtin= mysql_client_builtins; *builtin; builtin++)
add_plugin(&mysql, *builtin, 0, 0, unused);
pthread_mutex_unlock(&LOCK_load_client_plugin);
load_env_plugins(&mysql);
return 0;
}
|
O0
|
c
|
mysql_client_plugin_init:
pushq %rbp
movq %rsp, %rbp
subq $0x540, %rsp # imm = 0x540
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
leaq -0x530(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x60350
cmpb $0x0, 0x42312e(%rip) # 0x4bd290
je 0x9a173
movl $0x0, -0x504(%rbp)
jmp 0x9a244
leaq -0x500(%rbp), %rdi
xorl %esi, %esi
movl $0x4f8, %edx # imm = 0x4F8
callq 0x60350
leaq 0x42310b(%rip), %rdi # 0x4bd298
xorl %eax, %eax
movl %eax, %esi
callq 0x60450
leaq 0x423123(%rip), %rdi # 0x4bd2c0
movl $0x80, %edx
movq %rdx, %rsi
callq 0x89350
leaq 0x42314f(%rip), %rdi # 0x4bd300
xorl %esi, %esi
movl $0x40, %edx
callq 0x60350
movb $0x1, 0x4230cc(%rip) # 0x4bd290
leaq 0x4230cd(%rip), %rdi # 0x4bd298
callq 0x602d0
leaq 0x2660a9(%rip), %rax # 0x300280
movq %rax, -0x510(%rbp)
movq -0x510(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a222
movq -0x510(%rbp), %rax
movq (%rax), %rsi
leaq -0x530(%rbp), %r8
leaq -0x500(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x9a280
movq -0x510(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x510(%rbp)
jmp 0x9a1de
leaq 0x42306f(%rip), %rdi # 0x4bd298
callq 0x60290
leaq -0x500(%rbp), %rdi
callq 0x9a4b0
movl $0x0, -0x504(%rbp)
movl -0x504(%rbp), %eax
movl %eax, -0x534(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9a271
movl -0x534(%rbp), %eax
addq $0x540, %rsp # imm = 0x540
popq %rbp
retq
callq 0x60310
nopw %cs:(%rax,%rax)
|
mysql_client_plugin_init:
push rbp
mov rbp, rsp
sub rsp, 540h
mov rax, fs:28h
mov [rbp+var_8], rax
lea rdi, [rbp+var_530]
xor esi, esi
mov edx, 18h
call _memset
cmp cs:initialized, 0
jz short loc_9A173
mov [rbp+var_504], 0
jmp loc_9A244
loc_9A173:
lea rdi, [rbp+var_500]
xor esi, esi
mov edx, 4F8h
call _memset
lea rdi, LOCK_load_client_plugin
xor eax, eax
mov esi, eax
call _pthread_mutex_init
lea rdi, mem_root
mov edx, 80h
mov rsi, rdx
call ma_init_alloc_root
lea rdi, plugin_list
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov cs:initialized, 1
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_lock
lea rax, mysql_client_builtins
mov [rbp+var_510], rax
loc_9A1DE:
mov rax, [rbp+var_510]
cmp qword ptr [rax], 0
jz short loc_9A222
mov rax, [rbp+var_510]
mov rsi, [rax]
lea r8, [rbp+var_530]
lea rdi, [rbp+var_500]
xor eax, eax
mov edx, eax
xor ecx, ecx
call add_plugin
mov rax, [rbp+var_510]
add rax, 8
mov [rbp+var_510], rax
jmp short loc_9A1DE
loc_9A222:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rdi, [rbp+var_500]
call load_env_plugins
mov [rbp+var_504], 0
loc_9A244:
mov eax, [rbp+var_504]
mov [rbp+var_534], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9A271
mov eax, [rbp+var_534]
add rsp, 540h
pop rbp
retn
loc_9A271:
call ___stack_chk_fail
|
long long mysql_client_plugin_init()
{
_BYTE v1[32]; // [rsp+10h] [rbp-530h] BYREF
_QWORD *i; // [rsp+30h] [rbp-510h]
_BYTE v4[1272]; // [rsp+40h] [rbp-500h] BYREF
unsigned long long v5; // [rsp+538h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(v1, 0LL, 24LL);
if ( initialized )
{
return 0;
}
else
{
memset(v4, 0LL, sizeof(v4));
pthread_mutex_init(&LOCK_load_client_plugin, 0LL);
ma_init_alloc_root(mem_root, 128LL, 128LL);
memset(&plugin_list, 0LL, 64LL);
initialized = 1;
pthread_mutex_lock(&LOCK_load_client_plugin);
for ( i = &mysql_client_builtins; *i; ++i )
add_plugin(v4, *i, 0LL, 0LL, v1);
pthread_mutex_unlock(&LOCK_load_client_plugin);
load_env_plugins(v4);
return 0;
}
}
|
mysql_client_plugin_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x540
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0x530]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00160350
CMP byte ptr [0x005bd290],0x0
JZ 0x0019a173
MOV dword ptr [RBP + -0x504],0x0
JMP 0x0019a244
LAB_0019a173:
LEA RDI,[RBP + -0x500]
XOR ESI,ESI
MOV EDX,0x4f8
CALL 0x00160350
LEA RDI,[0x5bd298]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00160450
LEA RDI,[0x5bd2c0]
MOV EDX,0x80
MOV RSI,RDX
CALL 0x00189350
LEA RDI,[0x5bd300]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00160350
MOV byte ptr [0x005bd290],0x1
LEA RDI,[0x5bd298]
CALL 0x001602d0
LEA RAX,[0x400280]
MOV qword ptr [RBP + -0x510],RAX
LAB_0019a1de:
MOV RAX,qword ptr [RBP + -0x510]
CMP qword ptr [RAX],0x0
JZ 0x0019a222
MOV RAX,qword ptr [RBP + -0x510]
MOV RSI,qword ptr [RAX]
LEA R8,[RBP + -0x530]
LEA RDI,[RBP + -0x500]
XOR EAX,EAX
MOV EDX,EAX
XOR ECX,ECX
CALL 0x0019a280
MOV RAX,qword ptr [RBP + -0x510]
ADD RAX,0x8
MOV qword ptr [RBP + -0x510],RAX
JMP 0x0019a1de
LAB_0019a222:
LEA RDI,[0x5bd298]
CALL 0x00160290
LEA RDI,[RBP + -0x500]
CALL 0x0019a4b0
MOV dword ptr [RBP + -0x504],0x0
LAB_0019a244:
MOV EAX,dword ptr [RBP + -0x504]
MOV dword ptr [RBP + -0x534],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0019a271
MOV EAX,dword ptr [RBP + -0x534]
ADD RSP,0x540
POP RBP
RET
LAB_0019a271:
CALL 0x00160310
|
int4 mysql_client_plugin_init(void)
{
long in_FS_OFFSET;
int1 local_538 [32];
int **local_518;
int4 local_50c;
int1 local_508 [1272];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
memset(local_538,0,0x18);
if (initialized == '\0') {
memset(local_508,0,0x4f8);
pthread_mutex_init((pthread_mutex_t *)LOCK_load_client_plugin,(pthread_mutexattr_t *)0x0);
ma_init_alloc_root(mem_root);
memset(plugin_list,0,0x40);
initialized = '\x01';
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
for (local_518 = &mysql_client_builtins; *local_518 != (int *)0x0;
local_518 = local_518 + 1) {
add_plugin(local_508,*local_518,0,0,local_538);
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
load_env_plugins(local_508);
}
local_50c = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
|
58,525
|
stbtt__get_subrs
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h
|
static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
stbtt__buf pdict;
stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
if (!subrsoff) return stbtt__new_buf(NULL, 0);
stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
return stbtt__cff_get_index(&cff);
}
|
O0
|
c
|
stbtt__get_subrs:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x30d0
leaq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x7fa0
cmpl $0x0, -0x38(%rbp)
je 0x8072
cmpl $0x0, -0x3c(%rbp)
jne 0x8088
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x7b70
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x8102
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x8110
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x13, %esi
movl $0x1, %edx
leaq -0x34(%rbp), %rcx
callq 0x7fa0
cmpl $0x0, -0x34(%rbp)
jne 0x80e2
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x7b70
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x8102
movl -0x38(%rbp), %esi
addl -0x34(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x7cf0
leaq -0x20(%rbp), %rdi
callq 0x7dc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
|
stbtt__get_subrs:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_20], rdi
mov [rbp+var_18], rsi
mov [rbp+var_30], rdx
mov [rbp+var_28], rcx
mov [rbp+var_34], 0
lea rdi, [rbp+var_3C]
xor esi, esi
mov edx, 8
call _memset
lea rcx, [rbp+var_3C]
lea rdi, [rbp+var_30]
mov esi, 12h
mov edx, 2
call stbtt__dict_get_ints
cmp [rbp+var_38], 0
jz short loc_8072
cmp [rbp+var_3C], 0
jnz short loc_8088
loc_8072:
xor eax, eax
mov esi, eax
mov rdi, rsi
call stbtt__new_buf
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_8102
loc_8088:
mov esi, [rbp+var_38]
mov edx, [rbp+var_3C]
lea rdi, [rbp+var_20]
call stbtt__buf_range
mov [rbp+var_60], rax
mov [rbp+var_58], rdx
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
mov [rbp+var_48], rax
lea rdi, [rbp+var_50]
mov esi, 13h
mov edx, 1
lea rcx, [rbp+var_34]
call stbtt__dict_get_ints
cmp [rbp+var_34], 0
jnz short loc_80E2
xor eax, eax
mov esi, eax
mov rdi, rsi
call stbtt__new_buf
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_8102
loc_80E2:
mov esi, [rbp+var_38]
add esi, [rbp+var_34]
lea rdi, [rbp+var_20]
call stbtt__buf_seek
lea rdi, [rbp+var_20]
call stbtt__cff_get_index
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
loc_8102:
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
long long stbtt__get_subrs(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
_QWORD v8[2]; // [rsp+10h] [rbp-50h] BYREF
unsigned int v9; // [rsp+24h] [rbp-3Ch] BYREF
unsigned int v10; // [rsp+28h] [rbp-38h]
int v11; // [rsp+2Ch] [rbp-34h] BYREF
_QWORD v12[2]; // [rsp+30h] [rbp-30h] BYREF
_QWORD v13[2]; // [rsp+40h] [rbp-20h] BYREF
long long index; // [rsp+50h] [rbp-10h]
long long v15; // [rsp+58h] [rbp-8h]
v13[0] = a1;
v13[1] = a2;
v12[0] = a3;
v12[1] = a4;
v11 = 0;
memset(&v9, 0LL, 8LL);
stbtt__dict_get_ints((long long)v12, 0x12u, 2, (long long)&v9);
if ( v10 && v9 )
{
v8[0] = stbtt__buf_range(v13, v10, v9);
v8[1] = v5;
stbtt__dict_get_ints((long long)v8, 0x13u, 1, (long long)&v11);
if ( v11 )
{
stbtt__buf_seek((long long)v13, v11 + v10);
index = stbtt__cff_get_index((long long)v13);
}
else
{
index = stbtt__new_buf(0LL, 0LL);
}
v15 = v6;
}
else
{
index = stbtt__new_buf(0LL, 0LL);
v15 = v4;
}
return index;
}
|
stbtt__get_subrs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x34],0x0
LEA RDI,[RBP + -0x3c]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x001030d0
LEA RCX,[RBP + -0x3c]
LEA RDI,[RBP + -0x30]
MOV ESI,0x12
MOV EDX,0x2
CALL 0x00107fa0
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00108072
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00108088
LAB_00108072:
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00107b70
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x00108102
LAB_00108088:
MOV ESI,dword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x3c]
LEA RDI,[RBP + -0x20]
CALL 0x00108110
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x58],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x50]
MOV ESI,0x13
MOV EDX,0x1
LEA RCX,[RBP + -0x34]
CALL 0x00107fa0
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001080e2
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00107b70
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x00108102
LAB_001080e2:
MOV ESI,dword ptr [RBP + -0x38]
ADD ESI,dword ptr [RBP + -0x34]
LEA RDI,[RBP + -0x20]
CALL 0x00107cf0
LEA RDI,[RBP + -0x20]
CALL 0x00107dc0
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
LAB_00108102:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
int1 [16]
stbtt__get_subrs(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int1 auVar1 [16];
int1 local_58 [16];
int local_44;
int local_40;
int local_3c;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
local_3c = 0;
local_38 = param_3;
local_30 = param_4;
local_28 = param_1;
local_20 = param_2;
memset(&local_44,0,8);
stbtt__dict_get_ints(&local_38,0x12,2,&local_44);
if ((local_40 == 0) || (local_44 == 0)) {
auVar1 = stbtt__new_buf(0);
}
else {
local_58 = stbtt__buf_range(&local_28,local_40,local_44);
stbtt__dict_get_ints(local_58,0x13,1,&local_3c);
if (local_3c == 0) {
auVar1 = stbtt__new_buf(0);
}
else {
stbtt__buf_seek(&local_28,local_40 + local_3c);
auVar1 = stbtt__cff_get_index(&local_28);
}
}
return auVar1;
}
|
|
58,526
|
stbtt__get_subrs
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h
|
static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
stbtt__buf pdict;
stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
if (!subrsoff) return stbtt__new_buf(NULL, 0);
stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
return stbtt__cff_get_index(&cff);
}
|
O1
|
c
|
stbtt__get_subrs:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movl $0x0, 0xc(%rsp)
leaq 0x20(%rsp), %r14
movq $0x0, (%r14)
movl $0x12, %esi
movl $0x2, %edx
movq %r14, %rcx
callq 0x5ecd
movl (%r14), %ecx
movl 0x4(%r14), %r14d
testq %r14, %r14
setne %al
testl %ecx, %ecx
setne %sil
andb %al, %sil
xorl %eax, %eax
movl $0x0, %edx
cmpb $0x1, %sil
jne 0x61a3
movl %ecx, %eax
movl %eax, %ecx
orl %r14d, %ecx
js 0x6158
movl 0x1c(%rsp), %ecx
subl %r14d, %ecx
setl %dl
cmpl %eax, %ecx
setl %sil
xorl %ecx, %ecx
orb %dl, %sil
movl $0x0, %edx
jne 0x615c
addq %r14, %rbx
shlq $0x20, %rax
movq %rbx, %rcx
movq %rax, %rdx
jmp 0x615c
xorl %ecx, %ecx
xorl %edx, %edx
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0xc(%rsp), %rbx
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x5ecd
movl (%rbx), %eax
testl %eax, %eax
je 0x619f
addl %r14d, %eax
js 0x61ab
cmpl %eax, 0x1c(%rsp)
jl 0x61ab
leaq 0x10(%rsp), %rdi
movl %eax, 0x8(%rdi)
callq 0x5c4c
jmp 0x61a3
xorl %eax, %eax
xorl %edx, %edx
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d332(%rip), %rdi # 0x234e4
leaq 0x1d2bf(%rip), %rsi # 0x23478
leaq 0x1d33c(%rip), %rcx # 0x234fc
movl $0x47d, %edx # imm = 0x47D
callq 0x30b0
|
stbtt__get_subrs:
push r14
push rbx
sub rsp, 48h
mov rbx, rdi
mov [rsp+58h+var_48], rdi
mov [rsp+58h+var_40], rsi
lea rdi, [rsp+58h+var_20]
mov [rdi], rdx
mov [rdi+8], rcx
mov [rsp+58h+var_4C], 0
lea r14, [rsp+58h+var_38]
mov qword ptr [r14], 0
mov esi, 12h
mov edx, 2
mov rcx, r14
call stbtt__dict_get_ints
mov ecx, [r14]
mov r14d, [r14+4]
test r14, r14
setnz al
test ecx, ecx
setnz sil
and sil, al
xor eax, eax
mov edx, 0
cmp sil, 1
jnz short loc_61A3
mov eax, ecx
mov ecx, eax
or ecx, r14d
js short loc_6158
mov ecx, dword ptr [rsp+58h+var_40+4]
sub ecx, r14d
setl dl
cmp ecx, eax
setl sil
xor ecx, ecx
or sil, dl
mov edx, 0
jnz short loc_615C
add rbx, r14
shl rax, 20h
mov rcx, rbx
mov rdx, rax
jmp short loc_615C
loc_6158:
xor ecx, ecx
xor edx, edx
loc_615C:
lea rdi, [rsp+58h+var_30]
mov [rdi], rcx
mov [rdi+8], rdx
lea rbx, [rsp+58h+var_4C]
mov esi, 13h
mov edx, 1
mov rcx, rbx
call stbtt__dict_get_ints
mov eax, [rbx]
test eax, eax
jz short loc_619F
add eax, r14d
js short loc_61AB
cmp dword ptr [rsp+58h+var_40+4], eax
jl short loc_61AB
lea rdi, [rsp+58h+var_48]
mov [rdi+8], eax
call stbtt__cff_get_index
jmp short loc_61A3
loc_619F:
xor eax, eax
xor edx, edx
loc_61A3:
add rsp, 48h
pop rbx
pop r14
retn
loc_61AB:
lea rdi, aOBSizeO0; "!(o > b->size || o < 0)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidStbttBufSe; "void stbtt__buf_seek(stbtt__buf *, int)"
mov edx, 47Dh
call ___assert_fail
|
long long stbtt__get_subrs(long long a1, long long a2, long long a3, long long a4)
{
int v4; // r14d
long long result; // rax
long long v6; // rcx
unsigned long long v7; // rdx
int v8; // [rsp+Ch] [rbp-4Ch] BYREF
long long v9; // [rsp+10h] [rbp-48h] BYREF
long long v10; // [rsp+18h] [rbp-40h]
long long v11; // [rsp+20h] [rbp-38h] BYREF
_QWORD v12[2]; // [rsp+28h] [rbp-30h] BYREF
_QWORD v13[4]; // [rsp+38h] [rbp-20h] BYREF
v9 = a1;
v10 = a2;
v13[0] = a3;
v13[1] = a4;
v8 = 0;
v11 = 0LL;
stbtt__dict_get_ints((long long)v13, 18LL, 2LL, (long long)&v11);
v4 = HIDWORD(v11);
result = 0LL;
if ( HIDWORD(v11) != 0LL && (_DWORD)v11 != 0 )
{
if ( (int)(HIDWORD(v11) | v11) < 0 )
{
v6 = 0LL;
v7 = 0LL;
}
else
{
v6 = 0LL;
v7 = 0LL;
if ( SHIDWORD(v10) >= SHIDWORD(v11) && HIDWORD(v10) - HIDWORD(v11) >= (int)v11 )
{
v6 = HIDWORD(v11) + a1;
v7 = (unsigned long long)(unsigned int)v11 << 32;
}
}
v12[0] = v6;
v12[1] = v7;
stbtt__dict_get_ints((long long)v12, 19LL, 1LL, (long long)&v8);
if ( v8 )
{
if ( v4 + v8 < 0 || SHIDWORD(v10) < v4 + v8 )
__assert_fail(
"!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h",
1149LL,
"void stbtt__buf_seek(stbtt__buf *, int)");
LODWORD(v10) = v4 + v8;
return stbtt__cff_get_index((long long)&v9);
}
else
{
return 0LL;
}
}
return result;
}
|
stbtt__get_subrs:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x18],RSI
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI],RDX
MOV qword ptr [RDI + 0x8],RCX
MOV dword ptr [RSP + 0xc],0x0
LEA R14,[RSP + 0x20]
MOV qword ptr [R14],0x0
MOV ESI,0x12
MOV EDX,0x2
MOV RCX,R14
CALL 0x00105ecd
MOV ECX,dword ptr [R14]
MOV R14D,dword ptr [R14 + 0x4]
TEST R14,R14
SETNZ AL
TEST ECX,ECX
SETNZ SIL
AND SIL,AL
XOR EAX,EAX
MOV EDX,0x0
CMP SIL,0x1
JNZ 0x001061a3
MOV EAX,ECX
MOV ECX,EAX
OR ECX,R14D
JS 0x00106158
MOV ECX,dword ptr [RSP + 0x1c]
SUB ECX,R14D
SETL DL
CMP ECX,EAX
SETL SIL
XOR ECX,ECX
OR SIL,DL
MOV EDX,0x0
JNZ 0x0010615c
ADD RBX,R14
SHL RAX,0x20
MOV RCX,RBX
MOV RDX,RAX
JMP 0x0010615c
LAB_00106158:
XOR ECX,ECX
XOR EDX,EDX
LAB_0010615c:
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI],RCX
MOV qword ptr [RDI + 0x8],RDX
LEA RBX,[RSP + 0xc]
MOV ESI,0x13
MOV EDX,0x1
MOV RCX,RBX
CALL 0x00105ecd
MOV EAX,dword ptr [RBX]
TEST EAX,EAX
JZ 0x0010619f
ADD EAX,R14D
JS 0x001061ab
CMP dword ptr [RSP + 0x1c],EAX
JL 0x001061ab
LEA RDI,[RSP + 0x10]
MOV dword ptr [RDI + 0x8],EAX
CALL 0x00105c4c
JMP 0x001061a3
LAB_0010619f:
XOR EAX,EAX
XOR EDX,EDX
LAB_001061a3:
ADD RSP,0x48
POP RBX
POP R14
RET
LAB_001061ab:
LEA RDI,[0x1234e4]
LEA RSI,[0x123478]
LEA RCX,[0x1234fc]
MOV EDX,0x47d
CALL 0x001030b0
|
int8 stbtt__get_subrs(long param_1,int8 param_2,int8 param_3,int8 param_4)
{
uint uVar1;
int iVar2;
int8 uVar3;
int local_4c;
long local_48;
int8 local_40;
int8 local_38;
long local_30;
long local_28;
int8 local_20;
int8 local_18;
local_4c = 0;
local_38 = 0;
local_48 = param_1;
local_40 = param_2;
local_20 = param_3;
local_18 = param_4;
stbtt__dict_get_ints(&local_20,0x12,2,&local_38);
uVar1 = local_38._4_4_;
uVar3 = 0;
if ((uint)local_38 != 0 && (ulong)local_38._4_4_ != 0) {
if ((int)((uint)local_38 | local_38._4_4_) < 0) {
local_30 = 0;
local_28 = 0;
}
else {
local_30 = 0;
local_28 = 0;
if ((int)(uint)local_38 <= (int)(local_40._4_4_ - local_38._4_4_) &&
(int)local_38._4_4_ <= local_40._4_4_) {
local_30 = param_1 + (ulong)local_38._4_4_;
local_28 = local_38 << 0x20;
}
}
stbtt__dict_get_ints(&local_30,0x13,1,&local_4c);
if (local_4c == 0) {
uVar3 = 0;
}
else {
iVar2 = local_4c + uVar1;
if ((iVar2 < 0) || (local_40._4_4_ < iVar2)) {
/* WARNING: Subroutine does not return */
__assert_fail("!(o > b->size || o < 0)",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h"
,0x47d,"void stbtt__buf_seek(stbtt__buf *, int)");
}
local_40 = CONCAT44(local_40._4_4_,iVar2);
uVar3 = stbtt__cff_get_index();
}
}
return uVar3;
}
|
|
58,527
|
stbtt__get_subrs
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h
|
static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
stbtt__buf pdict;
stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
if (!subrsoff) return stbtt__new_buf(NULL, 0);
stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
return stbtt__cff_get_index(&cff);
}
|
O2
|
c
|
stbtt__get_subrs:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
andl $0x0, 0xc(%rsp)
leaq 0x20(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x12
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rcx
callq 0x5a9f
movl (%rbx), %edx
movl 0x4(%rbx), %ebx
testl %ebx, %ebx
setne %al
testl %edx, %edx
setne %sil
andb %al, %sil
xorl %eax, %eax
movl $0x0, %ecx
cmpb $0x1, %sil
jne 0x5c74
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x5c7f
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
leaq 0xc(%rsp), %r14
movq %r14, %rcx
callq 0x5a9f
movl (%r14), %esi
testl %esi, %esi
je 0x5c70
addl %ebx, %esi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x58df
movq %rbx, %rdi
callq 0x5925
movq %rdx, %rcx
jmp 0x5c74
xorl %eax, %eax
xorl %ecx, %ecx
movq %rcx, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
retq
|
stbtt__get_subrs:
push r14
push rbx
sub rsp, 48h
mov [rsp+58h+var_48], rdi
mov [rsp+58h+var_40], rsi
lea rdi, [rsp+58h+var_20]
mov [rdi], rdx
mov [rdi+8], rcx
and [rsp+58h+var_4C], 0
lea rbx, [rsp+58h+var_38]
and qword ptr [rbx], 0
push 12h
pop rsi
push 2
pop rdx
mov rcx, rbx
call stbtt__dict_get_ints
mov edx, [rbx]
mov ebx, [rbx+4]
test ebx, ebx
setnz al
test edx, edx
setnz sil
and sil, al
xor eax, eax
mov ecx, 0
cmp sil, 1
jnz short loc_5C74
lea rdi, [rsp+58h+var_48]
mov esi, ebx
call stbtt__buf_range
lea rdi, [rsp+58h+var_30]
mov [rdi], rax
mov [rdi+8], rdx
push 13h
pop rsi
push 1
pop rdx
lea r14, [rsp+58h+var_4C]
mov rcx, r14
call stbtt__dict_get_ints
mov esi, [r14]
test esi, esi
jz short loc_5C70
add esi, ebx
lea rbx, [rsp+58h+var_48]
mov rdi, rbx
call stbtt__buf_seek
mov rdi, rbx
call stbtt__cff_get_index
mov rcx, rdx
jmp short loc_5C74
loc_5C70:
xor eax, eax
xor ecx, ecx
loc_5C74:
mov rdx, rcx
add rsp, 48h
pop rbx
pop r14
retn
|
long long stbtt__get_subrs(long long a1, long long a2, long long a3, long long a4)
{
int v4; // ebx
long long result; // rax
long long v6; // rdx
int v7; // [rsp+Ch] [rbp-4Ch] BYREF
_QWORD v8[2]; // [rsp+10h] [rbp-48h] BYREF
long long v9; // [rsp+20h] [rbp-38h] BYREF
_QWORD v10[2]; // [rsp+28h] [rbp-30h] BYREF
_QWORD v11[4]; // [rsp+38h] [rbp-20h] BYREF
v8[0] = a1;
v8[1] = a2;
v11[0] = a3;
v11[1] = a4;
v7 = 0;
v9 = 0LL;
stbtt__dict_get_ints((long long)v11, 18, 2, (long long)&v9);
v4 = HIDWORD(v9);
result = 0LL;
if ( HIDWORD(v9) != 0 && (_DWORD)v9 != 0 )
{
v10[0] = stbtt__buf_range(v8, HIDWORD(v9), (unsigned int)v9);
v10[1] = v6;
stbtt__dict_get_ints((long long)v10, 19, 1, (long long)&v7);
if ( v7 )
{
stbtt__buf_seek((long long)v8, v4 + v7);
return stbtt__cff_get_index((long long)v8);
}
else
{
return 0LL;
}
}
return result;
}
|
stbtt__get_subrs:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x18],RSI
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI],RDX
MOV qword ptr [RDI + 0x8],RCX
AND dword ptr [RSP + 0xc],0x0
LEA RBX,[RSP + 0x20]
AND qword ptr [RBX],0x0
PUSH 0x12
POP RSI
PUSH 0x2
POP RDX
MOV RCX,RBX
CALL 0x00105a9f
MOV EDX,dword ptr [RBX]
MOV EBX,dword ptr [RBX + 0x4]
TEST EBX,EBX
SETNZ AL
TEST EDX,EDX
SETNZ SIL
AND SIL,AL
XOR EAX,EAX
MOV ECX,0x0
CMP SIL,0x1
JNZ 0x00105c74
LEA RDI,[RSP + 0x10]
MOV ESI,EBX
CALL 0x00105c7f
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],RDX
PUSH 0x13
POP RSI
PUSH 0x1
POP RDX
LEA R14,[RSP + 0xc]
MOV RCX,R14
CALL 0x00105a9f
MOV ESI,dword ptr [R14]
TEST ESI,ESI
JZ 0x00105c70
ADD ESI,EBX
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x001058df
MOV RDI,RBX
CALL 0x00105925
MOV RCX,RDX
JMP 0x00105c74
LAB_00105c70:
XOR EAX,EAX
XOR ECX,ECX
LAB_00105c74:
MOV RDX,RCX
ADD RSP,0x48
POP RBX
POP R14
RET
|
int1 [16]
stbtt__get_subrs(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int1 auVar2 [16];
int local_4c;
int8 local_48;
int8 local_40;
int8 local_38;
int1 local_30 [16];
int8 local_20;
int8 local_18;
local_4c = 0;
local_38 = 0;
local_48 = param_1;
local_40 = param_2;
local_20 = param_3;
local_18 = param_4;
stbtt__dict_get_ints(&local_20,0x12,2,&local_38);
iVar1 = local_38._4_4_;
auVar2 = ZEXT816(0);
if ((int)local_38 != 0 && local_38._4_4_ != 0) {
local_30 = stbtt__buf_range(&local_48,local_38._4_4_);
stbtt__dict_get_ints(local_30,0x13,1,&local_4c);
if (local_4c == 0) {
auVar2 = ZEXT816(0);
}
else {
stbtt__buf_seek(&local_48,local_4c + iVar1);
auVar2 = stbtt__cff_get_index(&local_48);
}
}
return auVar2;
}
|
|
58,528
|
CLI::App::check_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
|
MikePodsytnik[P]TCRtrie/build_O2/_deps/cli11-src/include/CLI/impl/App_inl.hpp
|
CLI11_NODISCARD CLI11_INLINE bool App::check_name(std::string name_to_check) const {
std::string local_name = name_;
if(ignore_underscore_) {
local_name = detail::remove_underscore(name_);
name_to_check = detail::remove_underscore(name_to_check);
}
if(ignore_case_) {
local_name = detail::to_lower(name_);
name_to_check = detail::to_lower(name_to_check);
}
if(local_name == name_to_check) {
return true;
}
for(auto les : aliases_) { // NOLINT(performance-for-range-copy)
if(ignore_underscore_) {
les = detail::remove_underscore(les);
}
if(ignore_case_) {
les = detail::to_lower(les);
}
if(les == name_to_check) {
return true;
}
}
return false;
}
|
O2
|
cpp
|
CLI::App::check_name(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
subq $0x138, %rsp # imm = 0x138
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x75e0
movq %r14, 0x8(%rsp)
cmpb $0x1, 0x299(%r14)
jne 0x18d24
leaq 0xb8(%rsp), %rdi
movq %rbx, %rsi
callq 0x75e0
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xfe63
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x7540
movq %r15, %rdi
callq 0x7860
leaq 0xb8(%rsp), %rdi
callq 0x7860
leaq 0x98(%rsp), %rdi
movq (%rsp), %rsi
callq 0x75e0
leaq 0x10(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xfe63
leaq 0x10(%rsp), %r15
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x7540
movq %r15, %rdi
callq 0x7860
leaq 0x98(%rsp), %rdi
callq 0x7860
movq 0x8(%rsp), %rax
cmpb $0x1, 0x298(%rax)
jne 0x18db6
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x75e0
leaq 0x10(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xfe31
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x7540
movq %rbx, %rdi
callq 0x7860
leaq 0x78(%rsp), %rdi
callq 0x7860
leaq 0x58(%rsp), %rdi
movq (%rsp), %rsi
callq 0x75e0
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xfe31
leaq 0x10(%rsp), %rbx
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x7540
movq %rbx, %rdi
callq 0x7860
leaq 0x58(%rsp), %rdi
callq 0x7860
leaq 0x38(%rsp), %rdi
movq (%rsp), %rsi
callq 0xe3b8
movb $0x1, %bpl
testb %al, %al
jne 0x18ec0
movq 0x8(%rsp), %rax
movq 0x2f0(%rax), %r15
movq 0x2f8(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%rsp), %r12
leaq 0xf8(%rsp), %r14
leaq 0x118(%rsp), %rbx
cmpq 0x30(%rsp), %r15
setne %bpl
je 0x18ec0
movq %r12, %rdi
movq %r15, %rsi
callq 0x75e0
movq 0x8(%rsp), %rax
cmpb $0x1, 0x299(%rax)
jne 0x18e55
movq %r14, %rdi
movq %r12, %rsi
callq 0x75e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfe63
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7540
movq %rbx, %rdi
callq 0x7860
movq %r14, %rdi
callq 0x7860
movq 0x8(%rsp), %rax
cmpb $0x1, 0x298(%rax)
jne 0x18e9c
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x75e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfe31
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7540
movq %rbx, %rdi
callq 0x7860
movq %r13, %rdi
callq 0x7860
movq %r12, %rdi
movq (%rsp), %rsi
callq 0xe3b8
movl %eax, %r13d
movq %r12, %rdi
callq 0x7860
addq $0x20, %r15
testb %r13b, %r13b
je 0x18dfc
leaq 0x38(%rsp), %rdi
callq 0x7860
movl %ebp, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
jmp 0x18f3d
jmp 0x18f44
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x18f3d
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x18f3d
jmp 0x18f44
jmp 0x18f44
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
jmp 0x18f3d
jmp 0x18f44
jmp 0x18f23
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
jmp 0x18f33
movq %rax, %rbx
jmp 0x18f38
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x7860
leaq 0x10(%rsp), %rdi
callq 0x7860
jmp 0x18f47
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7860
movq %rbx, %rdi
callq 0x7770
nop
|
_ZNK3CLI3App10check_nameENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov [rsp+168h+var_168], rsi
mov r14, rdi
lea rbx, [rdi+8]
lea rdi, [rsp+168h+var_130]
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov [rsp+168h+var_160], r14
cmp byte ptr [r14+299h], 1
jnz loc_18D24
lea rdi, [rsp+168h+var_B0]
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+168h+var_158]
lea rsi, [rsp+168h+var_B0]
call _ZN3CLI6detail17remove_underscoreENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::remove_underscore(std::string)
lea rdi, [rsp+168h+var_130]
lea r15, [rsp+168h+var_158]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_D0]
mov rsi, [rsp+168h+var_168]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+168h+var_158]
lea rsi, [rsp+168h+var_D0]
call _ZN3CLI6detail17remove_underscoreENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::remove_underscore(std::string)
lea r15, [rsp+168h+var_158]
mov rdi, [rsp+168h+var_168]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r15; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18D24:
mov rax, [rsp+168h+var_160]
cmp byte ptr [rax+298h], 1
jnz loc_18DB6
lea rdi, [rsp+168h+var_F0]
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+168h+var_158]
lea rsi, [rsp+168h+var_F0]
call _ZN3CLI6detail8to_lowerENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::to_lower(std::string)
lea rdi, [rsp+168h+var_130]
lea rbx, [rsp+168h+var_158]
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_110]
mov rsi, [rsp+168h+var_168]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rsp+168h+var_158]
lea rsi, [rsp+168h+var_110]
call _ZN3CLI6detail8to_lowerENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::to_lower(std::string)
lea rbx, [rsp+168h+var_158]
mov rdi, [rsp+168h+var_168]
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+168h+var_110]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18DB6:
lea rdi, [rsp+168h+var_130]
mov rsi, [rsp+168h+var_168]
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov bpl, 1
test al, al
jnz loc_18EC0
mov rax, [rsp+168h+var_160]
mov r15, [rax+2F0h]
mov rax, [rax+2F8h]
mov [rsp+168h+var_138], rax
lea r12, [rsp+168h+var_158]
lea r14, [rsp+168h+var_70]
lea rbx, [rsp+168h+var_50]
loc_18DFC:
cmp r15, [rsp+168h+var_138]
setnz bpl
jz loc_18EC0
mov rdi, r12
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rax, [rsp+168h+var_160]
cmp byte ptr [rax+299h], 1
jnz short loc_18E55
mov rdi, r14
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rbx
mov rsi, r14
call _ZN3CLI6detail17remove_underscoreENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::remove_underscore(std::string)
mov rdi, r12
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18E55:
mov rax, [rsp+168h+var_160]
cmp byte ptr [rax+298h], 1
jnz short loc_18E9C
lea r13, [rsp+168h+var_90]
mov rdi, r13
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, rbx
mov rsi, r13
call _ZN3CLI6detail8to_lowerENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::to_lower(std::string)
mov rdi, r12
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18E9C:
mov rdi, r12
mov rsi, [rsp+168h+var_168]
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
mov r13d, eax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
add r15, 20h ; ' '
test r13b, r13b
jz loc_18DFC
loc_18EC0:
lea rdi, [rsp+168h+var_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov eax, ebp
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_50]
jmp short loc_18F3D
jmp short loc_18F44
mov rbx, rax
lea rdi, [rsp+arg_70]
jmp short loc_18F3D
mov rbx, rax
lea rdi, [rsp+arg_90]
jmp short loc_18F3D
jmp short loc_18F44
jmp short loc_18F44
mov rbx, rax
lea rdi, [rsp+arg_B0]
jmp short loc_18F3D
jmp short loc_18F44
jmp short loc_18F23
mov rbx, rax
lea rdi, [rsp+arg_D0]
jmp short loc_18F33
loc_18F23:
mov rbx, rax
jmp short loc_18F38
mov rbx, rax
lea rdi, [rsp+arg_F0]; void *
loc_18F33:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18F38:
lea rdi, [rsp+arg_8]; void *
loc_18F3D:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_18F47
loc_18F44:
mov rbx, rax
loc_18F47:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long CLI::App::check_name(long long a1, _QWORD *a2)
{
unsigned int v2; // ebp
long long v3; // r15
bool v4; // r13
_QWORD v6[4]; // [rsp+10h] [rbp-158h] BYREF
long long v7; // [rsp+30h] [rbp-138h]
_QWORD v8[4]; // [rsp+38h] [rbp-130h] BYREF
_QWORD v9[4]; // [rsp+58h] [rbp-110h] BYREF
_QWORD v10[4]; // [rsp+78h] [rbp-F0h] BYREF
long long v11[4]; // [rsp+98h] [rbp-D0h] BYREF
long long v12[4]; // [rsp+B8h] [rbp-B0h] BYREF
_QWORD v13[4]; // [rsp+D8h] [rbp-90h] BYREF
long long v14[4]; // [rsp+F8h] [rbp-70h] BYREF
_BYTE v15[80]; // [rsp+118h] [rbp-50h] BYREF
std::string::basic_string(v8);
if ( *(_BYTE *)(a1 + 665) == 1 )
{
std::string::basic_string(v12);
CLI::detail::remove_underscore((long long)v6, v12);
std::string::operator=(v8, v6);
std::string::~string(v6);
std::string::~string(v12);
std::string::basic_string(v11);
CLI::detail::remove_underscore((long long)v6, v11);
std::string::operator=(a2, v6);
std::string::~string(v6);
std::string::~string(v11);
}
if ( *(_BYTE *)(a1 + 664) == 1 )
{
std::string::basic_string(v10);
CLI::detail::to_lower((long long)v6, v10);
std::string::operator=(v8, v6);
std::string::~string(v6);
std::string::~string(v10);
std::string::basic_string(v9);
CLI::detail::to_lower((long long)v6, v9);
std::string::operator=(a2, v6);
std::string::~string(v6);
std::string::~string(v9);
}
LOBYTE(v2) = 1;
if ( !std::operator==<char>(v8, a2) )
{
v3 = *(_QWORD *)(a1 + 752);
v7 = *(_QWORD *)(a1 + 760);
do
{
LOBYTE(v2) = v3 != v7;
if ( v3 == v7 )
break;
std::string::basic_string(v6);
if ( *(_BYTE *)(a1 + 665) == 1 )
{
std::string::basic_string(v14);
CLI::detail::remove_underscore((long long)v15, v14);
std::string::operator=(v6, v15);
std::string::~string(v15);
std::string::~string(v14);
}
if ( *(_BYTE *)(a1 + 664) == 1 )
{
std::string::basic_string(v13);
CLI::detail::to_lower((long long)v15, v13);
std::string::operator=(v6, v15);
std::string::~string(v15);
std::string::~string(v13);
}
v4 = std::operator==<char>(v6, a2);
std::string::~string(v6);
v3 += 32LL;
}
while ( !v4 );
}
std::string::~string(v8);
return v2;
}
|
check_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV qword ptr [RSP],RSI
MOV R14,RDI
LEA RBX,[RDI + 0x8]
LEA RDI,[RSP + 0x38]
MOV RSI,RBX
CALL 0x001075e0
MOV qword ptr [RSP + 0x8],R14
CMP byte ptr [R14 + 0x299],0x1
JNZ 0x00118d24
LAB_00118c92:
LEA RDI,[RSP + 0xb8]
MOV RSI,RBX
CALL 0x001075e0
LAB_00118ca2:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0xb8]
CALL 0x0010fe63
LEA RDI,[RSP + 0x38]
LEA R15,[RSP + 0x10]
MOV RSI,R15
CALL 0x00107540
MOV RDI,R15
CALL 0x00107860
LEA RDI,[RSP + 0xb8]
CALL 0x00107860
LAB_00118cdb:
LEA RDI,[RSP + 0x98]
MOV RSI,qword ptr [RSP]
CALL 0x001075e0
LAB_00118cec:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x98]
CALL 0x0010fe63
LEA R15,[RSP + 0x10]
MOV RDI,qword ptr [RSP]
MOV RSI,R15
CALL 0x00107540
MOV RDI,R15
CALL 0x00107860
LEA RDI,[RSP + 0x98]
CALL 0x00107860
LAB_00118d24:
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x298],0x1
JNZ 0x00118db6
LAB_00118d36:
LEA RDI,[RSP + 0x78]
MOV RSI,RBX
CALL 0x001075e0
LAB_00118d43:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x78]
CALL 0x0010fe31
LEA RDI,[RSP + 0x38]
LEA RBX,[RSP + 0x10]
MOV RSI,RBX
CALL 0x00107540
MOV RDI,RBX
CALL 0x00107860
LEA RDI,[RSP + 0x78]
CALL 0x00107860
LAB_00118d76:
LEA RDI,[RSP + 0x58]
MOV RSI,qword ptr [RSP]
CALL 0x001075e0
LAB_00118d84:
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x58]
CALL 0x0010fe31
LEA RBX,[RSP + 0x10]
MOV RDI,qword ptr [RSP]
MOV RSI,RBX
CALL 0x00107540
MOV RDI,RBX
CALL 0x00107860
LEA RDI,[RSP + 0x58]
CALL 0x00107860
LAB_00118db6:
LEA RDI,[RSP + 0x38]
MOV RSI,qword ptr [RSP]
CALL 0x0010e3b8
MOV BPL,0x1
TEST AL,AL
JNZ 0x00118ec0
MOV RAX,qword ptr [RSP + 0x8]
MOV R15,qword ptr [RAX + 0x2f0]
MOV RAX,qword ptr [RAX + 0x2f8]
MOV qword ptr [RSP + 0x30],RAX
LEA R12,[RSP + 0x10]
LEA R14,[RSP + 0xf8]
LEA RBX,[RSP + 0x118]
LAB_00118dfc:
CMP R15,qword ptr [RSP + 0x30]
SETNZ BPL
JZ 0x00118ec0
LAB_00118e0b:
MOV RDI,R12
MOV RSI,R15
CALL 0x001075e0
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x299],0x1
JNZ 0x00118e55
LAB_00118e24:
MOV RDI,R14
MOV RSI,R12
CALL 0x001075e0
LAB_00118e2f:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010fe63
MOV RDI,R12
MOV RSI,RBX
CALL 0x00107540
MOV RDI,RBX
CALL 0x00107860
MOV RDI,R14
CALL 0x00107860
LAB_00118e55:
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x298],0x1
JNZ 0x00118e9c
LAB_00118e63:
LEA R13,[RSP + 0xd8]
MOV RDI,R13
MOV RSI,R12
CALL 0x001075e0
LAB_00118e76:
MOV RDI,RBX
MOV RSI,R13
CALL 0x0010fe31
LAB_00118e81:
MOV RDI,R12
MOV RSI,RBX
CALL 0x00107540
MOV RDI,RBX
CALL 0x00107860
MOV RDI,R13
CALL 0x00107860
LAB_00118e9c:
MOV RDI,R12
MOV RSI,qword ptr [RSP]
CALL 0x0010e3b8
MOV R13D,EAX
MOV RDI,R12
CALL 0x00107860
ADD R15,0x20
TEST R13B,R13B
JZ 0x00118dfc
LAB_00118ec0:
LEA RDI,[RSP + 0x38]
CALL 0x00107860
MOV EAX,EBP
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* CLI::App::check_name(std::__cxx11::string) const */
ulong __thiscall CLI::App::check_name(App *this,string *param_2)
{
char cVar1;
int8 unaff_RBP;
ulong uVar2;
string *psVar3;
detail local_158 [32];
string *local_138;
string local_130 [32];
string local_110 [32];
string local_f0 [32];
string local_d0 [32];
string local_b0 [32];
string local_90 [32];
string local_70 [32];
string local_50 [32];
psVar3 = (string *)(this + 8);
std::__cxx11::string::string(local_130,psVar3);
if (this[0x299] == (App)0x1) {
/* try { // try from 00118c92 to 00118ca1 has its CatchHandler @ 00118f12 */
std::__cxx11::string::string(local_b0,psVar3);
/* try { // try from 00118ca2 to 00118cb3 has its CatchHandler @ 00118f05 */
detail::remove_underscore(local_158,local_b0);
std::__cxx11::string::operator=(local_130,(string *)local_158);
std::__cxx11::string::~string((string *)local_158);
std::__cxx11::string::~string(local_b0);
/* try { // try from 00118cdb to 00118ceb has its CatchHandler @ 00118f03 */
std::__cxx11::string::string(local_d0,param_2);
/* try { // try from 00118cec to 00118cfd has its CatchHandler @ 00118ef4 */
detail::remove_underscore(local_158,local_d0);
std::__cxx11::string::operator=(param_2,(string *)local_158);
std::__cxx11::string::~string((string *)local_158);
std::__cxx11::string::~string(local_d0);
}
if (this[0x298] == (App)0x1) {
/* try { // try from 00118d36 to 00118d42 has its CatchHandler @ 00118f01 */
std::__cxx11::string::string(local_f0,psVar3);
/* try { // try from 00118d43 to 00118d51 has its CatchHandler @ 00118eea */
detail::to_lower(local_158,local_f0);
std::__cxx11::string::operator=(local_130,(string *)local_158);
std::__cxx11::string::~string((string *)local_158);
std::__cxx11::string::~string(local_f0);
/* try { // try from 00118d76 to 00118d83 has its CatchHandler @ 00118ee8 */
std::__cxx11::string::string(local_110,param_2);
/* try { // try from 00118d84 to 00118d92 has its CatchHandler @ 00118ede */
detail::to_lower(local_158,local_110);
std::__cxx11::string::operator=(param_2,(string *)local_158);
std::__cxx11::string::~string((string *)local_158);
std::__cxx11::string::~string(local_110);
}
cVar1 = std::operator==(local_130,param_2);
uVar2 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
if (cVar1 == '\0') {
psVar3 = *(string **)(this + 0x2f0);
local_138 = *(string **)(this + 0x2f8);
do {
uVar2 = CONCAT71((int7)(uVar2 >> 8),psVar3 != local_138);
if (psVar3 == local_138) break;
/* try { // try from 00118e0b to 00118e15 has its CatchHandler @ 00118f44 */
std::__cxx11::string::string((string *)local_158,psVar3);
if (this[0x299] == (App)0x1) {
/* try { // try from 00118e24 to 00118e2e has its CatchHandler @ 00118f14 */
std::__cxx11::string::string(local_70,(string *)local_158);
/* try { // try from 00118e2f to 00118e39 has its CatchHandler @ 00118f28 */
detail::remove_underscore((detail *)local_50,local_70);
std::__cxx11::string::operator=((string *)local_158,local_50);
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string(local_70);
}
if (this[0x298] == (App)0x1) {
/* try { // try from 00118e63 to 00118e75 has its CatchHandler @ 00118f23 */
std::__cxx11::string::string(local_90,(string *)local_158);
/* try { // try from 00118e76 to 00118e80 has its CatchHandler @ 00118f16 */
detail::to_lower((detail *)local_50,local_90);
std::__cxx11::string::operator=((string *)local_158,local_50);
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string(local_90);
}
cVar1 = std::operator==((string *)local_158,param_2);
std::__cxx11::string::~string((string *)local_158);
psVar3 = psVar3 + 0x20;
} while (cVar1 == '\0');
}
std::__cxx11::string::~string(local_130);
return uVar2 & 0xffffffff;
}
|
|
58,529
|
mi_find_last_pos
|
eloqsql/storage/myisam/mi_write.c
|
static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
uchar *key, uint *return_key_length,
uchar **after_key)
{
uint keys, length, UNINIT_VAR(last_length), key_ref_length;
uchar *end,*lastpos,*prevpos;
uchar key_buff[HA_MAX_KEY_BUFF];
DBUG_ENTER("_mi_find_last_pos");
key_ref_length=2;
length=mi_getint(page)-key_ref_length;
page+=key_ref_length;
if (!(keyinfo->flag &
(HA_PACK_KEY | HA_SPACE_PACK_USED | HA_VAR_LENGTH_KEY |
HA_BINARY_PACK_KEY)))
{
keys=length/keyinfo->keylength-2;
*return_key_length=length=keyinfo->keylength;
end=page+keys*length;
*after_key=end+length;
memcpy(key,end,length);
DBUG_RETURN(end);
}
end=page+length-key_ref_length;
DBUG_ASSERT(page < end);
*key='\0';
length=0;
lastpos=page;
do
{
prevpos=lastpos; lastpos=page;
last_length=length;
memcpy(key, key_buff, length); /* previous key */
if (!(length=(*keyinfo->get_key)(keyinfo,0,&page,key_buff)))
{
mi_print_error(keyinfo->share, HA_ERR_CRASHED);
my_errno=HA_ERR_CRASHED;
DBUG_RETURN(0);
}
} while (page < end);
*return_key_length=last_length;
*after_key=lastpos;
DBUG_PRINT("exit",("returns: %p page: %p end: %p",
prevpos, page, end));
DBUG_RETURN(prevpos);
}
|
O0
|
c
|
mi_find_last_pos:
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp # imm = 0x520
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdx, -0x4e0(%rbp)
movq %rcx, -0x4e8(%rbp)
movq %r8, -0x4f0(%rbp)
movl -0x4fc(%rbp), %eax
movl %eax, -0x4fc(%rbp)
movl $0x2, -0x500(%rbp)
movq -0x4d8(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x4d8(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
subl -0x500(%rbp), %eax
movl %eax, -0x4f8(%rbp)
movl -0x500(%rbp), %ecx
movq -0x4d8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x4d8(%rbp)
movq -0x4d0(%rbp), %rax
movzwl 0xa(%rax), %eax
andl $0x2e, %eax
cmpl $0x0, %eax
jne 0xc7e25
movl -0x4f8(%rbp), %eax
movq -0x4d0(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
xorl %edx, %edx
divl %ecx
subl $0x2, %eax
movl %eax, -0x4f4(%rbp)
movq -0x4d0(%rbp), %rax
movzwl 0x12(%rax), %ecx
movl %ecx, -0x4f8(%rbp)
movq -0x4e8(%rbp), %rax
movl %ecx, (%rax)
movq -0x4d8(%rbp), %rax
movl -0x4f4(%rbp), %ecx
imull -0x4f8(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x508(%rbp)
movq -0x508(%rbp), %rcx
movl -0x4f8(%rbp), %eax
addq %rax, %rcx
movq -0x4f0(%rbp), %rax
movq %rcx, (%rax)
movq -0x4e0(%rbp), %rdi
movq -0x508(%rbp), %rsi
movl -0x4f8(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x508(%rbp), %rax
movq %rax, -0x4c8(%rbp)
jmp 0xc7f5d
movq -0x4d8(%rbp), %rax
movl -0x4f8(%rbp), %ecx
addq %rcx, %rax
movl -0x500(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x508(%rbp)
jmp 0xc7e4e
movq -0x4e0(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4f8(%rbp)
movq -0x4d8(%rbp), %rax
movq %rax, -0x510(%rbp)
movq -0x510(%rbp), %rax
movq %rax, -0x518(%rbp)
movq -0x4d8(%rbp), %rax
movq %rax, -0x510(%rbp)
movl -0x4f8(%rbp), %eax
movl %eax, -0x4fc(%rbp)
movq -0x4e0(%rbp), %rdi
leaq -0x4c0(%rbp), %rsi
movl -0x4f8(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x4d0(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x4d0(%rbp), %rdi
leaq -0x4c0(%rbp), %rcx
xorl %esi, %esi
leaq -0x4d8(%rbp), %rdx
callq *%rax
movl %eax, -0x4f8(%rbp)
cmpl $0x0, %eax
jne 0xc7f15
movq -0x4d0(%rbp), %rax
movq (%rax), %rax
movq 0x268(%rax), %rsi
movl $0x7e, %edi
callq 0xae570
callq 0xf60c0
movl $0x7e, (%rax)
movq $0x0, -0x4c8(%rbp)
jmp 0xc7f5d
jmp 0xc7f17
movq -0x4d8(%rbp), %rax
cmpq -0x508(%rbp), %rax
jb 0xc7e70
movl -0x4fc(%rbp), %ecx
movq -0x4e8(%rbp), %rax
movl %ecx, (%rax)
movq -0x510(%rbp), %rcx
movq -0x4f0(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc7f4d
jmp 0xc7f4f
movq -0x518(%rbp), %rax
movq %rax, -0x4c8(%rbp)
movq -0x4c8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc7f8d
movq -0x520(%rbp), %rax
addq $0x520, %rsp # imm = 0x520
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
_mi_find_last_pos:
push rbp
mov rbp, rsp
sub rsp, 520h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_4D0], rdi
mov [rbp+var_4D8], rsi
mov [rbp+var_4E0], rdx
mov [rbp+var_4E8], rcx
mov [rbp+var_4F0], r8
mov eax, [rbp+var_4FC]
mov [rbp+var_4FC], eax
mov [rbp+var_500], 2
mov rax, [rbp+var_4D8]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_4D8]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
sub eax, [rbp+var_500]
mov [rbp+var_4F8], eax
mov ecx, [rbp+var_500]
mov rax, [rbp+var_4D8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_4D8], rax
mov rax, [rbp+var_4D0]
movzx eax, word ptr [rax+0Ah]
and eax, 2Eh
cmp eax, 0
jnz loc_C7E25
mov eax, [rbp+var_4F8]
mov rcx, [rbp+var_4D0]
movzx ecx, word ptr [rcx+12h]
xor edx, edx
div ecx
sub eax, 2
mov [rbp+var_4F4], eax
mov rax, [rbp+var_4D0]
movzx ecx, word ptr [rax+12h]
mov [rbp+var_4F8], ecx
mov rax, [rbp+var_4E8]
mov [rax], ecx
mov rax, [rbp+var_4D8]
mov ecx, [rbp+var_4F4]
imul ecx, [rbp+var_4F8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_508], rax
mov rcx, [rbp+var_508]
mov eax, [rbp+var_4F8]
add rcx, rax
mov rax, [rbp+var_4F0]
mov [rax], rcx
mov rdi, [rbp+var_4E0]
mov rsi, [rbp+var_508]
mov eax, [rbp+var_4F8]
mov edx, eax
call _memcpy
mov rax, [rbp+var_508]
mov [rbp+var_4C8], rax
jmp loc_C7F5D
loc_C7E25:
mov rax, [rbp+var_4D8]
mov ecx, [rbp+var_4F8]
add rax, rcx
mov ecx, [rbp+var_500]
mov edx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_508], rax
jmp short $+2
loc_C7E4E:
mov rax, [rbp+var_4E0]
mov byte ptr [rax], 0
mov [rbp+var_4F8], 0
mov rax, [rbp+var_4D8]
mov [rbp+var_510], rax
loc_C7E70:
mov rax, [rbp+var_510]
mov [rbp+var_518], rax
mov rax, [rbp+var_4D8]
mov [rbp+var_510], rax
mov eax, [rbp+var_4F8]
mov [rbp+var_4FC], eax
mov rdi, [rbp+var_4E0]
lea rsi, [rbp+var_4C0]
mov eax, [rbp+var_4F8]
mov edx, eax
call _memcpy
mov rax, [rbp+var_4D0]
mov rax, [rax+48h]
mov rdi, [rbp+var_4D0]
lea rcx, [rbp+var_4C0]
xor esi, esi
lea rdx, [rbp+var_4D8]
call rax
mov [rbp+var_4F8], eax
cmp eax, 0
jnz short loc_C7F15
mov rax, [rbp+var_4D0]
mov rax, [rax]
mov rsi, [rax+268h]
mov edi, 7Eh ; '~'
call mi_report_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
mov [rbp+var_4C8], 0
jmp short loc_C7F5D
loc_C7F15:
jmp short $+2
loc_C7F17:
mov rax, [rbp+var_4D8]
cmp rax, [rbp+var_508]
jb loc_C7E70
mov ecx, [rbp+var_4FC]
mov rax, [rbp+var_4E8]
mov [rax], ecx
mov rcx, [rbp+var_510]
mov rax, [rbp+var_4F0]
mov [rax], rcx
jmp short $+2
loc_C7F4D:
jmp short $+2
loc_C7F4F:
mov rax, [rbp+var_518]
mov [rbp+var_4C8], rax
loc_C7F5D:
mov rax, [rbp+var_4C8]
mov [rbp+var_520], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C7F8D
mov rax, [rbp+var_520]
add rsp, 520h
pop rbp
retn
loc_C7F8D:
call ___stack_chk_fail
|
unsigned __int16 * mi_find_last_pos(
long long a1,
unsigned __int16 *a2,
_BYTE *a3,
unsigned int *a4,
unsigned __int16 **a5)
{
const char *v5; // rsi
unsigned __int16 *v7; // [rsp+8h] [rbp-518h]
unsigned __int16 *v8; // [rsp+10h] [rbp-510h]
char *v9; // [rsp+18h] [rbp-508h]
unsigned long long v10; // [rsp+18h] [rbp-508h]
unsigned int v11; // [rsp+24h] [rbp-4FCh]
unsigned int v12; // [rsp+28h] [rbp-4F8h]
unsigned int v13; // [rsp+28h] [rbp-4F8h]
unsigned int v14; // [rsp+28h] [rbp-4F8h]
unsigned int v15; // [rsp+2Ch] [rbp-4F4h]
unsigned __int16 *v19; // [rsp+48h] [rbp-4D8h] BYREF
long long v20; // [rsp+50h] [rbp-4D0h]
_BYTE v22[1208]; // [rsp+60h] [rbp-4C0h] BYREF
unsigned long long v23; // [rsp+518h] [rbp-8h]
v23 = __readfsqword(0x28u);
v20 = a1;
v19 = a2;
v12 = (_byteswap_ushort(*a2) & 0x7FFF) - 2;
v19 = a2 + 1;
if ( (*(_WORD *)(a1 + 10) & 0x2E) != 0 )
{
v10 = (unsigned long long)v19 + v12 - 2;
*a3 = 0;
v14 = 0;
v8 = v19;
do
{
v7 = v8;
v8 = v19;
v11 = v14;
memcpy(a3, v22, v14);
v14 = (*(long long ( **)(long long, _QWORD, unsigned __int16 **, _BYTE *))(v20 + 72))(v20, 0LL, &v19, v22);
if ( !v14 )
{
v5 = *(const char **)(*(_QWORD *)v20 + 616LL);
mi_report_error(126, (long long)v5);
*(_DWORD *)my_thread_var(126LL, v5) = 126;
return 0LL;
}
}
while ( (unsigned long long)v19 < v10 );
*a4 = v11;
*a5 = v8;
return v7;
}
else
{
v15 = v12 / *(unsigned __int16 *)(v20 + 18) - 2;
v13 = *(unsigned __int16 *)(v20 + 18);
*a4 = v13;
v9 = (char *)v19 + v13 * v15;
*a5 = (unsigned __int16 *)&v9[v13];
memcpy(a3, v9, v13);
return (unsigned __int16 *)v9;
}
}
|
_mi_find_last_pos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x520
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x4d0],RDI
MOV qword ptr [RBP + -0x4d8],RSI
MOV qword ptr [RBP + -0x4e0],RDX
MOV qword ptr [RBP + -0x4e8],RCX
MOV qword ptr [RBP + -0x4f0],R8
MOV EAX,dword ptr [RBP + -0x4fc]
MOV dword ptr [RBP + -0x4fc],EAX
MOV dword ptr [RBP + -0x500],0x2
MOV RAX,qword ptr [RBP + -0x4d8]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x4d8]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
SUB EAX,dword ptr [RBP + -0x500]
MOV dword ptr [RBP + -0x4f8],EAX
MOV ECX,dword ptr [RBP + -0x500]
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x4d8],RAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOVZX EAX,word ptr [RAX + 0xa]
AND EAX,0x2e
CMP EAX,0x0
JNZ 0x001c7e25
MOV EAX,dword ptr [RBP + -0x4f8]
MOV RCX,qword ptr [RBP + -0x4d0]
MOVZX ECX,word ptr [RCX + 0x12]
XOR EDX,EDX
DIV ECX
SUB EAX,0x2
MOV dword ptr [RBP + -0x4f4],EAX
MOV RAX,qword ptr [RBP + -0x4d0]
MOVZX ECX,word ptr [RAX + 0x12]
MOV dword ptr [RBP + -0x4f8],ECX
MOV RAX,qword ptr [RBP + -0x4e8]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,dword ptr [RBP + -0x4f4]
IMUL ECX,dword ptr [RBP + -0x4f8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x508],RAX
MOV RCX,qword ptr [RBP + -0x508]
MOV EAX,dword ptr [RBP + -0x4f8]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x4f0]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x4e0]
MOV RSI,qword ptr [RBP + -0x508]
MOV EAX,dword ptr [RBP + -0x4f8]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x508]
MOV qword ptr [RBP + -0x4c8],RAX
JMP 0x001c7f5d
LAB_001c7e25:
MOV RAX,qword ptr [RBP + -0x4d8]
MOV ECX,dword ptr [RBP + -0x4f8]
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x500]
MOV EDX,ECX
XOR ECX,ECX
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x508],RAX
JMP 0x001c7e4e
LAB_001c7e4e:
MOV RAX,qword ptr [RBP + -0x4e0]
MOV byte ptr [RAX],0x0
MOV dword ptr [RBP + -0x4f8],0x0
MOV RAX,qword ptr [RBP + -0x4d8]
MOV qword ptr [RBP + -0x510],RAX
LAB_001c7e70:
MOV RAX,qword ptr [RBP + -0x510]
MOV qword ptr [RBP + -0x518],RAX
MOV RAX,qword ptr [RBP + -0x4d8]
MOV qword ptr [RBP + -0x510],RAX
MOV EAX,dword ptr [RBP + -0x4f8]
MOV dword ptr [RBP + -0x4fc],EAX
MOV RDI,qword ptr [RBP + -0x4e0]
LEA RSI,[RBP + -0x4c0]
MOV EAX,dword ptr [RBP + -0x4f8]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX + 0x48]
MOV RDI,qword ptr [RBP + -0x4d0]
LEA RCX,[RBP + -0x4c0]
XOR ESI,ESI
LEA RDX,[RBP + -0x4d8]
CALL RAX
MOV dword ptr [RBP + -0x4f8],EAX
CMP EAX,0x0
JNZ 0x001c7f15
MOV RAX,qword ptr [RBP + -0x4d0]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x268]
MOV EDI,0x7e
CALL 0x001ae570
CALL 0x001f60c0
MOV dword ptr [RAX],0x7e
MOV qword ptr [RBP + -0x4c8],0x0
JMP 0x001c7f5d
LAB_001c7f15:
JMP 0x001c7f17
LAB_001c7f17:
MOV RAX,qword ptr [RBP + -0x4d8]
CMP RAX,qword ptr [RBP + -0x508]
JC 0x001c7e70
MOV ECX,dword ptr [RBP + -0x4fc]
MOV RAX,qword ptr [RBP + -0x4e8]
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RBP + -0x510]
MOV RAX,qword ptr [RBP + -0x4f0]
MOV qword ptr [RAX],RCX
JMP 0x001c7f4d
LAB_001c7f4d:
JMP 0x001c7f4f
LAB_001c7f4f:
MOV RAX,qword ptr [RBP + -0x518]
MOV qword ptr [RBP + -0x4c8],RAX
LAB_001c7f5d:
MOV RAX,qword ptr [RBP + -0x4c8]
MOV qword ptr [RBP + -0x520],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c7f8d
MOV RAX,qword ptr [RBP + -0x520]
ADD RSP,0x520
POP RBP
RET
LAB_001c7f8d:
CALL 0x0012a270
|
byte * _mi_find_last_pos(long *param_1,byte *param_2,int1 *param_3,uint *param_4,
int8 *param_5)
{
ushort uVar1;
byte *pbVar2;
byte *pbVar3;
uint uVar4;
byte *pbVar5;
int4 *puVar6;
uint uVar7;
long in_FS_OFFSET;
byte *local_518;
uint local_500;
byte *local_4e0;
long *local_4d8;
byte *local_4d0;
int1 local_4c8 [1208];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = ((uint)param_2[1] | (*param_2 & 0x7f) << 8) - 2;
local_518 = param_2 + 2;
local_4e0 = local_518;
local_4d8 = param_1;
if ((*(ushort *)((long)param_1 + 10) & 0x2e) == 0) {
uVar1 = *(ushort *)((long)param_1 + 0x12);
uVar7 = (uint)*(ushort *)((long)param_1 + 0x12);
*param_4 = uVar7;
local_518 = local_518 + (uVar4 / uVar1 - 2) * uVar7;
*param_5 = local_518 + uVar7;
memcpy(param_3,local_518,(ulong)uVar7);
local_4d0 = local_518;
}
else {
pbVar5 = local_518 + ((ulong)uVar4 - 2);
*param_3 = 0;
local_500 = 0;
uVar4 = local_500;
do {
local_500 = uVar4;
pbVar3 = local_4e0;
pbVar2 = local_518;
local_518 = local_4e0;
memcpy(param_3,local_4c8,(ulong)local_500);
uVar4 = (*(code *)local_4d8[9])(local_4d8,0,&local_4e0,local_4c8);
if (uVar4 == 0) {
mi_report_error(0x7e,*(int8 *)(*local_4d8 + 0x268));
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x7e;
local_4d0 = (byte *)0x0;
goto LAB_001c7f5d;
}
} while (local_4e0 < pbVar5);
*param_4 = local_500;
*param_5 = pbVar3;
local_4d0 = pbVar2;
}
LAB_001c7f5d:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_4d0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
58,530
|
LefDefParser::lefwCaseSensitive(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwCaseSensitive(const char *caseSensitive)
{
lefwObsoleteNum = LEFW_CASESENSITIVE;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_INIT && lefwState < LEFW_END)
return LEFW_BAD_ORDER; // not of the ENDs
if (versionNum >= 5.6)
return LEFW_OBSOLETE;
if (lefwSynArray[LEFW_CASESENSITIVE])
return LEFW_ALREADY_DEFINED;
if (strcmp(caseSensitive, "ON") && strcmp(caseSensitive, "OFF"))
return LEFW_BAD_DATA; // has to be either ON or OFF
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "NAMESCASESENSITIVE %s ;\n", caseSensitive);
else
fprintf(lefwFile, "NAMESCASESENSITIVE %s ;\n", caseSensitive);
lefwSynArray[LEFW_CASESENSITIVE] = 1;
lefwLines++;
return LEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::lefwCaseSensitive(char const*):
pushq %r15
pushq %r14
pushq %rbx
movl $0x16, 0x1e5ff(%rip) # 0x24d48
leaq 0x1e6b0(%rip), %rax # 0x24e00
movq (%rax), %r14
testq %r14, %r14
je 0x6801
leaq 0x1e8f1(%rip), %rcx # 0x25054
movl $0x2, %eax
cmpl $0x0, (%rcx)
je 0x6806
leaq 0x1e8d8(%rip), %rcx # 0x25050
movl (%rcx), %ecx
cmpl $0x1, %ecx
setne %dl
cmpl $0x4f, %ecx
setl %cl
testb %cl, %dl
jne 0x6806
movsd 0x1e5ae(%rip), %xmm0 # 0x24d40
movl $0x7, %eax
ucomisd 0x12969(%rip), %xmm0 # 0x19108
jae 0x6806
leaq 0x1e668(%rip), %r15 # 0x24e10
movl $0x4, %eax
cmpl $0x0, 0x58(%r15)
jne 0x6806
movq %rdi, %rbx
cmpb $0x4f, (%rdi)
jne 0x67c8
cmpb $0x4e, 0x1(%rbx)
jne 0x67c8
cmpb $0x0, 0x2(%rbx)
je 0x67e2
leaq 0x1326c(%rip), %rsi # 0x19a3b
movq %rbx, %rdi
callq 0x10e0
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x6806
cmpb $0x1, 0x1e903(%rip) # 0x250ec
jne 0x680c
leaq 0x13997(%rip), %rsi # 0x1a189
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x18c35
jmp 0x6820
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x13976(%rip), %rsi # 0x1a189
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10f0
movl $0x1, 0x58(%r15)
leaq 0x1e81d(%rip), %rax # 0x2504c
incl (%rax)
xorl %eax, %eax
jmp 0x6806
|
_ZN12LefDefParser17lefwCaseSensitiveEPKc:
push r15
push r14
push rbx
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 16h; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov r14, [rax]
test r14, r14
jz loc_6801
lea rcx, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rcx], 0
jz loc_6806
lea rcx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rcx]
cmp ecx, 1
setnz dl
cmp ecx, 4Fh ; 'O'
setl cl
test dl, cl
jnz short loc_6806
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
mov eax, 7
ucomisd xmm0, cs:dbl_19108
jnb short loc_6806
lea r15, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
mov eax, 4
cmp dword ptr [r15+58h], 0
jnz short loc_6806
mov rbx, rdi
cmp byte ptr [rdi], 4Fh ; 'O'
jnz short loc_67C8
cmp byte ptr [rbx+1], 4Eh ; 'N'
jnz short loc_67C8
cmp byte ptr [rbx+2], 0
jz short loc_67E2
loc_67C8:
lea rsi, aOff; "OFF"
mov rdi, rbx
call _strcmp
mov ecx, eax
mov eax, 3
test ecx, ecx
jnz short loc_6806
loc_67E2:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_680C
lea rsi, aNamescasesensi; "NAMESCASESENSITIVE %s ;\n"
mov rdi, r14
mov rdx, rbx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_6820
loc_6801:
mov eax, 1
loc_6806:
pop rbx
pop r14
pop r15
retn
loc_680C:
lea rsi, aNamescasesensi; "NAMESCASESENSITIVE %s ;\n"
mov rdi, r14
mov rdx, rbx
xor eax, eax
call _fprintf
loc_6820:
mov dword ptr [r15+58h], 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
jmp short loc_6806
|
long long LefDefParser::lefwCaseSensitive(
LefDefParser *this,
const char *a2,
long long a3,
long long a4,
int a5,
int a6)
{
long long v6; // r14
long long result; // rax
int v8; // ecx
LefDefParser::lefwObsoleteNum = 22;
v6 = *(_QWORD *)&LefDefParser::lefwFile;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit )
{
v8 = LefDefParser::lefwState;
LOBYTE(v8) = LefDefParser::lefwState < 79;
if ( LefDefParser::lefwState >= 79 || LefDefParser::lefwState == 1 )
{
result = 7LL;
if ( *(double *)&LefDefParser::versionNum < 5.6 )
{
result = 4LL;
if ( !LefDefParser::lefwSynArray[22] )
{
if ( *(_BYTE *)this == 79 && *((_BYTE *)this + 1) == 78 && !*((_BYTE *)this + 2)
|| (v8 = strcmp(this, "OFF"), result = 3LL, !v8) )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(v6, (unsigned int)"NAMESCASESENSITIVE %s ;\n", (_DWORD)this, v8, a5, a6);
else
fprintf(v6, "NAMESCASESENSITIVE %s ;\n", (const char *)this);
LefDefParser::lefwSynArray[22] = 1;
++LefDefParser::lefwLines;
return 0LL;
}
}
}
}
}
return result;
}
|
lefwCaseSensitive:
PUSH R15
PUSH R14
PUSH RBX
MOV dword ptr [0x00124d48],0x16
LEA RAX,[0x124e00]
MOV R14,qword ptr [RAX]
TEST R14,R14
JZ 0x00106801
LEA RCX,[0x125054]
MOV EAX,0x2
CMP dword ptr [RCX],0x0
JZ 0x00106806
LEA RCX,[0x125050]
MOV ECX,dword ptr [RCX]
CMP ECX,0x1
SETNZ DL
CMP ECX,0x4f
SETL CL
TEST DL,CL
JNZ 0x00106806
MOVSD XMM0,qword ptr [0x00124d40]
MOV EAX,0x7
UCOMISD XMM0,qword ptr [0x00119108]
JNC 0x00106806
LEA R15,[0x124e10]
MOV EAX,0x4
CMP dword ptr [R15 + 0x58],0x0
JNZ 0x00106806
MOV RBX,RDI
CMP byte ptr [RDI],0x4f
JNZ 0x001067c8
CMP byte ptr [RBX + 0x1],0x4e
JNZ 0x001067c8
CMP byte ptr [RBX + 0x2],0x0
JZ 0x001067e2
LAB_001067c8:
LEA RSI,[0x119a3b]
MOV RDI,RBX
CALL 0x001010e0
MOV ECX,EAX
MOV EAX,0x3
TEST ECX,ECX
JNZ 0x00106806
LAB_001067e2:
CMP byte ptr [0x001250ec],0x1
JNZ 0x0010680c
LEA RSI,[0x11a189]
MOV RDI,R14
MOV RDX,RBX
XOR EAX,EAX
CALL 0x00118c35
JMP 0x00106820
LAB_00106801:
MOV EAX,0x1
LAB_00106806:
POP RBX
POP R14
POP R15
RET
LAB_0010680c:
LEA RSI,[0x11a189]
MOV RDI,R14
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001010f0
LAB_00106820:
MOV dword ptr [R15 + 0x58],0x1
LEA RAX,[0x12504c]
INC dword ptr [RAX]
XOR EAX,EAX
JMP 0x00106806
|
/* LefDefParser::lefwCaseSensitive(char const*) */
int8 LefDefParser::lefwCaseSensitive(char *param_1)
{
_IO_FILE *__stream;
int iVar1;
int8 uVar2;
__stream = lefwFile;
lefwObsoleteNum = 0x16;
if (lefwFile == (_IO_FILE *)0x0) {
uVar2 = 1;
}
else {
uVar2 = 2;
if ((((lefwDidInit != 0) && (lefwState == 1 || 0x4e < lefwState)) &&
(uVar2 = 7, versionNum < DAT_00119108)) && (uVar2 = 4, lefwSynArray._88_4_ == 0)) {
if ((((*param_1 != 'O') || (param_1[1] != 'N')) || (param_1[2] != '\0')) &&
(iVar1 = strcmp(param_1,"OFF"), iVar1 != 0)) {
return 3;
}
if (lefwWriteEncrypt == '\x01') {
encPrint(__stream,"NAMESCASESENSITIVE %s ;\n",param_1);
}
else {
fprintf(__stream,"NAMESCASESENSITIVE %s ;\n",param_1);
}
lefwSynArray._88_4_ = 1;
lefwLines = lefwLines + 1;
uVar2 = 0;
}
}
return uVar2;
}
|
|
58,531
|
has_path
|
eloqsql/mysys/my_getwd.c
|
my_bool has_path(const char *name)
{
return MY_TEST(strchr(name, FN_LIBCHAR))
#if FN_LIBCHAR != '/'
|| MY_TEST(strchr(name, '/'))
#endif
#ifdef FN_DEVCHAR
|| MY_TEST(strchr(name, FN_DEVCHAR))
#endif
;
}
|
O0
|
c
|
has_path:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x240f0
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
has_path:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strchr
mov rdx, rax
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
add rsp, 10h
pop rbp
retn
|
_BOOL8 has_path(long long a1)
{
return strchr(a1, 47LL) != 0;
}
|
has_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x001240f0
MOV RDX,RAX
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
ADD RSP,0x10
POP RBP
RET
|
bool has_path(char *param_1)
{
char *pcVar1;
pcVar1 = strchr(param_1,0x2f);
return pcVar1 != (char *)0x0;
}
|
|
58,532
|
ftxui::flex_grow(std::shared_ptr<ftxui::Node>)
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/flex.cpp
|
Element flex_grow(Element child) {
return std::make_shared<Flex>(function_flex_grow, std::move(child));
}
|
O1
|
cpp
|
ftxui::flex_grow(std::shared_ptr<ftxui::Node>):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rip), %rsi # 0x23a47
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x23876
movq (%r14), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
_ZN5ftxui9flex_growESt10shared_ptrINS_4NodeEE:
push r14
push rbx
sub rsp, 18h
mov rdx, rsi
mov rbx, rdi
lea rsi, _ZN5ftxui12_GLOBAL__N_118function_flex_growERNS_11RequirementE; ftxui::`anonymous namespace'::function_flex_grow(ftxui::Requirement &)
lea r14, [rsp+28h+var_20]
mov rdi, r14
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_14FlexEJRFvRNS0_11RequirementEESt10shared_ptrINS0_4NodeEEEES7_IT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node> &&)
mov rax, [r14]
mov [rbx], rax
xor eax, eax
mov [rbx+8], rax
mov rcx, [r14+8]
mov [r14+8], rax
mov [rbx+8], rcx
mov rax, rbx
add rsp, 18h
pop rbx
pop r14
retn
|
_QWORD * ftxui::flex_grow(_QWORD *a1, __int128 *a2)
{
_QWORD v3[4]; // [rsp+8h] [rbp-20h] BYREF
std::make_shared<ftxui::`anonymous namespace'::Flex,void (&)(ftxui::Requirement &),std::shared_ptr<ftxui::Node>>(
v3,
(long long)ftxui::`anonymous namespace'::function_flex_grow,
a2);
*a1 = v3[0];
a1[1] = 0LL;
a1[1] = v3[1];
return a1;
}
|
flex_grow:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[0x123a47]
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00123876
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* ftxui::flex_grow(std::shared_ptr<ftxui::Node>) */
int8 * ftxui::flex_grow(int8 *param_1)
{
int8 local_20;
int8 local_18;
std::
make_shared<ftxui::(anonymous_namespace)::Flex,void(&)(ftxui::Requirement&),std::shared_ptr<ftxui::Node>>
((_func_void_Requirement_ptr *)&local_20,
(shared_ptr *)(anonymous_namespace)::function_flex_grow);
*param_1 = local_20;
param_1[1] = 0;
param_1[1] = local_18;
return param_1;
}
|
|
58,533
|
ggml_compute_forward_exp
|
monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c
|
static void ggml_compute_forward_exp(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_exp_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
}
|
O0
|
c
|
ggml_compute_forward_exp:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x3c9cb
jmp 0x3c9ba
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3dd10
jmp 0x3c9e5
leaq 0x75188(%rip), %rdi # 0xb1b5a
movl $0x1b0f, %esi # imm = 0x1B0F
leaq 0x752e9(%rip), %rdx # 0xb1cc7
movb $0x0, %al
callq 0xd030
addq $0x18, %rsp
retq
nopw (%rax,%rax)
|
ggml_compute_forward_exp:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rax, [rsp+18h+var_10]
mov rax, [rax+98h]
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov eax, [rax]
test eax, eax
jnz short loc_3C9CB
jmp short $+2
loc_3C9BA:
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call ggml_compute_forward_exp_f32
jmp short loc_3C9E5
loc_3C9CB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1B0Fh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_3C9E5:
add rsp, 18h
retn
|
double ggml_compute_forward_exp(long long a1, long long a2)
{
double result; // xmm0_8
if ( **(_DWORD **)(a2 + 152) )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
6927LL,
"fatal error");
ggml_compute_forward_exp_f32(a1, a2);
return result;
}
|
ggml_compute_forward_exp:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x0013c9cb
JMP 0x0013c9ba
LAB_0013c9ba:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0013dd10
JMP 0x0013c9e5
LAB_0013c9cb:
LEA RDI,[0x1b1b5a]
MOV ESI,0x1b0f
LEA RDX,[0x1b1cc7]
MOV AL,0x0
CALL 0x0010d030
LAB_0013c9e5:
ADD RSP,0x18
RET
|
void ggml_compute_forward_exp(int8 param_1,long param_2)
{
if (**(int **)(param_2 + 0x98) == 0) {
ggml_compute_forward_exp_f32(param_1,param_2);
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x1b0f,"fatal error");
}
|
|
58,534
|
my_wildcmp_8bit_impl
|
eloqsql/strings/ctype-simple.c
|
static
int my_wildcmp_8bit_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* Ok if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared trough cmp */
cmp=likeconv(cs,cmp);
do
{
/*
Find the next character in the subject string equal to 'cmp', then
check recursively my_wildcmp_8bit_impl() for the pattern remainder.
*/
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1); /* 'cmp' was not found in the subject string */
{
int tmp=my_wildcmp_8bit_impl(cs,str,str_end,
wildstr,wildend,escape,w_one,
w_many, recurse_level+1);
if (tmp <= 0)
return(tmp);
}
/*
The recursion call did not match. But it returned 1, which means
the pattern remainder has some non-special characters.
Continue, there is a chance that we'll find another 'cmp'
at a different position in the subject string.
*/
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
}
|
O0
|
c
|
my_wildcmp_8bit_impl:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
leaq 0x3b40d1(%rip), %rax # 0x407ab8
cmpq $0x0, (%rax)
je 0x53a0d
leaq 0x3b40c4(%rip), %rax # 0x407ab8
movq (%rax), %rax
movl 0x20(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0x53a0d
movl $0x1, -0x4(%rbp)
jmp 0x53d3a
jmp 0x53a0f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x53d22
jmp 0x53a1f
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl 0x18(%rbp), %ecx
movb %al, -0x41(%rbp)
je 0x53a40
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x53a4c
jmp 0x53af6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x34(%rbp), %eax
jne 0x53a72
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x53a72
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x53abc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x53ac8
movl $0x1, -0x4(%rbp)
jmp 0x53d3a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x53aea
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x53d3a
movl $0x1, -0x38(%rbp)
jmp 0x53a1f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x53b64
jmp 0x53b04
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x53b19
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x53d3a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x53b4c
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x53b04
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x53b62
jmp 0x53d22
jmp 0x53b64
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x53d1d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x53bd8
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x18(%rbp), %eax
jne 0x53b98
jmp 0x53bca
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x53bc8
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x53bba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53d3a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x53bca
jmp 0x53bd8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x53b80
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x53bee
movl $0x0, -0x4(%rbp)
jmp 0x53d3a
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x53c04
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53d3a
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movzbl %al, %eax
cmpl -0x34(%rbp), %eax
jne 0x53c38
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x53c38
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movzbl -0x39(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x53c58
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x43(%rbp)
je 0x53c86
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x39(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x53c8f
jmp 0x53c9d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x53c58
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x53cbb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53d3a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movl 0x10(%rbp), %r11d
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
addl $0x1, %eax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x539b0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jg 0x53d04
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x53d3a
jmp 0x53d06
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x53c56
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53d3a
jmp 0x53a0f
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_wildcmp_8bit_impl:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_10]
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_34], r9d
mov [rbp+var_38], 0FFFFFFFFh
lea rax, my_string_stack_guard
cmp qword ptr [rax], 0
jz short loc_53A0D
lea rax, my_string_stack_guard
mov rax, [rax]
mov edi, [rbp+arg_10]
call rax
cmp eax, 0
jz short loc_53A0D
mov [rbp+var_4], 1
jmp loc_53D3A
loc_53A0D:
jmp short $+2
loc_53A0F:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz loc_53D22
jmp short $+2
loc_53A1F:
mov rax, [rbp+var_28]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, [rbp+arg_8]
mov [rbp+var_41], al
jz short loc_53A40
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setnz al
mov [rbp+var_41], al
loc_53A40:
mov al, [rbp+var_41]
test al, 1
jnz short loc_53A4C
jmp loc_53AF6
loc_53A4C:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+var_34]
jnz short loc_53A72
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_53A72
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_53A72:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_53ABC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_18]
mov rsi, rdx
add rsi, 1
mov [rbp+var_18], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_53AC8
loc_53ABC:
mov [rbp+var_4], 1
jmp loc_53D3A
loc_53AC8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_53AEA
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
setnz al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp loc_53D3A
loc_53AEA:
mov [rbp+var_38], 1
jmp loc_53A1F
loc_53AF6:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_53B64
jmp short $+2
loc_53B04:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_53B19
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
jmp loc_53D3A
loc_53B19:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
add rcx, 1
mov [rbp+var_28], rcx
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_42], al
jnb short loc_53B4C
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
setz al
mov [rbp+var_42], al
loc_53B4C:
mov al, [rbp+var_42]
test al, 1
jnz short loc_53B04
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_53B62
jmp loc_53D22
loc_53B62:
jmp short $+2
loc_53B64:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz loc_53D1D
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_53B80:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz short loc_53BD8
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_8]
jnz short loc_53B98
jmp short loc_53BCA
loc_53B98:
mov rax, [rbp+var_28]
movsx eax, byte ptr [rax]
cmp eax, [rbp+arg_0]
jnz short loc_53BC8
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_53BBA
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_53D3A
loc_53BBA:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_53BCA
loc_53BC8:
jmp short loc_53BD8
loc_53BCA:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_53B80
loc_53BD8:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnz short loc_53BEE
mov [rbp+var_4], 0
jmp loc_53D3A
loc_53BEE:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz short loc_53C04
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_53D3A
loc_53C04:
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_39], al
movzx eax, al
cmp eax, [rbp+var_34]
jnz short loc_53C38
mov rax, [rbp+var_28]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_53C38
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 1
mov [rbp+var_28], rcx
mov al, [rax+1]
mov [rbp+var_39], al
loc_53C38:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
movzx ecx, [rbp+var_39]
mov al, [rax+rcx]
mov [rbp+var_39], al
loc_53C56:
jmp short $+2
loc_53C58:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_43], al
jz short loc_53C86
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_39]
cmp eax, ecx
setnz al
mov [rbp+var_43], al
loc_53C86:
mov al, [rbp+var_43]
test al, 1
jnz short loc_53C8F
jmp short loc_53C9D
loc_53C8F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_53C58
loc_53C9D:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
cmp rax, [rbp+var_20]
jnz short loc_53CBB
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_53D3A
loc_53CBB:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_30]
mov r9d, [rbp+var_34]
mov r11d, [rbp+arg_0]
mov r10d, [rbp+arg_8]
mov eax, [rbp+arg_10]
add eax, 1
mov [rsp+60h+var_60], r11d
mov [rsp+60h+var_58], r10d
mov [rsp+60h+var_50], eax
call my_wildcmp_8bit_impl
mov [rbp+var_40], eax
cmp [rbp+var_40], 0
jg short loc_53D04
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp short loc_53D3A
loc_53D04:
jmp short $+2
loc_53D06:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnz loc_53C56
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_53D3A
loc_53D1D:
jmp loc_53A0F
loc_53D22:
mov rdx, [rbp+var_18]
mov rsi, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_53D3A:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long my_wildcmp_8bit_impl(
long long a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
char *a4,
char *a5,
int a6,
int a7,
int a8,
unsigned int a9)
{
char *v9; // rcx
unsigned __int8 *v10; // rdx
char *v11; // rax
unsigned __int8 *v12; // rax
bool v14; // [rsp+1Dh] [rbp-43h]
bool v15; // [rsp+1Eh] [rbp-42h]
bool v16; // [rsp+1Fh] [rbp-41h]
int v17; // [rsp+20h] [rbp-40h]
unsigned __int8 v18; // [rsp+27h] [rbp-39h]
unsigned __int8 v19; // [rsp+27h] [rbp-39h]
unsigned int v20; // [rsp+28h] [rbp-38h]
char *i; // [rsp+38h] [rbp-28h]
int v25; // [rsp+38h] [rbp-28h]
v20 = -1;
if ( my_string_stack_guard && (unsigned int)my_string_stack_guard(a9) )
{
return 1;
}
else
{
do
{
if ( a4 != a5 )
{
while ( 1 )
{
v16 = 0;
if ( *a4 != a8 )
v16 = *a4 != a7;
if ( !v16 )
break;
if ( *a4 == a6 && a4 + 1 != a5 )
++a4;
if ( a2 == a3 )
return 1;
v9 = a4++;
v10 = a2++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + (unsigned __int8)*v9) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v10) )
return 1;
if ( a4 == a5 )
return a2 != a3;
v20 = 1;
}
if ( *a4 != a7 )
continue;
do
{
if ( a2 == a3 )
return v20;
++a2;
++a4;
v15 = 0;
if ( a4 < a5 )
v15 = *a4 == a7;
}
while ( v15 );
if ( a4 != a5 )
continue;
}
return a2 != a3;
}
while ( *a4 != a8 );
for ( i = a4 + 1; i != a5; ++i )
{
if ( *i != a8 )
{
if ( *i != a7 )
break;
if ( a2 == a3 )
return (unsigned int)-1;
++a2;
}
}
if ( i == a5 )
{
return 0;
}
else if ( a2 == a3 )
{
return (unsigned int)-1;
}
else
{
v18 = *i;
if ( (unsigned __int8)*i == a6 && i + 1 != a5 )
{
v11 = i;
LODWORD(i) = (_DWORD)i + 1;
v18 = v11[1];
}
v25 = (_DWORD)i + 1;
v19 = *(_BYTE *)(*(_QWORD *)(a1 + 88) + v18);
do
{
while ( 1 )
{
v14 = 0;
if ( a2 != a3 )
v14 = *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a2) != v19;
if ( !v14 )
break;
++a2;
}
v12 = a2++;
if ( v12 == a3 )
return (unsigned int)-1;
v17 = my_wildcmp_8bit_impl(a1, (_DWORD)a2, (_DWORD)a3, v25, (_DWORD)a5, a6, a7, a8, a9 + 1);
if ( v17 <= 0 )
return (unsigned int)v17;
}
while ( a2 != a3 );
return (unsigned int)-1;
}
}
}
|
my_wildcmp_8bit_impl:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV dword ptr [RBP + -0x34],R9D
MOV dword ptr [RBP + -0x38],0xffffffff
LEA RAX,[0x507ab8]
CMP qword ptr [RAX],0x0
JZ 0x00153a0d
LEA RAX,[0x507ab8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + 0x20]
CALL RAX
CMP EAX,0x0
JZ 0x00153a0d
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00153d3a
LAB_00153a0d:
JMP 0x00153a0f
LAB_00153a0f:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00153d22
JMP 0x00153a1f
LAB_00153a1f:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,dword ptr [RBP + 0x18]
MOV byte ptr [RBP + -0x41],AL
JZ 0x00153a40
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_00153a40:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x00153a4c
JMP 0x00153af6
LAB_00153a4c:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00153a72
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00153a72
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00153a72:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x00153abc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x18],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00153ac8
LAB_00153abc:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00153d3a
LAB_00153ac8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00153aea
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00153d3a
LAB_00153aea:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00153a1f
LAB_00153af6:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x00153b64
JMP 0x00153b04
LAB_00153b04:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00153b19
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00153d3a
LAB_00153b19:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x42],AL
JNC 0x00153b4c
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
SETZ AL
MOV byte ptr [RBP + -0x42],AL
LAB_00153b4c:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x00153b04
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00153b62
JMP 0x00153d22
LAB_00153b62:
JMP 0x00153b64
LAB_00153b64:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x00153d1d
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00153b80:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00153bd8
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x18]
JNZ 0x00153b98
JMP 0x00153bca
LAB_00153b98:
MOV RAX,qword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX]
CMP EAX,dword ptr [RBP + 0x10]
JNZ 0x00153bc8
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00153bba
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00153d3a
LAB_00153bba:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00153bca
LAB_00153bc8:
JMP 0x00153bd8
LAB_00153bca:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00153b80
LAB_00153bd8:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00153bee
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00153d3a
LAB_00153bee:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00153c04
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00153d3a
LAB_00153c04:
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x39],AL
MOVZX EAX,AL
CMP EAX,dword ptr [RBP + -0x34]
JNZ 0x00153c38
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00153c38
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x28],RCX
MOV AL,byte ptr [RAX + 0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00153c38:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX ECX,byte ptr [RBP + -0x39]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x39],AL
LAB_00153c56:
JMP 0x00153c58
LAB_00153c58:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x43],AL
JZ 0x00153c86
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x39]
CMP EAX,ECX
SETNZ AL
MOV byte ptr [RBP + -0x43],AL
LAB_00153c86:
MOV AL,byte ptr [RBP + -0x43]
TEST AL,0x1
JNZ 0x00153c8f
JMP 0x00153c9d
LAB_00153c8f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00153c58
LAB_00153c9d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00153cbb
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00153d3a
LAB_00153cbb:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x30]
MOV R9D,dword ptr [RBP + -0x34]
MOV R11D,dword ptr [RBP + 0x10]
MOV R10D,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001539b0
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0x0
JG 0x00153d04
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00153d3a
LAB_00153d04:
JMP 0x00153d06
LAB_00153d06:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00153c56
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00153d3a
LAB_00153d1d:
JMP 0x00153a0f
LAB_00153d22:
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_00153d3a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
uint my_wildcmp_8bit_impl
(long param_1,byte *param_2,byte *param_3,byte *param_4,byte *param_5,uint param_6,
int param_7,int param_8,int param_9)
{
char cVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
bool bVar5;
byte local_41;
uint local_40;
byte *local_30;
byte *local_20;
uint local_c;
local_40 = 0xffffffff;
local_30 = param_4;
local_20 = param_2;
if ((my_string_stack_guard == (code *)0x0) ||
(iVar2 = (*my_string_stack_guard)(param_9), iVar2 == 0)) {
do {
if (local_30 == param_5) {
LAB_00153d22:
return (uint)(local_20 != param_3);
}
while( true ) {
bVar5 = false;
if ((char)*local_30 != param_8) {
bVar5 = (char)*local_30 != param_7;
}
if (!bVar5) break;
if (((int)(char)*local_30 == param_6) && (local_30 + 1 != param_5)) {
local_30 = local_30 + 1;
}
if (local_20 == param_3) {
return 1;
}
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_30) !=
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20)) {
return 1;
}
if (local_30 + 1 == param_5) {
return (uint)(local_20 + 1 != param_3);
}
local_40 = 1;
local_30 = local_30 + 1;
local_20 = local_20 + 1;
}
if ((char)*local_30 == param_7) {
do {
if (local_20 == param_3) {
return local_40;
}
local_20 = local_20 + 1;
local_30 = local_30 + 1;
bVar5 = false;
if (local_30 < param_5) {
bVar5 = (char)*local_30 == param_7;
}
} while (bVar5);
if (local_30 == param_5) goto LAB_00153d22;
}
} while ((char)*local_30 != param_8);
while (pbVar4 = local_30, local_30 = pbVar4 + 1, local_30 != param_5) {
if ((char)*local_30 != param_8) {
if ((char)*local_30 != param_7) break;
if (local_20 == param_3) {
return 0xffffffff;
}
local_20 = local_20 + 1;
}
}
if (local_30 == param_5) {
local_c = 0;
}
else if (local_20 == param_3) {
local_c = 0xffffffff;
}
else {
local_41 = *local_30;
if ((local_41 == param_6) && (pbVar4 + 2 != param_5)) {
local_30 = pbVar4 + 2;
local_41 = pbVar4[2];
}
cVar1 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)local_41);
do {
while( true ) {
bVar5 = false;
if (local_20 != param_3) {
bVar5 = *(char *)(*(long *)(param_1 + 0x58) + (ulong)*local_20) != cVar1;
}
if (!bVar5) break;
local_20 = local_20 + 1;
}
pbVar4 = local_20 + 1;
if (local_20 == param_3) {
return 0xffffffff;
}
uVar3 = my_wildcmp_8bit_impl
(param_1,pbVar4,param_3,local_30 + 1,param_5,param_6,param_7,param_8,
param_9 + 1);
if ((int)uVar3 < 1) {
return uVar3;
}
local_20 = pbVar4;
} while (pbVar4 != param_3);
local_c = 0xffffffff;
}
}
else {
local_c = 1;
}
return local_c;
}
|
|
58,535
|
JS_DefinePropertyValueStr
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_DefinePropertyValueStr(JSContext *ctx, JSValue this_obj,
const char *prop, JSValue val, int flags)
{
JSAtom atom;
int ret;
atom = JS_NewAtom(ctx, prop);
ret = JS_DefinePropertyValue(ctx, this_obj, atom, val, flags);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O0
|
c
|
JS_DefinePropertyValueStr:
subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x284c0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %ecx
movl 0x50(%rsp), %eax
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x28(%rsp), %r8
movq 0x30(%rsp), %r9
movl %eax, (%rsp)
callq 0x371b0
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x29040
movl 0x10(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
|
JS_DefinePropertyValueStr:
sub rsp, 48h
mov eax, [rsp+48h+arg_0]
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_8], rdx
mov [rsp+48h+var_20], r8
mov [rsp+48h+var_18], r9
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_30], rcx
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_30]
call JS_NewAtom
mov [rsp+48h+var_34], eax
mov rdi, [rsp+48h+var_28]
mov ecx, [rsp+48h+var_34]
mov eax, [rsp+48h+arg_0]
mov rsi, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
mov r8, [rsp+48h+var_20]
mov r9, [rsp+48h+var_18]
mov [rsp+48h+var_48], eax
call JS_DefinePropertyValue
mov [rsp+48h+var_38], eax
mov rdi, [rsp+48h+var_28]
mov esi, [rsp+48h+var_34]
call JS_FreeAtom
mov eax, [rsp+48h+var_38]
add rsp, 48h
retn
|
long long JS_DefinePropertyValueStr(
long long a1,
long long a2,
long long a3,
unsigned __int8 *a4,
_DWORD *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
int a15)
{
__m128 v15; // xmm4
__m128 v16; // xmm5
unsigned int v18; // [rsp+10h] [rbp-38h]
unsigned int v19; // [rsp+14h] [rbp-34h]
v19 = JS_NewAtom(a1, a4);
v18 = JS_DefinePropertyValue(a1, a2, a3, v19, a5, a6, a7, a8, a9, a10, v15, v16, a13, a14, a15);
JS_FreeAtom(a1, v19);
return v18;
}
|
JS_DefinePropertyValueStr:
SUB RSP,0x48
MOV EAX,dword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x28],R8
MOV qword ptr [RSP + 0x30],R9
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RCX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001284c0
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP + 0x28]
MOV R9,qword ptr [RSP + 0x30]
MOV dword ptr [RSP],EAX
CALL 0x001371b0
MOV dword ptr [RSP + 0x10],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x00129040
MOV EAX,dword ptr [RSP + 0x10]
ADD RSP,0x48
RET
|
int4
JS_DefinePropertyValueStr
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int4 param_7)
{
int4 uVar1;
int4 uVar2;
uVar1 = JS_NewAtom(param_1,param_4);
uVar2 = JS_DefinePropertyValue(param_1,param_2,param_3,uVar1,param_5,param_6,param_7);
JS_FreeAtom(param_1,uVar1);
return uVar2;
}
|
|
58,536
|
JS_DefinePropertyValueStr
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_DefinePropertyValueStr(JSContext *ctx, JSValue this_obj,
const char *prop, JSValue val, int flags)
{
JSAtom atom;
int ret;
atom = JS_NewAtom(ctx, prop);
ret = JS_DefinePropertyValue(ctx, this_obj, atom, val, flags);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O1
|
c
|
JS_DefinePropertyValueStr:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %rcx, %rdi
callq 0xe240
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1fdc0
movl %eax, %r15d
movl 0x40(%rsp), %eax
movl %eax, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r15d, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x26abb
movl %eax, %ebx
movq %rbp, %rdi
movl %r15d, %esi
callq 0x207d8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_DefinePropertyValueStr:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r9
mov r14, r8
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbp, rdi
mov rdi, rcx
call _strlen
mov rdi, rbp
mov rsi, r15
mov rdx, rax
call JS_NewAtomLen
mov r15d, eax
mov eax, [rsp+38h+arg_0]
mov [rsp+38h+var_38], eax
mov rdi, rbp
mov rsi, r13
mov rdx, r12
mov ecx, r15d
mov r8, r14
mov r9, rbx
call JS_DefinePropertyValue
mov ebx, eax
mov rdi, rbp
mov esi, r15d
call JS_FreeAtom
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long JS_DefinePropertyValueStr(
long long a1,
unsigned long long a2,
long long a3,
unsigned __int8 *a4,
_DWORD *a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
int a15)
{
unsigned __int8 *v17; // r15
long long v19; // rax
__m128 v20; // xmm4
__m128 v21; // xmm5
v17 = a4;
v19 = strlen(a4);
LODWORD(v17) = JS_NewAtomLen(a1, v17, v19);
LODWORD(a6) = JS_DefinePropertyValue(a1, a2, a3, (unsigned int)v17, a5, a6, a7, a8, a9, a10, v20, v21, a13, a14, a15);
JS_FreeAtom(a1, (int)v17);
return (unsigned int)a6;
}
| |||
58,537
|
httplib::detail::decode_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline std::string decode_url(const std::string &s,
bool convert_plus_to_space) {
std::string result;
for (size_t i = 0; i < s.size(); i++) {
if (s[i] == '%' && i + 1 < s.size()) {
if (s[i + 1] == 'u') {
auto val = 0;
if (from_hex_to_i(s, i + 2, 4, val)) {
// 4 digits Unicode codes
char buff[4];
size_t len = to_utf8(val, buff);
if (len > 0) { result.append(buff, len); }
i += 5; // 'u0000'
} else {
result += s[i];
}
} else {
auto val = 0;
if (from_hex_to_i(s, i + 1, 2, val)) {
// 2 digits hex codes
result += static_cast<char>(val);
i += 2; // '00'
} else {
result += s[i];
}
}
} else if (convert_plus_to_space && s[i] == '+') {
result += ' ';
} else {
result += s[i];
}
}
return result;
}
|
O2
|
c
|
httplib::detail::decode_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
pushq $0x20
popq %r13
movq 0x8(%r14), %rcx
cmpq %rcx, %r12
jae 0x29e42
movq (%r14), %rdx
movb (%rdx,%r12), %al
cmpb $0x25, %al
jne 0x29dcc
leaq 0x1(%r12), %rsi
cmpq %rcx, %rsi
jae 0x29ddf
cmpb $0x75, (%rdx,%rsi)
jne 0x29df2
andl $0x0, 0x10(%rsp)
leaq 0x2(%r12), %rsi
movq %r14, %rdi
pushq $0x4
popq %rdx
leaq 0x10(%rsp), %rcx
callq 0x29e6d
testb %al, %al
je 0x29e1e
movl 0x10(%rsp), %edi
leaq 0x14(%rsp), %r15
movq %r15, %rsi
callq 0x29ee1
testq %rax, %rax
je 0x29dc6
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xa090
addq $0x5, %r12
jmp 0x29dea
movzbl %al, %ecx
testb %bpl, %bpl
movl %ecx, %edx
cmovnel %r13d, %edx
cmpb $0x2b, %al
cmovnel %ecx, %edx
movl %edx, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa5c0
incq %r12
jmp 0x29d5c
andl $0x0, 0xc(%rsp)
movq %r14, %rdi
pushq $0x2
popq %rdx
leaq 0xc(%rsp), %rcx
callq 0x29e6d
testb %al, %al
je 0x29e30
movsbl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0xa5c0
addq $0x2, %r12
jmp 0x29dea
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0xa5c0
jmp 0x29dea
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0xa5c0
jmp 0x29dea
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29e5a
jmp 0x29e5a
jmp 0x29e5a
movq %rax, %r14
movq %rbx, %rdi
callq 0xac20
movq %r14, %rdi
callq 0xaac0
|
_ZN7httplib6detail10decode_urlERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
xor r12d, r12d
push 20h ; ' '
pop r13
loc_29D5C:
mov rcx, [r14+8]
cmp r12, rcx
jnb loc_29E42
mov rdx, [r14]
mov al, [rdx+r12]
cmp al, 25h ; '%'
jnz short loc_29DCC
lea rsi, [r12+1]
cmp rsi, rcx
jnb short loc_29DDF
cmp byte ptr [rdx+rsi], 75h ; 'u'
jnz short loc_29DF2
and dword ptr [rsp+48h+var_38], 0
lea rsi, [r12+2]
mov rdi, r14
push 4
pop rdx
lea rcx, [rsp+48h+var_38]
call _ZN7httplib6detail13from_hex_to_iERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmmRi; httplib::detail::from_hex_to_i(std::string const&,ulong,ulong,int &)
test al, al
jz short loc_29E1E
mov edi, dword ptr [rsp+48h+var_38]; this
lea r15, [rsp+48h+var_38+4]
mov rsi, r15; int
call _ZN7httplib6detail7to_utf8EiPc; httplib::detail::to_utf8(int,char *)
test rax, rax
jz short loc_29DC6
mov rdi, rbx
mov rsi, r15
mov rdx, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
loc_29DC6:
add r12, 5
jmp short loc_29DEA
loc_29DCC:
movzx ecx, al
test bpl, bpl
mov edx, ecx
cmovnz edx, r13d
cmp al, 2Bh ; '+'
cmovnz edx, ecx
mov eax, edx
loc_29DDF:
movsx esi, al
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
loc_29DEA:
inc r12
jmp loc_29D5C
loc_29DF2:
and [rsp+48h+var_3C], 0
mov rdi, r14
push 2
pop rdx
lea rcx, [rsp+48h+var_3C]
call _ZN7httplib6detail13from_hex_to_iERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmmRi; httplib::detail::from_hex_to_i(std::string const&,ulong,ulong,int &)
test al, al
jz short loc_29E30
movsx esi, byte ptr [rsp+48h+var_3C]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r12, 2
jmp short loc_29DEA
loc_29E1E:
mov rax, [r14]
movsx esi, byte ptr [rax+r12]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_29DEA
loc_29E30:
mov rax, [r14]
movsx esi, byte ptr [rax+r12]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_29DEA
loc_29E42:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_29E5A
jmp short loc_29E5A
jmp short $+2
loc_29E5A:
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
|
long long httplib::detail::decode_url(long long a1, _QWORD *a2, char a3)
{
unsigned long long i; // r12
unsigned long long v6; // rcx
char v7; // al
unsigned long long v8; // rsi
char *v9; // rdx
long long v10; // rax
char v11; // dl
int v13; // [rsp+Ch] [rbp-3Ch] BYREF
unsigned int v14; // [rsp+10h] [rbp-38h] BYREF
_BYTE v15[52]; // [rsp+14h] [rbp-34h] BYREF
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
for ( i = 0LL; ; ++i )
{
v6 = a2[1];
if ( i >= v6 )
break;
v7 = *(_BYTE *)(*a2 + i);
if ( v7 != 37 )
{
v11 = *(_BYTE *)(*a2 + i);
if ( a3 )
v11 = 32;
if ( v7 != 43 )
v11 = *(_BYTE *)(*a2 + i);
v7 = v11;
LABEL_15:
std::string::push_back(a1, (unsigned int)v7);
continue;
}
v8 = i + 1;
if ( i + 1 >= v6 )
goto LABEL_15;
if ( *(_BYTE *)(*a2 + v8) != 117 )
{
v13 = 0;
if ( (unsigned __int8)httplib::detail::from_hex_to_i(a2, v8, 2LL, &v13) )
{
std::string::push_back(a1, (unsigned int)(char)v13);
i += 2LL;
continue;
}
LABEL_19:
std::string::push_back(a1, (unsigned int)*(char *)(*a2 + i));
continue;
}
v14 = 0;
if ( !(unsigned __int8)httplib::detail::from_hex_to_i(a2, i + 2, 4LL, &v14) )
goto LABEL_19;
v10 = httplib::detail::to_utf8((httplib::detail *)v14, (int)v15, v9);
if ( v10 )
std::string::append(a1, v15, v10);
i += 5LL;
}
return a1;
}
|
decode_url:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
XOR R12D,R12D
PUSH 0x20
POP R13
LAB_00129d5c:
MOV RCX,qword ptr [R14 + 0x8]
CMP R12,RCX
JNC 0x00129e42
MOV RDX,qword ptr [R14]
MOV AL,byte ptr [RDX + R12*0x1]
CMP AL,0x25
JNZ 0x00129dcc
LEA RSI,[R12 + 0x1]
CMP RSI,RCX
JNC 0x00129ddf
CMP byte ptr [RDX + RSI*0x1],0x75
JNZ 0x00129df2
AND dword ptr [RSP + 0x10],0x0
LEA RSI,[R12 + 0x2]
LAB_00129d8e:
MOV RDI,R14
PUSH 0x4
POP RDX
LEA RCX,[RSP + 0x10]
CALL 0x00129e6d
TEST AL,AL
JZ 0x00129e1e
MOV EDI,dword ptr [RSP + 0x10]
LEA R15,[RSP + 0x14]
MOV RSI,R15
CALL 0x00129ee1
TEST RAX,RAX
JZ 0x00129dc6
LAB_00129db8:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RAX
CALL 0x0010a090
LAB_00129dc6:
ADD R12,0x5
JMP 0x00129dea
LAB_00129dcc:
MOVZX ECX,AL
TEST BPL,BPL
MOV EDX,ECX
CMOVNZ EDX,R13D
CMP AL,0x2b
CMOVNZ EDX,ECX
MOV EAX,EDX
LAB_00129ddf:
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x0010a5c0
LAB_00129dea:
INC R12
JMP 0x00129d5c
LAB_00129df2:
AND dword ptr [RSP + 0xc],0x0
LAB_00129df7:
MOV RDI,R14
PUSH 0x2
POP RDX
LEA RCX,[RSP + 0xc]
CALL 0x00129e6d
TEST AL,AL
JZ 0x00129e30
MOVSX ESI,byte ptr [RSP + 0xc]
MOV RDI,RBX
CALL 0x0010a5c0
ADD R12,0x2
JMP 0x00129dea
LAB_00129e1e:
MOV RAX,qword ptr [R14]
MOVSX ESI,byte ptr [RAX + R12*0x1]
LAB_00129e26:
MOV RDI,RBX
CALL 0x0010a5c0
JMP 0x00129dea
LAB_00129e30:
MOV RAX,qword ptr [R14]
MOVSX ESI,byte ptr [RAX + R12*0x1]
LAB_00129e38:
MOV RDI,RBX
CALL 0x0010a5c0
LAB_00129e40:
JMP 0x00129dea
LAB_00129e42:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::decode_url(std::__cxx11::string const&, bool) */
string * httplib::detail::decode_url(string *param_1,bool param_2)
{
ulong uVar1;
char cVar2;
long lVar3;
int7 in_register_00000031;
string *psVar4;
char cVar5;
ulong uVar6;
int local_3c;
int local_38;
char local_34 [4];
psVar4 = (string *)CONCAT71(in_register_00000031,param_2);
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
for (uVar6 = 0; uVar6 < *(ulong *)(psVar4 + 8); uVar6 = uVar6 + 1) {
cVar5 = (char)param_1;
if ((*(char *)(*(long *)psVar4 + uVar6) == '%') &&
(uVar1 = uVar6 + 1, uVar1 < *(ulong *)(psVar4 + 8))) {
if (*(char *)(*(long *)psVar4 + uVar1) == 'u') {
local_38 = 0;
/* try { // try from 00129d8e to 00129d9d has its CatchHandler @ 00129e56 */
cVar2 = from_hex_to_i(psVar4,uVar6 + 2,4,&local_38);
if (cVar2 == '\0') {
/* try { // try from 00129e26 to 00129e2d has its CatchHandler @ 00129e56 */
std::__cxx11::string::push_back(cVar5);
}
else {
lVar3 = to_utf8(local_38,local_34);
if (lVar3 != 0) {
/* try { // try from 00129db8 to 00129dc5 has its CatchHandler @ 00129e54 */
std::__cxx11::string::append((char *)param_1,(ulong)local_34);
}
uVar6 = uVar6 + 5;
}
}
else {
local_3c = 0;
/* try { // try from 00129df7 to 00129e17 has its CatchHandler @ 00129e58 */
cVar2 = from_hex_to_i(psVar4,uVar1,2,&local_3c);
if (cVar2 == '\0') {
/* try { // try from 00129e38 to 00129e3f has its CatchHandler @ 00129e58 */
std::__cxx11::string::push_back(cVar5);
}
else {
std::__cxx11::string::push_back(cVar5);
uVar6 = uVar6 + 2;
}
}
}
else {
/* try { // try from 00129ddf to 00129de9 has its CatchHandler @ 00129e5a */
std::__cxx11::string::push_back(cVar5);
}
}
return param_1;
}
|
|
58,538
|
init_partitioned_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
int init_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
int i;
size_t mem_per_cache;
size_t mem_decr;
int cnt;
SIMPLE_KEY_CACHE_CB *partition;
SIMPLE_KEY_CACHE_CB **partition_ptr;
uint partitions= keycache->partitions;
int blocks= 0;
DBUG_ENTER("partitioned_init_key_cache");
keycache->key_cache_block_size = key_cache_block_size;
if (keycache->key_cache_inited)
partition_ptr= keycache->partition_array;
else
{
if(!(partition_ptr=
(SIMPLE_KEY_CACHE_CB **) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB *) *
partitions, MYF(MY_WME))))
DBUG_RETURN(-1);
bzero(partition_ptr, sizeof(SIMPLE_KEY_CACHE_CB *) * partitions);
keycache->partition_array= partition_ptr;
}
mem_per_cache = use_mem / partitions;
mem_decr= mem_per_cache / 5;
for (i= 0; i < (int) partitions; i++)
{
my_bool key_cache_inited= keycache->key_cache_inited;
if (key_cache_inited)
partition= *partition_ptr;
else
{
if (!(partition=
(SIMPLE_KEY_CACHE_CB *) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB),
MYF(MY_WME))))
continue;
partition->key_cache_inited= 0;
}
cnt= init_simple_key_cache(partition, key_cache_block_size, mem_per_cache,
division_limit, age_threshold,
changed_blocks_hash_size);
if (cnt <= 0)
{
end_simple_key_cache(partition, 1);
if (!key_cache_inited)
{
my_free(partition);
partition= 0;
}
if ((i == 0 && cnt < 0) || i > 0)
{
/*
Here we have two cases:
1. i == 0 and cnt < 0
cnt < 0 => mem_per_cache is not big enough to allocate minimal
number of key blocks in the key cache of the partition.
Decrease the the number of the partitions by 1 and start again.
2. i > 0
There is not enough memory for one of the succeeding partitions.
Just skip this partition decreasing the number of partitions in
the key cache by one.
Do not change the value of mem_per_cache in both cases.
*/
if (key_cache_inited)
{
my_free(partition);
partition= 0;
if(key_cache_inited)
memmove(partition_ptr, partition_ptr+1,
sizeof(partition_ptr)*(partitions-i-1));
}
if (!--partitions)
break;
}
else
{
/*
We come here when i == 0 && cnt == 0.
cnt == 0 => the memory allocator fails to allocate a block of
memory of the size mem_per_cache. Decrease the value of
mem_per_cache without changing the current number of partitions
and start again. Make sure that such a decrease may happen not
more than 5 times in total.
*/
if (use_mem <= mem_decr)
break;
use_mem-= mem_decr;
}
i--;
mem_per_cache= use_mem/partitions;
continue;
}
else
{
blocks+= cnt;
*partition_ptr++= partition;
}
}
keycache->partitions= partitions= (uint) (partition_ptr-keycache->partition_array);
keycache->key_cache_mem_size= mem_per_cache * partitions;
for (i= 0; i < (int) partitions; i++)
keycache->partition_array[i]->hash_factor= partitions;
keycache->key_cache_inited= 1;
if (!partitions)
blocks= -1;
DBUG_RETURN(blocks);
}
|
O0
|
c
|
init_partitioned_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7be70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x7bec4
leaq 0x38aae1(%rip), %rax # 0x406958
movl (%rax), %edi
movl -0x5c(%rbp), %eax
movl %eax, %esi
shlq $0x3, %rsi
movl $0x10, %edx
callq 0x8a930
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x7bea4
jmp 0x7be98
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c0db
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x291f0
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl -0x5c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x5, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jge 0x7c05a
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x61(%rbp)
cmpb $0x0, -0x61(%rbp)
je 0x7bf15
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x7bf43
leaq 0x38aa3c(%rip), %rax # 0x406958
movl (%rax), %edi
movl $0x170, %esi # imm = 0x170
movl $0x10, %edx
callq 0x8a930
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x7bf3c
jmp 0x7c04c
movq -0x50(%rbp), %rax
movb $0x0, (%rax)
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x38(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
callq 0x79ba0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jg 0x7c02b
movq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x7acc0
cmpb $0x0, -0x61(%rbp)
jne 0x7bf90
movq -0x50(%rbp), %rdi
callq 0x8acb0
movq $0x0, -0x50(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x7bf9c
cmpl $0x0, -0x44(%rbp)
jl 0x7bfa2
cmpl $0x0, -0x30(%rbp)
jle 0x7bff5
cmpb $0x0, -0x61(%rbp)
je 0x7bfe3
movq -0x50(%rbp), %rdi
callq 0x8acb0
movq $0x0, -0x50(%rbp)
cmpb $0x0, -0x61(%rbp)
je 0x7bfe1
movq -0x58(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
movl -0x5c(%rbp), %eax
subl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x296b0
jmp 0x7bfe3
movl -0x5c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x5c(%rbp)
cmpl $0x0, %eax
jne 0x7bff3
jmp 0x7c05a
jmp 0x7c010
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x7c001
jmp 0x7c05a
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl -0x5c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
jmp 0x7c04c
movl -0x44(%rbp), %eax
addl -0x60(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x50(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x58(%rbp)
movq %rcx, (%rax)
jmp 0x7c04c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7beed
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %ecx
movl %ecx, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x38(%rbp), %rcx
movl -0x5c(%rbp), %eax
imulq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jge 0x7c0bf
movl -0x5c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x164(%rax)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7c093
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
cmpl $0x0, -0x5c(%rbp)
jne 0x7c0d3
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c0d5
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
init_partitioned_key_cache:
push rbp
mov rbp, rsp
sub rsp, 70h
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_2C], r9d
mov rax, [rbp+var_10]
mov eax, [rax+1Ch]
mov [rbp+var_5C], eax
mov [rbp+var_60], 0
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+18h], ecx
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_7BE70
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_58], rax
jmp short loc_7BEC4
loc_7BE70:
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov eax, [rbp+var_5C]
mov esi, eax
shl rsi, 3
mov edx, 10h
call my_malloc
mov [rbp+var_58], rax
cmp rax, 0
jnz short loc_7BEA4
jmp short $+2
loc_7BE98:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_7C0DB
loc_7BEA4:
mov rdi, [rbp+var_58]
mov eax, [rbp+var_5C]
mov edx, eax
shl rdx, 3
xor esi, esi
call _memset
mov rcx, [rbp+var_58]
mov rax, [rbp+var_10]
mov [rax+8], rcx
loc_7BEC4:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_5C]
xor edx, edx
div rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov ecx, 5
xor edx, edx
div rcx
mov [rbp+var_40], rax
mov [rbp+var_30], 0
loc_7BEED:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_5C]
jge loc_7C05A
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_61], al
cmp [rbp+var_61], 0
jz short loc_7BF15
mov rax, [rbp+var_58]
mov rax, [rax]
mov [rbp+var_50], rax
jmp short loc_7BF43
loc_7BF15:
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 170h
mov edx, 10h
call my_malloc
mov [rbp+var_50], rax
cmp rax, 0
jnz short loc_7BF3C
jmp loc_7C04C
loc_7BF3C:
mov rax, [rbp+var_50]
mov byte ptr [rax], 0
loc_7BF43:
mov rdi, [rbp+var_50]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_38]
mov ecx, [rbp+var_24]
mov r8d, [rbp+var_28]
mov r9d, [rbp+var_2C]
call init_simple_key_cache
mov [rbp+var_44], eax
cmp [rbp+var_44], 0
jg loc_7C02B
mov rdi, [rbp+var_50]
mov esi, 1
call end_simple_key_cache
cmp [rbp+var_61], 0
jnz short loc_7BF90
mov rdi, [rbp+var_50]
call my_free
mov [rbp+var_50], 0
loc_7BF90:
cmp [rbp+var_30], 0
jnz short loc_7BF9C
cmp [rbp+var_44], 0
jl short loc_7BFA2
loc_7BF9C:
cmp [rbp+var_30], 0
jle short loc_7BFF5
loc_7BFA2:
cmp [rbp+var_61], 0
jz short loc_7BFE3
mov rdi, [rbp+var_50]
call my_free
mov [rbp+var_50], 0
cmp [rbp+var_61], 0
jz short loc_7BFE1
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_58]
add rsi, 8
mov eax, [rbp+var_5C]
sub eax, [rbp+var_30]
sub eax, 1
mov eax, eax
mov edx, eax
shl rdx, 3
call _memmove
loc_7BFE1:
jmp short $+2
loc_7BFE3:
mov eax, [rbp+var_5C]
add eax, 0FFFFFFFFh
mov [rbp+var_5C], eax
cmp eax, 0
jnz short loc_7BFF3
jmp short loc_7C05A
loc_7BFF3:
jmp short loc_7C010
loc_7BFF5:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
ja short loc_7C001
jmp short loc_7C05A
loc_7C001:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
loc_7C010:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_5C]
xor edx, edx
div rcx
mov [rbp+var_38], rax
jmp short loc_7C04C
loc_7C02B:
mov eax, [rbp+var_44]
add eax, [rbp+var_60]
mov [rbp+var_60], eax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_58]
mov rdx, rax
add rdx, 8
mov [rbp+var_58], rdx
mov [rax], rcx
jmp short $+2
loc_7C04C:
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp loc_7BEED
loc_7C05A:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rax, rcx
sar rax, 3
mov ecx, eax
mov [rbp+var_5C], ecx
mov rax, [rbp+var_10]
mov [rax+1Ch], ecx
mov rcx, [rbp+var_38]
mov eax, [rbp+var_5C]
imul rcx, rax
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov [rbp+var_30], 0
loc_7C093:
mov eax, [rbp+var_30]
cmp eax, [rbp+var_5C]
jge short loc_7C0BF
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rdx, [rbp+var_30]
mov rax, [rax+rdx*8]
mov [rax+164h], ecx
mov eax, [rbp+var_30]
add eax, 1
mov [rbp+var_30], eax
jmp short loc_7C093
loc_7C0BF:
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
cmp [rbp+var_5C], 0
jnz short loc_7C0D3
mov [rbp+var_60], 0FFFFFFFFh
loc_7C0D3:
jmp short $+2
loc_7C0D5:
mov eax, [rbp+var_60]
mov [rbp+var_4], eax
loc_7C0DB:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long init_partitioned_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
int inited; // eax
long long *v7; // rax
char v9; // [rsp+Fh] [rbp-61h]
unsigned int v10; // [rsp+10h] [rbp-60h]
unsigned int v11; // [rsp+14h] [rbp-5Ch]
unsigned int v12; // [rsp+14h] [rbp-5Ch]
long long *v13; // [rsp+18h] [rbp-58h]
_BYTE *v14; // [rsp+20h] [rbp-50h]
int v15; // [rsp+2Ch] [rbp-44h]
unsigned long long v16; // [rsp+30h] [rbp-40h]
unsigned long long v17; // [rsp+38h] [rbp-38h]
int i; // [rsp+40h] [rbp-30h]
int j; // [rsp+40h] [rbp-30h]
v11 = *((_DWORD *)a1 + 7);
v10 = 0;
*((_DWORD *)a1 + 6) = a2;
if ( *a1 )
{
v13 = (long long *)*((_QWORD *)a1 + 1);
}
else
{
v13 = (long long *)my_malloc(key_memory_KEY_CACHE, 8LL * v11, 16LL);
if ( !v13 )
return (unsigned int)-1;
memset(v13, 0LL, 8LL * v11);
*((_QWORD *)a1 + 1) = v13;
}
v17 = a3 / v11;
v16 = v17 / 5;
for ( i = 0; i < (int)v11; ++i )
{
v9 = *a1;
if ( *a1 )
{
v14 = (_BYTE *)*v13;
inited = init_simple_key_cache(*v13, a2, v17, a4, a5, a6);
}
else
{
v14 = (_BYTE *)my_malloc(key_memory_KEY_CACHE, 368LL, 16LL);
if ( !v14 )
continue;
*v14 = 0;
inited = init_simple_key_cache((long long)v14, a2, v17, a4, a5, a6);
}
v15 = inited;
if ( inited > 0 )
{
v10 += inited;
v7 = v13++;
*v7 = (long long)v14;
}
else
{
end_simple_key_cache((long long)v14, 1);
if ( !v9 )
{
my_free(v14);
v14 = 0LL;
}
if ( (i || v15 >= 0) && i <= 0 )
{
if ( a3 <= v16 )
break;
a3 -= v16;
}
else
{
if ( v9 )
{
my_free(v14);
memmove(v13, v13 + 1, 8LL * (v11 - i - 1));
}
if ( !--v11 )
break;
}
--i;
v17 = a3 / v11;
}
}
v12 = ((long long)v13 - *((_QWORD *)a1 + 1)) >> 3;
*((_DWORD *)a1 + 7) = v12;
*((_QWORD *)a1 + 2) = v12 * v17;
for ( j = 0; j < (int)v12; ++j )
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL * j) + 356LL) = v12;
*a1 = 1;
if ( !v12 )
return (unsigned int)-1;
return v10;
}
|
init_partitioned_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
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 dword ptr [RBP + -0x2c],R9D
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x5c],EAX
MOV dword ptr [RBP + -0x60],0x0
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x18],ECX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0017be70
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0017bec4
LAB_0017be70:
LEA RAX,[0x506958]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x5c]
MOV ESI,EAX
SHL RSI,0x3
MOV EDX,0x10
CALL 0x0018a930
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JNZ 0x0017bea4
JMP 0x0017be98
LAB_0017be98:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017c0db
LAB_0017bea4:
MOV RDI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x5c]
MOV EDX,EAX
SHL RDX,0x3
XOR ESI,ESI
CALL 0x001291f0
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_0017bec4:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x5c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,0x5
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x30],0x0
LAB_0017beed:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x5c]
JGE 0x0017c05a
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x61],AL
CMP byte ptr [RBP + -0x61],0x0
JZ 0x0017bf15
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0017bf43
LAB_0017bf15:
LEA RAX,[0x506958]
MOV EDI,dword ptr [RAX]
MOV ESI,0x170
MOV EDX,0x10
CALL 0x0018a930
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JNZ 0x0017bf3c
JMP 0x0017c04c
LAB_0017bf3c:
MOV RAX,qword ptr [RBP + -0x50]
MOV byte ptr [RAX],0x0
LAB_0017bf43:
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8D,dword ptr [RBP + -0x28]
MOV R9D,dword ptr [RBP + -0x2c]
CALL 0x00179ba0
MOV dword ptr [RBP + -0x44],EAX
CMP dword ptr [RBP + -0x44],0x0
JG 0x0017c02b
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,0x1
CALL 0x0017acc0
CMP byte ptr [RBP + -0x61],0x0
JNZ 0x0017bf90
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0018acb0
MOV qword ptr [RBP + -0x50],0x0
LAB_0017bf90:
CMP dword ptr [RBP + -0x30],0x0
JNZ 0x0017bf9c
CMP dword ptr [RBP + -0x44],0x0
JL 0x0017bfa2
LAB_0017bf9c:
CMP dword ptr [RBP + -0x30],0x0
JLE 0x0017bff5
LAB_0017bfa2:
CMP byte ptr [RBP + -0x61],0x0
JZ 0x0017bfe3
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x0018acb0
MOV qword ptr [RBP + -0x50],0x0
CMP byte ptr [RBP + -0x61],0x0
JZ 0x0017bfe1
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x8
MOV EAX,dword ptr [RBP + -0x5c]
SUB EAX,dword ptr [RBP + -0x30]
SUB EAX,0x1
MOV EAX,EAX
MOV EDX,EAX
SHL RDX,0x3
CALL 0x001296b0
LAB_0017bfe1:
JMP 0x0017bfe3
LAB_0017bfe3:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x5c],EAX
CMP EAX,0x0
JNZ 0x0017bff3
JMP 0x0017c05a
LAB_0017bff3:
JMP 0x0017c010
LAB_0017bff5:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x0017c001
JMP 0x0017c05a
LAB_0017c001:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_0017c010:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x5c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0017c04c
LAB_0017c02b:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x60],EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x58],RDX
MOV qword ptr [RAX],RCX
JMP 0x0017c04c
LAB_0017c04c:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0017beed
LAB_0017c05a:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RAX,RCX
SAR RAX,0x3
MOV ECX,EAX
MOV dword ptr [RBP + -0x5c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x1c],ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x5c]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV dword ptr [RBP + -0x30],0x0
LAB_0017c093:
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x5c]
JGE 0x0017c0bf
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + RDX*0x8]
MOV dword ptr [RAX + 0x164],ECX
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0017c093
LAB_0017c0bf:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
CMP dword ptr [RBP + -0x5c],0x0
JNZ 0x0017c0d3
MOV dword ptr [RBP + -0x60],0xffffffff
LAB_0017c0d3:
JMP 0x0017c0d5
LAB_0017c0d5:
MOV EAX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017c0db:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int init_partitioned_key_cache
(char *param_1,int4 param_2,ulong param_3,int4 param_4,int4 param_5,
int4 param_6)
{
char cVar1;
int iVar2;
ulong uVar3;
int local_68;
uint local_64;
int8 *local_60;
int1 *local_58;
ulong local_40;
int local_38;
ulong local_28;
local_64 = *(uint *)(param_1 + 0x1c);
local_68 = 0;
*(int4 *)(param_1 + 0x18) = param_2;
if (*param_1 == '\0') {
local_60 = (int8 *)my_malloc(key_memory_KEY_CACHE,(ulong)local_64 << 3,0x10);
if (local_60 == (int8 *)0x0) {
return -1;
}
memset(local_60,0,(ulong)local_64 << 3);
*(int8 **)(param_1 + 8) = local_60;
}
else {
local_60 = *(int8 **)(param_1 + 8);
}
local_40 = param_3 / local_64;
uVar3 = local_40 / 5;
local_28 = param_3;
for (local_38 = 0; local_38 < (int)local_64; local_38 = local_38 + 1) {
cVar1 = *param_1;
if (cVar1 == '\0') {
local_58 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x170,0x10);
if (local_58 != (int1 *)0x0) {
*local_58 = 0;
goto LAB_0017bf43;
}
}
else {
local_58 = (int1 *)*local_60;
LAB_0017bf43:
iVar2 = init_simple_key_cache(local_58,param_2,local_40,param_4,param_5,param_6);
if (iVar2 < 1) {
end_simple_key_cache(local_58,1);
if (cVar1 == '\0') {
my_free(local_58);
local_58 = (int1 *)0x0;
}
if (((local_38 == 0) && (iVar2 < 0)) || (0 < local_38)) {
if ((cVar1 != '\0') && (my_free(local_58), cVar1 != '\0')) {
memmove(local_60,local_60 + 1,(ulong)((local_64 - local_38) - 1) << 3);
}
local_64 = local_64 - 1;
if (local_64 == 0) break;
}
else {
if (local_28 <= uVar3) break;
local_28 = local_28 - uVar3;
}
local_38 = local_38 + -1;
local_40 = local_28 / local_64;
}
else {
local_68 = iVar2 + local_68;
*local_60 = local_58;
local_60 = local_60 + 1;
}
}
}
uVar3 = (long)local_60 - *(long *)(param_1 + 8) >> 3;
iVar2 = (int)uVar3;
*(int *)(param_1 + 0x1c) = iVar2;
*(ulong *)(param_1 + 0x10) = local_40 * (uVar3 & 0xffffffff);
for (local_38 = 0; local_38 < iVar2; local_38 = local_38 + 1) {
*(int *)(*(long *)(*(long *)(param_1 + 8) + (long)local_38 * 8) + 0x164) = iVar2;
}
*param_1 = '\x01';
if (iVar2 == 0) {
local_68 = -1;
}
return local_68;
}
|
|
58,539
|
init_partitioned_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
int init_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
uint key_cache_block_size,
size_t use_mem, uint division_limit,
uint age_threshold, uint changed_blocks_hash_size)
{
int i;
size_t mem_per_cache;
size_t mem_decr;
int cnt;
SIMPLE_KEY_CACHE_CB *partition;
SIMPLE_KEY_CACHE_CB **partition_ptr;
uint partitions= keycache->partitions;
int blocks= 0;
DBUG_ENTER("partitioned_init_key_cache");
keycache->key_cache_block_size = key_cache_block_size;
if (keycache->key_cache_inited)
partition_ptr= keycache->partition_array;
else
{
if(!(partition_ptr=
(SIMPLE_KEY_CACHE_CB **) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB *) *
partitions, MYF(MY_WME))))
DBUG_RETURN(-1);
bzero(partition_ptr, sizeof(SIMPLE_KEY_CACHE_CB *) * partitions);
keycache->partition_array= partition_ptr;
}
mem_per_cache = use_mem / partitions;
mem_decr= mem_per_cache / 5;
for (i= 0; i < (int) partitions; i++)
{
my_bool key_cache_inited= keycache->key_cache_inited;
if (key_cache_inited)
partition= *partition_ptr;
else
{
if (!(partition=
(SIMPLE_KEY_CACHE_CB *) my_malloc(key_memory_KEY_CACHE,
sizeof(SIMPLE_KEY_CACHE_CB),
MYF(MY_WME))))
continue;
partition->key_cache_inited= 0;
}
cnt= init_simple_key_cache(partition, key_cache_block_size, mem_per_cache,
division_limit, age_threshold,
changed_blocks_hash_size);
if (cnt <= 0)
{
end_simple_key_cache(partition, 1);
if (!key_cache_inited)
{
my_free(partition);
partition= 0;
}
if ((i == 0 && cnt < 0) || i > 0)
{
/*
Here we have two cases:
1. i == 0 and cnt < 0
cnt < 0 => mem_per_cache is not big enough to allocate minimal
number of key blocks in the key cache of the partition.
Decrease the the number of the partitions by 1 and start again.
2. i > 0
There is not enough memory for one of the succeeding partitions.
Just skip this partition decreasing the number of partitions in
the key cache by one.
Do not change the value of mem_per_cache in both cases.
*/
if (key_cache_inited)
{
my_free(partition);
partition= 0;
if(key_cache_inited)
memmove(partition_ptr, partition_ptr+1,
sizeof(partition_ptr)*(partitions-i-1));
}
if (!--partitions)
break;
}
else
{
/*
We come here when i == 0 && cnt == 0.
cnt == 0 => the memory allocator fails to allocate a block of
memory of the size mem_per_cache. Decrease the value of
mem_per_cache without changing the current number of partitions
and start again. Make sure that such a decrease may happen not
more than 5 times in total.
*/
if (use_mem <= mem_decr)
break;
use_mem-= mem_decr;
}
i--;
mem_per_cache= use_mem/partitions;
continue;
}
else
{
blocks+= cnt;
*partition_ptr++= partition;
}
}
keycache->partitions= partitions= (uint) (partition_ptr-keycache->partition_array);
keycache->key_cache_mem_size= mem_per_cache * partitions;
for (i= 0; i < (int) partitions; i++)
keycache->partition_array[i]->hash_factor= partitions;
keycache->key_cache_inited= 1;
if (!partitions)
blocks= -1;
DBUG_RETURN(blocks);
}
|
O3
|
c
|
init_partitioned_key_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x60(%rbp)
movl %r8d, -0x5c(%rbp)
movl %ecx, -0x58(%rbp)
movl 0x1c(%rdi), %r14d
movl %esi, -0x54(%rbp)
movl %esi, 0x18(%rdi)
cmpb $0x0, (%rdi)
movq %rdi, -0x38(%rbp)
je 0x58d18
movq %rdi, %r15
movq 0x8(%rdi), %r12
jmp 0x58d5d
movq %rdx, %rbx
leaq 0x35ff16(%rip), %rax # 0x3b8c38
movl (%rax), %edi
leaq (,%r14,8), %r15
movl $0x10, %edx
movq %r15, %rsi
callq 0x60401
testq %rax, %rax
je 0x58f26
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x281f0
movq -0x38(%rbp), %r15
movq %r12, 0x8(%r15)
movq %rbx, %rdx
xorl %edi, %edi
movq %rdx, -0x40(%rbp)
movq %rdx, %rax
xorl %edx, %edx
divq %r14
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rax, -0x50(%rbp)
mulq %rcx
testl %r14d, %r14d
jle 0x58ece
shrq $0x2, %rdx
movq %rdx, -0x68(%rbp)
movq $0x0, -0x48(%rbp)
xorl %ebx, %ebx
movb (%r15), %r13b
testb %r13b, %r13b
movq %r12, -0x30(%rbp)
je 0x58da9
movq (%r12), %r12
jmp 0x58dd0
leaq 0x35fe88(%rip), %rax # 0x3b8c38
movl (%rax), %edi
movl $0x170, %esi # imm = 0x170
movl $0x10, %edx
callq 0x60401
testq %rax, %rax
je 0x58e5a
movq %rax, %r12
movb $0x0, (%rax)
movq %r12, %rdi
movl -0x54(%rbp), %esi
movq -0x50(%rbp), %rdx
movl -0x58(%rbp), %ecx
movl -0x5c(%rbp), %r8d
movl -0x60(%rbp), %r9d
callq 0x57305
movl %eax, %r15d
testl %eax, %eax
jle 0x58e13
movq -0x48(%rbp), %rax
addl %r15d, %eax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movq %rax, %r12
addq $0x8, %r12
movq -0x38(%rbp), %r15
jmp 0x58eb6
movq %r12, %rdi
movl $0x1, %esi
callq 0x58206
testb %r13b, %r13b
je 0x58e60
testl %ebx, %ebx
sete %al
testl %r15d, %r15d
setne %cl
testl %ebx, %ebx
jg 0x58e38
andb %cl, %al
je 0x58e7b
movq %r12, %rdi
callq 0x6062e
movq -0x30(%rbp), %rdi
leaq 0x8(%rdi), %rsi
movl %ebx, %edx
notl %edx
addl %r14d, %edx
shlq $0x3, %rdx
callq 0x286f0
jmp 0x58e93
movq -0x30(%rbp), %r12
jmp 0x58eb6
movq %r12, %rdi
callq 0x6062e
testl %ebx, %ebx
sete %al
testl %r15d, %r15d
setne %cl
testl %ebx, %ebx
jg 0x58e93
andb %cl, %al
jne 0x58e93
movq -0x40(%rbp), %rax
subq -0x68(%rbp), %rax
movq -0x38(%rbp), %r15
jbe 0x58f2d
movq -0x30(%rbp), %r12
jmp 0x58ea4
decl %r14d
movq -0x38(%rbp), %r15
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %r12
je 0x58ec1
decl %ebx
movl %r14d, %ecx
movq %rax, -0x40(%rbp)
xorl %edx, %edx
divq %rcx
movq %rax, -0x50(%rbp)
incl %ebx
cmpl %r14d, %ebx
jl 0x58d97
movq %r12, %rcx
movq 0x8(%r15), %r12
movq -0x48(%rbp), %rdi
jmp 0x58ed1
movq %r12, %rcx
subq %r12, %rcx
shrq $0x3, %rcx
movl %ecx, 0x1c(%r15)
movl %ecx, %eax
imulq -0x50(%rbp), %rax
movq %rax, 0x10(%r15)
testl %ecx, %ecx
jle 0x58f0a
movl %ecx, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %edx, %edx
movq 0x8(%r15), %rsi
movq (%rsi,%rdx,8), %rsi
movl %ecx, 0x164(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x58ef4
movb $0x1, (%r15)
xorl %eax, %eax
cmpl $0x1, %ecx
sbbl %eax, %eax
orl %edi, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x58f17
movq -0x30(%rbp), %r12
jmp 0x58ec1
|
init_partitioned_key_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_60], r9d
mov [rbp+var_5C], r8d
mov [rbp+var_58], ecx
mov r14d, [rdi+1Ch]
mov [rbp+var_54], esi
mov [rdi+18h], esi
cmp byte ptr [rdi], 0
mov [rbp+var_38], rdi
jz short loc_58D18
mov r15, rdi
mov r12, [rdi+8]
jmp short loc_58D5D
loc_58D18:
mov rbx, rdx
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
lea r15, ds:0[r14*8]
mov edx, 10h
mov rsi, r15
call my_malloc
test rax, rax
jz loc_58F26
mov r12, rax
mov rdi, rax
xor esi, esi
mov rdx, r15
call _memset
mov r15, [rbp+var_38]
mov [r15+8], r12
mov rdx, rbx
loc_58D5D:
xor edi, edi
mov [rbp+var_40], rdx
mov rax, rdx
xor edx, edx
div r14
mov rcx, 0CCCCCCCCCCCCCCCDh
mov [rbp+var_50], rax
mul rcx
test r14d, r14d
jle loc_58ECE
shr rdx, 2
mov [rbp+var_68], rdx
mov [rbp+var_48], 0
xor ebx, ebx
loc_58D97:
mov r13b, [r15]
test r13b, r13b
mov [rbp+var_30], r12
jz short loc_58DA9
mov r12, [r12]
jmp short loc_58DD0
loc_58DA9:
lea rax, key_memory_KEY_CACHE
mov edi, [rax]
mov esi, 170h
mov edx, 10h
call my_malloc
test rax, rax
jz loc_58E5A
mov r12, rax
mov byte ptr [rax], 0
loc_58DD0:
mov rdi, r12
mov esi, [rbp+var_54]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_58]
mov r8d, [rbp+var_5C]
mov r9d, [rbp+var_60]
call init_simple_key_cache
mov r15d, eax
test eax, eax
jle short loc_58E13
mov rax, [rbp+var_48]
add eax, r15d
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
mov [rax], r12
mov r12, rax
add r12, 8
mov r15, [rbp+var_38]
jmp loc_58EB6
loc_58E13:
mov rdi, r12
mov esi, 1
call end_simple_key_cache
test r13b, r13b
jz short loc_58E60
test ebx, ebx
setz al
test r15d, r15d
setnz cl
test ebx, ebx
jg short loc_58E38
and al, cl
jz short loc_58E7B
loc_58E38:
mov rdi, r12
call my_free
mov rdi, [rbp+var_30]
lea rsi, [rdi+8]
mov edx, ebx
not edx
add edx, r14d
shl rdx, 3
call _memmove
jmp short loc_58E93
loc_58E5A:
mov r12, [rbp+var_30]
jmp short loc_58EB6
loc_58E60:
mov rdi, r12
call my_free
test ebx, ebx
setz al
test r15d, r15d
setnz cl
test ebx, ebx
jg short loc_58E93
and al, cl
jnz short loc_58E93
loc_58E7B:
mov rax, [rbp+var_40]
sub rax, [rbp+var_68]
mov r15, [rbp+var_38]
jbe loc_58F2D
mov r12, [rbp+var_30]
jmp short loc_58EA4
loc_58E93:
dec r14d
mov r15, [rbp+var_38]
mov rax, [rbp+var_40]
mov r12, [rbp+var_30]
jz short loc_58EC1
loc_58EA4:
dec ebx
mov ecx, r14d
mov [rbp+var_40], rax
xor edx, edx
div rcx
mov [rbp+var_50], rax
loc_58EB6:
inc ebx
cmp ebx, r14d
jl loc_58D97
loc_58EC1:
mov rcx, r12
mov r12, [r15+8]
mov rdi, [rbp+var_48]
jmp short loc_58ED1
loc_58ECE:
mov rcx, r12
loc_58ED1:
sub rcx, r12
shr rcx, 3
mov [r15+1Ch], ecx
mov eax, ecx
imul rax, [rbp+var_50]
mov [r15+10h], rax
test ecx, ecx
jle short loc_58F0A
mov eax, ecx
and eax, 7FFFFFFFh
xor edx, edx
loc_58EF4:
mov rsi, [r15+8]
mov rsi, [rsi+rdx*8]
mov [rsi+164h], ecx
inc rdx
cmp rax, rdx
jnz short loc_58EF4
loc_58F0A:
mov byte ptr [r15], 1
xor eax, eax
cmp ecx, 1
sbb eax, eax
or eax, edi
loc_58F17:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_58F26:
mov eax, 0FFFFFFFFh
jmp short loc_58F17
loc_58F2D:
mov r12, [rbp+var_30]
jmp short loc_58EC1
|
long long init_partitioned_key_cache(
char *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6)
{
unsigned long long v6; // r14
char *v7; // r15
char **v8; // r12
unsigned long long v9; // rbx
long long v10; // rax
int v11; // edi
unsigned __int128 v12; // rax
int v13; // ebx
char v14; // r13
char *v15; // r12
char *v16; // rax
int inited; // r15d
unsigned long long v18; // rax
char **v19; // rcx
unsigned long long v20; // rcx
long long v21; // rdx
unsigned long long v23; // [rsp+8h] [rbp-68h]
unsigned long long v27; // [rsp+20h] [rbp-50h]
int v28; // [rsp+28h] [rbp-48h]
unsigned long long v29; // [rsp+30h] [rbp-40h]
char **v31; // [rsp+40h] [rbp-30h]
v6 = *((unsigned int *)a1 + 7);
*((_DWORD *)a1 + 6) = a2;
if ( *a1 )
{
v7 = a1;
v8 = (char **)*((_QWORD *)a1 + 1);
}
else
{
v9 = a3;
v10 = my_malloc(key_memory_KEY_CACHE, 8 * v6);
if ( !v10 )
return 0xFFFFFFFFLL;
v8 = (char **)v10;
memset(v10, 0LL, 8 * v6);
v7 = a1;
*((_QWORD *)a1 + 1) = v8;
a3 = v9;
}
v11 = 0;
v29 = a3;
v27 = a3 / v6;
v12 = 0xCCCCCCCCCCCCCCCDLL * (unsigned __int128)(a3 / v6);
if ( (int)v6 <= 0 )
{
v19 = v8;
goto LABEL_27;
}
v23 = *((_QWORD *)&v12 + 1) >> 2;
v28 = 0;
v13 = 0;
while ( 1 )
{
v14 = *v7;
v31 = v8;
if ( *v7 )
{
v15 = *v8;
}
else
{
v16 = (char *)my_malloc(key_memory_KEY_CACHE, 368LL);
if ( !v16 )
goto LABEL_24;
v15 = v16;
*v16 = 0;
}
inited = init_simple_key_cache(v15, a2, v27, a4, a5, a6);
if ( inited <= 0 )
break;
v28 += inited;
*v31 = v15;
v8 = v31 + 1;
v7 = a1;
LABEL_24:
if ( ++v13 >= (int)v6 )
goto LABEL_25;
}
end_simple_key_cache((long long)v15, 1);
if ( v14 )
{
if ( v13 > 0 || inited != 0 && v13 == 0 )
{
my_free(v15);
memmove(v31, v31 + 1, 8LL * (unsigned int)(v6 + ~v13));
goto LABEL_22;
}
}
else
{
my_free(v15);
if ( v13 > 0 || inited != 0 && v13 == 0 )
{
LABEL_22:
LODWORD(v6) = v6 - 1;
v7 = a1;
v18 = v29;
v8 = v31;
if ( !(_DWORD)v6 )
goto LABEL_25;
goto LABEL_23;
}
}
v18 = v29 - v23;
v7 = a1;
if ( v29 > v23 )
{
v8 = v31;
LABEL_23:
--v13;
v29 = v18;
v27 = v18 / (unsigned int)v6;
goto LABEL_24;
}
v8 = v31;
LABEL_25:
v19 = v8;
v8 = (char **)*((_QWORD *)v7 + 1);
v11 = v28;
LABEL_27:
v20 = (unsigned long long)((char *)v19 - (char *)v8) >> 3;
*((_DWORD *)v7 + 7) = v20;
*((_QWORD *)v7 + 2) = v27 * (unsigned int)v20;
if ( (int)v20 > 0 )
{
v21 = 0LL;
do
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)v7 + 1) + 8 * v21++) + 356LL) = v20;
while ( (v20 & 0x7FFFFFFF) != v21 );
}
*v7 = 1;
return v11 | (unsigned int)-((_DWORD)v20 == 0);
}
|
init_partitioned_key_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x60],R9D
MOV dword ptr [RBP + -0x5c],R8D
MOV dword ptr [RBP + -0x58],ECX
MOV R14D,dword ptr [RDI + 0x1c]
MOV dword ptr [RBP + -0x54],ESI
MOV dword ptr [RDI + 0x18],ESI
CMP byte ptr [RDI],0x0
MOV qword ptr [RBP + -0x38],RDI
JZ 0x00158d18
MOV R15,RDI
MOV R12,qword ptr [RDI + 0x8]
JMP 0x00158d5d
LAB_00158d18:
MOV RBX,RDX
LEA RAX,[0x4b8c38]
MOV EDI,dword ptr [RAX]
LEA R15,[R14*0x8]
MOV EDX,0x10
MOV RSI,R15
CALL 0x00160401
TEST RAX,RAX
JZ 0x00158f26
MOV R12,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R15
CALL 0x001281f0
MOV R15,qword ptr [RBP + -0x38]
MOV qword ptr [R15 + 0x8],R12
MOV RDX,RBX
LAB_00158d5d:
XOR EDI,EDI
MOV qword ptr [RBP + -0x40],RDX
MOV RAX,RDX
XOR EDX,EDX
DIV R14
MOV RCX,-0x3333333333333333
MOV qword ptr [RBP + -0x50],RAX
MUL RCX
TEST R14D,R14D
JLE 0x00158ece
SHR RDX,0x2
MOV qword ptr [RBP + -0x68],RDX
MOV qword ptr [RBP + -0x48],0x0
XOR EBX,EBX
LAB_00158d97:
MOV R13B,byte ptr [R15]
TEST R13B,R13B
MOV qword ptr [RBP + -0x30],R12
JZ 0x00158da9
MOV R12,qword ptr [R12]
JMP 0x00158dd0
LAB_00158da9:
LEA RAX,[0x4b8c38]
MOV EDI,dword ptr [RAX]
MOV ESI,0x170
MOV EDX,0x10
CALL 0x00160401
TEST RAX,RAX
JZ 0x00158e5a
MOV R12,RAX
MOV byte ptr [RAX],0x0
LAB_00158dd0:
MOV RDI,R12
MOV ESI,dword ptr [RBP + -0x54]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x58]
MOV R8D,dword ptr [RBP + -0x5c]
MOV R9D,dword ptr [RBP + -0x60]
CALL 0x00157305
MOV R15D,EAX
TEST EAX,EAX
JLE 0x00158e13
MOV RAX,qword ptr [RBP + -0x48]
ADD EAX,R15D
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],R12
MOV R12,RAX
ADD R12,0x8
MOV R15,qword ptr [RBP + -0x38]
JMP 0x00158eb6
LAB_00158e13:
MOV RDI,R12
MOV ESI,0x1
CALL 0x00158206
TEST R13B,R13B
JZ 0x00158e60
TEST EBX,EBX
SETZ AL
TEST R15D,R15D
SETNZ CL
TEST EBX,EBX
JG 0x00158e38
AND AL,CL
JZ 0x00158e7b
LAB_00158e38:
MOV RDI,R12
CALL 0x0016062e
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[RDI + 0x8]
MOV EDX,EBX
NOT EDX
ADD EDX,R14D
SHL RDX,0x3
CALL 0x001286f0
JMP 0x00158e93
LAB_00158e5a:
MOV R12,qword ptr [RBP + -0x30]
JMP 0x00158eb6
LAB_00158e60:
MOV RDI,R12
CALL 0x0016062e
TEST EBX,EBX
SETZ AL
TEST R15D,R15D
SETNZ CL
TEST EBX,EBX
JG 0x00158e93
AND AL,CL
JNZ 0x00158e93
LAB_00158e7b:
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x68]
MOV R15,qword ptr [RBP + -0x38]
JBE 0x00158f2d
MOV R12,qword ptr [RBP + -0x30]
JMP 0x00158ea4
LAB_00158e93:
DEC R14D
MOV R15,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV R12,qword ptr [RBP + -0x30]
JZ 0x00158ec1
LAB_00158ea4:
DEC EBX
MOV ECX,R14D
MOV qword ptr [RBP + -0x40],RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_00158eb6:
INC EBX
CMP EBX,R14D
JL 0x00158d97
LAB_00158ec1:
MOV RCX,R12
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,qword ptr [RBP + -0x48]
JMP 0x00158ed1
LAB_00158ece:
MOV RCX,R12
LAB_00158ed1:
SUB RCX,R12
SHR RCX,0x3
MOV dword ptr [R15 + 0x1c],ECX
MOV EAX,ECX
IMUL RAX,qword ptr [RBP + -0x50]
MOV qword ptr [R15 + 0x10],RAX
TEST ECX,ECX
JLE 0x00158f0a
MOV EAX,ECX
AND EAX,0x7fffffff
XOR EDX,EDX
LAB_00158ef4:
MOV RSI,qword ptr [R15 + 0x8]
MOV RSI,qword ptr [RSI + RDX*0x8]
MOV dword ptr [RSI + 0x164],ECX
INC RDX
CMP RAX,RDX
JNZ 0x00158ef4
LAB_00158f0a:
MOV byte ptr [R15],0x1
XOR EAX,EAX
CMP ECX,0x1
SBB EAX,EAX
OR EAX,EDI
LAB_00158f17:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00158f26:
MOV EAX,0xffffffff
JMP 0x00158f17
LAB_00158f2d:
MOV R12,qword ptr [RBP + -0x30]
JMP 0x00158ec1
|
uint init_partitioned_key_cache
(char *param_1,int4 param_2,ulong param_3,int4 param_4,int4 param_5
,int4 param_6)
{
char cVar1;
int iVar2;
uint uVar3;
int8 *__s;
int1 *puVar4;
ulong uVar5;
ulong uVar6;
uint uVar7;
int8 *puVar8;
uint uVar9;
bool bVar10;
ulong local_58;
ulong local_48;
uVar7 = *(uint *)(param_1 + 0x1c);
uVar5 = (ulong)uVar7;
*(int4 *)(param_1 + 0x18) = param_2;
if (*param_1 == '\0') {
__s = (int8 *)my_malloc(key_memory_KEY_CACHE,uVar5 * 8,0x10);
if (__s == (int8 *)0x0) {
return 0xffffffff;
}
memset(__s,0,uVar5 * 8);
*(int8 **)(param_1 + 8) = __s;
}
else {
__s = *(int8 **)(param_1 + 8);
}
uVar3 = 0;
local_58 = param_3 / uVar5;
puVar8 = __s;
if (0 < (int)uVar7) {
uVar6 = local_58 / 5;
uVar3 = 0;
uVar7 = 0;
local_48 = param_3;
do {
cVar1 = *param_1;
if (cVar1 == '\0') {
puVar4 = (int1 *)my_malloc(key_memory_KEY_CACHE,0x170,0x10);
if (puVar4 != (int1 *)0x0) {
*puVar4 = 0;
goto LAB_00158dd0;
}
}
else {
puVar4 = (int1 *)*__s;
LAB_00158dd0:
iVar2 = init_simple_key_cache(puVar4,param_2,local_58,param_4,param_5,param_6);
if (iVar2 < 1) {
end_simple_key_cache(puVar4,1);
if (cVar1 == '\0') {
my_free(puVar4);
if (((int)uVar7 < 1) && (uVar7 != 0 || iVar2 == 0)) goto LAB_00158e7b;
LAB_00158e93:
uVar9 = (int)uVar5 - 1;
uVar5 = (ulong)uVar9;
if (uVar9 == 0) break;
}
else {
if ((0 < (int)uVar7) || (uVar7 == 0 && iVar2 != 0)) {
my_free(puVar4);
memmove(__s,__s + 1,(ulong)(~uVar7 + (int)uVar5) << 3);
goto LAB_00158e93;
}
LAB_00158e7b:
bVar10 = local_48 < uVar6;
local_48 = local_48 - uVar6;
if (bVar10 || local_48 == 0) break;
}
uVar7 = uVar7 - 1;
local_58 = local_48 / uVar5;
}
else {
uVar3 = uVar3 + iVar2;
*__s = puVar4;
__s = __s + 1;
}
}
uVar7 = uVar7 + 1;
} while ((int)uVar7 < (int)uVar5);
puVar8 = *(int8 **)(param_1 + 8);
}
uVar5 = (ulong)((long)__s - (long)puVar8) >> 3;
uVar7 = (uint)uVar5;
*(uint *)(param_1 + 0x1c) = uVar7;
*(ulong *)(param_1 + 0x10) = (uVar5 & 0xffffffff) * local_58;
if (0 < (int)uVar7) {
uVar5 = 0;
do {
*(uint *)(*(long *)(*(long *)(param_1 + 8) + uVar5 * 8) + 0x164) = uVar7;
uVar5 = uVar5 + 1;
} while ((uVar7 & 0x7fffffff) != uVar5);
}
*param_1 = '\x01';
return -(uint)(uVar7 == 0) | uVar3;
}
|
|
58,540
|
my_hash_sort_utf8mb3_nopad
|
eloqsql/strings/ctype-utf8.c
|
static void my_hash_sort_utf8mb3_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t 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=my_utf8mb3_uni(cs,&wc, (uchar *)s, (uchar*)e))>0 )
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, wc);
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf8mb3_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x672ea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x65140
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x672f6
jmp 0x67397
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0x65ef0
jmp 0x6730c
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xff, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x67348
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x8, %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x67381
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x672ba
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf8mb3_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_672BA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_672EA
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_672EA:
mov al, [rbp+var_59]
test al, 1
jnz short loc_672F6
jmp loc_67397
loc_672F6:
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_6730C:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFh
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_67348:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 8
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_67381:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_672BA
loc_67397:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf8mb3_nopad(
long long a1,
unsigned long long a2,
long long a3,
unsigned long long *a4,
_QWORD *a5,
long long a6)
{
_QWORD *result; // rax
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+10h] [rbp-50h]
long long v11; // [rsp+10h] [rbp-50h]
_QWORD *v12; // [rsp+18h] [rbp-48h]
unsigned long long v13; // [rsp+20h] [rbp-40h]
int v14; // [rsp+2Ch] [rbp-34h]
unsigned long long v15; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v16; // [rsp+38h] [rbp-28h]
unsigned long long *v17; // [rsp+40h] [rbp-20h]
long long v18; // [rsp+48h] [rbp-18h]
unsigned long long v19; // [rsp+50h] [rbp-10h]
long long v20; // [rsp+58h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v13 = a3 + a2;
v12 = *(_QWORD **)(a1 + 120);
v10 = *a4;
v8 = *a5;
while ( 1 )
{
v7 = 0;
if ( v19 < v13 )
{
v14 = my_utf8mb3_uni(v20, (long long)&v15, v19, v13, (long long)a5, a6);
v7 = v14 > 0;
}
if ( !v7 )
break;
my_tosort_unicode(v12, &v15, *(_DWORD *)(v20 + 12));
v11 = v10 ^ ((v10 << 8) + (unsigned __int8)v15 * (v8 + (v10 & 0x3F)));
v9 = v8 + 3;
v10 = v11 ^ ((v11 << 8) + (v15 >> 8) * (v9 + (v11 & 0x3F)));
v8 = v9 + 3;
v19 += v14;
}
*v17 = v10;
result = v16;
*v16 = v8;
return result;
}
|
my_hash_sort_utf8mb3_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_001672ba:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x001672ea
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00165140
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_001672ea:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x001672f6
JMP 0x00167397
LAB_001672f6:
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x00165ef0
JMP 0x0016730c
LAB_0016730c:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xff
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00167348
LAB_00167348:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x8
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00167381
LAB_00167381:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001672ba
LAB_00167397:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb3_nopad
(long param_1,ulong param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
bool bVar2;
long local_60;
ulong local_58;
int local_3c;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (local_38 & 0xff) + local_58 * 0x100 ^ local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (local_38 >> 8) + local_58 * 0x100 ^ local_58;
local_60 = local_60 + 6;
local_18 = local_18 + (long)local_3c;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
58,541
|
maria_rtree_set_key_mbr
|
eloqsql/storage/maria/ma_rt_key.c
|
int maria_rtree_set_key_mbr(MARIA_HA *info, MARIA_KEY *key,
my_off_t child_page)
{
MARIA_PAGE page;
DBUG_ENTER("maria_rtree_set_key_mbr");
if (_ma_fetch_keypage(&page, info, key->keyinfo, child_page,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, info->buff, 0))
DBUG_RETURN(-1);
DBUG_RETURN(maria_rtree_page_mbr(key->keyinfo->seg,
&page, key->data, key->data_length));
}
|
O0
|
c
|
maria_rtree_set_key_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x378(%rax), %rax
leaq -0x58(%rbp), %rdi
xorl %r8d, %r8d
movl $0x3, %r9d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x9b130
cmpb $0x0, %al
je 0x7ee0c
jmp 0x7ee03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ee37
jmp 0x7ee0e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq -0x58(%rbp), %rsi
callq 0x86b50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
|
maria_rtree_set_key_mbr:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rsi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rdx, [rax+8]
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rax, [rax+378h]
lea rdi, [rbp+var_58]
xor r8d, r8d
mov r9d, 3
mov [rsp+70h+var_70], rax
mov [rsp+70h+var_68], 0
call _ma_fetch_keypage
cmp al, 0
jz short loc_7EE0C
jmp short $+2
loc_7EE03:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_7EE37
loc_7EE0C:
jmp short $+2
loc_7EE0E:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdi, [rax+0C0h]
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
lea rsi, [rbp+var_58]
call maria_rtree_page_mbr
mov [rbp+var_4], eax
loc_7EE37:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long maria_rtree_set_key_mbr(long long a1, long long a2, long long a3)
{
_BYTE v4[56]; // [rsp+18h] [rbp-58h] BYREF
long long v5; // [rsp+50h] [rbp-20h]
long long v6; // [rsp+58h] [rbp-18h]
long long v7; // [rsp+60h] [rbp-10h]
v7 = a1;
v6 = a2;
v5 = a3;
if ( (unsigned __int8)ma_fetch_keypage((unsigned int)v4, a1, *(_QWORD *)(a2 + 8), a3, 0, 3, *(_QWORD *)(a1 + 888), 0) )
return (unsigned int)-1;
else
return (unsigned int)maria_rtree_page_mbr(
*(_QWORD *)(*(_QWORD *)(v6 + 8) + 192LL),
v4,
*(_QWORD *)v6,
*(unsigned int *)(v6 + 16));
}
|
maria_rtree_set_key_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x378]
LEA RDI,[RBP + -0x58]
XOR R8D,R8D
MOV R9D,0x3
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0x8],0x0
CALL 0x0019b130
CMP AL,0x0
JZ 0x0017ee0c
JMP 0x0017ee03
LAB_0017ee03:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0017ee37
LAB_0017ee0c:
JMP 0x0017ee0e
LAB_0017ee0e:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
LEA RSI,[RBP + -0x58]
CALL 0x00186b50
MOV dword ptr [RBP + -0x4],EAX
LAB_0017ee37:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4 maria_rtree_set_key_mbr(long param_1,int8 *param_2,int8 param_3)
{
char cVar1;
int1 local_60 [56];
int8 local_28;
int8 *local_20;
long local_18;
int4 local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
cVar1 = _ma_fetch_keypage(local_60,param_1,param_2[1],param_3,0,3,*(int8 *)(param_1 + 0x378)
,0);
if (cVar1 == '\0') {
local_c = maria_rtree_page_mbr
(*(int8 *)(local_20[1] + 0xc0),local_60,*local_20,
*(int4 *)(local_20 + 2));
}
else {
local_c = 0xffffffff;
}
return local_c;
}
|
|
58,542
|
stbi__hdr_convert(float*, unsigned char*, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = input[0] * f1;
output[1] = input[1] * f1;
output[2] = input[2] * f1;
}
if (req_comp == 2) output[1] = 1;
if (req_comp == 4) output[3] = 1;
} else {
switch (req_comp) {
case 4: output[3] = 1; /* fallthrough */
case 3: output[0] = output[1] = output[2] = 0;
break;
case 2: output[1] = 1; /* fallthrough */
case 1: output[0] = 0;
break;
}
}
}
|
O0
|
c
|
stbi__hdr_convert(float*, unsigned char*, int):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
je 0xa14d8
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %edi
subl $0x88, %edi
movss 0x1acc0d(%rip), %xmm0 # 0x24e008
callq 0xa5f20
movss %xmm0, 0x10(%rsp)
cmpl $0x2, 0x14(%rsp)
jg 0xa144c
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movq 0x18(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movq 0x18(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
mulss 0x10(%rsp), %xmm0
movss 0x1ad5bb(%rip), %xmm1 # 0x24e9f8
divss %xmm1, %xmm0
movq 0x20(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xa14a1
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
mulss 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movss %xmm0, (%rax)
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x18(%rsp), %rax
movzbl 0x2(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movss %xmm0, 0x8(%rax)
cmpl $0x2, 0x14(%rsp)
jne 0xa14ba
movq 0x20(%rsp), %rax
movss 0x1acb53(%rip), %xmm0 # 0x24e008
movss %xmm0, 0x4(%rax)
cmpl $0x4, 0x14(%rsp)
jne 0xa14d3
movq 0x20(%rsp), %rax
movss 0x1acb3a(%rip), %xmm0 # 0x24e008
movss %xmm0, 0xc(%rax)
jmp 0xa1559
movl 0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x3, %eax
ja 0xa1557
movq 0x8(%rsp), %rax
leaq 0x1ad682(%rip), %rcx # 0x24eb78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movss 0x1acafc(%rip), %xmm0 # 0x24e008
movss %xmm0, 0xc(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0xa1557
movq 0x20(%rsp), %rax
movss 0x1acac2(%rip), %xmm0 # 0x24e008
movss %xmm0, 0x4(%rax)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0xa1559
addq $0x28, %rsp
retq
nop
|
_ZL17stbi__hdr_convertPfPhi:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_14], edx
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax+3]
cmp eax, 0
jz loc_A14D8
mov rax, [rsp+28h+var_10]
movzx edi, byte ptr [rax+3]
sub edi, 88h; int
movss xmm0, cs:flt_24E008; float
call _ZSt5ldexpfi; std::ldexp(float,int)
movss [rsp+28h+var_18], xmm0
cmp [rsp+28h+var_14], 2
jg short loc_A144C
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax]
mov rcx, [rsp+28h+var_10]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
mov rcx, [rsp+28h+var_10]
movzx ecx, byte ptr [rcx+2]
add eax, ecx
cvtsi2ss xmm0, eax
mulss xmm0, [rsp+28h+var_18]
movss xmm1, cs:dword_24E9F8
divss xmm0, xmm1
mov rax, [rsp+28h+var_8]
movss dword ptr [rax], xmm0
jmp short loc_A14A1
loc_A144C:
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax]
cvtsi2ss xmm0, eax
mulss xmm0, [rsp+28h+var_18]
mov rax, [rsp+28h+var_8]
movss dword ptr [rax], xmm0
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax+1]
cvtsi2ss xmm0, eax
mulss xmm0, [rsp+28h+var_18]
mov rax, [rsp+28h+var_8]
movss dword ptr [rax+4], xmm0
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax+2]
cvtsi2ss xmm0, eax
mulss xmm0, [rsp+28h+var_18]
mov rax, [rsp+28h+var_8]
movss dword ptr [rax+8], xmm0
loc_A14A1:
cmp [rsp+28h+var_14], 2
jnz short loc_A14BA
mov rax, [rsp+28h+var_8]
movss xmm0, cs:flt_24E008
movss dword ptr [rax+4], xmm0
loc_A14BA:
cmp [rsp+28h+var_14], 4
jnz short loc_A14D3
mov rax, [rsp+28h+var_8]
movss xmm0, cs:flt_24E008
movss dword ptr [rax+0Ch], xmm0
loc_A14D3:
jmp loc_A1559
loc_A14D8:
mov eax, [rsp+28h+var_14]
dec eax; switch 4 cases
mov ecx, eax
mov [rsp+28h+var_20], rcx
sub eax, 3
ja short def_A14FD; jumptable 00000000000A14FD default case
mov rax, [rsp+28h+var_20]
lea rcx, jpt_A14FD
movsxd rax, ds:(jpt_A14FD - 24EB78h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_A14FF:
mov rax, [rsp+28h+var_8]; jumptable 00000000000A14FD case 4
movss xmm0, cs:flt_24E008
movss dword ptr [rax+0Ch], xmm0
loc_A1511:
mov rax, [rsp+28h+var_8]; jumptable 00000000000A14FD case 3
xorps xmm0, xmm0
movss dword ptr [rax+8], xmm0
mov rax, [rsp+28h+var_8]
xorps xmm0, xmm0
movss dword ptr [rax+4], xmm0
mov rax, [rsp+28h+var_8]
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
jmp short def_A14FD; jumptable 00000000000A14FD default case
loc_A1539:
mov rax, [rsp+28h+var_8]; jumptable 00000000000A14FD case 2
movss xmm0, cs:flt_24E008
movss dword ptr [rax+4], xmm0
loc_A154B:
mov rax, [rsp+28h+var_8]; jumptable 00000000000A14FD case 1
xorps xmm0, xmm0
movss dword ptr [rax], xmm0
def_A14FD:
jmp short $+2; jumptable 00000000000A14FD default case
loc_A1559:
add rsp, 28h
retn
|
long long stbi__hdr_convert(float *a1, unsigned __int8 *a2, int a3)
{
long long result; // rax
if ( a2[3] )
{
std::ldexp(1.0, a2[3] - 136);
if ( a3 > 2 )
{
*a1 = (float)*a2 * 1.0;
a1[1] = (float)a2[1] * 1.0;
result = (long long)a1;
a1[2] = (float)a2[2] * 1.0;
}
else
{
result = (long long)a1;
*a1 = (float)((float)(a2[2] + a2[1] + *a2) * 1.0) / 3.0;
}
if ( a3 == 2 )
{
result = (long long)a1;
a1[1] = 1.0;
}
if ( a3 == 4 )
{
result = (long long)a1;
a1[3] = 1.0;
}
}
else
{
result = (unsigned int)(a3 - 1);
switch ( a3 )
{
case 1:
goto LABEL_14;
case 2:
a1[1] = 1.0;
LABEL_14:
result = (long long)a1;
*a1 = 0.0;
return result;
case 3:
goto LABEL_12;
case 4:
a1[3] = 1.0;
LABEL_12:
a1[2] = 0.0;
a1[1] = 0.0;
result = (long long)a1;
*a1 = 0.0;
break;
default:
return result;
}
}
return result;
}
|
stbi__hdr_convert:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],EDX
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
CMP EAX,0x0
JZ 0x001a14d8
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EDI,byte ptr [RAX + 0x3]
SUB EDI,0x88
MOVSS XMM0,dword ptr [0x0034e008]
CALL 0x001a5f20
MOVSS dword ptr [RSP + 0x10],XMM0
CMP dword ptr [RSP + 0x14],0x2
JG 0x001a144c
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RSP + 0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOV RCX,qword ptr [RSP + 0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
ADD EAX,ECX
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RSP + 0x10]
MOVSS XMM1,dword ptr [0x0034e9f8]
DIVSS XMM0,XMM1
MOV RAX,qword ptr [RSP + 0x20]
MOVSS dword ptr [RAX],XMM0
JMP 0x001a14a1
LAB_001a144c:
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX]
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x20]
MOVSS dword ptr [RAX],XMM0
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x20]
MOVSS dword ptr [RAX + 0x4],XMM0
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x20]
MOVSS dword ptr [RAX + 0x8],XMM0
LAB_001a14a1:
CMP dword ptr [RSP + 0x14],0x2
JNZ 0x001a14ba
MOV RAX,qword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [0x0034e008]
MOVSS dword ptr [RAX + 0x4],XMM0
LAB_001a14ba:
CMP dword ptr [RSP + 0x14],0x4
JNZ 0x001a14d3
MOV RAX,qword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [0x0034e008]
MOVSS dword ptr [RAX + 0xc],XMM0
LAB_001a14d3:
JMP 0x001a1559
LAB_001a14d8:
MOV EAX,dword ptr [RSP + 0x14]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x8],RCX
SUB EAX,0x3
JA 0x001a1557
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x34eb78]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [0x0034e008]
MOVSS dword ptr [RAX + 0xc],XMM0
caseD_3:
MOV RAX,qword ptr [RSP + 0x20]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0x8],XMM0
MOV RAX,qword ptr [RSP + 0x20]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX + 0x4],XMM0
MOV RAX,qword ptr [RSP + 0x20]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
JMP 0x001a1557
caseD_2:
MOV RAX,qword ptr [RSP + 0x20]
MOVSS XMM0,dword ptr [0x0034e008]
MOVSS dword ptr [RAX + 0x4],XMM0
caseD_1:
MOV RAX,qword ptr [RSP + 0x20]
XORPS XMM0,XMM0
MOVSS dword ptr [RAX],XMM0
LAB_001a1557:
JMP 0x001a1559
default:
ADD RSP,0x28
RET
|
/* stbi__hdr_convert(float*, unsigned char*, int) */
void stbi__hdr_convert(float *param_1,uchar *param_2,int param_3)
{
float fVar1;
if (param_2[3] == '\0') {
switch(param_3) {
case 2:
param_1[1] = DAT_0034e008;
case 1:
*param_1 = 0.0;
break;
case 4:
param_1[3] = DAT_0034e008;
case 3:
param_1[2] = 0.0;
param_1[1] = 0.0;
*param_1 = 0.0;
}
}
else {
fVar1 = (float)std::ldexp(DAT_0034e008,param_2[3] - 0x88);
if (param_3 < 3) {
*param_1 = ((float)((uint)*param_2 + (uint)param_2[1] + (uint)param_2[2]) * fVar1) /
DAT_0034e9f8;
}
else {
*param_1 = (float)*param_2 * fVar1;
param_1[1] = (float)param_2[1] * fVar1;
param_1[2] = (float)param_2[2] * fVar1;
}
if (param_3 == 2) {
param_1[1] = DAT_0034e008;
}
if (param_3 == 4) {
param_1[3] = DAT_0034e008;
}
}
return;
}
|
|
58,543
|
stbi__hdr_convert(float*, unsigned char*, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = input[0] * f1;
output[1] = input[1] * f1;
output[2] = input[2] * f1;
}
if (req_comp == 2) output[1] = 1;
if (req_comp == 4) output[3] = 1;
} else {
switch (req_comp) {
case 4: output[3] = 1; /* fallthrough */
case 3: output[0] = output[1] = output[2] = 0;
break;
case 2: output[1] = 1; /* fallthrough */
case 1: output[0] = 0;
break;
}
}
}
|
O2
|
c
|
stbi__hdr_convert(float*, unsigned char*, int):
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movzbl 0x3(%rsi), %edi
testl %edi, %edi
je 0x4165f
movq %rsi, %r15
addl $0xffffff78, %edi # imm = 0xFFFFFF78
movss 0x83ab4(%rip), %xmm0 # 0xc50e0
callq 0x27090
movzbl (%r15), %eax
cmpl $0x2, %r14d
jg 0x41684
movzbl 0x1(%r15), %ecx
addl %eax, %ecx
movzbl 0x2(%r15), %eax
addl %ecx, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
divss 0x84487(%rip), %xmm0 # 0xc5ae0
movss %xmm0, (%rbx)
jmp 0x416b4
decl %r14d
cmpl $0x3, %r14d
ja 0x416e1
leaq 0x847b5(%rip), %rax # 0xc5e24
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x3f800000, 0x4(%rbx) # imm = 0x3F800000
andl $0x0, (%rbx)
jmp 0x416e1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx)
movzbl 0x1(%r15), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rbx)
movzbl 0x2(%r15), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
cmpl $0x4, %r14d
je 0x416c9
cmpl $0x2, %r14d
jne 0x416e1
movl $0x3f800000, 0x4(%rbx) # imm = 0x3F800000
jmp 0x416e1
movl $0x3f800000, 0xc(%rbx) # imm = 0x3F800000
jmp 0x416e1
movl $0x3f800000, 0xc(%rbx) # imm = 0x3F800000
andl $0x0, 0x8(%rbx)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
_ZL17stbi__hdr_convertPfPhi:
push r15
push r14
push rbx
mov r14d, edx
mov rbx, rdi
movzx edi, byte ptr [rsi+3]
test edi, edi
jz short loc_4165F
mov r15, rsi
add edi, 0FFFFFF78h
movss xmm0, cs:dword_C50E0
call _ldexpf
movzx eax, byte ptr [r15]
cmp r14d, 2
jg short loc_41684
movzx ecx, byte ptr [r15+1]
add ecx, eax
movzx eax, byte ptr [r15+2]
add eax, ecx
cvtsi2ss xmm1, eax
mulss xmm0, xmm1
divss xmm0, cs:dword_C5AE0
movss dword ptr [rbx], xmm0
jmp short loc_416B4
loc_4165F:
dec r14d; switch 4 cases
cmp r14d, 3
ja short def_41676; jumptable 0000000000041676 default case
lea rax, jpt_41676
movsxd rcx, ds:(jpt_41676 - 0C5E24h)[rax+r14*4]
add rcx, rax
jmp rcx; switch jump
loc_41678:
mov dword ptr [rbx+4], 3F800000h; jumptable 0000000000041676 case 2
loc_4167F:
and dword ptr [rbx], 0; jumptable 0000000000041676 case 1
jmp short def_41676; jumptable 0000000000041676 default case
loc_41684:
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx], xmm1
movzx eax, byte ptr [r15+1]
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx+4], xmm1
movzx eax, byte ptr [r15+2]
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx+8], xmm1
loc_416B4:
cmp r14d, 4
jz short loc_416C9
cmp r14d, 2
jnz short def_41676; jumptable 0000000000041676 default case
mov dword ptr [rbx+4], 3F800000h
jmp short def_41676; jumptable 0000000000041676 default case
loc_416C9:
mov dword ptr [rbx+0Ch], 3F800000h
jmp short def_41676; jumptable 0000000000041676 default case
loc_416D2:
mov dword ptr [rbx+0Ch], 3F800000h; jumptable 0000000000041676 case 4
loc_416D9:
and dword ptr [rbx+8], 0; jumptable 0000000000041676 case 3
and qword ptr [rbx], 0
def_41676:
pop rbx; jumptable 0000000000041676 default case
pop r14
pop r15
retn
|
void stbi__hdr_convert(float *a1, unsigned __int8 *a2, int a3)
{
int v4; // eax
if ( a2[3] )
{
ldexpf((unsigned int)a2[3] - 136, 1.0);
v4 = *a2;
if ( a3 > 2 )
{
*a1 = (float)v4 * 1.0;
a1[1] = (float)a2[1] * 1.0;
a1[2] = (float)a2[2] * 1.0;
}
else
{
*a1 = (float)(1.0 * (float)(v4 + a2[1] + a2[2])) / 3.0;
}
if ( a3 == 4 )
{
a1[3] = 1.0;
}
else if ( a3 == 2 )
{
a1[1] = 1.0;
}
}
else
{
switch ( a3 )
{
case 1:
goto LABEL_6;
case 2:
a1[1] = 1.0;
LABEL_6:
*a1 = 0.0;
return;
case 3:
goto LABEL_13;
case 4:
a1[3] = 1.0;
LABEL_13:
a1[2] = 0.0;
*(_QWORD *)a1 = 0LL;
break;
default:
return;
}
}
}
|
stbi__hdr_convert:
PUSH R15
PUSH R14
PUSH RBX
MOV R14D,EDX
MOV RBX,RDI
MOVZX EDI,byte ptr [RSI + 0x3]
TEST EDI,EDI
JZ 0x0014165f
MOV R15,RSI
ADD EDI,0xffffff78
MOVSS XMM0,dword ptr [0x001c50e0]
CALL 0x00127090
MOVZX EAX,byte ptr [R15]
CMP R14D,0x2
JG 0x00141684
MOVZX ECX,byte ptr [R15 + 0x1]
ADD ECX,EAX
MOVZX EAX,byte ptr [R15 + 0x2]
ADD EAX,ECX
CVTSI2SS XMM1,EAX
MULSS XMM0,XMM1
DIVSS XMM0,dword ptr [0x001c5ae0]
MOVSS dword ptr [RBX],XMM0
JMP 0x001416b4
LAB_0014165f:
DEC R14D
CMP R14D,0x3
JA 0x001416e1
LEA RAX,[0x1c5e24]
MOVSXD RCX,dword ptr [RAX + R14*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_2:
MOV dword ptr [RBX + 0x4],0x3f800000
caseD_1:
AND dword ptr [RBX],0x0
JMP 0x001416e1
LAB_00141684:
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX],XMM1
MOVZX EAX,byte ptr [R15 + 0x1]
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + 0x4],XMM1
MOVZX EAX,byte ptr [R15 + 0x2]
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + 0x8],XMM1
LAB_001416b4:
CMP R14D,0x4
JZ 0x001416c9
CMP R14D,0x2
JNZ 0x001416e1
MOV dword ptr [RBX + 0x4],0x3f800000
JMP 0x001416e1
LAB_001416c9:
MOV dword ptr [RBX + 0xc],0x3f800000
JMP 0x001416e1
caseD_4:
MOV dword ptr [RBX + 0xc],0x3f800000
caseD_3:
AND dword ptr [RBX + 0x8],0x0
AND qword ptr [RBX],0x0
default:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* stbi__hdr_convert(float*, unsigned char*, int) */
void stbi__hdr_convert(float *param_1,uchar *param_2,int param_3)
{
float fVar1;
if (param_2[3] == 0) {
switch(param_3) {
case 2:
param_1[1] = 1.0;
case 1:
*param_1 = 0.0;
break;
case 4:
param_1[3] = 1.0;
case 3:
param_1[2] = 0.0;
param_1[0] = 0.0;
param_1[1] = 0.0;
}
}
else {
fVar1 = ldexpf(DAT_001c50e0,param_2[3] - 0x88);
if (param_3 < 3) {
*param_1 = (fVar1 * (float)((uint)param_2[2] + (uint)param_2[1] + (uint)*param_2)) /
_DAT_001c5ae0;
}
else {
*param_1 = (float)*param_2 * fVar1;
param_1[1] = (float)param_2[1] * fVar1;
param_1[2] = (float)param_2[2] * fVar1;
}
if (param_3 == 4) {
param_1[3] = 1.0;
}
else if (param_3 == 2) {
param_1[1] = 1.0;
}
}
return;
}
|
|
58,544
|
stbi__hdr_convert(float*, unsigned char*, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = input[0] * f1;
output[1] = input[1] * f1;
output[2] = input[2] * f1;
}
if (req_comp == 2) output[1] = 1;
if (req_comp == 4) output[3] = 1;
} else {
switch (req_comp) {
case 4: output[3] = 1; /* fallthrough */
case 3: output[0] = output[1] = output[2] = 0;
break;
case 2: output[1] = 1; /* fallthrough */
case 1: output[0] = 0;
break;
}
}
}
|
O3
|
c
|
stbi__hdr_convert(float*, unsigned char*, int):
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movzbl 0x3(%rsi), %edi
testl %edi, %edi
je 0x423f4
movq %rsi, %r15
addl $0xffffff78, %edi # imm = 0xFFFFFF78
movss 0xc6d1f(%rip), %xmm0 # 0x1090e0
callq 0x1e070
movzbl (%r15), %eax
cmpl $0x2, %r14d
jg 0x42420
movzbl 0x1(%r15), %ecx
addl %eax, %ecx
movzbl 0x2(%r15), %eax
addl %ecx, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
divss 0xc7702(%rip), %xmm0 # 0x109af0
movss %xmm0, (%rbx)
jmp 0x42456
decl %r14d
cmpl $0x3, %r14d
ja 0x42489
leaq 0xc7b04(%rip), %rax # 0x109f0c
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x3f800000, 0x4(%rbx) # imm = 0x3F800000
movl $0x0, (%rbx)
jmp 0x42489
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx)
movzbl 0x1(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rbx)
movzbl 0x2(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
cmpl $0x4, %r14d
je 0x4246b
cmpl $0x2, %r14d
jne 0x42489
movl $0x3f800000, 0x4(%rbx) # imm = 0x3F800000
jmp 0x42489
movl $0x3f800000, 0xc(%rbx) # imm = 0x3F800000
jmp 0x42489
movl $0x3f800000, 0xc(%rbx) # imm = 0x3F800000
movl $0x0, 0x8(%rbx)
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
_ZL17stbi__hdr_convertPfPhi:
push r15
push r14
push rbx
mov r14d, edx
mov rbx, rdi
movzx edi, byte ptr [rsi+3]
test edi, edi
jz short loc_423F4
mov r15, rsi
add edi, 0FFFFFF78h
movss xmm0, cs:dword_1090E0
call _ldexpf
movzx eax, byte ptr [r15]
cmp r14d, 2
jg short loc_42420
movzx ecx, byte ptr [r15+1]
add ecx, eax
movzx eax, byte ptr [r15+2]
add eax, ecx
cvtsi2ss xmm1, eax
mulss xmm0, xmm1
divss xmm0, cs:dword_109AF0
movss dword ptr [rbx], xmm0
jmp short loc_42456
loc_423F4:
dec r14d; switch 4 cases
cmp r14d, 3
ja def_4240F; jumptable 000000000004240F default case
lea rax, jpt_4240F
movsxd rcx, ds:(jpt_4240F - 109F0Ch)[rax+r14*4]
add rcx, rax
jmp rcx; switch jump
loc_42411:
mov dword ptr [rbx+4], 3F800000h; jumptable 000000000004240F case 2
loc_42418:
mov dword ptr [rbx], 0; jumptable 000000000004240F case 1
jmp short def_4240F; jumptable 000000000004240F default case
loc_42420:
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx], xmm1
movzx eax, byte ptr [r15+1]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx+4], xmm1
movzx eax, byte ptr [r15+2]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rbx+8], xmm1
loc_42456:
cmp r14d, 4
jz short loc_4246B
cmp r14d, 2
jnz short def_4240F; jumptable 000000000004240F default case
mov dword ptr [rbx+4], 3F800000h
jmp short def_4240F; jumptable 000000000004240F default case
loc_4246B:
mov dword ptr [rbx+0Ch], 3F800000h
jmp short def_4240F; jumptable 000000000004240F default case
loc_42474:
mov dword ptr [rbx+0Ch], 3F800000h; jumptable 000000000004240F case 4
loc_4247B:
mov dword ptr [rbx+8], 0; jumptable 000000000004240F case 3
mov qword ptr [rbx], 0
def_4240F:
pop rbx; jumptable 000000000004240F default case
pop r14
pop r15
retn
|
void stbi__hdr_convert(float *a1, unsigned __int8 *a2, int a3)
{
int v4; // eax
if ( a2[3] )
{
ldexpf((unsigned int)a2[3] - 136, 1.0);
v4 = *a2;
if ( a3 > 2 )
{
*a1 = (float)v4 * 1.0;
a1[1] = (float)a2[1] * 1.0;
a1[2] = (float)a2[2] * 1.0;
}
else
{
*a1 = (float)(1.0 * (float)(v4 + a2[1] + a2[2])) / 3.0;
}
if ( a3 == 4 )
{
a1[3] = 1.0;
}
else if ( a3 == 2 )
{
a1[1] = 1.0;
}
}
else
{
switch ( a3 )
{
case 1:
goto LABEL_6;
case 2:
a1[1] = 1.0;
LABEL_6:
*a1 = 0.0;
return;
case 3:
goto LABEL_13;
case 4:
a1[3] = 1.0;
LABEL_13:
a1[2] = 0.0;
*(_QWORD *)a1 = 0LL;
break;
default:
return;
}
}
}
|
stbi__hdr_convert:
PUSH R15
PUSH R14
PUSH RBX
MOV R14D,EDX
MOV RBX,RDI
MOVZX EDI,byte ptr [RSI + 0x3]
TEST EDI,EDI
JZ 0x001423f4
MOV R15,RSI
ADD EDI,0xffffff78
MOVSS XMM0,dword ptr [0x002090e0]
CALL 0x0011e070
MOVZX EAX,byte ptr [R15]
CMP R14D,0x2
JG 0x00142420
MOVZX ECX,byte ptr [R15 + 0x1]
ADD ECX,EAX
MOVZX EAX,byte ptr [R15 + 0x2]
ADD EAX,ECX
CVTSI2SS XMM1,EAX
MULSS XMM0,XMM1
DIVSS XMM0,dword ptr [0x00209af0]
MOVSS dword ptr [RBX],XMM0
JMP 0x00142456
LAB_001423f4:
DEC R14D
CMP R14D,0x3
JA 0x00142489
LEA RAX,[0x209f0c]
MOVSXD RCX,dword ptr [RAX + R14*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_2:
MOV dword ptr [RBX + 0x4],0x3f800000
caseD_1:
MOV dword ptr [RBX],0x0
JMP 0x00142489
LAB_00142420:
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX],XMM1
MOVZX EAX,byte ptr [R15 + 0x1]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + 0x4],XMM1
MOVZX EAX,byte ptr [R15 + 0x2]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + 0x8],XMM1
LAB_00142456:
CMP R14D,0x4
JZ 0x0014246b
CMP R14D,0x2
JNZ 0x00142489
MOV dword ptr [RBX + 0x4],0x3f800000
JMP 0x00142489
LAB_0014246b:
MOV dword ptr [RBX + 0xc],0x3f800000
JMP 0x00142489
caseD_4:
MOV dword ptr [RBX + 0xc],0x3f800000
caseD_3:
MOV dword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX],0x0
default:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* stbi__hdr_convert(float*, unsigned char*, int) */
void stbi__hdr_convert(float *param_1,uchar *param_2,int param_3)
{
float fVar1;
if (param_2[3] == 0) {
switch(param_3) {
case 2:
param_1[1] = 1.0;
case 1:
*param_1 = 0.0;
break;
case 4:
param_1[3] = 1.0;
case 3:
param_1[2] = 0.0;
param_1[0] = 0.0;
param_1[1] = 0.0;
}
}
else {
fVar1 = ldexpf(DAT_002090e0,param_2[3] - 0x88);
if (param_3 < 3) {
*param_1 = (fVar1 * (float)((uint)param_2[2] + (uint)param_2[1] + (uint)*param_2)) /
_DAT_00209af0;
}
else {
*param_1 = (float)*param_2 * fVar1;
param_1[1] = (float)param_2[1] * fVar1;
param_1[2] = (float)param_2[2] * fVar1;
}
if (param_3 == 4) {
param_1[3] = 1.0;
}
else if (param_3 == 2) {
param_1[1] = 1.0;
}
}
return;
}
|
|
58,545
|
my_scan_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_scan_utf32(CHARSET_INFO *cs,
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for ( ; str < end; )
{
my_wc_t wc;
int res= my_utf32_uni(cs, &wc, (uchar*) str, (uchar*) end);
if (res < 0 || wc != ' ')
break;
str+= res;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
}
|
O3
|
c
|
my_scan_utf32:
cmpl $0x2, %ecx
jne 0xc5185
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq %rcx, %rax
cmpq %rdx, %rcx
jae 0xc5180
leaq 0x4(%rax), %rcx
cmpq %rdx, %rcx
ja 0xc5180
movzbl (%rax), %ecx
shll $0x18, %ecx
movzbl 0x1(%rax), %edi
shll $0x10, %edi
orl %ecx, %edi
xorl %ecx, %ecx
cmpl $0x110000, %edi # imm = 0x110000
setb %cl
movzwl 0x2(%rax), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
orl %edi, %r8d
leaq (%rax,%rcx,4), %rcx
cmpl $0x20, %r8d
je 0xc513a
subq %rsi, %rax
popq %rbp
retq
xorl %eax, %eax
retq
|
my_scan_utf32:
cmp ecx, 2
jnz short loc_C5185
push rbp
mov rbp, rsp
mov rcx, rsi
loc_C513A:
mov rax, rcx
cmp rcx, rdx
jnb short loc_C5180
lea rcx, [rax+4]
cmp rcx, rdx
ja short loc_C5180
movzx ecx, byte ptr [rax]
shl ecx, 18h
movzx edi, byte ptr [rax+1]
shl edi, 10h
or edi, ecx
xor ecx, ecx
cmp edi, offset unk_110000
setb cl
movzx r8d, word ptr [rax+2]
rol r8w, 8
movzx r8d, r8w
or r8d, edi
lea rcx, [rax+rcx*4]
cmp r8d, 20h ; ' '
jz short loc_C513A
loc_C5180:
sub rax, rsi
pop rbp
retn
loc_C5185:
xor eax, eax
retn
|
long long my_scan_utf32(long long a1, unsigned __int8 *a2, unsigned long long a3, int a4)
{
unsigned __int8 *v4; // rcx
unsigned __int8 *v5; // rax
unsigned int v6; // edi
if ( a4 != 2 )
return 0LL;
v4 = a2;
do
{
v5 = v4;
if ( (unsigned long long)v4 >= a3 )
break;
if ( (unsigned long long)(v4 + 4) > a3 )
break;
v6 = (*v4 << 24) | (v4[1] << 16);
v4 += 4 * (v6 < (unsigned int)&unk_110000);
}
while ( (v6 | (unsigned __int16)__ROL2__(*((_WORD *)v5 + 1), 8)) == 0x20 );
return v5 - a2;
}
|
my_scan_utf32:
CMP ECX,0x2
JNZ 0x001c5185
PUSH RBP
MOV RBP,RSP
MOV RCX,RSI
LAB_001c513a:
MOV RAX,RCX
CMP RCX,RDX
JNC 0x001c5180
LEA RCX,[RAX + 0x4]
CMP RCX,RDX
JA 0x001c5180
MOVZX ECX,byte ptr [RAX]
SHL ECX,0x18
MOVZX EDI,byte ptr [RAX + 0x1]
SHL EDI,0x10
OR EDI,ECX
XOR ECX,ECX
CMP EDI,0x110000
SETC CL
MOVZX R8D,word ptr [RAX + 0x2]
ROL R8W,0x8
MOVZX R8D,R8W
OR R8D,EDI
LEA RCX,[RAX + RCX*0x4]
CMP R8D,0x20
JZ 0x001c513a
LAB_001c5180:
SUB RAX,RSI
POP RBP
RET
LAB_001c5185:
XOR EAX,EAX
RET
|
long my_scan_utf32(int8 param_1,byte *param_2,byte *param_3,int param_4)
{
byte *pbVar1;
byte *pbVar2;
uint uVar3;
pbVar1 = param_2;
if (param_4 != 2) {
return 0;
}
do {
pbVar2 = pbVar1;
if ((param_3 <= pbVar2) || (param_3 < pbVar2 + 4)) break;
uVar3 = (uint)pbVar2[1] << 0x10 | (uint)*pbVar2 << 0x18;
pbVar1 = pbVar2 + (ulong)(uVar3 < 0x110000) * 4;
} while (((ushort)(*(ushort *)(pbVar2 + 2) << 8 | *(ushort *)(pbVar2 + 2) >> 8) | uVar3) == 0x20);
return (long)pbVar2 - (long)param_2;
}
|
|
58,546
|
SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
|
Dolphin-anty/Source/Core/Common/StringUtil.cpp
|
std::vector<std::string> SplitString(const std::string& str, const char delim)
{
std::istringstream iss(str);
std::vector<std::string> output(1);
while (std::getline(iss, *output.rbegin(), delim))
output.push_back("");
output.pop_back();
return output;
}
|
O0
|
cpp
|
SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movb %al, 0x1d7(%rsp)
movq 0x1d8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x8, %edx
callq 0x90d0
movb $0x0, 0x4f(%rsp)
leaq 0x4e(%rsp), %rdi
callq 0x2a350
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x4e(%rsp), %rdx
callq 0x2a360
leaq 0x4e(%rsp), %rdi
callq 0x2a3c0
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2a3d0
leaq 0x40(%rsp), %rdi
callq 0x2a420
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movsbl 0x1d7(%rsp), %edx
callq 0x9280
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x9a90
testb $0x1, %al
jne 0x288a4
jmp 0x288ec
leaq 0x1f(%rsp), %rdi
callq 0x9220
leaq 0x20(%rsp), %rdi
leaq 0x76ed3(%rip), %rsi # 0x9f78d
leaq 0x1f(%rsp), %rdx
callq 0x12a40
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2a450
leaq 0x20(%rsp), %rdi
callq 0x12a10
leaq 0x1f(%rsp), %rdi
callq 0x9d60
jmp 0x28861
movq 0x10(%rsp), %rdi
callq 0x2a480
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x2890c
movq 0x10(%rsp), %rdi
callq 0x2a4a0
leaq 0x50(%rsp), %rdi
callq 0x9790
movq 0x8(%rsp), %rax
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopw %cs:(%rax,%rax)
|
_Z11SplitStringRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
sub rsp, 1E8h
mov [rsp+1E8h+var_1D8], rdi
mov al, dl
mov rcx, rdi
mov [rsp+1E8h+var_1E0], rcx
mov [rsp+1E8h+var_8], rdi
mov [rsp+1E8h+var_10], rsi
mov [rsp+1E8h+var_11], al
mov rsi, [rsp+1E8h+var_10]
lea rdi, [rsp+1E8h+var_198]
mov edx, 8
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
mov [rsp+1E8h+var_199], 0
lea rdi, [rsp+1E8h+var_19A]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2Ev; std::allocator<std::string>::allocator(void)
mov rdi, [rsp+1E8h+var_1D8]
mov esi, 1
lea rdx, [rsp+1E8h+var_19A]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2EmRKS6_; std::vector<std::string>::vector(ulong,std::allocator<std::string> const&)
lea rdi, [rsp+1E8h+var_19A]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
loc_28861:
mov rsi, [rsp+1E8h+var_1D8]
lea rdi, [rsp+1E8h+var_1A8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE6rbeginEv; std::vector<std::string>::rbegin(void)
lea rdi, [rsp+1E8h+var_1A8]
call _ZNKSt16reverse_iteratorIN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS7_SaIS7_EEEEEdeEv; std::reverse_iterator<__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>>::operator*(void)
mov rsi, rax
lea rdi, [rsp+1E8h+var_198]
movsx edx, [rsp+1E8h+var_11]
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rdi, rax
mov rax, [rdi]
add rdi, [rax-18h]
call __ZNKSt9basic_iosIcSt11char_traitsIcEEcvbEv; std::ios::operator bool(void)
test al, 1
jnz short loc_288A4
jmp short loc_288EC
loc_288A4:
lea rdi, [rsp+1E8h+var_1C9]
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
lea rdi, [rsp+1E8h+var_1C8]
lea rsi, asc_9F789+4; ""
lea rdx, [rsp+1E8h+var_1C9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, [rsp+1E8h+var_1D8]
lea rsi, [rsp+1E8h+var_1C8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
lea rdi, [rsp+1E8h+var_1C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1E8h+var_1C9]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_28861
loc_288EC:
mov rdi, [rsp+1E8h+var_1D8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE8pop_backEv; std::vector<std::string>::pop_back(void)
mov [rsp+1E8h+var_199], 1
test [rsp+1E8h+var_199], 1
jnz short loc_2890C
mov rdi, [rsp+1E8h+var_1D8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_2890C:
lea rdi, [rsp+1E8h+var_198]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
mov rax, [rsp+1E8h+var_1E0]
add rsp, 1E8h
retn
|
long long SplitString(long long a1, long long a2, char a3)
{
long long v3; // rax
_QWORD *v4; // rax
char v6; // [rsp+1Fh] [rbp-1C9h] BYREF
_BYTE v7[32]; // [rsp+20h] [rbp-1C8h] BYREF
_BYTE v8[14]; // [rsp+40h] [rbp-1A8h] BYREF
char v9; // [rsp+4Eh] [rbp-19Ah] BYREF
char v10; // [rsp+4Fh] [rbp-199h]
_BYTE v11[391]; // [rsp+50h] [rbp-198h] BYREF
char v12; // [rsp+1D7h] [rbp-11h]
long long v13; // [rsp+1D8h] [rbp-10h]
long long v14; // [rsp+1E0h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
std::istringstream::basic_istringstream(v11, a2, 8LL);
v10 = 0;
std::allocator<std::string>::allocator(&v9);
std::vector<std::string>::vector(a1, 1LL, &v9);
std::allocator<std::string>::~allocator(&v9);
while ( 1 )
{
std::vector<std::string>::rbegin(v8, a1);
v3 = std::reverse_iterator<__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>>::operator*(v8);
v4 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v11, v3, (unsigned int)v12);
if ( (std::ios::operator bool((char *)v4 + *(_QWORD *)(*v4 - 24LL)) & 1) == 0 )
break;
std::allocator<char>::allocator(&v6);
std::string::basic_string<std::allocator<char>>((long long)v7, (long long)"", (long long)&v6);
std::vector<std::string>::push_back(a1, v7);
std::string::~string(v7);
std::allocator<char>::~allocator(&v6);
}
std::vector<std::string>::pop_back(a1);
v10 = 1;
std::istringstream::~istringstream(v11);
return a1;
}
|
SplitString:
SUB RSP,0x1e8
MOV qword ptr [RSP + 0x10],RDI
MOV AL,DL
MOV RCX,RDI
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x1e0],RDI
MOV qword ptr [RSP + 0x1d8],RSI
MOV byte ptr [RSP + 0x1d7],AL
MOV RSI,qword ptr [RSP + 0x1d8]
LEA RDI,[RSP + 0x50]
MOV EDX,0x8
CALL 0x001090d0
MOV byte ptr [RSP + 0x4f],0x0
LEA RDI,[RSP + 0x4e]
CALL 0x0012a350
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0x1
LEA RDX,[RSP + 0x4e]
CALL 0x0012a360
LEA RDI,[RSP + 0x4e]
CALL 0x0012a3c0
LAB_00128861:
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x40]
CALL 0x0012a3d0
LEA RDI,[RSP + 0x40]
CALL 0x0012a420
MOV RSI,RAX
LEA RDI,[RSP + 0x50]
MOVSX EDX,byte ptr [RSP + 0x1d7]
CALL 0x00109280
MOV RDI,RAX
MOV RAX,qword ptr [RDI]
ADD RDI,qword ptr [RAX + -0x18]
CALL 0x00109a90
TEST AL,0x1
JNZ 0x001288a4
JMP 0x001288ec
LAB_001288a4:
LEA RDI,[RSP + 0x1f]
CALL 0x00109220
LEA RDI,[RSP + 0x20]
LEA RSI,[0x19f78d]
LEA RDX,[RSP + 0x1f]
CALL 0x00112a40
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x20]
CALL 0x0012a450
LEA RDI,[RSP + 0x20]
CALL 0x00112a10
LEA RDI,[RSP + 0x1f]
CALL 0x00109d60
JMP 0x00128861
LAB_001288ec:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0012a480
MOV byte ptr [RSP + 0x4f],0x1
TEST byte ptr [RSP + 0x4f],0x1
JNZ 0x0012890c
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0012a4a0
LAB_0012890c:
LEA RDI,[RSP + 0x50]
CALL 0x00109790
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x1e8
RET
|
/* WARNING: Removing unreachable block (ram,0x00128902) */
/* SplitString(std::__cxx11::string const&, char) */
string * SplitString(string *param_1,char param_2)
{
bool bVar1;
string *psVar2;
istream *piVar3;
char in_DL;
int7 in_register_00000031;
allocator local_1c9;
string local_1c8 [32];
reverse_iterator<__gnu_cxx::__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
local_1a8 [14];
allocator<std::__cxx11::string> local_19a;
int1 local_199;
istringstream local_198 [391];
char local_11;
int8 local_10;
string *local_8;
local_10 = CONCAT71(in_register_00000031,param_2);
local_11 = in_DL;
local_8 = param_1;
std::__cxx11::istringstream::istringstream(local_198,local_10,8);
local_199 = 0;
std::allocator<std::__cxx11::string>::allocator(&local_19a);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,1,
(allocator *)&local_19a);
std::allocator<std::__cxx11::string>::~allocator(&local_19a);
while( true ) {
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::rbegin();
psVar2 = (string *)
std::
reverse_iterator<__gnu_cxx::__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::operator*(local_1a8);
piVar3 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_198,psVar2,local_11);
bVar1 = std::ios::operator_cast_to_bool((ios *)(piVar3 + *(long *)(*(long *)piVar3 + -0x18)));
if (!bVar1) break;
std::allocator<char>::allocator();
std::__cxx11::string::string<std::allocator<char>>(local_1c8,"",&local_1c9);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
local_1c8);
std::__cxx11::string::~string(local_1c8);
std::allocator<char>::~allocator((allocator<char> *)&local_1c9);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::pop_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1);
local_199 = 1;
std::__cxx11::istringstream::~istringstream(local_198);
return param_1;
}
|
|
58,547
|
my_register_filename
|
eloqsql/mysys/my_open.c
|
File my_register_filename(File fd, const char *FileName, enum file_type
type_of_file, uint error_message_number, myf MyFlags)
{
DBUG_ENTER("my_register_filename");
if ((int) fd >= MY_FILE_MIN)
{
my_atomic_add32_explicit(&my_file_opened, 1, MY_MEMORY_ORDER_RELAXED);
if ((uint) fd >= my_file_limit || (MyFlags & MY_NO_REGISTER))
DBUG_RETURN(fd);
my_file_info[fd].name = my_strdup(key_memory_my_file_info, FileName, MyFlags);
statistic_increment(my_file_total_opened,&THR_LOCK_open);
my_file_info[fd].type = type_of_file;
DBUG_PRINT("exit",("fd: %d",fd));
DBUG_RETURN(fd);
}
my_errno= errno;
DBUG_PRINT("error",("Got error %d on open", my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
{
if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
FileName, my_errno);
}
DBUG_RETURN(-1);
}
|
O0
|
c
|
my_register_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x8ba46
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0x381660(%rip), %rcx # 0x40d004
lock
xaddl %eax, (%rcx)
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %eax
leaq 0x1be72b(%rip), %rcx # 0x24a0e0
cmpl (%rcx), %eax
jae 0x8b9c9
movq -0x20(%rbp), %rax
andq $0x2004, %rax # imm = 0x2004
cmpq $0x0, %rax
je 0x8b9d6
jmp 0x8b9cb
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8babd
leaq 0x381b57(%rip), %rax # 0x40d534
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8b390
movq %rax, %rcx
leaq 0x1be6f2(%rip), %rax # 0x24a0e8
movq (%rax), %rax
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
leaq 0x3815e2(%rip), %rax # 0x40cff0
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x3815d4(%rip), %rax # 0x40cff0
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
leaq 0x1be6bf(%rip), %rax # 0x24a0e8
movq (%rax), %rax
movslq -0x8(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x8ba3c
jmp 0x8ba3e
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8babd
callq 0x389e0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x8ca30
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8ba5c
movq -0x20(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
je 0x8bab4
callq 0x8ca30
cmpl $0x18, (%rax)
jne 0x8ba7b
movl $0x17, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
andq $0x440, %rax # imm = 0x440
orq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x8ca30
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl (%rax), %ecx
movb $0x0, %al
callq 0x85630
jmp 0x8bab6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_register_filename:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov [rbp+var_20], r8
cmp [rbp+var_8], 0
jl loc_8BA46
mov [rbp+var_24], 1
mov eax, [rbp+var_24]
lea rcx, my_file_opened
lock xadd [rcx], eax
mov [rbp+var_28], eax
mov eax, [rbp+var_8]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb short loc_8B9C9
mov rax, [rbp+var_20]
and rax, 2004h
cmp rax, 0
jz short loc_8B9D6
loc_8B9C9:
jmp short $+2
loc_8B9CB:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp loc_8BABD
loc_8B9D6:
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_20]
call my_strdup
mov rcx, rax
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_8]
shl rdx, 4
add rax, rdx
mov [rax], rcx
lea rax, my_file_total_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_file_total_opened
mov [rax], rcx
mov ecx, [rbp+var_14]
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_8]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short $+2
loc_8BA3C:
jmp short $+2
loc_8BA3E:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp short loc_8BABD
loc_8BA46:
call ___errno_location
mov eax, [rax]
mov [rbp+var_2C], eax
call _my_thread_var
mov ecx, [rbp+var_2C]
mov [rax], ecx
jmp short $+2
loc_8BA5C:
mov rax, [rbp+var_20]
and rax, 19h
cmp rax, 0
jz short loc_8BAB4
call _my_thread_var
cmp dword ptr [rax], 18h
jnz short loc_8BA7B
mov [rbp+var_18], 17h
loc_8BA7B:
mov eax, [rbp+var_18]
mov [rbp+var_44], eax
mov rax, [rbp+var_20]
and rax, 440h
or rax, 4
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
call _my_thread_var
mov edi, [rbp+var_44]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
mov ecx, [rax]
mov al, 0
call my_error
loc_8BAB4:
jmp short $+2
loc_8BAB6:
mov [rbp+var_4], 0FFFFFFFFh
loc_8BABD:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long my_register_filename(long long a1, long long a2, int a3, unsigned int a4, __int16 a5)
{
unsigned int *v5; // rax
int v7; // [rsp+24h] [rbp-2Ch]
if ( (int)a1 < 0 )
{
v7 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var() = v7;
if ( (a5 & 0x19) != 0 )
{
if ( *(_DWORD *)my_thread_var() == 24 )
a4 = 23;
v5 = (unsigned int *)my_thread_var();
my_error(a4, a5 & 0x440 | 4LL, a2, *v5);
}
return (unsigned int)-1;
}
else
{
_InterlockedExchangeAdd(my_file_opened, 1u);
if ( (unsigned int)a1 >= my_file_limit || (a5 & 0x2004) != 0 )
{
return (unsigned int)a1;
}
else
{
*((_QWORD *)my_file_info + 2 * (int)a1) = my_strdup(key_memory_my_file_info, a2, a5);
++my_file_total_opened;
*((_DWORD *)my_file_info + 4 * (int)a1 + 2) = a3;
return (unsigned int)a1;
}
}
}
|
my_register_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV qword ptr [RBP + -0x20],R8
CMP dword ptr [RBP + -0x8],0x0
JL 0x0018ba46
MOV dword ptr [RBP + -0x24],0x1
MOV EAX,dword ptr [RBP + -0x24]
LEA RCX,[0x50d004]
XADD.LOCK dword ptr [RCX],EAX
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x8]
LEA RCX,[0x34a0e0]
CMP EAX,dword ptr [RCX]
JNC 0x0018b9c9
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x2004
CMP RAX,0x0
JZ 0x0018b9d6
LAB_0018b9c9:
JMP 0x0018b9cb
LAB_0018b9cb:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018babd
LAB_0018b9d6:
LEA RAX,[0x50d534]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0018b390
MOV RCX,RAX
LEA RAX,[0x34a0e8]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x8]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LEA RAX,[0x50cff0]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x50cff0]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x14]
LEA RAX,[0x34a0e8]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x8]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x0018ba3c
LAB_0018ba3c:
JMP 0x0018ba3e
LAB_0018ba3e:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018babd
LAB_0018ba46:
CALL 0x001389e0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
CALL 0x0018ca30
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
JMP 0x0018ba5c
LAB_0018ba5c:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x19
CMP RAX,0x0
JZ 0x0018bab4
CALL 0x0018ca30
CMP dword ptr [RAX],0x18
JNZ 0x0018ba7b
MOV dword ptr [RBP + -0x18],0x17
LAB_0018ba7b:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x440
OR RAX,0x4
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
CALL 0x0018ca30
MOV EDI,dword ptr [RBP + -0x44]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX]
MOV AL,0x0
CALL 0x00185630
LAB_0018bab4:
JMP 0x0018bab6
LAB_0018bab6:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_0018babd:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
uint my_register_filename
(uint param_1,int8 param_2,int4 param_3,int4 param_4,ulong param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int4 *puVar4;
int4 local_20;
uint local_c;
if ((int)param_1 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_5 & 0x19) != 0) {
piVar3 = (int *)_my_thread_var();
local_20 = param_4;
if (*piVar3 == 0x18) {
local_20 = 0x17;
}
puVar4 = (int4 *)_my_thread_var();
my_error(local_20,param_5 & 0x440 | 4,param_2,*puVar4);
}
local_c = 0xffffffff;
}
else {
LOCK();
my_file_opened = my_file_opened + 1;
UNLOCK();
local_c = param_1;
if ((param_1 < my_file_limit) && ((param_5 & 0x2004) == 0)) {
uVar2 = my_strdup(key_memory_my_file_info,param_2,param_5);
*(int8 *)(my_file_info + (long)(int)param_1 * 0x10) = uVar2;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (long)(int)param_1 * 0x10 + 8) = param_3;
}
}
return local_c;
}
|
|
58,548
|
my_register_filename
|
eloqsql/mysys/my_open.c
|
File my_register_filename(File fd, const char *FileName, enum file_type
type_of_file, uint error_message_number, myf MyFlags)
{
DBUG_ENTER("my_register_filename");
if ((int) fd >= MY_FILE_MIN)
{
my_atomic_add32_explicit(&my_file_opened, 1, MY_MEMORY_ORDER_RELAXED);
if ((uint) fd >= my_file_limit || (MyFlags & MY_NO_REGISTER))
DBUG_RETURN(fd);
my_file_info[fd].name = my_strdup(key_memory_my_file_info, FileName, MyFlags);
statistic_increment(my_file_total_opened,&THR_LOCK_open);
my_file_info[fd].type = type_of_file;
DBUG_PRINT("exit",("fd: %d",fd));
DBUG_RETURN(fd);
}
my_errno= errno;
DBUG_PRINT("error",("Got error %d on open", my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
{
if (my_errno == EMFILE)
error_message_number= EE_OUT_OF_FILERESOURCES;
my_error(error_message_number,
MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
FileName, my_errno);
}
DBUG_RETURN(-1);
}
|
O3
|
c
|
my_register_filename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rsi, %r15
testl %edi, %edi
js 0x307bd
movl %edi, %ebx
leaq 0x348d45(%rip), %rax # 0x3794a4
lock
incl (%rax)
testl $0x2004, %r14d # imm = 0x2004
jne 0x3080c
leaq 0x2c9efa(%rip), %rax # 0x2fa670
cmpl %ebx, (%rax)
jbe 0x3080c
movl %edx, %r13d
leaq 0x34924c(%rip), %rax # 0x3799d4
movl (%rax), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3039c
leaq 0x2c9edc(%rip), %rcx # 0x2fa678
movq (%rcx), %rdx
movl %ebx, %esi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
leaq 0x348ce0(%rip), %rax # 0x379490
incq (%rax)
movq (%rcx), %rax
movl %r13d, 0x8(%rax,%rsi)
jmp 0x3080c
movl %ecx, %r12d
callq 0x24050
movl (%rax), %ebx
callq 0x3193e
movl %ebx, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testb $0x19, %r14b
je 0x3080c
callq 0x3193e
cmpl $0x18, (%rax)
movl $0x17, %eax
cmovel %eax, %r12d
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
callq 0x3193e
movl (%rax), %ecx
movl %r12d, %edi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2cce7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_register_filename:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rsi
test edi, edi
js short loc_307BD
mov ebx, edi
lea rax, my_file_opened
lock inc dword ptr [rax]
test r14d, 2004h
jnz loc_3080C
lea rax, my_file_limit
cmp [rax], ebx
jbe loc_3080C
mov r13d, edx
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, r15
mov rdx, r14
call my_strdup
lea rcx, my_file_info
mov rdx, [rcx]
mov esi, ebx
shl rsi, 4
mov [rdx+rsi], rax
lea rax, my_file_total_opened
inc qword ptr [rax]
mov rax, [rcx]
mov [rax+rsi+8], r13d
jmp short loc_3080C
loc_307BD:
mov r12d, ecx
call ___errno_location
mov ebx, [rax]
call _my_thread_var
mov [rax], ebx
mov ebx, 0FFFFFFFFh
test r14b, 19h
jz short loc_3080C
call _my_thread_var
cmp dword ptr [rax], 18h
mov eax, 17h
cmovz r12d, eax
and r14d, 440h
or r14, 4
call _my_thread_var
mov ecx, [rax]
mov edi, r12d
mov rsi, r14
mov rdx, r15
xor eax, eax
call my_error
loc_3080C:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_register_filename(long long a1, long long a2, int a3, unsigned int a4, __int16 a5)
{
unsigned int v6; // ebx
long long v8; // rax
long long v9; // rsi
int v11; // ebx
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
long long v20; // rdx
long long v21; // rcx
long long v22; // r8
long long v23; // r9
unsigned int *v24; // rax
if ( (int)a1 < 0 )
{
v11 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var(a1, a2, v12, v13, v14, v15) = v11;
v6 = -1;
if ( (a5 & 0x19) != 0 )
{
if ( *(_DWORD *)my_thread_var(a1, a2, v16, v17, v18, v19) == 24 )
a4 = 23;
v24 = (unsigned int *)my_thread_var(a1, a2, v20, v21, v22, v23);
my_error(a4, a5 & 0x440 | 4LL, a2, *v24);
}
}
else
{
v6 = a1;
_InterlockedIncrement(my_file_opened);
if ( (a5 & 0x2004) == 0 && my_file_limit > (unsigned int)a1 )
{
v8 = my_strdup(key_memory_my_file_info, a2, a5);
v9 = 16LL * (unsigned int)a1;
*(_QWORD *)((char *)my_file_info + v9) = v8;
++my_file_total_opened;
*(_DWORD *)((char *)my_file_info + v9 + 8) = a3;
}
}
return v6;
}
|
my_register_filename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RSI
TEST EDI,EDI
JS 0x001307bd
MOV EBX,EDI
LEA RAX,[0x4794a4]
INC.LOCK dword ptr [RAX]
TEST R14D,0x2004
JNZ 0x0013080c
LEA RAX,[0x3fa670]
CMP dword ptr [RAX],EBX
JBE 0x0013080c
MOV R13D,EDX
LEA RAX,[0x4799d4]
MOV EDI,dword ptr [RAX]
MOV RSI,R15
MOV RDX,R14
CALL 0x0013039c
LEA RCX,[0x3fa678]
MOV RDX,qword ptr [RCX]
MOV ESI,EBX
SHL RSI,0x4
MOV qword ptr [RDX + RSI*0x1],RAX
LEA RAX,[0x479490]
INC qword ptr [RAX]
MOV RAX,qword ptr [RCX]
MOV dword ptr [RAX + RSI*0x1 + 0x8],R13D
JMP 0x0013080c
LAB_001307bd:
MOV R12D,ECX
CALL 0x00124050
MOV EBX,dword ptr [RAX]
CALL 0x0013193e
MOV dword ptr [RAX],EBX
MOV EBX,0xffffffff
TEST R14B,0x19
JZ 0x0013080c
CALL 0x0013193e
CMP dword ptr [RAX],0x18
MOV EAX,0x17
CMOVZ R12D,EAX
AND R14D,0x440
OR R14,0x4
CALL 0x0013193e
MOV ECX,dword ptr [RAX]
MOV EDI,R12D
MOV RSI,R14
MOV RDX,R15
XOR EAX,EAX
CALL 0x0012cce7
LAB_0013080c:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint my_register_filename
(uint param_1,int8 param_2,int4 param_3,int4 param_4,ulong param_5)
{
int iVar1;
int8 uVar2;
int *piVar3;
int4 *puVar4;
if ((int)param_1 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
param_1 = 0xffffffff;
if ((param_5 & 0x19) != 0) {
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 0x18) {
param_4 = 0x17;
}
puVar4 = (int4 *)_my_thread_var();
my_error(param_4,(uint)param_5 & 0x440 | 4,param_2,*puVar4);
}
}
else {
LOCK();
my_file_opened = my_file_opened + 1;
UNLOCK();
if (((param_5 & 0x2004) == 0) && (param_1 < my_file_limit)) {
uVar2 = my_strdup(key_memory_my_file_info,param_2,param_5);
*(int8 *)(my_file_info + (ulong)param_1 * 0x10) = uVar2;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (ulong)param_1 * 0x10 + 8) = param_3;
}
}
return param_1;
}
|
|
58,549
|
ma_check_env_str
|
eloqsql/libmariadb/include/ma_string.h
|
static inline my_bool ma_check_env_str(const char *env)
{
unsigned int i;
if (!env)
return 1;
for (i=0; i < MAX_ENV_SIZE; i++)
{
if (env[i] == 0)
break;
}
if (i >= MAX_ENV_SIZE)
return 1;
return 0;
}
|
O0
|
c
|
ma_check_env_str:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x50b95
movb $0x1, -0x1(%rbp)
jmp 0x50bd7
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jae 0x50bc4
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x50bb7
jmp 0x50bc4
jmp 0x50bb9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50b9c
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jb 0x50bd3
movb $0x1, -0x1(%rbp)
jmp 0x50bd7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
|
ma_check_env_str:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_50B95
mov [rbp+var_1], 1
jmp short loc_50BD7
loc_50B95:
mov [rbp+var_14], 0
loc_50B9C:
cmp [rbp+var_14], 400h
jnb short loc_50BC4
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
movsx eax, byte ptr [rax+rcx]
cmp eax, 0
jnz short loc_50BB7
jmp short loc_50BC4
loc_50BB7:
jmp short $+2
loc_50BB9:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_50B9C
loc_50BC4:
cmp [rbp+var_14], 400h
jb short loc_50BD3
mov [rbp+var_1], 1
jmp short loc_50BD7
loc_50BD3:
mov [rbp+var_1], 0
loc_50BD7:
mov al, [rbp+var_1]
pop rbp
retn
|
bool ma_check_env_str(long long a1)
{
unsigned int i; // [rsp+0h] [rbp-14h]
if ( !a1 )
return 1;
for ( i = 0; i < 0x400 && *(_BYTE *)(a1 + i); ++i )
;
return i >= 0x400;
}
|
ma_check_env_str:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00150b95
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00150bd7
LAB_00150b95:
MOV dword ptr [RBP + -0x14],0x0
LAB_00150b9c:
CMP dword ptr [RBP + -0x14],0x400
JNC 0x00150bc4
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JNZ 0x00150bb7
JMP 0x00150bc4
LAB_00150bb7:
JMP 0x00150bb9
LAB_00150bb9:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00150b9c
LAB_00150bc4:
CMP dword ptr [RBP + -0x14],0x400
JC 0x00150bd3
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00150bd7
LAB_00150bd3:
MOV byte ptr [RBP + -0x1],0x0
LAB_00150bd7:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 ma_check_env_str(long param_1)
{
uint local_1c;
int1 local_9;
if (param_1 == 0) {
local_9 = 1;
}
else {
for (local_1c = 0; (local_1c < 0x400 && (*(char *)(param_1 + (ulong)local_1c) != '\0'));
local_1c = local_1c + 1) {
}
if (local_1c < 0x400) {
local_9 = 0;
}
else {
local_9 = 1;
}
}
return local_9;
}
|
|
58,550
|
get_first_set
|
eloqsql/mysys/my_bitmap.c
|
static inline uint get_first_set(my_bitmap_map value, uint word_pos)
{
uchar *byte_ptr= (uchar*)&value;
uchar byte_value;
uint byte_pos, bit_pos;
DBUG_ASSERT(value);
for (byte_pos=0; ; byte_pos++, byte_ptr++)
{
if ((byte_value= *byte_ptr))
{
for (bit_pos=0; ; bit_pos++)
if (byte_value & (1 << bit_pos))
return (word_pos*32) + (byte_pos*8) + bit_pos;
}
}
return MY_BIT_NONE; /* Impossible */
}
|
O0
|
c
|
get_first_set:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf04a4
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0xf04f6
movl $0x0, -0x1c(%rbp)
movzbl -0x11(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xf04e9
movl -0x8(%rbp), %eax
shll $0x5, %eax
movl -0x18(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
popq %rbp
retq
jmp 0xf04eb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf04bf
jmp 0xf04f8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf04ab
nop
|
get_first_set:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
lea rax, [rbp+var_4]
mov [rbp+var_10], rax
jmp short $+2
loc_F04A4:
mov [rbp+var_18], 0
loc_F04AB:
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_11], al
cmp al, 0
jz short loc_F04F6
mov [rbp+var_1C], 0
loc_F04BF:
movzx eax, [rbp+var_11]
mov ecx, [rbp+var_1C]
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jz short loc_F04E9
mov eax, [rbp+var_8]
shl eax, 5
mov ecx, [rbp+var_18]
shl ecx, 3
add eax, ecx
add eax, [rbp+var_1C]
pop rbp
retn
loc_F04E9:
jmp short $+2
loc_F04EB:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_F04BF
loc_F04F6:
jmp short $+2
loc_F04F8:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_F04AB
|
long long get_first_set(int a1, int a2)
{
int i; // [rsp+0h] [rbp-1Ch]
int v4; // [rsp+4h] [rbp-18h]
int *v5; // [rsp+Ch] [rbp-10h]
int v6; // [rsp+18h] [rbp-4h] BYREF
v6 = a1;
v5 = &v6;
v4 = 0;
while ( !*(_BYTE *)v5 )
{
++v4;
v5 = (int *)((char *)v5 + 1);
}
for ( i = 0; ((1 << i) & *(unsigned __int8 *)v5) == 0; ++i )
;
return (unsigned int)(i + 8 * v4 + 32 * a2);
}
|
get_first_set:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
LEA RAX,[RBP + -0x4]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f04a4
LAB_001f04a4:
MOV dword ptr [RBP + -0x18],0x0
LAB_001f04ab:
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
CMP AL,0x0
JZ 0x001f04f6
MOV dword ptr [RBP + -0x1c],0x0
LAB_001f04bf:
MOVZX EAX,byte ptr [RBP + -0x11]
MOV ECX,dword ptr [RBP + -0x1c]
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JZ 0x001f04e9
MOV EAX,dword ptr [RBP + -0x8]
SHL EAX,0x5
MOV ECX,dword ptr [RBP + -0x18]
SHL ECX,0x3
ADD EAX,ECX
ADD EAX,dword ptr [RBP + -0x1c]
POP RBP
RET
LAB_001f04e9:
JMP 0x001f04eb
LAB_001f04eb:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001f04bf
LAB_001f04f6:
JMP 0x001f04f8
LAB_001f04f8:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f04ab
|
int get_first_set(int8 param_1,int param_2)
{
int local_24;
int local_20;
byte *local_18;
byte local_c [4];
local_20 = 0;
for (local_18 = local_c; *local_18 == 0; local_18 = local_18 + 1) {
local_20 = local_20 + 1;
}
local_24 = 0;
while (((uint)*local_18 & 1 << ((byte)local_24 & 0x1f)) == 0) {
local_24 = local_24 + 1;
}
return param_2 * 0x20 + local_20 * 8 + local_24;
}
|
|
58,551
|
PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
void PFS_table::safe_aggregate_io(const TABLE_SHARE *optional_server_share,
PFS_table_stat *table_stat,
PFS_table_share *table_share)
{
assert(table_stat != NULL);
assert(table_share != NULL);
uint key_count= sanitize_index_count(table_share->m_key_count);
PFS_table_share_index *to_stat;
PFS_table_io_stat *from_stat;
uint index;
assert(key_count <= MAX_INDEXES);
/* Aggregate stats for each index, if any */
for (index= 0; index < key_count; index++)
{
from_stat= & table_stat->m_index_stat[index];
if (from_stat->m_has_data)
{
if (optional_server_share != NULL)
{
/*
An instrumented thread is closing a table,
and capable of providing index names when
creating index statistics on the fly.
*/
to_stat= table_share->find_or_create_index_stat(optional_server_share, index);
}
else
{
/*
A monitoring thread, performing TRUNCATE TABLE,
is asking to flush existing stats from table handles,
but it does not know about index names used in handles.
If the index stat already exists, find it and aggregate to it.
It the index stat does not exist yet, drop the stat and do nothing.
*/
to_stat= table_share->find_index_stat(index);
}
if (to_stat != NULL)
{
/* Aggregate to TABLE_IO_SUMMARY */
to_stat->m_stat.aggregate(from_stat);
}
}
}
/* Aggregate stats for the table */
from_stat= & table_stat->m_index_stat[MAX_INDEXES];
if (from_stat->m_has_data)
{
to_stat= table_share->find_or_create_index_stat(NULL, MAX_INDEXES);
if (to_stat != NULL)
{
/* Aggregate to TABLE_IO_SUMMARY */
to_stat->m_stat.aggregate(from_stat);
}
}
table_stat->fast_reset_io();
}
|
O0
|
cpp
|
PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1ac(%rax), %edi
callq 0x31b40
movl %eax, -0x1c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x3ba4a
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x3ba3d
cmpq $0x0, -0x8(%rbp)
je 0x3ba10
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x2da50
movq %rax, -0x28(%rbp)
jmp 0x3ba20
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x2da00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3ba3b
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq -0x30(%rbp), %rsi
callq 0x31b70
jmp 0x3ba3d
jmp 0x3ba3f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3b9cd
movq -0x10(%rbp), %rax
addq $0x2200, %rax # imm = 0x2200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x3ba94
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x40, %edx
callq 0x2da50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3ba92
movq -0x28(%rbp), %rdi
addq $0xc8, %rdi
movq -0x30(%rbp), %rsi
callq 0x31b70
jmp 0x3ba94
movq -0x10(%rbp), %rdi
callq 0x40480
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN9PFS_table17safe_aggregate_ioEPK11TABLE_SHAREP14PFS_table_statP15PFS_table_share:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov edi, [rax+1ACh]; unsigned int
call _Z20sanitize_index_countj; sanitize_index_count(uint)
mov [rbp+var_1C], eax
mov [rbp+var_34], 0
loc_3B9CD:
mov eax, [rbp+var_34]
cmp eax, [rbp+var_1C]
jnb short loc_3BA4A
mov rax, [rbp+var_10]
mov ecx, [rbp+var_34]
imul rcx, 88h
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
test byte ptr [rax], 1
jz short loc_3BA3D
cmp [rbp+var_8], 0
jz short loc_3BA10
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_8]
mov edx, [rbp+var_34]
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
mov [rbp+var_28], rax
jmp short loc_3BA20
loc_3BA10:
mov rdi, [rbp+var_18]; this
mov esi, [rbp+var_34]; unsigned int
call _ZNK15PFS_table_share15find_index_statEj; PFS_table_share::find_index_stat(uint)
mov [rbp+var_28], rax
loc_3BA20:
cmp [rbp+var_28], 0
jz short loc_3BA3B
mov rdi, [rbp+var_28]
add rdi, 0C8h; this
mov rsi, [rbp+var_30]; PFS_table_io_stat *
call _ZN17PFS_table_io_stat9aggregateEPKS_; PFS_table_io_stat::aggregate(PFS_table_io_stat const*)
loc_3BA3B:
jmp short $+2
loc_3BA3D:
jmp short $+2
loc_3BA3F:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
jmp short loc_3B9CD
loc_3BA4A:
mov rax, [rbp+var_10]
add rax, 2200h
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
test byte ptr [rax], 1
jz short loc_3BA94
mov rdi, [rbp+var_18]
xor eax, eax
mov esi, eax
mov edx, 40h ; '@'
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_3BA92
mov rdi, [rbp+var_28]
add rdi, 0C8h; this
mov rsi, [rbp+var_30]; PFS_table_io_stat *
call _ZN17PFS_table_io_stat9aggregateEPKS_; PFS_table_io_stat::aggregate(PFS_table_io_stat const*)
loc_3BA92:
jmp short $+2
loc_3BA94:
mov rdi, [rbp+var_10]; this
call _ZN14PFS_table_stat13fast_reset_ioEv; PFS_table_stat::fast_reset_io(void)
add rsp, 40h
pop rbp
retn
|
long long PFS_table::safe_aggregate_io(long long a1, long long a2, unsigned int *a3)
{
unsigned int i; // [rsp+Ch] [rbp-34h]
PFS_table_io_stat *v5; // [rsp+10h] [rbp-30h]
signed long long index_stat; // [rsp+18h] [rbp-28h]
signed long long v7; // [rsp+18h] [rbp-28h]
unsigned int v8; // [rsp+24h] [rbp-1Ch]
v8 = sanitize_index_count(a3[107]);
for ( i = 0; i < v8; ++i )
{
v5 = (PFS_table_io_stat *)(136LL * i + a2);
if ( (*(_BYTE *)v5 & 1) != 0 )
{
if ( a1 )
index_stat = PFS_table_share::find_or_create_index_stat((long long)a3, a1, i);
else
index_stat = PFS_table_share::find_index_stat((PFS_table_share *)a3, i);
if ( index_stat )
PFS_table_io_stat::aggregate((PFS_table_io_stat *)(index_stat + 200), v5);
}
}
if ( (*(_BYTE *)(a2 + 8704) & 1) != 0 )
{
v7 = PFS_table_share::find_or_create_index_stat((long long)a3, 0LL, 0x40u);
if ( v7 )
PFS_table_io_stat::aggregate((PFS_table_io_stat *)(v7 + 200), (const PFS_table_io_stat *)(a2 + 8704));
}
return PFS_table_stat::fast_reset_io((PFS_table_stat *)a2);
}
|
safe_aggregate_io:
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 RAX,qword ptr [RBP + -0x18]
MOV EDI,dword ptr [RAX + 0x1ac]
CALL 0x00131b40
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x34],0x0
LAB_0013b9cd:
MOV EAX,dword ptr [RBP + -0x34]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0013ba4a
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x34]
IMUL RCX,RCX,0x88
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
TEST byte ptr [RAX],0x1
JZ 0x0013ba3d
CMP qword ptr [RBP + -0x8],0x0
JZ 0x0013ba10
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0x34]
CALL 0x0012da50
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0013ba20
LAB_0013ba10:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x34]
CALL 0x0012da00
MOV qword ptr [RBP + -0x28],RAX
LAB_0013ba20:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013ba3b
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xc8
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00131b70
LAB_0013ba3b:
JMP 0x0013ba3d
LAB_0013ba3d:
JMP 0x0013ba3f
LAB_0013ba3f:
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0013b9cd
LAB_0013ba4a:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2200
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
TEST byte ptr [RAX],0x1
JZ 0x0013ba94
MOV RDI,qword ptr [RBP + -0x18]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x40
CALL 0x0012da50
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0013ba92
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xc8
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00131b70
LAB_0013ba92:
JMP 0x0013ba94
LAB_0013ba94:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00140480
ADD RSP,0x40
POP RBP
RET
|
/* PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*) */
void PFS_table::safe_aggregate_io
(TABLE_SHARE *param_1,PFS_table_stat *param_2,PFS_table_share *param_3)
{
uint uVar1;
long lVar2;
uint local_3c;
long local_30;
uVar1 = sanitize_index_count(*(uint *)(param_3 + 0x1ac));
for (local_3c = 0; local_3c < uVar1; local_3c = local_3c + 1) {
if (((byte)*(PFS_table_io_stat *)(param_2 + (ulong)local_3c * 0x88) & 1) != 0) {
if (param_1 == (TABLE_SHARE *)0x0) {
local_30 = PFS_table_share::find_index_stat(param_3,local_3c);
}
else {
local_30 = PFS_table_share::find_or_create_index_stat(param_3,param_1,local_3c);
}
if (local_30 != 0) {
PFS_table_io_stat::aggregate
((PFS_table_io_stat *)(local_30 + 200),
(PFS_table_io_stat *)(param_2 + (ulong)local_3c * 0x88));
}
}
}
if ((((byte)*(PFS_table_io_stat *)(param_2 + 0x2200) & 1) != 0) &&
(lVar2 = PFS_table_share::find_or_create_index_stat(param_3,(TABLE_SHARE *)0x0,0x40),
lVar2 != 0)) {
PFS_table_io_stat::aggregate
((PFS_table_io_stat *)(lVar2 + 200),(PFS_table_io_stat *)(param_2 + 0x2200));
}
PFS_table_stat::fast_reset_io(param_2);
return;
}
|
|
58,552
|
PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
void PFS_table::safe_aggregate_io(const TABLE_SHARE *optional_server_share,
PFS_table_stat *table_stat,
PFS_table_share *table_share)
{
assert(table_stat != NULL);
assert(table_share != NULL);
uint key_count= sanitize_index_count(table_share->m_key_count);
PFS_table_share_index *to_stat;
PFS_table_io_stat *from_stat;
uint index;
assert(key_count <= MAX_INDEXES);
/* Aggregate stats for each index, if any */
for (index= 0; index < key_count; index++)
{
from_stat= & table_stat->m_index_stat[index];
if (from_stat->m_has_data)
{
if (optional_server_share != NULL)
{
/*
An instrumented thread is closing a table,
and capable of providing index names when
creating index statistics on the fly.
*/
to_stat= table_share->find_or_create_index_stat(optional_server_share, index);
}
else
{
/*
A monitoring thread, performing TRUNCATE TABLE,
is asking to flush existing stats from table handles,
but it does not know about index names used in handles.
If the index stat already exists, find it and aggregate to it.
It the index stat does not exist yet, drop the stat and do nothing.
*/
to_stat= table_share->find_index_stat(index);
}
if (to_stat != NULL)
{
/* Aggregate to TABLE_IO_SUMMARY */
to_stat->m_stat.aggregate(from_stat);
}
}
}
/* Aggregate stats for the table */
from_stat= & table_stat->m_index_stat[MAX_INDEXES];
if (from_stat->m_has_data)
{
to_stat= table_share->find_or_create_index_stat(NULL, MAX_INDEXES);
if (to_stat != NULL)
{
/* Aggregate to TABLE_IO_SUMMARY */
to_stat->m_stat.aggregate(from_stat);
}
}
table_stat->fast_reset_io();
}
|
O3
|
cpp
|
PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movl 0x1ac(%rdx), %ebx
leal -0x1(%rbx), %eax
cmpl $0x3f, %eax
ja 0x37c56
movq %rdi, %r15
xorl %r12d, %r12d
movq -0x30(%rbp), %r13
cmpb $0x1, (%r13)
jne 0x37c47
movq %r14, %rdi
testq %r15, %r15
je 0x37c29
movq %r15, %rsi
movl %r12d, %edx
callq 0x2fe4c
jmp 0x37c31
movl %r12d, %esi
callq 0x2fe3c
testq %rax, %rax
je 0x37c47
addq $0xc8, %rax
movq %rax, %rdi
movq %r13, %rsi
callq 0x3aa1c
incq %r12
addq $0x88, %r13
cmpq %rbx, %r12
jb 0x37c0d
movq -0x30(%rbp), %rbx
cmpb $0x1, 0x2200(%rbx)
jne 0x37c8c
movq %r14, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2fe4c
testq %rax, %rax
je 0x37c8c
leaq 0x2200(%rbx), %rsi
addq $0xc8, %rax
movq %rax, %rdi
callq 0x3aa1c
leaq 0x39913d(%rip), %rsi # 0x3d0dd0
movl $0x2288, %edx # imm = 0x2288
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26290
|
_ZN9PFS_table17safe_aggregate_ioEPK11TABLE_SHAREP14PFS_table_statP15PFS_table_share:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov [rbp+var_30], rsi
mov ebx, [rdx+1ACh]
lea eax, [rbx-1]
cmp eax, 3Fh ; '?'
ja short loc_37C56
mov r15, rdi
xor r12d, r12d
mov r13, [rbp+var_30]
loc_37C0D:
cmp byte ptr [r13+0], 1
jnz short loc_37C47
mov rdi, r14; this
test r15, r15
jz short loc_37C29
mov rsi, r15
mov edx, r12d
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
jmp short loc_37C31
loc_37C29:
mov esi, r12d; unsigned int
call _ZNK15PFS_table_share15find_index_statEj; PFS_table_share::find_index_stat(uint)
loc_37C31:
test rax, rax
jz short loc_37C47
add rax, 0C8h
mov rdi, rax
mov rsi, r13
call _ZN17PFS_table_io_stat9aggregateEPKS_; PFS_table_io_stat::aggregate(PFS_table_io_stat const*)
loc_37C47:
inc r12
add r13, 88h
cmp r12, rbx
jb short loc_37C0D
loc_37C56:
mov rbx, [rbp+var_30]
cmp byte ptr [rbx+2200h], 1
jnz short loc_37C8C
mov rdi, r14
xor esi, esi
mov edx, 40h ; '@'
call _ZN15PFS_table_share25find_or_create_index_statEPK11TABLE_SHAREj; PFS_table_share::find_or_create_index_stat(TABLE_SHARE const*,uint)
test rax, rax
jz short loc_37C8C
lea rsi, [rbx+2200h]
add rax, 0C8h
mov rdi, rax
call _ZN17PFS_table_io_stat9aggregateEPKS_; PFS_table_io_stat::aggregate(PFS_table_io_stat const*)
loc_37C8C:
lea rsi, _ZN14PFS_table_stat16g_reset_templateE; PFS_table_stat::g_reset_template
mov edx, 2288h
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memcpy
|
long long PFS_table::safe_aggregate_io(long long a1, _BYTE *a2, unsigned int *a3)
{
unsigned long long v4; // rbx
unsigned long long v5; // r12
_BYTE *v6; // r13
signed long long v7; // rax
signed long long index_stat; // rax
v4 = a3[107];
if ( (unsigned int)(v4 - 1) <= 0x3F )
{
v5 = 0LL;
v6 = a2;
do
{
if ( *v6 == 1 )
{
v7 = a1
? PFS_table_share::find_or_create_index_stat((long long)a3, a1, v5)
: PFS_table_share::find_index_stat((PFS_table_share *)a3, v5);
if ( v7 )
PFS_table_io_stat::aggregate(v7 + 200, v6);
}
++v5;
v6 += 136;
}
while ( v5 < v4 );
}
if ( a2[8704] == 1 )
{
index_stat = PFS_table_share::find_or_create_index_stat((long long)a3, 0LL, 0x40u);
if ( index_stat )
PFS_table_io_stat::aggregate(index_stat + 200, a2 + 8704);
}
return memcpy(a2, PFS_table_stat::g_reset_template, 8840LL);
}
|
safe_aggregate_io:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV qword ptr [RBP + -0x30],RSI
MOV EBX,dword ptr [RDX + 0x1ac]
LEA EAX,[RBX + -0x1]
CMP EAX,0x3f
JA 0x00137c56
MOV R15,RDI
XOR R12D,R12D
MOV R13,qword ptr [RBP + -0x30]
LAB_00137c0d:
CMP byte ptr [R13],0x1
JNZ 0x00137c47
MOV RDI,R14
TEST R15,R15
JZ 0x00137c29
MOV RSI,R15
MOV EDX,R12D
CALL 0x0012fe4c
JMP 0x00137c31
LAB_00137c29:
MOV ESI,R12D
CALL 0x0012fe3c
LAB_00137c31:
TEST RAX,RAX
JZ 0x00137c47
ADD RAX,0xc8
MOV RDI,RAX
MOV RSI,R13
CALL 0x0013aa1c
LAB_00137c47:
INC R12
ADD R13,0x88
CMP R12,RBX
JC 0x00137c0d
LAB_00137c56:
MOV RBX,qword ptr [RBP + -0x30]
CMP byte ptr [RBX + 0x2200],0x1
JNZ 0x00137c8c
MOV RDI,R14
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0012fe4c
TEST RAX,RAX
JZ 0x00137c8c
LEA RSI,[RBX + 0x2200]
ADD RAX,0xc8
MOV RDI,RAX
CALL 0x0013aa1c
LAB_00137c8c:
LEA RSI,[0x4d0dd0]
MOV EDX,0x2288
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00126290
|
/* PFS_table::safe_aggregate_io(TABLE_SHARE const*, PFS_table_stat*, PFS_table_share*) */
void PFS_table::safe_aggregate_io
(TABLE_SHARE *param_1,PFS_table_stat *param_2,PFS_table_share *param_3)
{
uint uVar1;
long lVar2;
ulong uVar3;
PFS_table_stat *pPVar4;
uVar1 = *(uint *)(param_3 + 0x1ac);
if (uVar1 - 1 < 0x40) {
uVar3 = 0;
pPVar4 = param_2;
do {
if (*(PFS_table_io_stat *)pPVar4 == (PFS_table_io_stat)0x1) {
if (param_1 == (TABLE_SHARE *)0x0) {
lVar2 = PFS_table_share::find_index_stat(param_3,(uint)uVar3);
}
else {
lVar2 = PFS_table_share::find_or_create_index_stat(param_3,param_1,(uint)uVar3);
}
if (lVar2 != 0) {
PFS_table_io_stat::aggregate
((PFS_table_io_stat *)(lVar2 + 200),(PFS_table_io_stat *)pPVar4);
}
}
uVar3 = uVar3 + 1;
pPVar4 = (PFS_table_stat *)((PFS_table_io_stat *)pPVar4 + 0x88);
} while (uVar3 < uVar1);
}
if (param_2[0x2200] == (PFS_table_stat)0x1) {
lVar2 = PFS_table_share::find_or_create_index_stat(param_3,(TABLE_SHARE *)0x0,0x40);
if (lVar2 != 0) {
PFS_table_io_stat::aggregate
((PFS_table_io_stat *)(lVar2 + 200),(PFS_table_io_stat *)(param_2 + 0x2200));
}
}
memcpy(param_2,&PFS_table_stat::g_reset_template,0x2288);
return;
}
|
|
58,553
|
my_mb_wc_euc_kr
|
eloqsql/strings/ctype-euc_kr.c
|
static int
my_mb_wc_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_ksc5601_uni_onechar((hi<<8)+s[1])))
return -2;
return 2;
}
|
O3
|
c
|
my_mb_wc_euc_kr:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xaf44d
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0xaf40c
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xaf44d
movzbl %dil, %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
je 0xaf44d
cmpl $0xff, %ecx
je 0xaf44d
movzbl 0x1(%rdx), %edx
leal 0x1(%rdx), %edi
cmpb $-0x7f, %dil
ja 0xaf44e
movl %edx, %edi
andb $-0x21, %dil
addb $-0x5b, %dil
cmpb $-0x1a, %dil
jae 0xaf44e
retq
pushq %rbp
movq %rsp, %rbp
shll $0x8, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff7ebf, %eax # imm = 0xFFFF7EBF
cmpl $0x47bd, %eax # imm = 0x47BD
ja 0xaf46f
movl %eax, %eax
leaq 0x8d573(%rip), %rcx # 0x13c9e0
jmp 0xaf488
orl %edx, %ecx
addl $0xffff355f, %ecx # imm = 0xFFFF355F
cmpl $0x335e, %ecx # imm = 0x335E
jae 0xaf4a1
movl %ecx, %eax
leaq 0x964d8(%rip), %rcx # 0x145960
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0xaf4ad
jmp 0xaf4a8
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
|
my_mb_wc_euc_kr:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_AF44D
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_AF40C
mov [rsi], rdi
mov eax, 1
retn
loc_AF40C:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_AF44D
movzx ecx, dil
xor eax, eax
cmp ecx, 80h
jz short locret_AF44D
cmp ecx, 0FFh
jz short locret_AF44D
movzx edx, byte ptr [rdx+1]
lea edi, [rdx+1]
cmp dil, 81h
ja short loc_AF44E
mov edi, edx
and dil, 0DFh
add dil, 0A5h
cmp dil, 0E6h
jnb short loc_AF44E
locret_AF44D:
retn
loc_AF44E:
push rbp
mov rbp, rsp
shl ecx, 8
lea eax, [rcx+rdx]
add eax, 0FFFF7EBFh
cmp eax, 47BDh
ja short loc_AF46F
mov eax, eax
lea rcx, tab_ksc5601_uni0
jmp short loc_AF488
loc_AF46F:
or ecx, edx
add ecx, 0FFFF355Fh
cmp ecx, 335Eh
jnb short loc_AF4A1
mov eax, ecx
lea rcx, tab_ksc5601_uni1
loc_AF488:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_AF4AD
jmp short loc_AF4A8
loc_AF4A1:
mov qword ptr [rsi], 0
loc_AF4A8:
mov eax, 0FFFFFFFEh
loc_AF4AD:
pop rbp
retn
|
long long my_mb_wc_euc_kr(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // edx
int v7; // ecx
long long v8; // rax
unsigned __int16 *v9; // rcx
unsigned int v10; // ecx
long long v11; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)v5 != 128 && (unsigned __int8)v5 != 255 )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) > 0x81u || (unsigned __int8)((v6 & 0xDF) - 91) >= 0xE6u )
{
v7 = (unsigned __int8)v5 << 8;
LODWORD(v8) = v7 + v6 - 33089;
if ( (unsigned int)v8 > 0x47BD )
{
v10 = (v6 | v7) - 51873;
if ( v10 >= 0x335E )
{
*a2 = 0LL;
return 4294967294LL;
}
v8 = v10;
v9 = (unsigned __int16 *)&tab_ksc5601_uni1;
}
else
{
v8 = (unsigned int)v8;
v9 = (unsigned __int16 *)&tab_ksc5601_uni0;
}
v11 = v9[v8];
*a2 = v11;
result = 2LL;
if ( (_WORD)v11 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
|
my_mb_wc_euc_kr:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001af44d
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x001af40c
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_001af40c:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001af44d
MOVZX ECX,DIL
XOR EAX,EAX
CMP ECX,0x80
JZ 0x001af44d
CMP ECX,0xff
JZ 0x001af44d
MOVZX EDX,byte ptr [RDX + 0x1]
LEA EDI,[RDX + 0x1]
CMP DIL,0x81
JA 0x001af44e
MOV EDI,EDX
AND DIL,0xdf
ADD DIL,0xa5
CMP DIL,0xe6
JNC 0x001af44e
LAB_001af44d:
RET
LAB_001af44e:
PUSH RBP
MOV RBP,RSP
SHL ECX,0x8
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff7ebf
CMP EAX,0x47bd
JA 0x001af46f
MOV EAX,EAX
LEA RCX,[0x23c9e0]
JMP 0x001af488
LAB_001af46f:
OR ECX,EDX
ADD ECX,0xffff355f
CMP ECX,0x335e
JNC 0x001af4a1
MOV EAX,ECX
LEA RCX,[0x245960]
LAB_001af488:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x001af4ad
JMP 0x001af4a8
LAB_001af4a1:
MOV qword ptr [RSI],0x0
LAB_001af4a8:
MOV EAX,0xfffffffe
LAB_001af4ad:
POP RBP
RET
|
int8 my_mb_wc_euc_kr(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
int1 *puVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
bVar1 = *param_3;
if (-1 < (long)(char)bVar1) {
*param_2 = (long)(char)bVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if (bVar1 == 0x80) {
return 0;
}
if (bVar1 == 0xff) {
return 0;
}
bVar2 = param_3[1];
if (((byte)(bVar2 + 1) < 0x82) && ((byte)((bVar2 & 0xdf) + 0xa5) < 0xe6)) {
return 0;
}
uVar4 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0x8141;
if (uVar4 < 0x47be) {
puVar5 = tab_ksc5601_uni0;
}
else {
uVar4 = CONCAT11(bVar1,bVar2) - 0xcaa1;
if (0x335d < uVar4) {
*param_2 = 0;
return 0xfffffffe;
}
puVar5 = tab_ksc5601_uni1;
}
uVar3 = *(ushort *)(puVar5 + (ulong)uVar4 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 == 0) {
return 0xfffffffe;
}
return 2;
}
|
|
58,554
|
backtick_string
|
eloqsql/strings/my_vsnprintf.c
|
static char *backtick_string(CHARSET_INFO *cs, char *to, const char *end,
char *par, size_t par_len, char quote_char,
my_bool cut)
{
char *last[3]= {0,0,0};
uint char_len;
char *start= to;
char *par_end= par + par_len;
size_t buff_length= (size_t) (end - to);
uint index= 0;
if (buff_length <= par_len)
goto err;
*start++= quote_char;
for ( ; par < par_end; par+= char_len)
{
uchar c= *(uchar *) par;
if (cut)
{
last[index]= start;
index= (index + 1) % 3;
}
char_len= my_ci_charlen_fix(cs, (const uchar *) par, (const uchar *) par_end);
if (char_len == 1 && c == (uchar) quote_char )
{
if (start + 1 >= end)
goto err;
*start++= quote_char;
}
if (start + char_len >= end)
goto err;
start= strnmov(start, par, char_len);
}
if (start + 1 >= end)
goto err;
if (cut)
{
uint dots= 0;
start= NULL;
for (; dots < 3; dots++)
{
if (index == 0)
index= 2;
else
index--;
if (!last[index])
break;
start= last[index];
}
if (start == NULL)
goto err; // there was no characters at all
for (; dots; dots--)
*start++= '.';
}
*start++= quote_char;
return start;
err:
*to='\0';
return to;
}
|
O0
|
c
|
backtick_string:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x24180
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x824b2
jmp 0x8264a
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x8258e
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x75(%rbp)
cmpb $0x0, 0x10(%rbp)
je 0x82501
movq -0x60(%rbp), %rcx
movl -0x74(%rbp), %eax
movq %rcx, -0x50(%rbp,%rax,8)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x74(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x826c0
movl %eax, -0x54(%rbp)
cmpl $0x1, -0x54(%rbp)
jne 0x8254e
movzbl -0x75(%rbp), %eax
movzbl -0x31(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8254e
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0x8253a
jmp 0x8264a
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jb 0x82563
jmp 0x8264a
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0x82bc0
movq %rax, -0x60(%rbp)
movl -0x54(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x824c6
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0x825a1
jmp 0x8264a
cmpb $0x0, 0x10(%rbp)
je 0x8262c
movl $0x0, -0x7c(%rbp)
movq $0x0, -0x60(%rbp)
cmpl $0x3, -0x7c(%rbp)
jae 0x825fc
cmpl $0x0, -0x74(%rbp)
jne 0x825cf
movl $0x2, -0x74(%rbp)
jmp 0x825d8
movl -0x74(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpq $0x0, -0x50(%rbp,%rax,8)
jne 0x825e5
jmp 0x825fc
movl -0x74(%rbp), %eax
movq -0x50(%rbp,%rax,8), %rax
movq %rax, -0x60(%rbp)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x825ba
cmpq $0x0, -0x60(%rbp)
jne 0x82605
jmp 0x8264a
jmp 0x82607
cmpl $0x0, -0x7c(%rbp)
je 0x8262a
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2e, (%rax)
movl -0x7c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x82607
jmp 0x8262c
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x82659
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
backtick_string:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, r9b
mov r9b, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 18h
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_68], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_70], rax
mov [rbp+var_74], 0
mov rax, [rbp+var_70]
cmp rax, [rbp+var_30]
ja short loc_824B2
jmp loc_8264A
loc_824B2:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_824C6:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_68]
jnb loc_8258E
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_75], al
cmp [rbp+arg_0], 0
jz short loc_82501
mov rcx, [rbp+var_60]
mov eax, [rbp+var_74]
mov [rbp+rax*8+var_50], rcx
mov eax, [rbp+var_74]
add eax, 1
mov ecx, 3
xor edx, edx
div ecx
mov [rbp+var_74], edx
loc_82501:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_68]
call my_ci_charlen_fix
mov [rbp+var_54], eax
cmp [rbp+var_54], 1
jnz short loc_8254E
movzx eax, [rbp+var_75]
movzx ecx, [rbp+var_31]
cmp eax, ecx
jnz short loc_8254E
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_8253A
jmp loc_8264A
loc_8253A:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_8254E:
mov rax, [rbp+var_60]
mov ecx, [rbp+var_54]
add rax, rcx
cmp rax, [rbp+var_20]
jb short loc_82563
jmp loc_8264A
loc_82563:
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_54]
mov edx, eax
call strnmov
mov [rbp+var_60], rax
mov ecx, [rbp+var_54]
mov rax, [rbp+var_28]
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_824C6
loc_8258E:
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_825A1
jmp loc_8264A
loc_825A1:
cmp [rbp+arg_0], 0
jz loc_8262C
mov [rbp+var_7C], 0
mov [rbp+var_60], 0
loc_825BA:
cmp [rbp+var_7C], 3
jnb short loc_825FC
cmp [rbp+var_74], 0
jnz short loc_825CF
mov [rbp+var_74], 2
jmp short loc_825D8
loc_825CF:
mov eax, [rbp+var_74]
add eax, 0FFFFFFFFh
mov [rbp+var_74], eax
loc_825D8:
mov eax, [rbp+var_74]
cmp [rbp+rax*8+var_50], 0
jnz short loc_825E5
jmp short loc_825FC
loc_825E5:
mov eax, [rbp+var_74]
mov rax, [rbp+rax*8+var_50]
mov [rbp+var_60], rax
mov eax, [rbp+var_7C]
add eax, 1
mov [rbp+var_7C], eax
jmp short loc_825BA
loc_825FC:
cmp [rbp+var_60], 0
jnz short loc_82605
jmp short loc_8264A
loc_82605:
jmp short $+2
loc_82607:
cmp [rbp+var_7C], 0
jz short loc_8262A
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_7C]
add eax, 0FFFFFFFFh
mov [rbp+var_7C], eax
jmp short loc_82607
loc_8262A:
jmp short $+2
loc_8262C:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
mov rax, [rbp+var_60]
mov [rbp+var_8], rax
jmp short loc_82659
loc_8264A:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_82659:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
_BYTE * backtick_string(
long long a1,
_BYTE *a2,
unsigned long long a3,
char *a4,
unsigned long long a5,
char a6,
char a7)
{
_BYTE *v7; // rax
_BYTE *v8; // rax
unsigned int v10; // [rsp+4h] [rbp-7Ch]
char v11; // [rsp+Bh] [rbp-75h]
unsigned int v12; // [rsp+Ch] [rbp-74h]
char *v13; // [rsp+18h] [rbp-68h]
_BYTE *v14; // [rsp+20h] [rbp-60h]
unsigned int v15; // [rsp+2Ch] [rbp-54h]
_QWORD v16[3]; // [rsp+30h] [rbp-50h] BYREF
char v17; // [rsp+4Fh] [rbp-31h]
unsigned long long v18; // [rsp+50h] [rbp-30h]
char *v19; // [rsp+58h] [rbp-28h]
unsigned long long v20; // [rsp+60h] [rbp-20h]
_BYTE *v21; // [rsp+68h] [rbp-18h]
long long v22; // [rsp+70h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
memset(v16, 0LL, sizeof(v16));
v13 = &v19[v18];
v12 = 0;
if ( v20 - (unsigned long long)v21 <= v18 )
goto LABEL_25;
v14 = v21 + 1;
*v21 = v17;
while ( v19 < v13 )
{
v11 = *v19;
if ( a7 )
{
v16[v12] = v14;
v12 = (v12 + 1) % 3;
}
v15 = my_ci_charlen_fix(v22, v19, v13);
if ( v15 == 1 && v11 == v17 )
{
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
v7 = v14++;
*v7 = v17;
}
if ( (unsigned long long)&v14[v15] >= v20 )
goto LABEL_25;
v14 = (_BYTE *)strnmov(v14, v19, v15);
v19 += v15;
}
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
if ( a7 )
{
v10 = 0;
v14 = 0LL;
while ( v10 < 3 )
{
if ( v12 )
--v12;
else
v12 = 2;
if ( !v16[v12] )
break;
v14 = (_BYTE *)v16[v12];
++v10;
}
if ( v14 )
{
while ( v10 )
{
v8 = v14++;
*v8 = 46;
--v10;
}
goto LABEL_24;
}
LABEL_25:
*v21 = 0;
return v21;
}
LABEL_24:
*v14 = v17;
return v14 + 1;
}
|
backtick_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,R9B
MOV R9B,byte ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00124180
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV dword ptr [RBP + -0x74],0x0
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x30]
JA 0x001824b2
JMP 0x0018264a
LAB_001824b2:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_001824c6:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x0018258e
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
CMP byte ptr [RBP + 0x10],0x0
JZ 0x00182501
MOV RCX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + -0x74]
MOV qword ptr [RBP + RAX*0x8 + -0x50],RCX
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV ECX,0x3
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x74],EDX
LAB_00182501:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x001826c0
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x1
JNZ 0x0018254e
MOVZX EAX,byte ptr [RBP + -0x75]
MOVZX ECX,byte ptr [RBP + -0x31]
CMP EAX,ECX
JNZ 0x0018254e
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x0018253a
JMP 0x0018264a
LAB_0018253a:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_0018254e:
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JC 0x00182563
JMP 0x0018264a
LAB_00182563:
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
CALL 0x00182bc0
MOV qword ptr [RBP + -0x60],RAX
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001824c6
LAB_0018258e:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001825a1
JMP 0x0018264a
LAB_001825a1:
CMP byte ptr [RBP + 0x10],0x0
JZ 0x0018262c
MOV dword ptr [RBP + -0x7c],0x0
MOV qword ptr [RBP + -0x60],0x0
LAB_001825ba:
CMP dword ptr [RBP + -0x7c],0x3
JNC 0x001825fc
CMP dword ptr [RBP + -0x74],0x0
JNZ 0x001825cf
MOV dword ptr [RBP + -0x74],0x2
JMP 0x001825d8
LAB_001825cf:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x74],EAX
LAB_001825d8:
MOV EAX,dword ptr [RBP + -0x74]
CMP qword ptr [RBP + RAX*0x8 + -0x50],0x0
JNZ 0x001825e5
JMP 0x001825fc
LAB_001825e5:
MOV EAX,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x001825ba
LAB_001825fc:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x00182605
JMP 0x0018264a
LAB_00182605:
JMP 0x00182607
LAB_00182607:
CMP dword ptr [RBP + -0x7c],0x0
JZ 0x0018262a
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2e
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x00182607
LAB_0018262a:
JMP 0x0018262c
LAB_0018262c:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00182659
LAB_0018264a:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_00182659:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
char * backtick_string(int8 param_1,char *param_2,char *param_3,char *param_4,ulong param_5,
char param_6,char param_7)
{
char cVar1;
uint uVar2;
char *pcVar3;
uint local_84;
uint local_7c;
char *local_68;
long local_58 [3];
char local_39;
ulong local_38;
char *local_30;
char *local_28;
char *local_20;
int8 local_18;
local_39 = param_6;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_58,0,0x18);
pcVar3 = local_30 + local_38;
local_7c = 0;
if (local_38 < (ulong)((long)local_28 - (long)local_20)) {
local_68 = local_20 + 1;
*local_20 = local_39;
for (; local_30 < pcVar3; local_30 = local_30 + uVar2) {
cVar1 = *local_30;
if (param_7 != '\0') {
local_58[local_7c] = (long)local_68;
local_7c = (local_7c + 1) % 3;
}
uVar2 = my_ci_charlen_fix(local_18,local_30,pcVar3);
if ((uVar2 == 1) && (cVar1 == local_39)) {
if (local_28 <= local_68 + 1) goto LAB_0018264a;
*local_68 = local_39;
local_68 = local_68 + 1;
}
if (local_28 <= local_68 + uVar2) goto LAB_0018264a;
local_68 = (char *)strnmov(local_68,local_30,uVar2);
}
if (local_68 + 1 < local_28) {
if (param_7 != '\0') {
local_68 = (char *)0x0;
for (local_84 = 0; local_84 < 3; local_84 = local_84 + 1) {
if (local_7c == 0) {
local_7c = 2;
}
else {
local_7c = local_7c - 1;
}
if (local_58[local_7c] == 0) break;
local_68 = (char *)local_58[local_7c];
}
if (local_68 == (char *)0x0) goto LAB_0018264a;
for (; local_84 != 0; local_84 = local_84 - 1) {
*local_68 = '.';
local_68 = local_68 + 1;
}
}
*local_68 = local_39;
return local_68 + 1;
}
}
LAB_0018264a:
*local_20 = '\0';
return local_20;
}
|
|
58,555
|
js_regexp_get_flags
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_get_flags(JSContext *ctx, JSValue this_val)
{
char str[8], *p = str;
int res;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "hasIndices"));
if (res < 0)
goto exception;
if (res)
*p++ = 'd';
res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_global));
if (res < 0)
goto exception;
if (res)
*p++ = 'g';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "ignoreCase"));
if (res < 0)
goto exception;
if (res)
*p++ = 'i';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "multiline"));
if (res < 0)
goto exception;
if (res)
*p++ = 'm';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "dotAll"));
if (res < 0)
goto exception;
if (res)
*p++ = 's';
res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_unicode));
if (res < 0)
goto exception;
if (res)
*p++ = 'u';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "unicodeSets"));
if (res < 0)
goto exception;
if (res)
*p++ = 'v';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "sticky"));
if (res < 0)
goto exception;
if (res)
*p++ = 'y';
if (p == str)
return JS_AtomToString(ctx, JS_ATOM_empty_string);
return js_new_string8_len(ctx, str, p - str);
exception:
return JS_EXCEPTION;
}
|
O1
|
c
|
js_regexp_get_flags:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rdi, %r14
cmpl $-0x1, %r12d
jne 0x478f2
movq %rsi, %r13
leaq 0x58259(%rip), %rcx # 0x9fb1a
movq %r14, %rdi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
movl $0x6, %ebx
testl %eax, %eax
js 0x47aae
je 0x47910
leaq 0x9(%rsp), %r15
movb $0x64, -0x1(%r15)
jmp 0x47915
leaq 0x5772c(%rip), %rsi # 0x9f025
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %ebx
jmp 0x47ab1
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x6f, %ecx
movq %r13, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x47952
movb $0x67, (%r15)
incq %r15
leaq 0x5818a(%rip), %rcx # 0x9fae3
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x47983
movb $0x69, (%r15)
incq %r15
leaq 0x58164(%rip), %rcx # 0x9faee
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x479b4
movb $0x6d, (%r15)
incq %r15
leaq 0x5813d(%rip), %rcx # 0x9faf8
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x479e5
movb $0x73, (%r15)
incq %r15
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x70, %ecx
movq %r13, %r8
movq %r12, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x47a22
movb $0x75, (%r15)
incq %r15
leaq 0x580de(%rip), %rcx # 0x9fb07
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x47a4f
movb $0x76, (%r15)
incq %r15
leaq 0x580bd(%rip), %rcx # 0x9fb13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x242ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0d
testl %eax, %eax
js 0x47aae
je 0x47a7c
movb $0x79, (%r15)
incq %r15
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rax
cmpq %rax, %r15
je 0x47acb
leaq 0x8(%rsp), %rsi
subl %esi, %r15d
movq %r14, %rdi
movl %r15d, %edx
callq 0x201dd
movq %rax, %r15
movq %rdx, %rbx
andq %rax, %r12
jmp 0x47ab4
xorl %r15d, %r15d
xorl %r12d, %r12d
movl %r15d, %eax
orq %r12, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r14), %rax
movq 0x68(%rax), %rax
movq 0x178(%rax), %r15
incl (%r15)
andq %r15, %r12
movq $-0x7, %rbx
jmp 0x47ab4
|
js_regexp_get_flags:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r14, rdi
cmp r12d, 0FFFFFFFFh
jnz short loc_478F2
mov r13, rsi
lea rcx, aHasindices; "hasIndices"
mov rdi, r14
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
mov ebx, 6
test eax, eax
js loc_47AAE
jz short loc_47910
lea r15, [rsp+38h+var_2F]
mov byte ptr [r15-1], 64h ; 'd'
jmp short loc_47915
loc_478F2:
lea rsi, aOperandPrototy+20h; "not an object"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov ebx, 6
jmp loc_47AB1
loc_47910:
lea r15, [rsp+38h+var_30]
loc_47915:
mov rdi, r14
mov rsi, r13
mov rdx, r12
mov ecx, 6Fh ; 'o'
mov r8, r13
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_47AAE
jz short loc_47952
mov byte ptr [r15], 67h ; 'g'
inc r15
loc_47952:
lea rcx, aIgnorecase; "ignoreCase"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_47AAE
jz short loc_47983
mov byte ptr [r15], 69h ; 'i'
inc r15
loc_47983:
lea rcx, aMultiline; "multiline"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_47AAE
jz short loc_479B4
mov byte ptr [r15], 6Dh ; 'm'
inc r15
loc_479B4:
lea rcx, aDotall; "dotAll"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_47AAE
jz short loc_479E5
mov byte ptr [r15], 73h ; 's'
inc r15
loc_479E5:
mov rdi, r14
mov rsi, r13
mov rdx, r12
mov ecx, 70h ; 'p'
mov r8, r13
mov r9, r12
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_47AAE
jz short loc_47A22
mov byte ptr [r15], 75h ; 'u'
inc r15
loc_47A22:
lea rcx, aUnicodesets; "unicodeSets"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js short loc_47AAE
jz short loc_47A4F
mov byte ptr [r15], 76h ; 'v'
inc r15
loc_47A4F:
lea rcx, aSticky; "sticky"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js short loc_47AAE
jz short loc_47A7C
mov byte ptr [r15], 79h ; 'y'
inc r15
loc_47A7C:
mov r12, 0FFFFFFFF00000000h
lea rax, [rsp+38h+var_30]
cmp r15, rax
jz short loc_47ACB
lea rsi, [rsp+38h+var_30]
sub r15d, esi
mov rdi, r14
mov edx, r15d
call js_new_string8_len
mov r15, rax
mov rbx, rdx
and r12, rax
jmp short loc_47AB4
loc_47AAE:
xor r15d, r15d
loc_47AB1:
xor r12d, r12d
loc_47AB4:
mov eax, r15d
or rax, r12
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_47ACB:
mov rax, [r14+18h]
mov rax, [rax+68h]
mov r15, [rax+178h]
inc dword ptr [r15]
and r12, r15
mov rbx, 0FFFFFFFFFFFFFFF9h
jmp short loc_47AB4
|
unsigned long long js_regexp_get_flags(
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 PropertyStr; // rax
long long v16; // rdx
int v17; // eax
char *v18; // r15
unsigned long long PropertyInternal2; // rax
long long v20; // rdx
int v21; // eax
unsigned long long v22; // rax
long long v23; // rdx
int v24; // eax
unsigned long long v25; // rax
long long v26; // rdx
int v27; // eax
unsigned long long v28; // rax
long long v29; // rdx
int v30; // eax
unsigned long long v31; // rax
long long v32; // rdx
int v33; // eax
unsigned long long v34; // rax
long long v35; // rdx
int v36; // eax
unsigned long long v37; // rax
long long v38; // rdx
int v39; // eax
long long v40; // rax
unsigned long long v41; // r12
char v43; // [rsp+0h] [rbp-38h]
char v44; // [rsp+8h] [rbp-30h] BYREF
char v45; // [rsp+9h] [rbp-2Fh] BYREF
if ( (_DWORD)a3 != -1 )
{
LODWORD(v18) = 0;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v43);
LABEL_31:
v41 = 0LL;
return v41 | (unsigned int)v18;
}
PropertyStr = JS_GetPropertyStr(a1, a2, a3, "hasIndices");
v17 = JS_ToBoolFree(a1, PropertyStr, v16);
if ( v17 < 0 )
goto LABEL_30;
if ( v17 )
{
v18 = &v45;
v44 = 100;
}
else
{
v18 = &v44;
}
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, 0x6Fu, a2, a3, 0LL, 0);
v21 = JS_ToBoolFree(a1, PropertyInternal2, v20);
if ( v21 < 0 )
goto LABEL_30;
if ( v21 )
*v18++ = 103;
v22 = JS_GetPropertyStr(a1, a2, a3, "ignoreCase");
v24 = JS_ToBoolFree(a1, v22, v23);
if ( v24 < 0 )
goto LABEL_30;
if ( v24 )
*v18++ = 105;
v25 = JS_GetPropertyStr(a1, a2, a3, "multiline");
v27 = JS_ToBoolFree(a1, v25, v26);
if ( v27 < 0 )
goto LABEL_30;
if ( v27 )
*v18++ = 109;
v28 = JS_GetPropertyStr(a1, a2, a3, "dotAll");
v30 = JS_ToBoolFree(a1, v28, v29);
if ( v30 < 0 )
goto LABEL_30;
if ( v30 )
*v18++ = 115;
v31 = JS_GetPropertyInternal2(a1, a2, a3, 0x70u, a2, a3, 0LL, 0);
v33 = JS_ToBoolFree(a1, v31, v32);
if ( v33 < 0 )
goto LABEL_30;
if ( v33 )
*v18++ = 117;
v34 = JS_GetPropertyStr(a1, a2, a3, "unicodeSets");
v36 = JS_ToBoolFree(a1, v34, v35);
if ( v36 < 0 )
goto LABEL_30;
if ( v36 )
*v18++ = 118;
v37 = JS_GetPropertyStr(a1, a2, a3, "sticky");
v39 = JS_ToBoolFree(a1, v37, v38);
if ( v39 < 0 )
{
LABEL_30:
LODWORD(v18) = 0;
goto LABEL_31;
}
if ( v39 )
*v18++ = 121;
if ( v18 == &v44 )
{
v18 = *(char **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 376LL);
++*(_DWORD *)v18;
v41 = (unsigned long long)v18 & 0xFFFFFFFF00000000LL;
}
else
{
v40 = js_new_string8_len(a1, (long long)&v44, (unsigned int)v18 - (unsigned int)&v44);
LODWORD(v18) = v40;
v41 = v40 & 0xFFFFFFFF00000000LL;
}
return v41 | (unsigned int)v18;
}
|
js_regexp_get_flags:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R14,RDI
CMP R12D,-0x1
JNZ 0x001478f2
MOV R13,RSI
LEA RCX,[0x19fb1a]
MOV RDI,R14
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
MOV EBX,0x6
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147910
LEA R15,[RSP + 0x9]
MOV byte ptr [R15 + -0x1],0x64
JMP 0x00147915
LAB_001478f2:
LEA RSI,[0x19f025]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
MOV EBX,0x6
JMP 0x00147ab1
LAB_00147910:
LEA R15,[RSP + 0x8]
LAB_00147915:
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x6f
MOV R8,R13
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147952
MOV byte ptr [R15],0x67
INC R15
LAB_00147952:
LEA RCX,[0x19fae3]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147983
MOV byte ptr [R15],0x69
INC R15
LAB_00147983:
LEA RCX,[0x19faee]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x001479b4
MOV byte ptr [R15],0x6d
INC R15
LAB_001479b4:
LEA RCX,[0x19faf8]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x001479e5
MOV byte ptr [R15],0x73
INC R15
LAB_001479e5:
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x70
MOV R8,R13
MOV R9,R12
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147a22
MOV byte ptr [R15],0x75
INC R15
LAB_00147a22:
LEA RCX,[0x19fb07]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147a4f
MOV byte ptr [R15],0x76
INC R15
LAB_00147a4f:
LEA RCX,[0x19fb13]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x001242ea
MOV RDI,R14
MOV RSI,RAX
CALL 0x00122d0d
TEST EAX,EAX
JS 0x00147aae
JZ 0x00147a7c
MOV byte ptr [R15],0x79
INC R15
LAB_00147a7c:
MOV R12,-0x100000000
LEA RAX,[RSP + 0x8]
CMP R15,RAX
JZ 0x00147acb
LEA RSI,[RSP + 0x8]
SUB R15D,ESI
MOV RDI,R14
MOV EDX,R15D
CALL 0x001201dd
MOV R15,RAX
MOV RBX,RDX
AND R12,RAX
JMP 0x00147ab4
LAB_00147aae:
XOR R15D,R15D
LAB_00147ab1:
XOR R12D,R12D
LAB_00147ab4:
MOV EAX,R15D
OR RAX,R12
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00147acb:
MOV RAX,qword ptr [R14 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV R15,qword ptr [RAX + 0x178]
INC dword ptr [R15]
AND R12,R15
MOV RBX,-0x7
JMP 0x00147ab4
|
int1 [16] js_regexp_get_flags(long param_1,int8 param_2,int8 param_3)
{
int *piVar1;
int iVar2;
int8 uVar3;
ulong uVar4;
int1 *puVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int1 local_30 [8];
if ((int)param_3 == -1) {
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"hasIndices");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 == 0) {
puVar5 = local_30;
}
else {
puVar5 = local_30 + 1;
local_30[0] = 100;
}
uVar3 = JS_GetPropertyInternal2(param_1,param_2,param_3,0x6f,param_2,param_3,0,0);
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x67;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"ignoreCase");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x69;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"multiline");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x6d;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"dotAll");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x73;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyInternal2(param_1,param_2,param_3,0x70,param_2,param_3,0,0);
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x75;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"unicodeSets");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x76;
puVar5 = puVar5 + 1;
}
uVar3 = JS_GetPropertyStr(param_1,param_2,param_3,"sticky");
iVar2 = JS_ToBoolFree(param_1,uVar3);
if (-1 < iVar2) {
if (iVar2 != 0) {
*puVar5 = 0x79;
puVar5 = puVar5 + 1;
}
if (puVar5 == local_30) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x178);
*piVar1 = *piVar1 + 1;
uVar4 = (ulong)piVar1 & 0xffffffff00000000;
auVar6._8_8_ = 0xfffffffffffffff9;
auVar6._0_8_ = piVar1;
}
else {
auVar6 = js_new_string8_len(param_1,local_30,(int)puVar5 - (int)local_30);
uVar4 = auVar6._0_8_ & 0xffffffff00000000;
}
goto LAB_00147ab4;
}
}
}
}
}
}
}
}
}
else {
JS_ThrowTypeError(param_1,"not an object");
}
auVar6 = ZEXT816(6) << 0x40;
uVar4 = 0;
LAB_00147ab4:
auVar7._0_8_ = auVar6._0_8_ & 0xffffffff | uVar4;
auVar7._8_8_ = auVar6._8_8_;
return auVar7;
}
|
|
58,556
|
js_regexp_get_flags
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_regexp_get_flags(JSContext *ctx, JSValue this_val)
{
char str[8], *p = str;
int res;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "hasIndices"));
if (res < 0)
goto exception;
if (res)
*p++ = 'd';
res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_global));
if (res < 0)
goto exception;
if (res)
*p++ = 'g';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "ignoreCase"));
if (res < 0)
goto exception;
if (res)
*p++ = 'i';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "multiline"));
if (res < 0)
goto exception;
if (res)
*p++ = 'm';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "dotAll"));
if (res < 0)
goto exception;
if (res)
*p++ = 's';
res = JS_ToBoolFree(ctx, JS_GetProperty(ctx, this_val, JS_ATOM_unicode));
if (res < 0)
goto exception;
if (res)
*p++ = 'u';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "unicodeSets"));
if (res < 0)
goto exception;
if (res)
*p++ = 'v';
res = JS_ToBoolFree(ctx, JS_GetPropertyStr(ctx, this_val, "sticky"));
if (res < 0)
goto exception;
if (res)
*p++ = 'y';
if (p == str)
return JS_AtomToString(ctx, JS_ATOM_empty_string);
return js_new_string8_len(ctx, str, p - str);
exception:
return JS_EXCEPTION;
}
|
O2
|
c
|
js_regexp_get_flags:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rdi, %r14
cmpl $-0x1, %r12d
jne 0x3ddf7
movq %rsi, %r13
leaq 0x48c9e(%rip), %rcx # 0x86a6a
movq %r14, %rdi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
pushq $0x6
popq %rbx
testl %eax, %eax
js 0x3de02
je 0x3de1d
leaq 0x9(%rsp), %r15
movb $0x64, -0x1(%r15)
jmp 0x3de22
movq %r14, %rdi
callq 0x1d5e1
pushq $0x6
popq %rbx
xorl %eax, %eax
xorl %r12d, %r12d
movl %eax, %eax
orq %r12, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r15
pushq $0x6f
popq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1b043
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3de4b
movb $0x67, (%r15)
incq %r15
leaq 0x48be1(%rip), %rcx # 0x86a33
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3de78
movb $0x69, (%r15)
incq %r15
leaq 0x48bbf(%rip), %rcx # 0x86a3e
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3dea9
movb $0x6d, (%r15)
incq %r15
leaq 0x48b98(%rip), %rcx # 0x86a48
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3deda
movb $0x73, (%r15)
incq %r15
pushq $0x70
popq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1b043
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3df07
movb $0x75, (%r15)
incq %r15
leaq 0x48b49(%rip), %rcx # 0x86a57
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3df38
movb $0x76, (%r15)
incq %r15
leaq 0x48b24(%rip), %rcx # 0x86a63
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1e3fb
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cdfa
testl %eax, %eax
js 0x3de02
je 0x3df69
movb $0x79, (%r15)
incq %r15
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
leaq 0x8(%rsp), %rax
cmpq %rax, %r15
je 0x3df92
leaq 0x8(%rsp), %rsi
subl %esi, %r15d
movq %r14, %rdi
movl %r15d, %edx
callq 0x1a4e8
jmp 0x3df9d
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0x1a990
movq %rdx, %rbx
andq %rax, %r12
jmp 0x3de07
|
js_regexp_get_flags:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r14, rdi
cmp r12d, 0FFFFFFFFh
jnz short loc_3DDF7
mov r13, rsi
lea rcx, aHasindices; "hasIndices"
mov rdi, r14
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
push 6
pop rbx
test eax, eax
js short loc_3DE02
jz short loc_3DE1D
lea r15, [rsp+38h+var_2F]
mov byte ptr [r15-1], 64h ; 'd'
jmp short loc_3DE22
loc_3DDF7:
mov rdi, r14
call JS_ThrowTypeErrorNotAnObject
push 6
pop rbx
loc_3DE02:
xor eax, eax
xor r12d, r12d
loc_3DE07:
mov eax, eax
or rax, r12
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_3DE1D:
lea r15, [rsp+38h+var_30]
loc_3DE22:
push 6Fh ; 'o'
pop rcx
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetProperty
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js short loc_3DE02
jz short loc_3DE4B
mov byte ptr [r15], 67h ; 'g'
inc r15
loc_3DE4B:
lea rcx, aIgnorecase; "ignoreCase"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js short loc_3DE02
jz short loc_3DE78
mov byte ptr [r15], 69h ; 'i'
inc r15
loc_3DE78:
lea rcx, aMultiline; "multiline"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_3DE02
jz short loc_3DEA9
mov byte ptr [r15], 6Dh ; 'm'
inc r15
loc_3DEA9:
lea rcx, aDotall; "dotAll"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_3DE02
jz short loc_3DEDA
mov byte ptr [r15], 73h ; 's'
inc r15
loc_3DEDA:
push 70h ; 'p'
pop rcx
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetProperty
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_3DE02
jz short loc_3DF07
mov byte ptr [r15], 75h ; 'u'
inc r15
loc_3DF07:
lea rcx, aUnicodesets; "unicodeSets"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_3DE02
jz short loc_3DF38
mov byte ptr [r15], 76h ; 'v'
inc r15
loc_3DF38:
lea rcx, aSticky; "sticky"
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_GetPropertyStr
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
js loc_3DE02
jz short loc_3DF69
mov byte ptr [r15], 79h ; 'y'
inc r15
loc_3DF69:
mov r12, 0FFFFFFFF00000000h
lea rax, [rsp+38h+var_30]
cmp r15, rax
jz short loc_3DF92
lea rsi, [rsp+38h+var_30]
sub r15d, esi
mov rdi, r14
mov edx, r15d
call js_new_string8_len
jmp short loc_3DF9D
loc_3DF92:
push 2Fh ; '/'
pop rsi
mov rdi, r14
call JS_AtomToString
loc_3DF9D:
mov rbx, rdx
and r12, rax
jmp loc_3DE07
|
unsigned long long js_regexp_get_flags(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long PropertyStr; // rax
long long v15; // rdx
int v16; // eax
char *v17; // r15
long long v18; // rax
unsigned long long v19; // r12
long long Property; // rax
long long v22; // rdx
int v23; // eax
long long v24; // rax
long long v25; // rdx
int v26; // eax
long long v27; // rax
long long v28; // rdx
int v29; // eax
long long v30; // rax
long long v31; // rdx
int v32; // eax
long long v33; // rax
long long v34; // rdx
int v35; // eax
long long v36; // rax
long long v37; // rdx
int v38; // eax
long long v39; // rax
long long v40; // rdx
int v41; // eax
char v42; // [rsp+0h] [rbp-38h]
char v43; // [rsp+8h] [rbp-30h] BYREF
char v44; // [rsp+9h] [rbp-2Fh] BYREF
if ( (_DWORD)a3 != -1 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6, v42);
LABEL_6:
LODWORD(v18) = 0;
v19 = 0LL;
return v19 | (unsigned int)v18;
}
PropertyStr = JS_GetPropertyStr(a1, a2, -1, "hasIndices");
v16 = JS_ToBoolFree(a1, PropertyStr, v15);
if ( v16 < 0 )
goto LABEL_6;
if ( v16 )
{
v17 = &v44;
v43 = 100;
}
else
{
v17 = &v43;
}
Property = JS_GetProperty(a1, a2, -1, 111);
v23 = JS_ToBoolFree(a1, Property, v22);
if ( v23 < 0 )
goto LABEL_6;
if ( v23 )
*v17++ = 103;
v24 = JS_GetPropertyStr(a1, a2, -1, "ignoreCase");
v26 = JS_ToBoolFree(a1, v24, v25);
if ( v26 < 0 )
goto LABEL_6;
if ( v26 )
*v17++ = 105;
v27 = JS_GetPropertyStr(a1, a2, -1, "multiline");
v29 = JS_ToBoolFree(a1, v27, v28);
if ( v29 < 0 )
goto LABEL_6;
if ( v29 )
*v17++ = 109;
v30 = JS_GetPropertyStr(a1, a2, -1, "dotAll");
v32 = JS_ToBoolFree(a1, v30, v31);
if ( v32 < 0 )
goto LABEL_6;
if ( v32 )
*v17++ = 115;
v33 = JS_GetProperty(a1, a2, -1, 112);
v35 = JS_ToBoolFree(a1, v33, v34);
if ( v35 < 0 )
goto LABEL_6;
if ( v35 )
*v17++ = 117;
v36 = JS_GetPropertyStr(a1, a2, -1, "unicodeSets");
v38 = JS_ToBoolFree(a1, v36, v37);
if ( v38 < 0 )
goto LABEL_6;
if ( v38 )
*v17++ = 118;
v39 = JS_GetPropertyStr(a1, a2, -1, "sticky");
v41 = JS_ToBoolFree(a1, v39, v40);
if ( v41 < 0 )
goto LABEL_6;
if ( v41 )
*v17++ = 121;
if ( v17 == &v43 )
v18 = JS_AtomToString(a1, 47);
else
v18 = js_new_string8_len(a1, (long long)&v43, (unsigned int)v17 - (unsigned int)&v43);
v19 = v18 & 0xFFFFFFFF00000000LL;
return v19 | (unsigned int)v18;
}
|
js_regexp_get_flags:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R14,RDI
CMP R12D,-0x1
JNZ 0x0013ddf7
MOV R13,RSI
LEA RCX,[0x186a6a]
MOV RDI,R14
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
PUSH 0x6
POP RBX
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013de1d
LEA R15,[RSP + 0x9]
MOV byte ptr [R15 + -0x1],0x64
JMP 0x0013de22
LAB_0013ddf7:
MOV RDI,R14
CALL 0x0011d5e1
PUSH 0x6
POP RBX
LAB_0013de02:
XOR EAX,EAX
XOR R12D,R12D
LAB_0013de07:
MOV EAX,EAX
OR RAX,R12
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0013de1d:
LEA R15,[RSP + 0x8]
LAB_0013de22:
PUSH 0x6f
POP RCX
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011b043
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013de4b
MOV byte ptr [R15],0x67
INC R15
LAB_0013de4b:
LEA RCX,[0x186a33]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013de78
MOV byte ptr [R15],0x69
INC R15
LAB_0013de78:
LEA RCX,[0x186a3e]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013dea9
MOV byte ptr [R15],0x6d
INC R15
LAB_0013dea9:
LEA RCX,[0x186a48]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013deda
MOV byte ptr [R15],0x73
INC R15
LAB_0013deda:
PUSH 0x70
POP RCX
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011b043
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013df07
MOV byte ptr [R15],0x75
INC R15
LAB_0013df07:
LEA RCX,[0x186a57]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013df38
MOV byte ptr [R15],0x76
INC R15
LAB_0013df38:
LEA RCX,[0x186a63]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011e3fb
MOV RDI,R14
MOV RSI,RAX
CALL 0x0011cdfa
TEST EAX,EAX
JS 0x0013de02
JZ 0x0013df69
MOV byte ptr [R15],0x79
INC R15
LAB_0013df69:
MOV R12,-0x100000000
LEA RAX,[RSP + 0x8]
CMP R15,RAX
JZ 0x0013df92
LEA RSI,[RSP + 0x8]
SUB R15D,ESI
MOV RDI,R14
MOV EDX,R15D
CALL 0x0011a4e8
JMP 0x0013df9d
LAB_0013df92:
PUSH 0x2f
POP RSI
MOV RDI,R14
CALL 0x0011a990
LAB_0013df9d:
MOV RBX,RDX
AND R12,RAX
JMP 0x0013de07
|
int1 [16] js_regexp_get_flags(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
int1 auVar5 [16];
int1 auVar6 [16];
int1 local_30 [8];
if ((int)param_3 == -1) {
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"hasIndices");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 == 0) {
puVar4 = local_30;
}
else {
puVar4 = local_30 + 1;
local_30[0] = 100;
}
uVar2 = JS_GetProperty(param_1,param_2,param_3,0x6f);
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x67;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"ignoreCase");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x69;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"multiline");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x6d;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"dotAll");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x73;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetProperty(param_1,param_2,param_3,0x70);
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x75;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"unicodeSets");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x76;
puVar4 = puVar4 + 1;
}
uVar2 = JS_GetPropertyStr(param_1,param_2,param_3,"sticky");
iVar1 = JS_ToBoolFree(param_1,uVar2);
if (-1 < iVar1) {
if (iVar1 != 0) {
*puVar4 = 0x79;
puVar4 = puVar4 + 1;
}
if (puVar4 == local_30) {
auVar6 = JS_AtomToString(param_1,0x2f);
}
else {
auVar6 = js_new_string8_len(param_1,local_30,(int)puVar4 - (int)local_30);
}
uVar3 = auVar6._0_8_ & 0xffffffff00000000;
goto LAB_0013de07;
}
}
}
}
}
}
}
}
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
}
auVar6 = ZEXT816(6) << 0x40;
uVar3 = 0;
LAB_0013de07:
auVar5._0_8_ = auVar6._0_8_ & 0xffffffff | uVar3;
auVar5._8_8_ = auVar6._8_8_;
return auVar5;
}
|
|
58,557
|
my_mb_wc_filename
|
eloqsql/strings/ctype-utf8.c
|
static int
my_mb_wc_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int byte1, byte2;
if (s >= e)
return MY_CS_TOOSMALL;
if (*s < 128 && filename_safe_char[*s])
{
*pwc= *s;
return 1;
}
if (*s != MY_FILENAME_ESCAPE)
return MY_CS_ILSEQ;
if (s + 3 > e)
return MY_CS_TOOSMALL3;
byte1= s[1];
if (byte1 == 0)
return MY_CS_ILSEQ; /* avoid possible out-of-bounds read */
byte2= s[2];
if (byte1 >= 0x30 && byte1 <= 0x7F &&
byte2 >= 0x30 && byte2 <= 0x7F)
{
int code= (byte1 - 0x30) * 80 + byte2 - 0x30;
if (code < 5994 && touni[code])
{
*pwc= touni[code];
return 3;
}
if (byte1 == '@' && byte2 == '@')
{
*pwc= 0;
return 3;
}
}
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if ((byte1= hexlo(byte1)) >= 0 &&
(byte2= hexlo(byte2)) >= 0)
{
int byte3= hexlo(s[3]);
int byte4= hexlo(s[3] ? s[4] : 0);
if (byte3 >=0 && byte4 >=0)
{
*pwc= (byte1 << 12) + (byte2 << 8) + (byte3 << 4) + byte4;
return 5;
}
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_mb_wc_filename:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x5ae26
movsbq (%rdx), %r8
testq %r8, %r8
js 0x5ae24
leaq 0x2823c2(%rip), %rdi # 0x2dd0f0
movl $0x1, %eax
cmpb $0x0, (%r8,%rdi)
je 0x5ad42
movq %r8, (%rsi)
jmp 0x5ae26
cmpb $0x40, %r8b
jne 0x5ae24
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x5ae26
movzbl 0x1(%rdx), %r10d
testl %r10d, %r10d
je 0x5ae24
movb 0x2(%rdx), %al
movzbl %al, %r9d
cmpb $0x30, %r10b
setge %al
cmpb $0x30, %r9b
setge %r8b
andb %al, %r8b
cmpb $0x1, %r8b
jne 0x5addd
leal (%r10,%r10,4), %eax
shll $0x4, %eax
addl %r9d, %eax
addl $0xfffff100, %eax # imm = 0xFFFFF100
cmpl $0x1799, %eax # imm = 0x1799
jg 0x5adbf
addl $-0x30, %eax
leaq 0x2823c5(%rip), %r8 # 0x2dd170
movzwl (%r8,%rax,2), %r8d
testq %r8, %r8
je 0x5adbf
movl $0x3, %eax
jmp 0x5ad3a
movl %r10d, %eax
xorb $0x40, %al
movl %r9d, %r8d
xorb $0x40, %r8b
orb %al, %r8b
jne 0x5addd
movl $0x3, %eax
xorl %r8d, %r8d
jmp 0x5ad3a
addq $0x4, %rdx
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdx
ja 0x5ae26
movl %r10d, %eax
leaq 0x28525b(%rip), %r10 # 0x2e0050
movzbl (%rax,%r10), %ecx
testb %cl, %cl
js 0x5ae24
movl %r9d, %eax
movzbl (%rax,%r10), %r9d
movl $0x0, %eax
testb %r9b, %r9b
js 0x5ae26
movzbl (%rdi), %edi
xorl %eax, %eax
movzbl (%rdi,%r10), %r8d
testq %rdi, %rdi
je 0x5ae28
movzbl (%rdx), %edx
jmp 0x5ae2a
xorl %eax, %eax
popq %rbp
retq
xorl %edx, %edx
testb %r8b, %r8b
js 0x5ae26
movb (%rdx,%r10), %dl
testb %dl, %dl
js 0x5ae26
movzbl %dl, %eax
shll $0xc, %ecx
shll $0x8, %r9d
shll $0x4, %r8d
addq %rcx, %r8
addq %r9, %r8
addq %rax, %r8
movl $0x5, %eax
jmp 0x5ad3a
|
my_mb_wc_filename:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_5AE26
movsx r8, byte ptr [rdx]
test r8, r8
js loc_5AE24
lea rdi, filename_safe_char
mov eax, 1
cmp byte ptr [r8+rdi], 0
jz short loc_5AD42
loc_5AD3A:
mov [rsi], r8
jmp loc_5AE26
loc_5AD42:
cmp r8b, 40h ; '@'
jnz loc_5AE24
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_5AE26
movzx r10d, byte ptr [rdx+1]
test r10d, r10d
jz loc_5AE24
mov al, [rdx+2]
movzx r9d, al
cmp r10b, 30h ; '0'
setnl al
cmp r9b, 30h ; '0'
setnl r8b
and r8b, al
cmp r8b, 1
jnz short loc_5ADDD
lea eax, [r10+r10*4]
shl eax, 4
add eax, r9d
add eax, 0FFFFF100h
cmp eax, 1799h
jg short loc_5ADBF
add eax, 0FFFFFFD0h
lea r8, touni
movzx r8d, word ptr [r8+rax*2]
test r8, r8
jz short loc_5ADBF
mov eax, 3
jmp loc_5AD3A
loc_5ADBF:
mov eax, r10d
xor al, 40h
mov r8d, r9d
xor r8b, 40h
or r8b, al
jnz short loc_5ADDD
mov eax, 3
xor r8d, r8d
jmp loc_5AD3A
loc_5ADDD:
add rdx, 4
mov eax, 0FFFFFF98h
cmp rdx, rcx
ja short loc_5AE26
mov eax, r10d
lea r10, hexlo_hex_lo_digit
movzx ecx, byte ptr [rax+r10]
test cl, cl
js short loc_5AE24
mov eax, r9d
movzx r9d, byte ptr [rax+r10]
mov eax, 0
test r9b, r9b
js short loc_5AE26
movzx edi, byte ptr [rdi]
xor eax, eax
movzx r8d, byte ptr [rdi+r10]
test rdi, rdi
jz short loc_5AE28
movzx edx, byte ptr [rdx]
jmp short loc_5AE2A
loc_5AE24:
xor eax, eax
loc_5AE26:
pop rbp
retn
loc_5AE28:
xor edx, edx
loc_5AE2A:
test r8b, r8b
js short loc_5AE26
mov dl, [rdx+r10]
test dl, dl
js short loc_5AE26
movzx eax, dl
shl ecx, 0Ch
shl r9d, 8
shl r8d, 4
add r8, rcx
add r8, r9
add r8, rax
mov eax, 5
jmp loc_5AD3A
|
long long my_mb_wc_filename(long long a1, signed long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
signed long long v5; // r8
unsigned __int8 *v6; // rdi
int v7; // r10d
int v8; // r9d
long long v9; // rax
unsigned __int8 *v10; // rdx
int v11; // ecx
int v12; // r9d
long long v13; // rdi
int v14; // r8d
long long v15; // rdx
char v16; // dl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( v5 < 0 )
return 0LL;
result = 1LL;
if ( filename_safe_char[v5] )
{
LABEL_4:
*a2 = v5;
return result;
}
if ( (_BYTE)v5 != 64 )
return 0LL;
v6 = (unsigned __int8 *)(a3 + 3);
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v7 = (unsigned __int8)a3[1];
if ( !a3[1] )
return 0LL;
v8 = (unsigned __int8)a3[2];
if ( (char)v7 >= 48 && (char)v8 >= 48 )
{
if ( v8 + 80 * v7 - 3840 <= 6041 )
{
v9 = (unsigned int)(v8 + 80 * v7 - 3888);
v5 = touni[v9];
if ( touni[v9] )
{
result = 3LL;
goto LABEL_4;
}
}
if ( !((unsigned __int8)v7 ^ 0x40 | (unsigned __int8)v8 ^ 0x40) )
{
result = 3LL;
v5 = 0LL;
goto LABEL_4;
}
}
v10 = (unsigned __int8 *)(a3 + 4);
result = 4294967192LL;
if ( (unsigned long long)v10 <= a4 )
{
v11 = hexlo_hex_lo_digit[v7];
if ( (v11 & 0x80u) == 0 )
{
v12 = hexlo_hex_lo_digit[v8];
result = 0LL;
if ( (v12 & 0x80u) == 0 )
{
v13 = *v6;
result = 0LL;
v14 = hexlo_hex_lo_digit[v13];
v15 = v13 ? *v10 : 0LL;
if ( (v14 & 0x80u) == 0 )
{
v16 = hexlo_hex_lo_digit[v15];
if ( v16 >= 0 )
{
v5 = (unsigned __int8)v16
+ (unsigned int)(v12 << 8)
+ (unsigned int)(v11 << 12)
+ (unsigned long long)(unsigned int)(16 * v14);
result = 5LL;
goto LABEL_4;
}
}
}
return result;
}
return 0LL;
}
return result;
}
|
my_mb_wc_filename:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0015ae26
MOVSX R8,byte ptr [RDX]
TEST R8,R8
JS 0x0015ae24
LEA RDI,[0x3dd0f0]
MOV EAX,0x1
CMP byte ptr [R8 + RDI*0x1],0x0
JZ 0x0015ad42
LAB_0015ad3a:
MOV qword ptr [RSI],R8
JMP 0x0015ae26
LAB_0015ad42:
CMP R8B,0x40
JNZ 0x0015ae24
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x0015ae26
MOVZX R10D,byte ptr [RDX + 0x1]
TEST R10D,R10D
JZ 0x0015ae24
MOV AL,byte ptr [RDX + 0x2]
MOVZX R9D,AL
CMP R10B,0x30
SETGE AL
CMP R9B,0x30
SETGE R8B
AND R8B,AL
CMP R8B,0x1
JNZ 0x0015addd
LEA EAX,[R10 + R10*0x4]
SHL EAX,0x4
ADD EAX,R9D
ADD EAX,0xfffff100
CMP EAX,0x1799
JG 0x0015adbf
ADD EAX,-0x30
LEA R8,[0x3dd170]
MOVZX R8D,word ptr [R8 + RAX*0x2]
TEST R8,R8
JZ 0x0015adbf
MOV EAX,0x3
JMP 0x0015ad3a
LAB_0015adbf:
MOV EAX,R10D
XOR AL,0x40
MOV R8D,R9D
XOR R8B,0x40
OR R8B,AL
JNZ 0x0015addd
MOV EAX,0x3
XOR R8D,R8D
JMP 0x0015ad3a
LAB_0015addd:
ADD RDX,0x4
MOV EAX,0xffffff98
CMP RDX,RCX
JA 0x0015ae26
MOV EAX,R10D
LEA R10,[0x3e0050]
MOVZX ECX,byte ptr [RAX + R10*0x1]
TEST CL,CL
JS 0x0015ae24
MOV EAX,R9D
MOVZX R9D,byte ptr [RAX + R10*0x1]
MOV EAX,0x0
TEST R9B,R9B
JS 0x0015ae26
MOVZX EDI,byte ptr [RDI]
XOR EAX,EAX
MOVZX R8D,byte ptr [RDI + R10*0x1]
TEST RDI,RDI
JZ 0x0015ae28
MOVZX EDX,byte ptr [RDX]
JMP 0x0015ae2a
LAB_0015ae24:
XOR EAX,EAX
LAB_0015ae26:
POP RBP
RET
LAB_0015ae28:
XOR EDX,EDX
LAB_0015ae2a:
TEST R8B,R8B
JS 0x0015ae26
MOV DL,byte ptr [RDX + R10*0x1]
TEST DL,DL
JS 0x0015ae26
MOVZX EAX,DL
SHL ECX,0xc
SHL R9D,0x8
SHL R8D,0x4
ADD R8,RCX
ADD R8,R9
ADD R8,RAX
MOV EAX,0x5
JMP 0x0015ad3a
|
int8 my_mb_wc_filename(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int iVar3;
int8 uVar4;
ulong uVar5;
ulong uVar6;
if (param_4 <= param_3) {
return 0xffffff9b;
}
uVar6 = (ulong)(char)*param_3;
if ((long)uVar6 < 0) {
return 0;
}
uVar4 = 1;
if (filename_safe_char[uVar6] != '\0') goto LAB_0015ad3a;
if (*param_3 == 0x40) {
if (param_4 < param_3 + 3) {
return 0xffffff99;
}
bVar2 = param_3[1];
if (bVar2 == 0) {
return 0;
}
bVar1 = param_3[2];
if ('/' < (char)bVar1 && '/' < (char)bVar2) {
iVar3 = ((uint)bVar2 + (uint)bVar2 * 4) * 0x10 + (uint)bVar1;
if ((iVar3 + -0xf00 < 0x179a) &&
(uVar6 = (ulong)*(ushort *)(touni + (ulong)(iVar3 - 0xf30) * 2), uVar6 != 0)) {
uVar4 = 3;
goto LAB_0015ad3a;
}
if (bVar1 == 0x40 && bVar2 == 0x40) {
uVar4 = 3;
uVar6 = 0;
goto LAB_0015ad3a;
}
}
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
if (-1 < (char)hexlo_hex_lo_digit[bVar2]) {
if ((char)hexlo_hex_lo_digit[bVar1] < '\0') {
return 0;
}
uVar6 = (ulong)param_3[3];
if (uVar6 == 0) {
uVar5 = 0;
}
else {
uVar5 = (ulong)param_3[4];
}
if ((char)hexlo_hex_lo_digit[uVar6] < '\0') {
return 0;
}
if ((char)hexlo_hex_lo_digit[uVar5] < '\0') {
return 0;
}
uVar6 = (ulong)(byte)hexlo_hex_lo_digit[uVar6] * 0x10 +
(ulong)(byte)hexlo_hex_lo_digit[bVar2] * 0x1000 +
(ulong)(byte)hexlo_hex_lo_digit[bVar1] * 0x100 +
(ulong)(byte)hexlo_hex_lo_digit[uVar5];
uVar4 = 5;
LAB_0015ad3a:
*param_2 = uVar6;
return uVar4;
}
}
return 0;
}
|
|
58,558
|
minja::IfExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!condition) throw std::runtime_error("IfExpr.condition is null");
if (!then_expr) throw std::runtime_error("IfExpr.then_expr is null");
if (condition->evaluate(context).to_bool()) {
return then_expr->evaluate(context);
}
if (else_expr) {
return else_expr->evaluate(context);
}
return nullptr;
}
|
O2
|
cpp
|
minja::IfExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x71f06
cmpq $0x0, 0x30(%r15)
je 0x71f22
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x6371a
movq %r12, %rdi
callq 0x638f0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x639aa
testb %bpl, %bpl
je 0x71ed1
movq 0x30(%r15), %rsi
jmp 0x71eda
movq 0x40(%r15), %rsi
testq %rsi, %rsi
je 0x71ef5
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6371a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x68002
jmp 0x71ee5
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %r14
leaq 0x448a7(%rip), %rsi # 0xb67bf
movq %rax, %rdi
callq 0x24320
jmp 0x71f3c
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %r14
leaq 0x448a4(%rip), %rsi # 0xb67d8
movq %rax, %rdi
callq 0x24320
movq 0x8f0ad(%rip), %rsi # 0x100ff0
movq 0x8f006(%rip), %rdx # 0x100f50
movq %r14, %rdi
callq 0x24ef0
jmp 0x71f54
movq %rax, %rbx
movq %r14, %rdi
callq 0x24680
jmp 0x71f6c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x639aa
movq %rbx, %rdi
callq 0x24f80
|
_ZNK5minja6IfExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz short loc_71F06
cmp qword ptr [r15+30h], 0
jz short loc_71F22
mov r14, rdx
mov rbx, rdi
mov r12, rsp
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, r12; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov ebp, eax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jz short loc_71ED1
mov rsi, [r15+30h]
jmp short loc_71EDA
loc_71ED1:
mov rsi, [r15+40h]
test rsi, rsi
jz short loc_71EF5
loc_71EDA:
mov rdi, rbx
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
loc_71EE5:
mov rax, rbx
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_71EF5:
mov rsi, rsp
and qword ptr [rsi], 0
mov rdi, rbx
call _ZN5minja5ValueC2ERKDn; minja::Value::Value(decltype(nullptr) const&)
jmp short loc_71EE5
loc_71F06:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aIfexprConditio; "IfExpr.condition is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_71F3C
loc_71F22:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aIfexprThenExpr; "IfExpr.then_expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_71F3C:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short $+2
loc_71F54:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_71F6C
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_71F6C:
mov rdi, rbx
call __Unwind_Resume
|
_OWORD * minja::IfExpr::do_evaluate(_OWORD *a1, _QWORD *a2)
{
void (***v3)(void); // rsi
char v4; // bp
void (***v5)(void); // rsi
std::runtime_error *exception; // r14
_QWORD v8[15]; // [rsp+0h] [rbp-78h] BYREF
v3 = (void (***)(void))a2[4];
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "IfExpr.condition is null");
goto LABEL_11;
}
if ( !a2[6] )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "IfExpr.then_expr is null");
LABEL_11:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v8, v3);
v4 = minja::Value::to_bool((minja::Value *)v8);
minja::Value::~Value((minja::Value *)v8);
if ( v4 )
{
v5 = (void (***)(void))a2[6];
}
else
{
v5 = (void (***)(void))a2[8];
if ( !v5 )
{
v8[0] = 0LL;
minja::Value::Value(a1);
return a1;
}
}
minja::Expression::evaluate((long long)a1, v5);
return a1;
}
|
do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x00171f06
CMP qword ptr [R15 + 0x30],0x0
JZ 0x00171f22
MOV R14,RDX
MOV RBX,RDI
MOV R12,RSP
MOV RDI,R12
CALL 0x0016371a
LAB_00171eb4:
MOV RDI,R12
CALL 0x001638f0
LAB_00171ebc:
MOV EBP,EAX
MOV RDI,RSP
CALL 0x001639aa
TEST BPL,BPL
JZ 0x00171ed1
MOV RSI,qword ptr [R15 + 0x30]
JMP 0x00171eda
LAB_00171ed1:
MOV RSI,qword ptr [R15 + 0x40]
TEST RSI,RSI
JZ 0x00171ef5
LAB_00171eda:
MOV RDI,RBX
MOV RDX,R14
CALL 0x0016371a
LAB_00171ee5:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00171ef5:
MOV RSI,RSP
AND qword ptr [RSI],0x0
MOV RDI,RBX
CALL 0x00168002
JMP 0x00171ee5
LAB_00171f06:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV R14,RAX
LAB_00171f11:
LEA RSI,[0x1b67bf]
MOV RDI,RAX
CALL 0x00124320
LAB_00171f20:
JMP 0x00171f3c
LAB_00171f22:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV R14,RAX
LAB_00171f2d:
LEA RSI,[0x1b67d8]
MOV RDI,RAX
CALL 0x00124320
LAB_00171f3c:
MOV RSI,qword ptr [0x00200ff0]
MOV RDX,qword ptr [0x00200f50]
MOV RDI,R14
CALL 0x00124ef0
|
/* minja::IfExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
IfExpr * __thiscall minja::IfExpr::do_evaluate(IfExpr *this,shared_ptr *param_1)
{
char cVar1;
runtime_error *this_00;
shared_ptr *psVar2;
_func_decltype_nullptr *local_78 [10];
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00171f11 to 00171f1f has its CatchHandler @ 00171f54 */
std::runtime_error::runtime_error(this_00,"IfExpr.condition is null");
}
else {
if (*(long *)(param_1 + 0x30) != 0) {
Expression::evaluate((Expression *)local_78,*(shared_ptr **)(param_1 + 0x20));
/* try { // try from 00171eb4 to 00171ebb has its CatchHandler @ 00171f61 */
cVar1 = Value::to_bool((Value *)local_78);
Value::~Value((Value *)local_78);
if (cVar1 == '\0') {
psVar2 = *(shared_ptr **)(param_1 + 0x40);
if (psVar2 == (shared_ptr *)0x0) {
local_78[0] = (_func_decltype_nullptr *)0x0;
Value::Value((Value *)this,local_78);
return this;
}
}
else {
psVar2 = *(shared_ptr **)(param_1 + 0x30);
}
Expression::evaluate((Expression *)this,psVar2);
return this;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00171f2d to 00171f3b has its CatchHandler @ 00171f52 */
std::runtime_error::runtime_error(this_00,"IfExpr.then_expr is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00200ff0,PTR__runtime_error_00200f50);
}
|
|
58,559
|
map_to_isogenous_E2
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/map_to_g2.c
|
static void map_to_isogenous_E2(POINTonE2 *p, const vec384x u)
{
static const vec384x minus_A = {
{ 0 },
{ TO_LIMB_T(0xd4c4fffffcec5869), TO_LIMB_T(0x1da3f3eed25bfd79),
TO_LIMB_T(0x7fa833c5136fff67), TO_LIMB_T(0x59261433cd540cbd),
TO_LIMB_T(0x48450f5f2b84682c), TO_LIMB_T(0x07e05d00bf959233) }
};
static const vec384x Z = { /* -2 - i */
{ TO_LIMB_T(0x87ebfffffff9555c), TO_LIMB_T(0x656fffe5da8ffffa),
TO_LIMB_T(0x0fd0749345d33ad2), TO_LIMB_T(0xd951e663066576f4),
TO_LIMB_T(0xde291a3d41e980d3), TO_LIMB_T(0x0815664c7dfe040d) },
{ TO_LIMB_T(0x43f5fffffffcaaae), TO_LIMB_T(0x32b7fff2ed47fffd),
TO_LIMB_T(0x07e83a49a2e99d69), TO_LIMB_T(0xeca8f3318332bb7a),
TO_LIMB_T(0xef148d1ea0f4c069), TO_LIMB_T(0x040ab3263eff0206) }
};
static const vec384x recip_ZZZ = { /* 1/(Z^3) */
{ TO_LIMB_T(0x65018f5c28f598eb), TO_LIMB_T(0xe6020417f022d916),
TO_LIMB_T(0xd6327313288369c7), TO_LIMB_T(0x622ded8eb447156f),
TO_LIMB_T(0xe52a2aee72c2a01f), TO_LIMB_T(0x089812fb8481ffe4) },
{ TO_LIMB_T(0x2574eb851eb8619f), TO_LIMB_T(0xdba2e97912925604),
TO_LIMB_T(0x67e495a909e7a18e), TO_LIMB_T(0xdf2da23b8145b8f7),
TO_LIMB_T(0xcf5d3728310ebf6d), TO_LIMB_T(0x11be446236f4c116) }
};
static const vec384x magic_ZZZ = { /* 1/Z^3 = a + b*i */
/* a^2 + b^2 */
{ TO_LIMB_T(0xaa7eb851eb8508e0), TO_LIMB_T(0x1c54fdf360989374),
TO_LIMB_T(0xc87f2fc6e716c62e), TO_LIMB_T(0x0124aefb1f9efea7),
TO_LIMB_T(0xb2f8be63e844865c), TO_LIMB_T(0x08b47f775a7ef35a) },
/* (a^2 + b^2)^((P-3)/4) */
{ TO_LIMB_T(0xe4132bbd838cf70a), TO_LIMB_T(0x01d769ac83772c19),
TO_LIMB_T(0xa83dd6e974c22e45), TO_LIMB_T(0xbc8ec3e777b08dff),
TO_LIMB_T(0xc035c2042ecf5da3), TO_LIMB_T(0x073929e97f0850bf) }
};
static const vec384x ZxA = { /* 240 - 480*i */
{ TO_LIMB_T(0xe53a000003135242), TO_LIMB_T(0x01080c0fdef80285),
TO_LIMB_T(0xe7889edbe340f6bd), TO_LIMB_T(0x0b51375126310601),
TO_LIMB_T(0x02d6985717c744ab), TO_LIMB_T(0x1220b4e979ea5467) },
{ TO_LIMB_T(0xa989fffff9d8b0d2), TO_LIMB_T(0x3b47e7dda4b7faf3),
TO_LIMB_T(0xff50678a26dffece), TO_LIMB_T(0xb24c28679aa8197a),
TO_LIMB_T(0x908a1ebe5708d058), TO_LIMB_T(0x0fc0ba017f2b2466) }
};
vec384x uu, tv2, tv4, x2n, gx1, gxd, y2;
#if 0
vec384x xn, x1n, xd, y, y1, Zuu;
#else
# define xn p->X
# define y p->Y
# define xd p->Z
# define x1n xn
# define y1 y
# define Zuu x2n
#endif
#define sgn0_fp2(a) (sgn0_pty_mont_384x((a), BLS12_381_P, p0) & 1)
bool_t e1, e2;
/*
* as per map_to_curve() from poc/sswu_opt.sage at
* https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve
* with 9mod16 twists...
*/
/* x numerator variants */
sqr_fp2(uu, u); /* uu = u^2 */
mul_fp2(Zuu, Z, uu); /* Zuu = Z * uu */
sqr_fp2(tv2, Zuu); /* tv2 = Zuu^2 */
add_fp2(tv2, tv2, Zuu); /* tv2 = tv2 + Zuu */
add_fp2(x1n, tv2, BLS12_381_Rx.p2); /* x1n = tv2 + 1 */
mul_fp2(x1n, x1n, Bprime_E2); /* x1n = x1n * B */
mul_fp2(x2n, Zuu, x1n); /* x2n = Zuu * x1n */
/* x denumenator */
mul_fp2(xd, minus_A, tv2); /* xd = -A * tv2 */
e1 = vec_is_zero(xd, sizeof(xd)); /* e1 = xd == 0 */
vec_select(xd, ZxA, xd, sizeof(xd), e1); /* # If xd == 0, set xd = Z*A */
/* y numerators variants */
sqr_fp2(tv2, xd); /* tv2 = xd^2 */
mul_fp2(gxd, xd, tv2); /* gxd = xd^3 */
mul_fp2(tv2, Aprime_E2, tv2); /* tv2 = A * tv2 */
sqr_fp2(gx1, x1n); /* gx1 = x1n^2 */
add_fp2(gx1, gx1, tv2); /* gx1 = gx1 + tv2 # x1n^2 + A*xd^2 */
mul_fp2(gx1, gx1, x1n); /* gx1 = gx1 * x1n # x1n^3 + A*x1n*xd^2 */
mul_fp2(tv2, Bprime_E2, gxd); /* tv2 = B * gxd */
add_fp2(gx1, gx1, tv2); /* gx1 = gx1 + tv2 # x1^3 + A*x1*xd^2 + B*xd^3 */
sqr_fp2(tv4, gxd); /* tv4 = gxd^2 */
mul_fp2(tv2, gx1, gxd); /* tv2 = gx1 * gxd */
mul_fp2(tv4, tv4, tv2); /* tv4 = tv4 * tv2 # gx1*gxd^3 */
e2 = recip_sqrt_fp2(y1, tv4, /* y1 = tv4^c1 # (gx1*gxd^3)^((p^2-9)/16) */
recip_ZZZ, magic_ZZZ);
mul_fp2(y1, y1, tv2); /* y1 = y1 * tv2 # gx1*gxd*y1 */
mul_fp2(y2, y1, uu); /* y2 = y1 * uu */
mul_fp2(y2, y2, u); /* y2 = y2 * u */
/* choose numerators */
vec_select(xn, x1n, x2n, sizeof(xn), e2); /* xn = e2 ? x1n : x2n */
vec_select(y, y1, y2, sizeof(y), e2); /* y = e2 ? y1 : y2 */
e1 = sgn0_fp2(u);
e2 = sgn0_fp2(y);
cneg_fp2(y, y, e1^e2); /* fix sign of y */
/* return (xn, xd, y, 1) */
/* convert (xn, xd, y, 1) to Jacobian projective coordinates */
mul_fp2(p->X, xn, xd); /* X = xn * xd */
mul_fp2(p->Y, y, gxd); /* Y = y * xd^3 */
#ifndef xd
vec_copy(p->Z, xd, sizeof(xd)); /* Z = xd */
#else
# undef xn
# undef y
# undef xd
# undef x1n
# undef y1
# undef Zuu
# undef tv4
#endif
#undef sgn0_fp2
}
|
O2
|
c
|
map_to_isogenous_E2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
movq %rsi, -0x48(%rbp)
movq %rdi, %rbx
leaq -0x320(%rbp), %r14
movq %r14, %rdi
callq 0x5ad98
leaq 0x2489c(%rip), %rsi # 0x80dc0
leaq -0x260(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5ad73
leaq -0x2c0(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5ad98
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5acb9
leaq 0x2378b(%rip), %rdx # 0x7fce8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5acb9
leaq 0x249d1(%rip), %r14 # 0x80f40
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5ad73
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5ad73
leaq 0xc0(%rbx), %r15
movq %r15, -0x40(%rbp)
leaq 0x247c3(%rip), %rsi # 0x80d60
movq %r15, %rdi
movq %r13, %rdx
callq 0x5ad73
pushq $0x60
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x510f5
leaq 0x24922(%rip), %rsi # 0x80ee0
movq %r15, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x51073
movq %r13, %rdi
movq %r15, %rsi
callq 0x5ad98
leaq -0x200(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5ad73
leaq 0x2470a(%rip), %rsi # 0x80d00
movq %r13, %rdi
movq %r13, %rdx
callq 0x5ad73
leaq -0x3e0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5ad98
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5acb9
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rbx, -0x30(%rbp)
callq 0x5ad73
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5ad73
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5acb9
leaq -0x1a0(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ad98
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5ad73
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5ad73
leaq 0x60(%rbx), %r12
leaq -0x380(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %r13
callq 0x582c9
leaq -0x170(%rbp), %rsi
leaq -0x140(%rbp), %r14
movq %r14, %rdi
callq 0x582c9
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x56a78
leaq -0xe0(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5c01a
movq %rax, %r14
leaq 0x2474a(%rip), %rdx # 0x80e20
leaq -0xb0(%rbp), %rdi
movq %r13, %rsi
callq 0x5ad73
leaq 0x24794(%rip), %rdx # 0x80e80
leaq -0x350(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5aad8
leaq 0x247ab(%rip), %rdx # 0x80eb0
leaq -0x110(%rbp), %rdi
movq %rbx, %rsi
callq 0x5aad8
pushq $0x30
popq %rbx
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq %r14, -0x38(%rbp)
movq %r14, %r8
callq 0x51073
leaq -0xe0(%rbp), %rdi
movq %rdi, %rsi
movq %rdi, %r13
leaq -0x110(%rbp), %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x51073
leaq -0xb0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
movq %rdi, %rdx
pushq $0x60
popq %rcx
movq %r14, %r8
callq 0x51073
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5aad8
leaq -0x140(%rbp), %r14
movq %r14, %rdi
leaq -0xb0(%rbp), %r13
movq %r13, %rsi
movq %r15, %rdx
callq 0x5aa6c
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x56a78
movq %r15, %rdi
movq %rbx, %rsi
callq 0x510f5
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x51073
movq %r15, %rdi
movq %r15, %rsi
callq 0x5c93a
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c01a
movq -0x30(%rbp), %rbx
leaq 0x90(%rbx), %r14
leaq -0x80(%rbp), %rsi
movq %r14, %rdi
callq 0x5c93a
movq %r14, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5aad8
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5aad8
movq %r12, %rdi
movq %r12, %rsi
movq %r12, %rdx
leaq -0xb0(%rbp), %rcx
callq 0x5c94b
movq %r12, %rdi
movq %r12, %rsi
leaq -0xe0(%rbp), %r15
movq %r15, %rdx
callq 0x5aad8
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5aad8
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x56a89
movq %r12, %rdi
movq %r12, %rsi
leaq -0x2c0(%rbp), %rdx
callq 0x5ad73
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
leaq -0x320(%rbp), %rdx
callq 0x5ad73
movq %r14, %rdi
movq %r14, %rsi
movq -0x48(%rbp), %r13
movq %r13, %rdx
callq 0x5ad73
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x260(%rbp), %rdx
pushq $0x60
popq %r15
movq %r15, %rcx
movq -0x38(%rbp), %rbx
movq %rbx, %r8
callq 0x51073
movq %r12, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x51073
leaq 0x233e8(%rip), %r14 # 0x7fcb0
movabsq $-0x760c000300030003, %r15 # imm = 0x89F3FFFCFFFCFFFD
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x68fe0
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x68fe0
xorl %eax, %r13d
andl $0x1, %r13d
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5add4
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
movq -0x40(%rbp), %rdx
callq 0x5ad73
movq %r12, %rdi
movq %r12, %rsi
leaq -0x200(%rbp), %rdx
callq 0x5ad73
addq $0x3b8, %rsp # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
map_to_isogenous_E2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 3B8h
mov [rbp+var_48], rsi
mov rbx, rdi
lea r14, [rbp+var_320]
mov rdi, r14
call sqr_fp2
lea rsi, map_to_isogenous_E2_Z
lea r15, [rbp+var_260]
mov rdi, r15
mov rdx, r14
call mul_fp2
lea r13, [rbp+var_2C0]
mov rdi, r13
mov rsi, r15
call sqr_fp2
mov rdi, r13
mov rsi, r13
mov rdx, r15
call add_fp2
lea rdx, BLS12_381_Rx
mov rdi, rbx
mov rsi, r13
call add_fp2
lea r14, Bprime_E2
mov rdi, rbx
mov rsi, rbx
mov rdx, r14
call mul_fp2
mov rdi, r15
mov rsi, r15
mov rdx, rbx
call mul_fp2
lea r15, [rbx+0C0h]
mov [rbp+var_40], r15
lea rsi, map_to_isogenous_E2_minus_A
mov rdi, r15
mov rdx, r13
call mul_fp2
push 60h ; '`'
pop r12
mov rdi, r15
mov rsi, r12
call vec_is_zero
lea rsi, map_to_isogenous_E2_ZxA
mov rdi, r15
mov rdx, r15
mov rcx, r12
mov r8, rax
call vec_select
mov rdi, r13
mov rsi, r15
call sqr_fp2
lea r12, [rbp+var_200]
mov rdi, r12
mov rsi, r15
mov rdx, r13
call mul_fp2
lea rsi, Aprime_E2
mov rdi, r13
mov rdx, r13
call mul_fp2
lea r15, [rbp+var_3E0]
mov rdi, r15
mov rsi, rbx
call sqr_fp2
mov rdi, r15
mov rsi, r15
mov rdx, r13
call add_fp2
mov rdi, r15
mov rsi, r15
mov rdx, rbx
mov [rbp+var_30], rbx
call mul_fp2
mov rdi, r13
mov rsi, r14
mov rdx, r12
call mul_fp2
mov rdi, r15
mov rsi, r15
mov rdx, r13
call add_fp2
lea r14, [rbp+var_1A0]
mov rdi, r14
mov rsi, r12
call sqr_fp2
mov rdi, r13
mov rsi, r15
mov rdx, r12
call mul_fp2
mov rdi, r14
mov rsi, r14
mov rdx, r13
call mul_fp2
lea r12, [rbx+60h]
lea r15, [rbp+var_380]
mov rdi, r15
mov rsi, r14
mov r13, r14
call sqr_fp
lea rsi, [rbp+var_170]
lea r14, [rbp+var_140]
mov rdi, r14
call sqr_fp
mov rdi, r15
mov rsi, r15
mov rdx, r14
call add_fp
lea rbx, [rbp+var_E0]
mov rdi, rbx
mov rsi, r15
call recip_sqrt_fp
mov r14, rax
lea rdx, map_to_isogenous_E2_recip_ZZZ
lea rdi, [rbp+var_B0]
mov rsi, r13
call mul_fp2
lea rdx, map_to_isogenous_E2_magic_ZZZ
lea r13, [rbp+var_350]
mov rdi, r13
mov rsi, r15
call mul_fp
lea rdx, unk_80EB0
lea rdi, [rbp+var_110]
mov rsi, rbx
call mul_fp
push 30h ; '0'
pop rbx
mov rdi, r15
mov rsi, r15
mov rdx, r13
mov rcx, rbx
mov [rbp+var_38], r14
mov r8, r14
call vec_select
lea rdi, [rbp+var_E0]
mov rsi, rdi
mov r13, rdi
lea rdx, [rbp+var_110]
mov rcx, rbx
mov r8, r14
call vec_select
lea rdi, [rbp+var_B0]
lea rsi, [rbp+var_1A0]
mov rdx, rdi
push 60h ; '`'
pop rcx
mov r8, r14
call vec_select
mov rdi, r15
mov rsi, r15
mov rdx, r13
call mul_fp
lea r14, [rbp+var_140]
mov rdi, r14
lea r13, [rbp+var_B0]
mov rsi, r13
mov rdx, r15
call _sub_fp
mov rdi, r15
mov rsi, r13
mov rdx, r15
call add_fp
mov rdi, r15
mov rsi, rbx
call vec_is_zero
mov rdi, r15
mov rsi, r14
mov rdx, r15
mov rcx, rbx
mov r8, rax
call vec_select
mov rdi, r15
mov rsi, r15
call div_by_2_fp
mov rdi, r12
mov rsi, r15
call recip_sqrt_fp
mov rbx, [rbp+var_30]
lea r14, [rbx+90h]
lea rsi, [rbp+var_80]
mov rdi, r14
call div_by_2_fp
mov rdi, r14
mov rsi, r14
mov rdx, r12
call mul_fp
mov rdi, r12
mov rsi, r12
mov rdx, r15
call mul_fp
mov rdi, r12
mov rsi, r12
mov rdx, r12
lea rcx, [rbp+var_B0]
call sqrt_align_fp2
mov rdi, r12
mov rsi, r12
lea r15, [rbp+var_E0]
mov rdx, r15
call mul_fp
mov rdi, r14
mov rsi, r14
mov rdx, r15
call mul_fp
push 1
pop rdx
mov rdi, r14
mov rsi, r14
call cneg_fp
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_2C0]
call mul_fp2
lea r14, [rbp+var_B0]
mov rdi, r14
mov rsi, r12
lea rdx, [rbp+var_320]
call mul_fp2
mov rdi, r14
mov rsi, r14
mov r13, [rbp+var_48]
mov rdx, r13
call mul_fp2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_260]
push 60h ; '`'
pop r15
mov rcx, r15
mov rbx, [rbp+var_38]
mov r8, rbx
call vec_select
mov rdi, r12
mov rsi, r12
mov rdx, r14
mov rcx, r15
mov r8, rbx
call vec_select
lea r14, BLS12_381_P
mov r15, 89F3FFFCFFFCFFFDh
mov rdi, r13
mov rsi, r14
mov rdx, r15
call sgn0_pty_mont_384x
mov r13, rax
mov rdi, r12
mov rsi, r14
mov rdx, r15
call sgn0_pty_mont_384x
xor r13d, eax
and r13d, 1
mov rdi, r12
mov rsi, r12
mov rdx, r13
call cneg_fp2
mov rdi, [rbp+var_30]
mov rsi, rdi
mov rdx, [rbp+var_40]
call mul_fp2
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_200]
call mul_fp2
add rsp, 3B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long map_to_isogenous_E2(long long a1, long long a2)
{
unsigned long long is_zero; // rax
long long v4; // r12
unsigned long long v5; // r14
unsigned long long v6; // rax
long long v7; // rbx
long long v8; // r14
long long v9; // r13
long long v10; // rdi
long long v11; // rsi
long long v12; // rbx
unsigned __int8 v13; // al
_BYTE v15[96]; // [rsp+0h] [rbp-3E0h] BYREF
_BYTE v16[48]; // [rsp+60h] [rbp-380h] BYREF
_BYTE v17[48]; // [rsp+90h] [rbp-350h] BYREF
_BYTE v18[96]; // [rsp+C0h] [rbp-320h] BYREF
_BYTE v19[96]; // [rsp+120h] [rbp-2C0h] BYREF
_BYTE v20[96]; // [rsp+180h] [rbp-260h] BYREF
_BYTE v21[96]; // [rsp+1E0h] [rbp-200h] BYREF
_BYTE v22[48]; // [rsp+240h] [rbp-1A0h] BYREF
_BYTE v23[48]; // [rsp+270h] [rbp-170h] BYREF
_BYTE v24[48]; // [rsp+2A0h] [rbp-140h] BYREF
_BYTE v25[48]; // [rsp+2D0h] [rbp-110h] BYREF
_BYTE v26[48]; // [rsp+300h] [rbp-E0h] BYREF
_BYTE v27[48]; // [rsp+330h] [rbp-B0h] BYREF
_BYTE v28[56]; // [rsp+360h] [rbp-80h] BYREF
long long v29; // [rsp+398h] [rbp-48h]
long long v30; // [rsp+3A0h] [rbp-40h]
unsigned long long v31; // [rsp+3A8h] [rbp-38h]
long long v32; // [rsp+3B0h] [rbp-30h]
v29 = a2;
sqr_fp2((long long)v18, a2);
mul_fp2((long long)v20, (long long)&map_to_isogenous_E2_Z, (long long)v18);
sqr_fp2((long long)v19, (long long)v20);
add_fp2((long long)v19, (long long)v19, (long long)v20);
add_fp2(a1, (long long)v19, (long long)&BLS12_381_Rx);
mul_fp2(a1, a1, (long long)&Bprime_E2);
mul_fp2((long long)v20, (long long)v20, a1);
v30 = a1 + 192;
mul_fp2(a1 + 192, (long long)&map_to_isogenous_E2_minus_A, (long long)v19);
is_zero = vec_is_zero(a1 + 192, 0x60uLL);
vec_select(a1 + 192, (long long)&map_to_isogenous_E2_ZxA, a1 + 192, 0x60uLL, is_zero);
sqr_fp2((long long)v19, a1 + 192);
mul_fp2((long long)v21, a1 + 192, (long long)v19);
mul_fp2((long long)v19, (long long)&Aprime_E2, (long long)v19);
sqr_fp2((long long)v15, a1);
add_fp2((long long)v15, (long long)v15, (long long)v19);
v32 = a1;
mul_fp2((long long)v15, (long long)v15, a1);
mul_fp2((long long)v19, (long long)&Bprime_E2, (long long)v21);
add_fp2((long long)v15, (long long)v15, (long long)v19);
sqr_fp2((long long)v22, (long long)v21);
mul_fp2((long long)v19, (long long)v15, (long long)v21);
mul_fp2((long long)v22, (long long)v22, (long long)v19);
v4 = a1 + 96;
sqr_fp((long long)v16, (long long)v22);
sqr_fp((long long)v24, (long long)v23);
add_fp((long long)v16, (long long)v16, (long long)v24);
v5 = recip_sqrt_fp((long long)v26, (long long)v16);
mul_fp2((long long)v27, (long long)v22, (long long)&map_to_isogenous_E2_recip_ZZZ);
mul_fp((long long)v17, (long long)v16, (long long)&map_to_isogenous_E2_magic_ZZZ);
mul_fp((long long)v25, (long long)v26, (long long)&unk_80EB0);
v31 = v5;
vec_select((long long)v16, (long long)v16, (long long)v17, 0x30uLL, v5);
vec_select((long long)v26, (long long)v26, (long long)v25, 0x30uLL, v5);
vec_select((long long)v27, (long long)v22, (long long)v27, 0x60uLL, v5);
mul_fp((long long)v16, (long long)v16, (long long)v26);
sub_fp((long long)v24, (long long)v27, (long long)v16);
add_fp((long long)v16, (long long)v27, (long long)v16);
v6 = vec_is_zero((long long)v16, 0x30uLL);
vec_select((long long)v16, (long long)v24, (long long)v16, 0x30uLL, v6);
div_by_2_fp(v16, v16);
recip_sqrt_fp(a1 + 96, (long long)v16);
v7 = v32;
v8 = v32 + 144;
div_by_2_fp(v32 + 144, v28);
mul_fp(v8, v8, a1 + 96);
mul_fp(v4, v4, (long long)v16);
sqrt_align_fp2(v4, v4, v4, v27);
mul_fp(v4, v4, (long long)v26);
mul_fp(v8, v8, (long long)v26);
cneg_fp(v8, v8, 1LL);
mul_fp2(v4, v4, (long long)v19);
mul_fp2((long long)v27, a1 + 96, (long long)v18);
v9 = v29;
mul_fp2((long long)v27, (long long)v27, v29);
v10 = v7;
v11 = v7;
v12 = v31;
vec_select(v10, v11, (long long)v20, 0x60uLL, v31);
vec_select(v4, v4, (long long)v27, 0x60uLL, v12);
LOBYTE(v9) = sgn0_pty_mont_384x(v9, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
v13 = sgn0_pty_mont_384x(v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
cneg_fp2(v4, v4, (v13 ^ (unsigned __int8)v9) & 1);
mul_fp2(v32, v32, v30);
return mul_fp2(v4, v4, (long long)v21);
}
|
map_to_isogenous_E2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x3b8
MOV qword ptr [RBP + -0x48],RSI
MOV RBX,RDI
LEA R14,[RBP + -0x320]
MOV RDI,R14
CALL 0x0015ad98
LEA RSI,[0x180dc0]
LEA R15,[RBP + -0x260]
MOV RDI,R15
MOV RDX,R14
CALL 0x0015ad73
LEA R13,[RBP + -0x2c0]
MOV RDI,R13
MOV RSI,R15
CALL 0x0015ad98
MOV RDI,R13
MOV RSI,R13
MOV RDX,R15
CALL 0x0015acb9
LEA RDX,[0x17fce8]
MOV RDI,RBX
MOV RSI,R13
CALL 0x0015acb9
LEA R14,[0x180f40]
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R14
CALL 0x0015ad73
MOV RDI,R15
MOV RSI,R15
MOV RDX,RBX
CALL 0x0015ad73
LEA R15,[RBX + 0xc0]
MOV qword ptr [RBP + -0x40],R15
LEA RSI,[0x180d60]
MOV RDI,R15
MOV RDX,R13
CALL 0x0015ad73
PUSH 0x60
POP R12
MOV RDI,R15
MOV RSI,R12
CALL 0x001510f5
LEA RSI,[0x180ee0]
MOV RDI,R15
MOV RDX,R15
MOV RCX,R12
MOV R8,RAX
CALL 0x00151073
MOV RDI,R13
MOV RSI,R15
CALL 0x0015ad98
LEA R12,[RBP + -0x200]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
CALL 0x0015ad73
LEA RSI,[0x180d00]
MOV RDI,R13
MOV RDX,R13
CALL 0x0015ad73
LEA R15,[RBP + -0x3e0]
MOV RDI,R15
MOV RSI,RBX
CALL 0x0015ad98
MOV RDI,R15
MOV RSI,R15
MOV RDX,R13
CALL 0x0015acb9
MOV RDI,R15
MOV RSI,R15
MOV RDX,RBX
MOV qword ptr [RBP + -0x30],RBX
CALL 0x0015ad73
MOV RDI,R13
MOV RSI,R14
MOV RDX,R12
CALL 0x0015ad73
MOV RDI,R15
MOV RSI,R15
MOV RDX,R13
CALL 0x0015acb9
LEA R14,[RBP + -0x1a0]
MOV RDI,R14
MOV RSI,R12
CALL 0x0015ad98
MOV RDI,R13
MOV RSI,R15
MOV RDX,R12
CALL 0x0015ad73
MOV RDI,R14
MOV RSI,R14
MOV RDX,R13
CALL 0x0015ad73
LEA R12,[RBX + 0x60]
LEA R15,[RBP + -0x380]
MOV RDI,R15
MOV RSI,R14
MOV R13,R14
CALL 0x001582c9
LEA RSI,[RBP + -0x170]
LEA R14,[RBP + -0x140]
MOV RDI,R14
CALL 0x001582c9
MOV RDI,R15
MOV RSI,R15
MOV RDX,R14
CALL 0x00156a78
LEA RBX,[RBP + -0xe0]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0015c01a
MOV R14,RAX
LEA RDX,[0x180e20]
LEA RDI,[RBP + -0xb0]
MOV RSI,R13
CALL 0x0015ad73
LEA RDX,[0x180e80]
LEA R13,[RBP + -0x350]
MOV RDI,R13
MOV RSI,R15
CALL 0x0015aad8
LEA RDX,[0x180eb0]
LEA RDI,[RBP + -0x110]
MOV RSI,RBX
CALL 0x0015aad8
PUSH 0x30
POP RBX
MOV RDI,R15
MOV RSI,R15
MOV RDX,R13
MOV RCX,RBX
MOV qword ptr [RBP + -0x38],R14
MOV R8,R14
CALL 0x00151073
LEA RDI,[RBP + -0xe0]
MOV RSI,RDI
MOV R13,RDI
LEA RDX,[RBP + -0x110]
MOV RCX,RBX
MOV R8,R14
CALL 0x00151073
LEA RDI,[RBP + -0xb0]
LEA RSI,[RBP + -0x1a0]
MOV RDX,RDI
PUSH 0x60
POP RCX
MOV R8,R14
CALL 0x00151073
MOV RDI,R15
MOV RSI,R15
MOV RDX,R13
CALL 0x0015aad8
LEA R14,[RBP + -0x140]
MOV RDI,R14
LEA R13,[RBP + -0xb0]
MOV RSI,R13
MOV RDX,R15
CALL 0x0015aa6c
MOV RDI,R15
MOV RSI,R13
MOV RDX,R15
CALL 0x00156a78
MOV RDI,R15
MOV RSI,RBX
CALL 0x001510f5
MOV RDI,R15
MOV RSI,R14
MOV RDX,R15
MOV RCX,RBX
MOV R8,RAX
CALL 0x00151073
MOV RDI,R15
MOV RSI,R15
CALL 0x0015c93a
MOV RDI,R12
MOV RSI,R15
CALL 0x0015c01a
MOV RBX,qword ptr [RBP + -0x30]
LEA R14,[RBX + 0x90]
LEA RSI,[RBP + -0x80]
MOV RDI,R14
CALL 0x0015c93a
MOV RDI,R14
MOV RSI,R14
MOV RDX,R12
CALL 0x0015aad8
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
CALL 0x0015aad8
MOV RDI,R12
MOV RSI,R12
MOV RDX,R12
LEA RCX,[RBP + -0xb0]
CALL 0x0015c94b
MOV RDI,R12
MOV RSI,R12
LEA R15,[RBP + -0xe0]
MOV RDX,R15
CALL 0x0015aad8
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
CALL 0x0015aad8
PUSH 0x1
POP RDX
MOV RDI,R14
MOV RSI,R14
CALL 0x00156a89
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0x2c0]
CALL 0x0015ad73
LEA R14,[RBP + -0xb0]
MOV RDI,R14
MOV RSI,R12
LEA RDX,[RBP + -0x320]
CALL 0x0015ad73
MOV RDI,R14
MOV RSI,R14
MOV R13,qword ptr [RBP + -0x48]
MOV RDX,R13
CALL 0x0015ad73
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x260]
PUSH 0x60
POP R15
MOV RCX,R15
MOV RBX,qword ptr [RBP + -0x38]
MOV R8,RBX
CALL 0x00151073
MOV RDI,R12
MOV RSI,R12
MOV RDX,R14
MOV RCX,R15
MOV R8,RBX
CALL 0x00151073
LEA R14,[0x17fcb0]
MOV R15,-0x760c000300030003
MOV RDI,R13
MOV RSI,R14
MOV RDX,R15
CALL 0x00168fe0
MOV R13,RAX
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
CALL 0x00168fe0
XOR R13D,EAX
AND R13D,0x1
MOV RDI,R12
MOV RSI,R12
MOV RDX,R13
CALL 0x0015add4
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,RDI
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x0015ad73
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0x200]
CALL 0x0015ad73
ADD RSP,0x3b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void map_to_isogenous_E2(long param_1,int8 param_2)
{
long lVar1;
int8 uVar2;
int8 uVar3;
long lVar4;
uint uVar5;
uint uVar6;
int1 local_3e8 [96];
int1 local_388 [48];
int1 local_358 [48];
int1 local_328 [96];
int1 local_2c8 [96];
int1 local_268 [96];
int1 local_208 [96];
int1 local_1a8 [48];
int1 local_178 [48];
int1 local_148 [48];
int1 local_118 [48];
int1 local_e8 [48];
int1 local_b8 [48];
int1 local_88 [56];
int8 local_50;
long local_48;
int8 local_40;
long local_38;
local_50 = param_2;
sqr_fp2(local_328);
mul_fp2(local_268,map_to_isogenous_E2_Z,local_328);
sqr_fp2(local_2c8,local_268);
add_fp2(local_2c8,local_2c8,local_268);
add_fp2(param_1,local_2c8,BLS12_381_Rx);
mul_fp2(param_1,param_1,Bprime_E2);
mul_fp2(local_268,local_268,param_1);
lVar1 = param_1 + 0xc0;
local_48 = lVar1;
mul_fp2(lVar1,map_to_isogenous_E2_minus_A,local_2c8);
uVar2 = vec_is_zero(lVar1,0x60);
vec_select(lVar1,map_to_isogenous_E2_ZxA,lVar1,0x60,uVar2);
sqr_fp2(local_2c8,lVar1);
mul_fp2(local_208,lVar1,local_2c8);
mul_fp2(local_2c8,Aprime_E2,local_2c8);
sqr_fp2(local_3e8,param_1);
add_fp2(local_3e8,local_3e8,local_2c8);
local_38 = param_1;
mul_fp2(local_3e8,local_3e8,param_1);
mul_fp2(local_2c8,Bprime_E2,local_208);
add_fp2(local_3e8,local_3e8,local_2c8);
sqr_fp2(local_1a8,local_208);
mul_fp2(local_2c8,local_3e8,local_208);
mul_fp2(local_1a8,local_1a8,local_2c8);
param_1 = param_1 + 0x60;
sqr_fp(local_388,local_1a8);
sqr_fp(local_148,local_178);
add_fp(local_388,local_388,local_148);
uVar2 = recip_sqrt_fp(local_e8,local_388);
mul_fp2(local_b8,local_1a8,map_to_isogenous_E2_recip_ZZZ);
mul_fp(local_358,local_388,map_to_isogenous_E2_magic_ZZZ);
mul_fp(local_118,local_e8,0x180eb0);
local_40 = uVar2;
vec_select(local_388,local_388,local_358,0x30,uVar2);
vec_select(local_e8,local_e8,local_118,0x30,uVar2);
vec_select(local_b8,local_1a8,local_b8,0x60,uVar2);
mul_fp(local_388,local_388,local_e8);
sub_fp(local_148,local_b8,local_388);
add_fp(local_388,local_b8,local_388);
uVar2 = vec_is_zero(local_388,0x30);
vec_select(local_388,local_148,local_388,0x30,uVar2);
div_by_2_fp(local_388,local_388);
recip_sqrt_fp(param_1,local_388);
lVar4 = local_38;
lVar1 = local_38 + 0x90;
div_by_2_fp(lVar1,local_88);
mul_fp(lVar1,lVar1,param_1);
mul_fp(param_1,param_1,local_388);
sqrt_align_fp2(param_1,param_1,param_1,local_b8);
mul_fp(param_1,param_1,local_e8);
mul_fp(lVar1,lVar1,local_e8);
cneg_fp(lVar1,lVar1,1);
mul_fp2(param_1,param_1,local_2c8);
mul_fp2(local_b8,param_1,local_328);
uVar2 = local_50;
mul_fp2(local_b8,local_b8,local_50);
uVar3 = local_40;
vec_select(lVar4,lVar4,local_268,0x60,local_40);
vec_select(param_1,param_1,local_b8,0x60,uVar3);
uVar5 = sgn0_pty_mont_384x(uVar2,BLS12_381_P,0x89f3fffcfffcfffd);
uVar6 = sgn0_pty_mont_384x(param_1,BLS12_381_P,0x89f3fffcfffcfffd);
cneg_fp2(param_1,param_1,(uVar5 ^ uVar6) & 1);
mul_fp2(local_38,local_38,local_48);
mul_fp2(param_1,param_1,local_208);
return;
}
|
|
58,560
|
nglog::base_logging::LogStreamBuf::~LogStreamBuf()
|
ng-log[P]ng-log/src/ng-log/logging.h
|
class NGLOG_EXPORT LogStreamBuf : public std::streambuf {
public:
// REQUIREMENTS: "len" must be >= 2 to account for the '\n' and '\0'.
LogStreamBuf(char* buf, int len) { setp(buf, buf + len - 2); }
// This effectively ignores overflow.
int_type overflow(int_type ch) { return ch; }
// Legacy public ostrstream method.
size_t pcount() const { return static_cast<size_t>(pptr() - pbase()); }
char* pbase() const { return std::streambuf::pbase(); }
}
|
O2
|
c
|
nglog::base_logging::LogStreamBuf::~LogStreamBuf():
pushq %rbx
movq %rdi, %rbx
callq 0x7ac0
movq %rbx, %rdi
popq %rbx
jmp 0x7690
|
_ZN5nglog12base_logging12LogStreamBufD0Ev:
push rbx
mov rbx, rdi
call __ZNSt15basic_streambufIcSt11char_traitsIcEED2Ev; std::streambuf::~streambuf()
mov rdi, rbx
pop rbx
jmp _free
|
void nglog::base_logging::LogStreamBuf::~LogStreamBuf(nglog::base_logging::LogStreamBuf *this)
{
std::streambuf::~streambuf();
free(this);
}
|
~LogStreamBuf:
PUSH RBX
MOV RBX,RDI
CALL 0x00107ac0
MOV RDI,RBX
POP RBX
JMP 0x00107690
|
/* nglog::base_logging::LogStreamBuf::~LogStreamBuf() */
void __thiscall nglog::base_logging::LogStreamBuf::~LogStreamBuf(LogStreamBuf *this)
{
std::streambuf::~streambuf((streambuf *)this);
free(this);
return;
}
|
|
58,561
|
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>>>>>::lexer(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>>>>&&, bool)
|
monkey531[P]llama/common/./json.hpp
|
explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{}
|
O1
|
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>>>>>::lexer(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>>>>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x83aa(%rip), %rcx # 0xfbc9c
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0x1c1d0
movq (%rax), %rax
testq %rax, %rax
je 0xf3913
movsbl (%rax), %eax
jmp 0xf3918
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, aErrorWhileHand_0+34h; ""
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_F3913
movsx eax, byte ptr [rax]
jmp short loc_F3918
loc_F3913:
mov eax, 2Eh ; '.'
loc_F3918:
mov [rbx+90h], eax
pop rbx
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>>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = "";
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv(a1);
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
|
lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
MOV dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
MOV qword ptr [RDI + 0x58],RAX
MOV byte ptr [RDI + 0x60],AL
LEA RCX,[0x1fbc9c]
MOV qword ptr [RDI + 0x70],RCX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
MOV qword ptr [RDI + 0x88],RAX
CALL 0x0011c1d0
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x001f3913
MOVSX EAX,byte ptr [RAX]
JMP 0x001f3918
LAB_001f3913:
MOV EAX,0x2e
LAB_001f3918:
MOV dword ptr [RBX + 0x90],EAX
POP RBX
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 > >
>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, bool) */
void __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>>>
::lexer(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,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
int iVar2;
lconv *plVar3;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (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>>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (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>>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(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 + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (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>>>
)0x0;
*(char **)(this + 0x70) = "";
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
plVar3 = localeconv();
if (plVar3->decimal_point == (char *)0x0) {
iVar2 = 0x2e;
}
else {
iVar2 = (int)*plVar3->decimal_point;
}
*(int *)(this + 0x90) = iVar2;
return;
}
|
|
58,562
|
my_uni_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
my_wc_t wc, uchar *r, uchar *e)
{
if ( r+2 > e )
return MY_CS_TOOSMALL2;
if (wc > 0xFFFF) /* UCS2 does not support characters outside BMP */
return MY_CS_ILUNI;
r[0]= (uchar) (wc >> 8);
r[1]= (uchar) (wc & 0xFF);
return 2;
}
|
O0
|
c
|
my_uni_ucs2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6bc0b
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6bc48
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x6bc1e
movl $0x0, -0x4(%rbp)
jmp 0x6bc48
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_uni_ucs2:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6BC0B
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_6BC48
loc_6BC0B:
cmp [rbp+var_18], 0FFFFh
jbe short loc_6BC1E
mov [rbp+var_4], 0
jmp short loc_6BC48
loc_6BC1E:
mov rax, [rbp+var_18]
shr rax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rax, [rbp+var_18]
and rax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_6BC48:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_uni_ucs2(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
if ( a2 <= 0xFFFF )
{
*a3 = BYTE1(a2);
a3[1] = a2;
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
|
my_uni_ucs2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016bc0b
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016bc48
LAB_0016bc0b:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x0016bc1e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016bc48
LAB_0016bc1e:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0016bc48:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_ucs2(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else if (param_2 < 0x10000) {
*param_3 = (char)(param_2 >> 8);
param_3[1] = (char)param_2;
local_c = 2;
}
else {
local_c = 0;
}
return local_c;
}
|
|
58,563
|
my_uni_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
my_wc_t wc, uchar *r, uchar *e)
{
if ( r+2 > e )
return MY_CS_TOOSMALL2;
if (wc > 0xFFFF) /* UCS2 does not support characters outside BMP */
return MY_CS_ILUNI;
r[0]= (uchar) (wc >> 8);
r[1]= (uchar) (wc & 0xFF);
return 2;
}
|
O3
|
c
|
my_uni_ucs2:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x51258
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x51258
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
popq %rbp
retq
|
my_uni_ucs2:
push rbp
mov rbp, rsp
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_51258
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_51258
rol si, 8
mov [rdx], si
mov eax, 2
loc_51258:
pop rbp
retn
|
long long my_uni_ucs2(long long a1, unsigned long long a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
*a3 = __ROL2__(a2, 8);
return 2LL;
}
}
return result;
}
|
my_uni_ucs2:
PUSH RBP
MOV RBP,RSP
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00151258
XOR EAX,EAX
CMP RSI,0xffff
JA 0x00151258
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
LAB_00151258:
POP RBP
RET
|
int8 my_uni_ucs2(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9a;
if ((param_3 + 1 <= param_4) && (uVar1 = 0, param_2 < 0x10000)) {
*param_3 = (ushort)param_2 << 8 | (ushort)param_2 >> 8;
uVar1 = 2;
}
return uVar1;
}
|
|
58,564
|
compile_if_stmt
|
fabiosvm[P]rak/src/compiler.c
|
static inline void compile_if_stmt(RakCompiler *comp, uint16_t *off, RakError *err)
{
next(comp, err);
begin_scope(comp);
if (match(comp, RAK_TOKEN_KIND_LET_KW))
{
compile_let_decl(comp, err);
if (!rak_is_ok(err)) return;
}
compile_expr(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump1 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
emit_instr(comp, rak_pop_instr(), err);
if (!rak_is_ok(err)) return;
if (!match(comp, RAK_TOKEN_KIND_LBRACE))
{
expected_token_error(err, RAK_TOKEN_KIND_LBRACE, comp->lex.tok);
return;
}
compile_block(comp, err);
if (!rak_is_ok(err)) return;
end_scope(comp, err);
if (!rak_is_ok(err)) return;
uint16_t jump2 = emit_instr(comp, rak_nop_instr(), err);
if (!rak_is_ok(err)) return;
uint32_t instr = rak_jump_if_false_instr((uint16_t) comp->chunk.instrs.len);
patch_instr(comp, jump1, instr);
uint16_t _off;
compile_if_stmt_cont(comp, &_off, err);
if (!rak_is_ok(err)) return;
patch_instr(comp, jump2, rak_jump_instr(_off));
if (off) *off = _off;
}
|
O0
|
c
|
compile_if_stmt:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x27f8, %rdi # imm = 0x27F8
movq -0x18(%rbp), %rsi
callq 0x86c0
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5306
jmp 0x54bf
jmp 0x5308
movq -0x8(%rbp), %rdi
callq 0x5cf0
movq -0x8(%rbp), %rax
cmpl $0x29, 0x2810(%rax)
jne 0x533b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4ca0
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5339
jmp 0x54bf
jmp 0x533b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5e80
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5356
jmp 0x54bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x4700
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5377
jmp 0x54bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xc, %esi
callq 0x4700
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5397
jmp 0x54bf
movq -0x8(%rbp), %rax
cmpl $0x8, 0x2810(%rax)
je 0x53de
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
addq $0x27f8, %rax # imm = 0x27F8
addq $0x18, %rax
movl $0x8, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x5df0
jmp 0x54bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c00
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x53f9
jmp 0x54bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d10
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5414
jmp 0x54bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x4700
movw %ax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5435
jmp 0x54bf
movq -0x8(%rbp), %rax
movl 0xffc(%rax), %eax
movzwl %ax, %eax
andl $0xffff, %eax # imm = 0xFFFF
shll $0x8, %eax
orl $0xe, %eax
movl %eax, -0x20(%rbp)
jmp 0x5452
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x1000(%rax), %rax
movzwl -0x1a(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x5469
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x22(%rbp), %rsi
callq 0x7e40
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x5485
jmp 0x54bf
jmp 0x5487
jmp 0x5489
movzwl -0x22(%rbp), %edx
andl $0xffff, %edx # imm = 0xFFFF
shll $0x8, %edx
orl $0xd, %edx
movq -0x8(%rbp), %rax
movq 0x1000(%rax), %rax
movzwl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x54ad
cmpq $0x0, -0x10(%rbp)
je 0x54bf
movw -0x22(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
compile_if_stmt:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
add rdi, 27F8h
mov rsi, [rbp+var_18]
call rak_lexer_next
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5306
jmp loc_54BF
loc_5306:
jmp short $+2
loc_5308:
mov rdi, [rbp+var_8]
call begin_scope
mov rax, [rbp+var_8]
cmp dword ptr [rax+2810h], 29h ; ')'
jnz short loc_533B
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call compile_let_decl
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5339
jmp loc_54BF
loc_5339:
jmp short $+2
loc_533B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call compile_expr
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5356
jmp loc_54BF
loc_5356:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
xor esi, esi
call rak_chunk_append_instr
mov [rbp+var_1A], ax
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5377
jmp loc_54BF
loc_5377:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
mov esi, 0Ch
call rak_chunk_append_instr
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5397
jmp loc_54BF
loc_5397:
mov rax, [rbp+var_8]
cmp dword ptr [rax+2810h], 8
jz short loc_53DE
mov rdi, [rbp+var_18]
mov rax, [rbp+var_8]
add rax, 27F8h
add rax, 18h
mov esi, 8
mov rcx, [rax]
mov [rsp+40h+var_40], rcx
mov rcx, [rax+8]
mov [rsp+40h+var_38], rcx
mov rax, [rax+10h]
mov [rsp+40h+var_30], rax
call expected_token_error
jmp loc_54BF
loc_53DE:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call compile_block
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_53F9
jmp loc_54BF
loc_53F9:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call end_scope
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5414
jmp loc_54BF
loc_5414:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
xor esi, esi
call rak_chunk_append_instr
mov [rbp+var_1C], ax
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5435
jmp loc_54BF
loc_5435:
mov rax, [rbp+var_8]
mov eax, [rax+0FFCh]
movzx eax, ax
and eax, 0FFFFh
shl eax, 8
or eax, 0Eh
mov [rbp+var_20], eax
jmp short $+2
loc_5452:
mov edx, [rbp+var_20]
mov rax, [rbp+var_8]
mov rax, [rax+1000h]
movzx ecx, [rbp+var_1A]
mov [rax+rcx*4], edx
jmp short $+2
loc_5469:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
lea rsi, [rbp+var_22]
call compile_if_stmt_cont
mov rax, [rbp+var_18]
test byte ptr [rax], 1
jnz short loc_5485
jmp short loc_54BF
loc_5485:
jmp short $+2
loc_5487:
jmp short $+2
loc_5489:
movzx edx, [rbp+var_22]
and edx, 0FFFFh
shl edx, 8
or edx, 0Dh
mov rax, [rbp+var_8]
mov rax, [rax+1000h]
movzx ecx, [rbp+var_1C]
mov [rax+rcx*4], edx
jmp short $+2
loc_54AD:
cmp [rbp+var_10], 0
jz short loc_54BF
mov cx, [rbp+var_22]
mov rax, [rbp+var_10]
mov [rax], cx
loc_54BF:
add rsp, 40h
pop rbp
retn
|
unsigned __int16 * compile_if_stmt(_QWORD *a1, unsigned __int16 *a2, unsigned __int16 *a3)
{
unsigned __int16 *result; // rax
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // edx
int v11; // r8d
int v12; // r9d
int v13; // ecx
int v14; // r8d
int v15; // r9d
unsigned __int16 v16; // [rsp+1Eh] [rbp-22h] BYREF
int v17; // [rsp+20h] [rbp-20h]
unsigned __int16 v18; // [rsp+24h] [rbp-1Ch]
unsigned __int16 appended; // [rsp+26h] [rbp-1Ah]
unsigned __int16 *v20; // [rsp+28h] [rbp-18h]
unsigned __int16 *v21; // [rsp+30h] [rbp-10h]
_QWORD *v22; // [rsp+38h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = a3;
rak_lexer_next(a1 + 1279, a3);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
begin_scope(v22);
if ( *((_DWORD *)v22 + 2564) != 41 || (compile_let_decl(v22, v20), result = v20, (*(_BYTE *)v20 & 1) != 0) )
{
compile_expr(v22, v20);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
appended = rak_chunk_append_instr((long long)v22, 0, v20, v4, v5, v6);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
rak_chunk_append_instr((long long)v22, 12, v20, v7, v8, v9);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
if ( *((_DWORD *)v22 + 2564) == 8 )
{
compile_block((long long)v22, v20);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
end_scope(v22, v20);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
v18 = rak_chunk_append_instr((long long)v22, 0, v20, v13, v14, v15);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
v17 = ((unsigned __int16)*((_DWORD *)v22 + 1023) << 8) | 0xE;
*(_DWORD *)(v22[512] + 4LL * appended) = v17;
compile_if_stmt_cont(v22, &v16, v20);
result = v20;
if ( (*(_BYTE *)v20 & 1) != 0 )
{
result = (unsigned __int16 *)v22[512];
*(_DWORD *)&result[2 * v18] = (v16 << 8) | 0xD;
if ( v21 )
{
result = v21;
*v21 = v16;
}
}
}
}
}
}
else
{
return (unsigned __int16 *)expected_token_error(
(_DWORD)v20,
8,
v10,
v22[1283],
v11,
v12,
v22[1282],
v22[1283],
v22[1284]);
}
}
}
}
}
}
return result;
}
|
compile_if_stmt:
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 RDI,qword ptr [RBP + -0x8]
ADD RDI,0x27f8
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001086c0
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105306
JMP 0x001054bf
LAB_00105306:
JMP 0x00105308
LAB_00105308:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00105cf0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x2810],0x29
JNZ 0x0010533b
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00104ca0
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105339
JMP 0x001054bf
LAB_00105339:
JMP 0x0010533b
LAB_0010533b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00105e80
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105356
JMP 0x001054bf
LAB_00105356:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x00104700
MOV word ptr [RBP + -0x1a],AX
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105377
JMP 0x001054bf
LAB_00105377:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV ESI,0xc
CALL 0x00104700
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105397
JMP 0x001054bf
LAB_00105397:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x2810],0x8
JZ 0x001053de
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x27f8
ADD RAX,0x18
MOV ESI,0x8
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00105df0
JMP 0x001054bf
LAB_001053de:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00104c00
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x001053f9
JMP 0x001054bf
LAB_001053f9:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00105d10
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105414
JMP 0x001054bf
LAB_00105414:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x00104700
MOV word ptr [RBP + -0x1c],AX
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105435
JMP 0x001054bf
LAB_00105435:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xffc]
MOVZX EAX,AX
AND EAX,0xffff
SHL EAX,0x8
OR EAX,0xe
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00105452
LAB_00105452:
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x1000]
MOVZX ECX,word ptr [RBP + -0x1a]
MOV dword ptr [RAX + RCX*0x4],EDX
JMP 0x00105469
LAB_00105469:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x22]
CALL 0x00107e40
MOV RAX,qword ptr [RBP + -0x18]
TEST byte ptr [RAX],0x1
JNZ 0x00105485
JMP 0x001054bf
LAB_00105485:
JMP 0x00105487
LAB_00105487:
JMP 0x00105489
LAB_00105489:
MOVZX EDX,word ptr [RBP + -0x22]
AND EDX,0xffff
SHL EDX,0x8
OR EDX,0xd
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x1000]
MOVZX ECX,word ptr [RBP + -0x1c]
MOV dword ptr [RAX + RCX*0x4],EDX
JMP 0x001054ad
LAB_001054ad:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001054bf
MOV CX,word ptr [RBP + -0x22]
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX],CX
LAB_001054bf:
ADD RSP,0x40
POP RBP
RET
|
void compile_if_stmt(long param_1,ushort *param_2,byte *param_3)
{
ushort local_2a;
uint local_28;
ushort local_24;
ushort local_22;
byte *local_20;
ushort *local_18;
long local_10;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
rak_lexer_next(param_1 + 0x27f8,param_3);
if (((*local_20 & 1) != 0) &&
((((begin_scope(local_10), *(int *)(local_10 + 0x2810) != 0x29 ||
(compile_let_decl(local_10,local_20), (*local_20 & 1) != 0)) &&
(compile_expr(local_10,local_20), (*local_20 & 1) != 0)) &&
((local_22 = rak_chunk_append_instr(local_10,0,local_20), (*local_20 & 1) != 0 &&
(rak_chunk_append_instr(local_10,0xc,local_20), (*local_20 & 1) != 0)))))) {
if (*(int *)(local_10 + 0x2810) == 8) {
compile_block(local_10,local_20);
if ((((*local_20 & 1) != 0) && (end_scope(local_10,local_20), (*local_20 & 1) != 0)) &&
(local_24 = rak_chunk_append_instr(local_10,0,local_20), (*local_20 & 1) != 0)) {
local_28 = (*(uint *)(local_10 + 0xffc) & 0xffff) << 8 | 0xe;
*(uint *)(*(long *)(local_10 + 0x1000) + (ulong)local_22 * 4) = local_28;
compile_if_stmt_cont(local_10,&local_2a,local_20);
if (((*local_20 & 1) != 0) &&
(*(uint *)(*(long *)(local_10 + 0x1000) + (ulong)local_24 * 4) =
(uint)local_2a << 8 | 0xd, local_18 != (ushort *)0x0)) {
*local_18 = local_2a;
}
}
}
else {
expected_token_error(local_20,8);
}
}
return;
}
|
|
58,565
|
my_casedn_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O3
|
c
|
my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0xc9cd3
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0xc9cd3
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0xc9cb5
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0xc9cb5
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0xc9cd3
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0xc9c6e
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_casedn_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_C9CD3
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_C9C6E:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_C9CD3
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_C9CB5
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_C9CB5
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4+4]
mov [rbp+var_40], rsi
loc_C9CB5:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_C9CD3
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_C9C6E
loc_C9CD3:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17 + 4);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
|
my_casedn_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x001c9cd3
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_001c9c6e:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x001c9cd3
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x001c9cb5
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x001c9cb5
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_001c9cb5:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x001c9cd3
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x001c9c6e
LAB_001c9cd3:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + 4 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
|
|
58,566
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool)
|
llama.cpp/common/./json.hpp
|
std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
}
|
O3
|
cpp
|
std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&, bool):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
movl 0x38(%rdi), %eax
leaq -0x1(%rax), %rcx
addq $0x3e, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x30(%rdi), %rax
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %edi, %edi
cmpq %r14, %rdx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rcx, %rax
jae 0x322af
leaq 0x8(%rsp), %rdi
callq 0x314ca
testb %bpl, %bpl
jne 0x3226c
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0x1c(%rsp)
movb $0x5, 0x7(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x323b8
leaq 0x80(%rbx), %rdi
leaq 0x1c(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x3239b
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x322b9
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x3239b
cmpb $0x2, (%rax)
jne 0x322fc
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2f928
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x32397
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x323aa
movups 0x8(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq (%rbx), %rax
movb (%rax), %cl
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
callq 0x300e0
movq (%rbx), %r14
jmp 0x32397
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r14, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x32352
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x3239b
movups 0x8(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x70(%rbx), %rax
movb (%rax), %cl
movb (%rdi), %dl
movb %dl, (%rax)
movb %cl, (%rdi)
movq 0x8(%rax), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
callq 0x300e0
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x323a0
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x300e0
movl %ebx, %eax
movq %r14, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1ccf0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x300e0
movq %rbx, %rdi
callq 0x1c7d0
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRSB_EESt4pairIbPSF_EOT_b:
push rbp
push r14
push rbx
sub rsp, 40h
mov ebp, edx
mov rbx, rdi
mov r14, 8000000000000000h
mov eax, [rdi+38h]
lea rcx, [rax-1]
add rax, 3Eh ; '>'
test rcx, rcx
cmovns rax, rcx
sar rax, 6
shl rax, 3
add rax, [rdi+30h]
lea rdx, [r14+3Fh]
and rdx, rcx
xor edi, edi
cmp rdx, r14
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rcx
jnb loc_322AF
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
test bpl, bpl
jnz short loc_3226C
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+58h+var_3C], eax
mov [rsp+58h+var_51], 5
cmp qword ptr [rbx+90h], 0
jz loc_323B8
lea rdi, [rbx+80h]
lea rsi, [rsp+58h+var_3C]
lea rdx, [rsp+58h+var_51]
lea rcx, [rsp+58h+var_50]
call qword ptr [rbx+98h]
test al, al
jz loc_3239B
loc_3226C:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_322B9
mov rax, [rax-8]
test rax, rax
jz loc_3239B
cmp byte ptr [rax], 2
jnz short loc_322FC
mov rdi, [rax+8]
lea rsi, [rsp+58h+var_50]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_32397
loc_322AF:
xor ebx, ebx
xor r14d, r14d
jmp loc_323AA
loc_322B9:
movups xmm0, [rsp+58h+var_50]
lea rdi, [rsp+58h+var_28]
movaps xmmword ptr [rdi], xmm0
mov byte ptr [rsp+58h+var_50], 0
mov qword ptr [rsp+58h+var_50+8], 0
mov rax, [rbx]
mov cl, [rax]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_32397
loc_322FC:
mov rax, [rbx+58h]
mov esi, [rbx+60h]
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r14+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r14
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_32352
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_32352:
test rdx, rdx
jz short loc_3239B
movups xmm0, [rsp+58h+var_50]
lea rdi, [rsp+58h+var_38]
movaps xmmword ptr [rdi], xmm0
mov byte ptr [rsp+58h+var_50], 0
mov qword ptr [rsp+58h+var_50+8], 0
mov rax, [rbx+70h]
mov cl, [rax]
mov dl, [rdi]
mov [rax], dl
mov [rdi], cl
mov rcx, [rax+8]
mov rdx, [rdi+8]
mov [rax+8], rdx
mov [rdi+8], rcx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_32397:
mov bl, 1
jmp short loc_323A0
loc_3239B:
xor ebx, ebx
xor r14d, r14d
loc_323A0:
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_323AA:
mov eax, ebx
mov rdx, r14
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_323B8:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<std::string&>(
char **a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
signed long long v6; // rcx
long long v7; // rax
long long v8; // rax
char *v9; // rax
long long v10; // rax
char *v11; // rax
char v12; // cl
long long v13; // rcx
char *v14; // rax
long long v15; // rsi
long long v16; // rdx
long long v17; // rdx
char *v18; // rax
char v19; // cl
long long v20; // rcx
char v22; // [rsp+7h] [rbp-51h] BYREF
__int128 v23; // [rsp+8h] [rbp-50h] BYREF
int v24; // [rsp+1Ch] [rbp-3Ch] BYREF
__int128 v25; // [rsp+20h] [rbp-38h] BYREF
__int128 v26; // [rsp+30h] [rbp-28h] BYREF
v4 = (unsigned int)a1;
v5 = *((unsigned int *)a1 + 14);
v6 = v5 - 1;
v7 = v5 + 62;
if ( v6 >= 0 )
v7 = v6;
v8 = *(_QWORD *)&a1[6][8 * (v7 >> 6) - 8 + 8 * ((v6 & 0x800000000000003FLL) <= 0x8000000000000000LL)];
if ( _bittest64(&v8, v6) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
(long long)&v23,
a2);
if ( a3 )
goto LABEL_7;
v24 = (unsigned long long)(a1[2] - a1[1]) >> 3;
v22 = 5;
if ( !a1[18] )
std::__throw_bad_function_call();
if ( ((unsigned __int8 ( *)(char **, int *, char *, __int128 *))a1[19])(a1 + 16, &v24, &v22, &v23) )
{
LABEL_7:
v9 = a1[2];
if ( a1[1] == v9 )
{
v26 = v23;
LOBYTE(v23) = 0;
*((_QWORD *)&v23 + 1) = 0LL;
v11 = *a1;
v12 = **a1;
*v11 = v26;
LOBYTE(v26) = v12;
v13 = *((_QWORD *)v11 + 1);
*((_QWORD *)v11 + 1) = *((_QWORD *)&v26 + 1);
*((_QWORD *)&v26 + 1) = v13;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
goto LABEL_19;
}
v10 = *((_QWORD *)v9 - 1);
if ( v10 )
{
if ( *(_BYTE *)v10 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(v10 + 8),
(long long)&v23);
LABEL_19:
LOBYTE(v4) = 1;
LABEL_21:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v23);
return v4;
}
v14 = a1[11];
v15 = *((unsigned int *)a1 + 24);
v16 = v15 + 62;
if ( v15 - 1 >= 0 )
v16 = v15 - 1;
v17 = *(_QWORD *)&v14[8 * (v16 >> 6) - 8 + 8 * (((v15 - 1) & 0x800000000000003FLL) <= 0x8000000000000000LL)] & (1LL << ((unsigned __int8)v15 - 1));
*((_DWORD *)a1 + 24) = v15 - 1;
if ( !(_DWORD)v15 )
{
*((_DWORD *)a1 + 24) = 63;
a1[11] = v14 - 8;
}
if ( v17 )
{
v25 = v23;
LOBYTE(v23) = 0;
*((_QWORD *)&v23 + 1) = 0LL;
v18 = a1[14];
v19 = *v18;
*v18 = v25;
LOBYTE(v25) = v19;
v20 = *((_QWORD *)v18 + 1);
*((_QWORD *)v18 + 1) = *((_QWORD *)&v25 + 1);
*((_QWORD *)&v25 + 1) = v20;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
goto LABEL_19;
}
}
}
v4 = 0;
goto LABEL_21;
}
return 0;
}
|
handle_value<std::__cxx11::string&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV EBP,EDX
MOV RBX,RDI
MOV R14,-0x8000000000000000
MOV EAX,dword ptr [RDI + 0x38]
LEA RCX,[RAX + -0x1]
ADD RAX,0x3e
TEST RCX,RCX
CMOVNS RAX,RCX
SAR RAX,0x6
SHL RAX,0x3
ADD RAX,qword ptr [RDI + 0x30]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR EDI,EDI
CMP RDX,R14
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RCX
JNC 0x001322af
LEA RDI,[RSP + 0x8]
CALL 0x001314ca
TEST BPL,BPL
JNZ 0x0013226c
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0x1c],EAX
MOV byte ptr [RSP + 0x7],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x001323b8
LEA RDI,[RBX + 0x80]
LAB_0013224f:
LEA RSI,[RSP + 0x1c]
LEA RDX,[RSP + 0x7]
LEA RCX,[RSP + 0x8]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0013239b
LAB_0013226c:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x001322b9
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0013239b
CMP byte ptr [RAX],0x2
JNZ 0x001322fc
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x0012f928
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x00132397
LAB_001322af:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x001323aa
LAB_001322b9:
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV byte ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RBX]
MOV CL,byte ptr [RAX]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
CALL 0x001300e0
MOV R14,qword ptr [RBX]
JMP 0x00132397
LAB_001322fc:
MOV RAX,qword ptr [RBX + 0x58]
MOV ESI,dword ptr [RBX + 0x60]
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R14
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x00132352
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_00132352:
TEST RDX,RDX
JZ 0x0013239b
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x20]
MOVAPS xmmword ptr [RDI],XMM0
MOV byte ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [RBX + 0x70]
MOV CL,byte ptr [RAX]
MOV DL,byte ptr [RDI]
MOV byte ptr [RAX],DL
MOV byte ptr [RDI],CL
MOV RCX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RDI + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RDI + 0x8],RCX
CALL 0x001300e0
MOV R14,qword ptr [RBX + 0x70]
LAB_00132397:
MOV BL,0x1
JMP 0x001323a0
LAB_0013239b:
XOR EBX,EBX
XOR R14D,R14D
LAB_001323a0:
LEA RDI,[RSP + 0x8]
CALL 0x001300e0
LAB_001323aa:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001323b8:
CALL 0x0011ccf0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<std::__cxx11::string&>(std::__cxx11::string&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<std::__cxx11::string&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1,bool param_2)
{
basic_json bVar1;
uint uVar2;
char *pcVar3;
basic_json *pbVar4;
basic_json bVar5;
int8 uVar6;
char cVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
int1 auVar11 [16];
int1 local_51;
basic_json local_50;
int7 uStack_4f;
int8 uStack_48;
int4 local_3c;
basic_json local_38;
int7 uStack_37;
int8 uStack_30;
basic_json local_28;
int7 uStack_27;
int8 uStack_20;
uVar9 = (ulong)*(uint *)(this + 0x38) - 1;
uVar8 = (ulong)*(uint *)(this + 0x38) + 0x3e;
if (-1 < (long)uVar9) {
uVar8 = uVar9;
}
if ((*(ulong *)(((long)uVar8 >> 6) * 8 + *(long *)(this + 0x30) + -8 +
(ulong)((uVar9 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar9 & 0x3f) &
1) == 0) {
uVar9 = 0;
lVar10 = 0;
goto LAB_001323aa;
}
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(&local_50);
if (param_2) {
LAB_0013226c:
uVar6 = uStack_48;
bVar5 = local_50;
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_50 = (basic_json)0x0;
uStack_48 = 0;
pbVar4 = *(basic_json **)this;
bVar1 = *pbVar4;
*pbVar4 = bVar5;
_local_28 = CONCAT71(uStack_4f,bVar1);
uStack_20 = *(int8 *)(pbVar4 + 8);
*(int8 *)(pbVar4 + 8) = uVar6;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_28);
lVar10 = *(long *)this;
}
else {
pcVar3 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar3 == (char *)0x0) goto LAB_0013239b;
if (*pcVar3 == '\x02') {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar3 + 8),&local_50);
lVar10 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
else {
uVar2 = *(uint *)(this + 0x60);
uVar9 = (ulong)uVar2 - 1;
uVar8 = (ulong)uVar2 + 0x3e;
if (-1 < (long)uVar9) {
uVar8 = uVar9;
}
uVar8 = *(ulong *)(*(long *)(this + 0x58) + ((long)uVar8 >> 6) * 8 + -8 +
(ulong)((uVar9 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar2 - 1;
if (uVar2 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = *(long *)(this + 0x58) + -8;
}
if ((1L << ((byte)uVar9 & 0x3f) & uVar8) == 0) goto LAB_0013239b;
local_50 = (basic_json)0x0;
uStack_48 = 0;
pbVar4 = *(basic_json **)(this + 0x70);
bVar1 = *pbVar4;
*pbVar4 = bVar5;
_local_38 = CONCAT71(uStack_4f,bVar1);
uStack_30 = *(int8 *)(pbVar4 + 8);
*(int8 *)(pbVar4 + 8) = uVar6;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar10 = *(long *)(this + 0x70);
}
}
uVar9 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_51 = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
/* try { // try from 0013224f to 001323bc has its CatchHandler @ 001323bd */
cVar7 = (**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_51,&local_50);
if (cVar7 != '\0') goto LAB_0013226c;
LAB_0013239b:
uVar9 = 0;
lVar10 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_50);
LAB_001323aa:
auVar11._0_8_ = uVar9 & 0xffffffff;
auVar11._8_8_ = lVar10;
return auVar11;
}
|
|
58,567
|
create_temp_file
|
eloqsql/mysys/mf_tempfile.c
|
File create_temp_file(char *to, const char *dir, const char *prefix,
int mode, myf MyFlags)
{
File file= -1;
DBUG_ENTER("create_temp_file");
DBUG_PRINT("enter", ("dir: %s, prefix: %s", dir ? dir : "(null)", prefix));
DBUG_ASSERT((mode & (O_EXCL | O_TRUNC | O_CREAT | O_RDWR)) == 0);
mode|= O_TRUNC | O_CREAT | O_RDWR; /* not O_EXCL, see Windows code below */
#ifdef _WIN32
{
TCHAR path_buf[MAX_PATH-14];
/*
Use GetTempPath to determine path for temporary files.
This is because the documentation for GetTempFileName
has the following to say about this parameter:
"If this parameter is NULL, the function fails."
*/
if (!dir)
{
if(GetTempPath(sizeof(path_buf), path_buf) > 0)
dir = path_buf;
}
/*
Use GetTempFileName to generate a unique filename, create
the file and release it's handle
- uses up to the first three letters from prefix
*/
if (GetTempFileName(dir, prefix, 0, to) == 0)
DBUG_RETURN(-1);
DBUG_PRINT("info", ("name: %s", to));
if (MyFlags & MY_TEMPORARY)
mode|= O_SHORT_LIVED | O_TEMPORARY;
/*
Open the file without O_EXCL flag
since the file has already been created by GetTempFileName
*/
if ((file= my_open(to, mode, MyFlags)) < 0)
{
/* Open failed, remove the file created by GetTempFileName */
int tmp= my_errno;
(void) my_delete(to, MYF(0));
my_errno= tmp;
}
}
#elif defined(HAVE_MKSTEMP)
if (!dir && ! (dir =getenv("TMPDIR")))
dir= DEFAULT_TMPDIR;
#ifdef O_TMPFILE
{
static int O_TMPFILE_works= 1;
if ((MyFlags & MY_TEMPORARY) && O_TMPFILE_works)
{
/* explictly don't use O_EXCL here has it has a different
meaning with O_TMPFILE
*/
if ((file= open(dir, (mode & ~O_CREAT) | O_TMPFILE | O_CLOEXEC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) >= 0)
{
my_snprintf(to, FN_REFLEN, "%s/#sql/fd=%d", dir, file);
file=my_register_filename(file, to, FILE_BY_O_TMPFILE,
EE_CANTCREATEFILE, MyFlags);
}
else if (errno == EOPNOTSUPP || errno == EINVAL)
{
my_printf_error(EE_CANTCREATEFILE, "O_TMPFILE is not supported on %s "
"(disabling future attempts)",
MYF(ME_NOTE | ME_ERROR_LOG_ONLY), dir);
O_TMPFILE_works= 0;
}
}
}
if (file == -1)
#endif /* O_TMPFILE */
{
char prefix_buff[30];
uint pfx_len;
File org_file;
pfx_len= (uint) (strmov(strnmov(prefix_buff,
prefix ? prefix : "tmp.",
sizeof(prefix_buff)-7),"XXXXXX") -
prefix_buff);
if (strlen(dir)+ pfx_len > FN_REFLEN-2)
{
errno=my_errno= ENAMETOOLONG;
DBUG_RETURN(file);
}
strmov(convert_dirname(to,dir,NullS),prefix_buff);
org_file=mkstemp(to);
if (org_file >= 0 && (MyFlags & MY_TEMPORARY))
(void) my_delete(to, MYF(MY_WME));
file=my_register_filename(org_file, to, FILE_BY_MKSTEMP,
EE_CANTCREATEFILE, MyFlags);
/* If we didn't manage to register the name, remove the temp file */
if (org_file >= 0 && file < 0)
{
int tmp=my_errno;
close(org_file);
(void) my_delete(to, MYF(MY_WME));
my_errno=tmp;
}
}
#else
#error No implementation found for create_temp_file
#endif
if (file >= 0)
statistic_increment(my_tmp_file_created,&THR_LOCK_open);
DBUG_RETURN(file);
}
|
O0
|
c
|
create_temp_file:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movl %ecx, -0x54(%rbp)
movq %r8, -0x60(%rbp)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
jmp 0x102cc4
jmp 0x102cc6
jmp 0x102cc8
movl -0x54(%rbp), %eax
orl $0x242, %eax # imm = 0x242
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x102cfb
leaq 0x51251(%rip), %rdi # 0x153f32
callq 0x2a5e0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x102cfb
leaq 0x51242(%rip), %rax # 0x153f39
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x102dc0
cmpl $0x0, 0x1bc4f4(%rip) # 0x2bf208
je 0x102dc0
movq -0x48(%rbp), %rdi
movl -0x54(%rbp), %esi
andl $-0x41, %esi
orl $0x410000, %esi # imm = 0x410000
orl $0x80000, %esi # imm = 0x80000
movl $0x1b0, %edx # imm = 0x1B0
movb $0x0, %al
callq 0x2a950
movl %eax, -0x64(%rbp)
cmpl $0x0, %eax
jl 0x102d82
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rcx
movl -0x64(%rbp), %r8d
movl $0x200, %esi # imm = 0x200
leaq 0x511e2(%rip), %rdx # 0x153f3e
movb $0x0, %al
callq 0x14cce0
movl -0x64(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %r8
movl $0x5, %edx
movl $0x1, %ecx
callq 0xf3d50
movl %eax, -0x64(%rbp)
jmp 0x102dbe
callq 0x2a760
cmpl $0x5f, (%rax)
je 0x102d96
callq 0x2a760
cmpl $0x16, (%rax)
jne 0x102dbc
movq -0x48(%rbp), %rcx
movl $0x1, %edi
leaq 0x511a6(%rip), %rsi # 0x153f4c
movl $0x480, %edx # imm = 0x480
movb $0x0, %al
callq 0xef670
movl $0x0, 0x1bc44c(%rip) # 0x2bf208
jmp 0x102dbe
jmp 0x102dc0
cmpl $-0x1, -0x64(%rbp)
jne 0x102f04
leaq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x102de3
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x102df0
leaq 0x5119f(%rip), %rax # 0x153f89
movq %rax, -0x80(%rbp)
jmp 0x102df0
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl $0x17, %edx
callq 0x14d880
movq %rax, %rdi
leaq 0x51182(%rip), %rsi # 0x153f8e
callq 0x2a730
leaq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x68(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2a350
movl -0x68(%rbp), %ecx
addq %rcx, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
jbe 0x102e53
callq 0xf5a70
movl $0x24, (%rax)
callq 0x2a760
movl $0x24, (%rax)
movl -0x64(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x102f2a
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xdf0b0
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2a730
movq -0x40(%rbp), %rdi
movl $0x80000, %esi # imm = 0x80000
callq 0x2a510
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jl 0x102ea3
movq -0x60(%rbp), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x102ea3
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0xef130
movl -0x6c(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %r8
movl $0x6, %edx
movl $0x1, %ecx
callq 0xf3d50
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x6c(%rbp)
jl 0x102f02
cmpl $0x0, -0x64(%rbp)
jge 0x102f02
callq 0xf5a70
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movl -0x6c(%rbp), %edi
callq 0x2a1c0
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0xef130
movl -0x70(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0xf5a70
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x102f04
cmpl $0x0, -0x64(%rbp)
jl 0x102f22
leaq 0xb7eea7(%rip), %rax # 0xc81db8
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xb7ee99(%rip), %rax # 0xc81db8
movq %rcx, (%rax)
jmp 0x102f24
movl -0x64(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x88(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x102f54
movl -0x88(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
nopl (%rax)
|
create_temp_file:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_40], rdi
mov [rbp+var_48], rsi
mov [rbp+var_50], rdx
mov [rbp+var_54], ecx
mov [rbp+var_60], r8
mov [rbp+var_64], 0FFFFFFFFh
jmp short $+2
loc_102CC4:
jmp short $+2
loc_102CC6:
jmp short $+2
loc_102CC8:
mov eax, [rbp+var_54]
or eax, 242h
mov [rbp+var_54], eax
cmp [rbp+var_48], 0
jnz short loc_102CFB
lea rdi, aTmpdir; "TMPDIR"
call _getenv
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_102CFB
lea rax, aTmp_0; "/tmp"
mov [rbp+var_48], rax
loc_102CFB:
mov rax, [rbp+var_60]
and rax, 40h
cmp rax, 0
jz loc_102DC0
cmp cs:create_temp_file_O_TMPFILE_works, 0
jz loc_102DC0
mov rdi, [rbp+var_48]
mov esi, [rbp+var_54]
and esi, 0FFFFFFBFh
or esi, 410000h
or esi, 80000h
mov edx, 1B0h
mov al, 0
call _open64
mov [rbp+var_64], eax
cmp eax, 0
jl short loc_102D82
mov rdi, [rbp+var_40]
mov rcx, [rbp+var_48]
mov r8d, [rbp+var_64]
mov esi, 200h
lea rdx, aSSqlFdD; "%s/#sql/fd=%d"
mov al, 0
call my_snprintf
mov edi, [rbp+var_64]
mov rsi, [rbp+var_40]
mov r8, [rbp+var_60]
mov edx, 5
mov ecx, 1
call my_register_filename
mov [rbp+var_64], eax
jmp short loc_102DBE
loc_102D82:
call ___errno_location
cmp dword ptr [rax], 5Fh ; '_'
jz short loc_102D96
call ___errno_location
cmp dword ptr [rax], 16h
jnz short loc_102DBC
loc_102D96:
mov rcx, [rbp+var_48]
mov edi, 1
lea rsi, aOTmpfileIsNotS; "O_TMPFILE is not supported on %s (disab"...
mov edx, 480h
mov al, 0
call my_printf_error
mov cs:create_temp_file_O_TMPFILE_works, 0
loc_102DBC:
jmp short $+2
loc_102DBE:
jmp short $+2
loc_102DC0:
cmp [rbp+var_64], 0FFFFFFFFh
jnz loc_102F04
lea rax, [rbp+var_30]
mov [rbp+var_78], rax
cmp [rbp+var_50], 0
jz short loc_102DE3
mov rax, [rbp+var_50]
mov [rbp+var_80], rax
jmp short loc_102DF0
loc_102DE3:
lea rax, aTmp_1; "tmp."
mov [rbp+var_80], rax
jmp short $+2
loc_102DF0:
mov rdi, [rbp+var_78]
mov rsi, [rbp+var_80]
mov edx, 17h
call strnmov
mov rdi, rax
lea rsi, aXxxxxx; "XXXXXX"
call _stpcpy
lea rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_68], eax
mov rdi, [rbp+var_48]
call _strlen
mov ecx, [rbp+var_68]
add rax, rcx
cmp rax, 1FEh
jbe short loc_102E53
call _my_thread_var
mov dword ptr [rax], 24h ; '$'
call ___errno_location
mov dword ptr [rax], 24h ; '$'
mov eax, [rbp+var_64]
mov [rbp+var_34], eax
jmp loc_102F2A
loc_102E53:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_48]
xor eax, eax
mov edx, eax
call convert_dirname
mov rdi, rax
lea rsi, [rbp+var_30]
call _stpcpy
mov rdi, [rbp+var_40]
mov esi, 80000h
call _mkostemp64
mov [rbp+var_6C], eax
cmp [rbp+var_6C], 0
jl short loc_102EA3
mov rax, [rbp+var_60]
and rax, 40h
cmp rax, 0
jz short loc_102EA3
mov rdi, [rbp+var_40]
mov esi, 10h
call my_delete
loc_102EA3:
mov edi, [rbp+var_6C]
mov rsi, [rbp+var_40]
mov r8, [rbp+var_60]
mov edx, 6
mov ecx, 1
call my_register_filename
mov [rbp+var_64], eax
cmp [rbp+var_6C], 0
jl short loc_102F02
cmp [rbp+var_64], 0
jge short loc_102F02
call _my_thread_var
mov eax, [rax]
mov [rbp+var_70], eax
mov edi, [rbp+var_6C]
call _close
mov rdi, [rbp+var_40]
mov esi, 10h
call my_delete
mov eax, [rbp+var_70]
mov [rbp+var_84], eax
call _my_thread_var
mov ecx, [rbp+var_84]
mov [rax], ecx
loc_102F02:
jmp short $+2
loc_102F04:
cmp [rbp+var_64], 0
jl short loc_102F22
lea rax, my_tmp_file_created
mov rcx, [rax]
add rcx, 1
lea rax, my_tmp_file_created
mov [rax], rcx
loc_102F22:
jmp short $+2
loc_102F24:
mov eax, [rbp+var_64]
mov [rbp+var_34], eax
loc_102F2A:
mov eax, [rbp+var_34]
mov [rbp+var_88], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_102F54
mov eax, [rbp+var_88]
add rsp, 90h
pop rbp
retn
loc_102F54:
call ___stack_chk_fail
|
long long create_temp_file(char *a1, const char *a2, long long a3, int a4, __int16 a5)
{
int v5; // r9d
long long v6; // rax
_BYTE *v7; // rax
int v9; // [rsp+20h] [rbp-70h]
int v10; // [rsp+24h] [rbp-6Ch]
unsigned int v11; // [rsp+28h] [rbp-68h]
int v12; // [rsp+2Ch] [rbp-64h]
int v14; // [rsp+3Ch] [rbp-54h]
const char *v16; // [rsp+48h] [rbp-48h]
_BYTE v18[40]; // [rsp+60h] [rbp-30h] BYREF
unsigned long long v19; // [rsp+88h] [rbp-8h]
v19 = __readfsqword(0x28u);
v16 = a2;
v12 = -1;
v14 = a4 | 0x242;
if ( !a2 )
{
v16 = (const char *)getenv("TMPDIR");
if ( !v16 )
v16 = "/tmp";
}
if ( (a5 & 0x40) != 0 && create_temp_file_O_TMPFILE_works )
{
v12 = open64(v16, v14 & 0xFFB6FFBF | 0x490000, 432LL);
if ( v12 < 0 )
{
if ( *(_DWORD *)__errno_location() == 95 || *(_DWORD *)__errno_location() == 22 )
{
my_printf_error(1, (long long)"O_TMPFILE is not supported on %s (disabling future attempts)", 1152LL, v16);
create_temp_file_O_TMPFILE_works = 0;
}
}
else
{
my_snprintf((_DWORD)a1, 512, (unsigned int)"%s/#sql/fd=%d", (_DWORD)v16, v12, v5);
v12 = my_register_filename((unsigned int)v12, a1, 5, 1u, a5);
}
}
if ( v12 == -1 )
{
if ( a3 )
v6 = strnmov(v18, a3, 23LL);
else
v6 = strnmov(v18, "tmp.", 23LL);
v11 = stpcpy(v6, "XXXXXX") - (_QWORD)v18;
if ( (unsigned long long)v11 + strlen(v16) > 0x1FE )
{
*(_DWORD *)my_thread_var(v16, "XXXXXX") = 36;
*(_DWORD *)__errno_location() = 36;
return (unsigned int)-1;
}
v7 = convert_dirname(a1, (long long)v16, 0LL);
stpcpy(v7, v18);
v10 = mkostemp64(a1, 0x80000LL);
if ( v10 >= 0 && (a5 & 0x40) != 0 )
my_delete((long long)a1, (const char *)&word_10);
v12 = my_register_filename((unsigned int)v10, a1, 6, 1u, a5);
if ( v10 >= 0 && v12 < 0 )
{
v9 = *(_DWORD *)my_thread_var((unsigned int)v10, a1);
close((unsigned int)v10);
my_delete((long long)a1, (const char *)&word_10);
*(_DWORD *)my_thread_var(a1, (const char *)&word_10) = v9;
}
}
if ( v12 >= 0 )
++my_tmp_file_created;
return (unsigned int)v12;
}
| |||
58,568
|
create_temp_file
|
eloqsql/mysys/mf_tempfile.c
|
File create_temp_file(char *to, const char *dir, const char *prefix,
int mode, myf MyFlags)
{
File file= -1;
DBUG_ENTER("create_temp_file");
DBUG_PRINT("enter", ("dir: %s, prefix: %s", dir ? dir : "(null)", prefix));
DBUG_ASSERT((mode & (O_EXCL | O_TRUNC | O_CREAT | O_RDWR)) == 0);
mode|= O_TRUNC | O_CREAT | O_RDWR; /* not O_EXCL, see Windows code below */
#ifdef _WIN32
{
TCHAR path_buf[MAX_PATH-14];
/*
Use GetTempPath to determine path for temporary files.
This is because the documentation for GetTempFileName
has the following to say about this parameter:
"If this parameter is NULL, the function fails."
*/
if (!dir)
{
if(GetTempPath(sizeof(path_buf), path_buf) > 0)
dir = path_buf;
}
/*
Use GetTempFileName to generate a unique filename, create
the file and release it's handle
- uses up to the first three letters from prefix
*/
if (GetTempFileName(dir, prefix, 0, to) == 0)
DBUG_RETURN(-1);
DBUG_PRINT("info", ("name: %s", to));
if (MyFlags & MY_TEMPORARY)
mode|= O_SHORT_LIVED | O_TEMPORARY;
/*
Open the file without O_EXCL flag
since the file has already been created by GetTempFileName
*/
if ((file= my_open(to, mode, MyFlags)) < 0)
{
/* Open failed, remove the file created by GetTempFileName */
int tmp= my_errno;
(void) my_delete(to, MYF(0));
my_errno= tmp;
}
}
#elif defined(HAVE_MKSTEMP)
if (!dir && ! (dir =getenv("TMPDIR")))
dir= DEFAULT_TMPDIR;
#ifdef O_TMPFILE
{
static int O_TMPFILE_works= 1;
if ((MyFlags & MY_TEMPORARY) && O_TMPFILE_works)
{
/* explictly don't use O_EXCL here has it has a different
meaning with O_TMPFILE
*/
if ((file= open(dir, (mode & ~O_CREAT) | O_TMPFILE | O_CLOEXEC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) >= 0)
{
my_snprintf(to, FN_REFLEN, "%s/#sql/fd=%d", dir, file);
file=my_register_filename(file, to, FILE_BY_O_TMPFILE,
EE_CANTCREATEFILE, MyFlags);
}
else if (errno == EOPNOTSUPP || errno == EINVAL)
{
my_printf_error(EE_CANTCREATEFILE, "O_TMPFILE is not supported on %s "
"(disabling future attempts)",
MYF(ME_NOTE | ME_ERROR_LOG_ONLY), dir);
O_TMPFILE_works= 0;
}
}
}
if (file == -1)
#endif /* O_TMPFILE */
{
char prefix_buff[30];
uint pfx_len;
File org_file;
pfx_len= (uint) (strmov(strnmov(prefix_buff,
prefix ? prefix : "tmp.",
sizeof(prefix_buff)-7),"XXXXXX") -
prefix_buff);
if (strlen(dir)+ pfx_len > FN_REFLEN-2)
{
errno=my_errno= ENAMETOOLONG;
DBUG_RETURN(file);
}
strmov(convert_dirname(to,dir,NullS),prefix_buff);
org_file=mkstemp(to);
if (org_file >= 0 && (MyFlags & MY_TEMPORARY))
(void) my_delete(to, MYF(MY_WME));
file=my_register_filename(org_file, to, FILE_BY_MKSTEMP,
EE_CANTCREATEFILE, MyFlags);
/* If we didn't manage to register the name, remove the temp file */
if (org_file >= 0 && file < 0)
{
int tmp=my_errno;
close(org_file);
(void) my_delete(to, MYF(MY_WME));
my_errno=tmp;
}
}
#else
#error No implementation found for create_temp_file
#endif
if (file >= 0)
statistic_increment(my_tmp_file_created,&THR_LOCK_open);
DBUG_RETURN(file);
}
|
O3
|
c
|
create_temp_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
testq %rsi, %rsi
jne 0xa8960
leaq 0x345de(%rip), %rdi # 0xdcf2b
callq 0x29620
testq %rax, %rax
leaq 0x345d6(%rip), %r15 # 0xdcf32
cmovneq %rax, %r15
testb $0x40, %r14b
je 0xa8a14
testb $0x1, 0xb604d7(%rip) # 0xc08e48
jne 0xa8a14
andl $0xffb6fdbd, %r13d # imm = 0xFFB6FDBD
orl $0x490202, %r13d # imm = 0x490202
movq %r15, %rdi
movl %r13d, %esi
movl $0x1b0, %edx # imm = 0x1B0
xorl %eax, %eax
callq 0x299c0
movl %eax, %r13d
testl %eax, %eax
js 0xa89d7
leaq 0x34592(%rip), %rdx # 0xdcf37
movl $0x200, %esi # imm = 0x200
movq %rbx, %rdi
movq %r15, %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0xd6956
movl %r13d, %edi
movq %rbx, %rsi
movl $0x5, %edx
movl $0x1, %ecx
movq %r14, %r8
callq 0x9fff6
movl %eax, %r13d
jmp 0xa8a0a
callq 0x297b0
movl (%rax), %eax
cmpl $0x5f, %eax
je 0xa89e8
cmpl $0x16, %eax
jne 0xa8a0a
leaq 0x34556(%rip), %rsi # 0xdcf45
movl $0x480, %edx # imm = 0x480
movl $0x1, %edi
movq %r15, %rcx
xorl %eax, %eax
callq 0x9de41
movb $0x1, 0xb6043e(%rip) # 0xc08e48
cmpl $-0x1, %r13d
jne 0xa8afd
testq %r12, %r12
leaq 0x34564(%rip), %rsi # 0xdcf82
cmovneq %r12, %rsi
leaq -0x50(%rbp), %r12
movl $0x17, %edx
movq %r12, %rdi
callq 0xd6d58
movq %rax, %r13
movl $0x58585858, (%rax) # imm = 0x58585858
movl $0x585858, 0x3(%rax) # imm = 0x585858
subl %r12d, %r13d
addl $0x6, %r13d
movq %r15, %rdi
callq 0x29350
addq %rax, %r13
cmpq $0x1fe, %r13 # imm = 0x1FE
ja 0xa8b0e
testb $0x40, %r14b
sete %r12b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x944cb
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x29360
movq %rbx, %rdi
movl $0x80000, %esi # imm = 0x80000
callq 0x29550
movl %eax, %r15d
testl %eax, %eax
sets %al
orb %r12b, %al
jne 0xa8aaa
movl $0x10, %esi
movq %rbx, %rdi
callq 0x9dab0
testl %r15d, %r15d
setns %r12b
movl %r15d, %edi
movq %rbx, %rsi
movl $0x6, %edx
movl $0x1, %ecx
movq %r14, %r8
callq 0x9fff6
movl %eax, %r13d
testl %eax, %eax
sets %al
andb %r12b, %al
cmpb $0x1, %al
jne 0xa8afd
callq 0xa1672
movl (%rax), %r14d
movl %r15d, %edi
callq 0x291b0
movl $0x10, %esi
movq %rbx, %rdi
callq 0x9dab0
callq 0xa1672
movl %r14d, (%rax)
testl %r13d, %r13d
js 0xa8b27
leaq 0xb5f6af(%rip), %rax # 0xc081b8
incq (%rax)
jmp 0xa8b27
callq 0xa1672
movl $0x24, %ebx
movl %ebx, (%rax)
callq 0x297b0
movl %ebx, (%rax)
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa8b48
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
nopl (%rax)
|
create_temp_file:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, r8
mov r13d, ecx
mov r12, rdx
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
test rsi, rsi
jnz short loc_A8960
lea rdi, aTmpdir; "TMPDIR"
call _getenv
test rax, rax
lea r15, aTmp_0; "/tmp"
cmovnz r15, rax
loc_A8960:
test r14b, 40h
jz loc_A8A14
test cs:create_temp_file_O_TMPFILE_works, 1
jnz loc_A8A14
and r13d, 0FFB6FDBDh
or r13d, 490202h
mov rdi, r15
mov esi, r13d
mov edx, 1B0h
xor eax, eax
call _open64
mov r13d, eax
test eax, eax
js short loc_A89D7
lea rdx, aSSqlFdD; "%s/#sql/fd=%d"
mov esi, 200h
mov rdi, rbx
mov rcx, r15
mov r8d, r13d
xor eax, eax
call my_snprintf
mov edi, r13d
mov rsi, rbx
mov edx, 5
mov ecx, 1
mov r8, r14
call my_register_filename
mov r13d, eax
jmp short loc_A8A0A
loc_A89D7:
call ___errno_location
mov eax, [rax]
cmp eax, 5Fh ; '_'
jz short loc_A89E8
cmp eax, 16h
jnz short loc_A8A0A
loc_A89E8:
lea rsi, aOTmpfileIsNotS; "O_TMPFILE is not supported on %s (disab"...
mov edx, 480h
mov edi, 1
mov rcx, r15
xor eax, eax
call my_printf_error
mov cs:create_temp_file_O_TMPFILE_works, 1
loc_A8A0A:
cmp r13d, 0FFFFFFFFh
jnz loc_A8AFD
loc_A8A14:
test r12, r12
lea rsi, aTmp_1; "tmp."
cmovnz rsi, r12
lea r12, [rbp+var_50]
mov edx, 17h
mov rdi, r12
call strnmov
mov r13, rax
mov dword ptr [rax], 58585858h
mov dword ptr [rax+3], offset unk_585858
sub r13d, r12d
add r13d, 6
mov rdi, r15
call _strlen
add r13, rax
cmp r13, 1FEh
ja loc_A8B0E
test r14b, 40h
setz r12b
mov rdi, rbx
mov rsi, r15
xor edx, edx
call convert_dirname
lea rsi, [rbp+var_50]
mov rdi, rax
call _strcpy
mov rdi, rbx
mov esi, 80000h
call _mkostemp64
mov r15d, eax
test eax, eax
sets al
or al, r12b
jnz short loc_A8AAA
mov esi, 10h
mov rdi, rbx
call my_delete
loc_A8AAA:
test r15d, r15d
setns r12b
mov edi, r15d
mov rsi, rbx
mov edx, 6
mov ecx, 1
mov r8, r14
call my_register_filename
mov r13d, eax
test eax, eax
sets al
and al, r12b
cmp al, 1
jnz short loc_A8AFD
call _my_thread_var
mov r14d, [rax]
mov edi, r15d
call _close
mov esi, 10h
mov rdi, rbx
call my_delete
call _my_thread_var
mov [rax], r14d
loc_A8AFD:
test r13d, r13d
js short loc_A8B27
lea rax, my_tmp_file_created
inc qword ptr [rax]
jmp short loc_A8B27
loc_A8B0E:
call _my_thread_var
mov ebx, 24h ; '$'
mov [rax], ebx
call ___errno_location
mov [rax], ebx
mov r13d, 0FFFFFFFFh
loc_A8B27:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A8B48
mov eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A8B48:
call ___stack_chk_fail
|
long long create_temp_file(
char *a1,
const char *a2,
const char *a3,
int a4,
__int16 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
const char *v16; // r15
long long v17; // rax
int v18; // eax
int v19; // r9d
int v20; // r13d
int v21; // eax
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
const char *v26; // rsi
_DWORD *v27; // rax
_WORD *v28; // rax
int v29; // r15d
int v30; // r14d
char v32[32]; // [rsp+0h] [rbp-50h] BYREF
unsigned long long v33; // [rsp+20h] [rbp-30h]
v16 = a2;
v33 = __readfsqword(0x28u);
if ( !a2 )
{
v17 = getenv("TMPDIR");
v16 = "/tmp";
if ( v17 )
v16 = (const char *)v17;
}
if ( (a5 & 0x40) == 0 || (create_temp_file_O_TMPFILE_works & 1) != 0 )
goto LABEL_12;
v18 = open64(v16, a4 & 0xFFB6FDBD | 0x490202, 432LL);
v20 = v18;
if ( v18 < 0 )
{
v21 = *(_DWORD *)__errno_location(v16);
if ( v21 == 95 || v21 == 22 )
{
my_printf_error(
1,
(long long)"O_TMPFILE is not supported on %s (disabling future attempts)",
1152,
(long long)v16,
v22,
v23,
a6,
a7,
a8,
a9,
v24,
v25,
a12,
a13,
v32[0]);
create_temp_file_O_TMPFILE_works = 1;
}
}
else
{
my_snprintf((_DWORD)a1, 512, (unsigned int)"%s/#sql/fd=%d", (_DWORD)v16, v18, v19);
v20 = my_register_filename((unsigned int)v20, a1, 5, 1u, a5);
}
if ( v20 == -1 )
{
LABEL_12:
v26 = "tmp.";
if ( a3 )
v26 = a3;
v27 = (_DWORD *)strnmov(v32, v26, 23LL);
*v27 = 1482184792;
*(_DWORD *)((char *)v27 + 3) = (_DWORD)&unk_585858;
if ( strlen(v16) + (unsigned long long)((unsigned int)v27 - (unsigned int)v32 + 6) > 0x1FE )
{
*(_DWORD *)my_thread_var(v16, v26) = 36;
*(_DWORD *)__errno_location(v16) = 36;
return (unsigned int)-1;
}
v28 = convert_dirname(a1, (long long)v16, 0LL);
strcpy(v28, v32);
v29 = mkostemp64(a1, 0x80000LL);
if ( (a5 & 0x40) != 0 && v29 >= 0 )
my_delete((long long)a1, (const char *)&word_10);
v20 = my_register_filename((unsigned int)v29, a1, 6, 1u, a5);
if ( v29 >= 0 && v20 < 0 )
{
v30 = *(_DWORD *)my_thread_var((unsigned int)v29, a1);
close((unsigned int)v29);
my_delete((long long)a1, (const char *)&word_10);
*(_DWORD *)my_thread_var(a1, (const char *)&word_10) = v30;
}
}
if ( v20 >= 0 )
++my_tmp_file_created;
return (unsigned int)v20;
}
|
create_temp_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,R8
MOV R13D,ECX
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
TEST RSI,RSI
JNZ 0x001a8960
LEA RDI,[0x1dcf2b]
CALL 0x00129620
TEST RAX,RAX
LEA R15,[0x1dcf32]
CMOVNZ R15,RAX
LAB_001a8960:
TEST R14B,0x40
JZ 0x001a8a14
TEST byte ptr [0x00d08e48],0x1
JNZ 0x001a8a14
AND R13D,0xffb6fdbd
OR R13D,0x490202
MOV RDI,R15
MOV ESI,R13D
MOV EDX,0x1b0
XOR EAX,EAX
CALL 0x001299c0
MOV R13D,EAX
TEST EAX,EAX
JS 0x001a89d7
LEA RDX,[0x1dcf37]
MOV ESI,0x200
MOV RDI,RBX
MOV RCX,R15
MOV R8D,R13D
XOR EAX,EAX
CALL 0x001d6956
MOV EDI,R13D
MOV RSI,RBX
MOV EDX,0x5
MOV ECX,0x1
MOV R8,R14
CALL 0x0019fff6
MOV R13D,EAX
JMP 0x001a8a0a
LAB_001a89d7:
CALL 0x001297b0
MOV EAX,dword ptr [RAX]
CMP EAX,0x5f
JZ 0x001a89e8
CMP EAX,0x16
JNZ 0x001a8a0a
LAB_001a89e8:
LEA RSI,[0x1dcf45]
MOV EDX,0x480
MOV EDI,0x1
MOV RCX,R15
XOR EAX,EAX
CALL 0x0019de41
MOV byte ptr [0x00d08e48],0x1
LAB_001a8a0a:
CMP R13D,-0x1
JNZ 0x001a8afd
LAB_001a8a14:
TEST R12,R12
LEA RSI,[0x1dcf82]
CMOVNZ RSI,R12
LEA R12,[RBP + -0x50]
MOV EDX,0x17
MOV RDI,R12
CALL 0x001d6d58
MOV R13,RAX
MOV dword ptr [RAX],0x58585858
MOV dword ptr [RAX + 0x3],0x585858
SUB R13D,R12D
ADD R13D,0x6
MOV RDI,R15
CALL 0x00129350
ADD R13,RAX
CMP R13,0x1fe
JA 0x001a8b0e
TEST R14B,0x40
SETZ R12B
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL 0x001944cb
LEA RSI,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00129360
MOV RDI,RBX
MOV ESI,0x80000
CALL 0x00129550
MOV R15D,EAX
TEST EAX,EAX
SETS AL
OR AL,R12B
JNZ 0x001a8aaa
MOV ESI,0x10
MOV RDI,RBX
CALL 0x0019dab0
LAB_001a8aaa:
TEST R15D,R15D
SETNS R12B
MOV EDI,R15D
MOV RSI,RBX
MOV EDX,0x6
MOV ECX,0x1
MOV R8,R14
CALL 0x0019fff6
MOV R13D,EAX
TEST EAX,EAX
SETS AL
AND AL,R12B
CMP AL,0x1
JNZ 0x001a8afd
CALL 0x001a1672
MOV R14D,dword ptr [RAX]
MOV EDI,R15D
CALL 0x001291b0
MOV ESI,0x10
MOV RDI,RBX
CALL 0x0019dab0
CALL 0x001a1672
MOV dword ptr [RAX],R14D
LAB_001a8afd:
TEST R13D,R13D
JS 0x001a8b27
LEA RAX,[0xd081b8]
INC qword ptr [RAX]
JMP 0x001a8b27
LAB_001a8b0e:
CALL 0x001a1672
MOV EBX,0x24
MOV dword ptr [RAX],EBX
CALL 0x001297b0
MOV dword ptr [RAX],EBX
MOV R13D,0xffffffff
LAB_001a8b27:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a8b48
MOV EAX,R13D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a8b48:
CALL 0x00129270
|
int create_temp_file(char *param_1,char *param_2,int *param_3,uint param_4,ulong param_5)
{
int4 uVar1;
int iVar2;
int __fd;
char *pcVar3;
int4 *puVar4;
size_t sVar5;
int *piVar6;
int *puVar7;
long in_FS_OFFSET;
char local_58 [32];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (param_2 == (char *)0x0) {
pcVar3 = getenv("TMPDIR");
param_2 = "/tmp";
if (pcVar3 != (char *)0x0) {
param_2 = pcVar3;
}
}
if (((param_5 & 0x40) == 0) || ((create_temp_file_O_TMPFILE_works & 1) != 0)) {
LAB_001a8a14:
puVar7 = &DAT_001dcf82;
if (param_3 != (int *)0x0) {
puVar7 = param_3;
}
puVar4 = (int4 *)strnmov(local_58,puVar7,0x17);
*puVar4 = 0x58585858;
*(int4 *)((long)puVar4 + 3) = 0x585858;
sVar5 = strlen(param_2);
if (0x1fe < (((int)puVar4 - (int)local_58) + 6) + sVar5) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x24;
piVar6 = __errno_location();
*piVar6 = 0x24;
iVar2 = -1;
goto LAB_001a8b27;
}
pcVar3 = (char *)convert_dirname(param_1,param_2,0);
strcpy(pcVar3,local_58);
__fd = mkostemp64(param_1,0x80000);
if (-1 < __fd && (param_5 & 0x40) != 0) {
my_delete(param_1,0x10);
}
iVar2 = my_register_filename(__fd,param_1,6,1,param_5);
if (iVar2 < 0 && -1 < __fd) {
puVar4 = (int4 *)_my_thread_var();
uVar1 = *puVar4;
close(__fd);
my_delete(param_1,0x10);
puVar4 = (int4 *)_my_thread_var();
*puVar4 = uVar1;
}
}
else {
iVar2 = open64(param_2,param_4 & 0xffb6fdbd | 0x490202,0x1b0);
if (iVar2 < 0) {
piVar6 = __errno_location();
if ((*piVar6 == 0x5f) || (*piVar6 == 0x16)) {
my_printf_error(1,"O_TMPFILE is not supported on %s (disabling future attempts)",0x480,
param_2);
create_temp_file_O_TMPFILE_works = 1;
}
}
else {
my_snprintf(param_1,0x200,"%s/#sql/fd=%d",param_2,iVar2);
iVar2 = my_register_filename(iVar2,param_1,5,1,param_5);
}
if (iVar2 == -1) goto LAB_001a8a14;
}
if (-1 < iVar2) {
my_tmp_file_created = my_tmp_file_created + 1;
}
LAB_001a8b27:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
58,569
|
mysql_stmt_free_result_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_free_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_free_result,
(parms->stmt),
parms->stmt->mysql,
my_bool,
r_my_bool)
}
|
O3
|
c
|
mysql_stmt_free_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x38(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rbx
callq 0x242f0
movb %al, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_free_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+38h]
mov rax, [rax+480h]
mov rbx, [rax+28h]
call mysql_stmt_free_result
mov [rbx+8], al
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_free_result_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_free_result(v1);
*(_BYTE *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_stmt_free_result_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x001242f0
MOV byte ptr [RBX + 0x8],AL
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_free_result_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_free_result();
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
58,570
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&)
|
monkey531[P]llama/common/json.hpp
|
std::pair<iterator, bool> emplace(const key_type& key, T&& t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(key, std::forward<T>(t));
return {std::prev(this->end()), true};
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&):
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x115720
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rdi
callq 0x115790
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x115750
testb $0x1, %al
jne 0x1292bb
jmp 0x129312
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1157c0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x48(%rsp), %rdx
callq 0x129370
testb $0x1, %al
jne 0x1292e9
jmp 0x129304
movb $0x0, 0x2f(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x2f(%rsp), %rdx
callq 0x1220d0
jmp 0x129362
jmp 0x129306
leaq 0x38(%rsp), %rdi
callq 0x115b10
jmp 0x129297
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1293a0
movq 0x8(%rsp), %rdi
callq 0x115790
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x122190
movq %rax, 0x20(%rsp)
movb $0x1, 0x17(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x17(%rsp), %rdx
callq 0x1221d0
movq 0x58(%rsp), %rax
movb 0x60(%rsp), %dl
addq $0x68, %rsp
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_:
sub rsp, 68h
mov [rsp+68h+var_18], rdi
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_28], rdx
mov rdi, [rsp+68h+var_18]
mov [rsp+68h+var_60], rdi
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE5beginEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::begin(void)
mov [rsp+68h+var_30], rax
loc_129297:
mov rdi, [rsp+68h+var_60]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+68h+var_38], rax
lea rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_38]
call _ZN9__gnu_cxxneIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbRKNS_17__normal_iteratorIT_T0_EEST_; __gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&,__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>> const&)
test al, 1
jnz short loc_1292BB
jmp short loc_129312
loc_1292BB:
mov rax, [rsp+68h+var_60]
add rax, 18h
mov [rsp+68h+var_68], rax
lea rdi, [rsp+68h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator->(void)
mov rdi, [rsp+68h+var_68]
mov rsi, rax
mov rdx, [rsp+68h+var_20]
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEESI_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSJ_OSK_
test al, 1
jnz short loc_1292E9
jmp short loc_129304
loc_1292E9:
mov [rsp+68h+var_39], 0
lea rdi, [rsp+68h+var_10]
lea rsi, [rsp+68h+var_30]
lea rdx, [rsp+68h+var_39]
call _ZNSt4pairIN9__gnu_cxx17__normal_iteratorIPS_IKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbEC2IRSO_bTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIST_SU_EEEbE4typeELb1EEEOST_OSU_
jmp short loc_129362
loc_129304:
jmp short $+2
loc_129306:
lea rdi, [rsp+68h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator++(void)
jmp short loc_129297
loc_129312:
mov rdi, [rsp+68h+var_60]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_28]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRSF_SH_EEERSI_DpOT_; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value &&)
mov rdi, [rsp+68h+var_60]
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE3endEv; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::end(void)
mov [rsp+68h+var_50], rax
mov rdi, [rsp+68h+var_50]
mov esi, 1
call _ZSt4prevIN9__gnu_cxx17__normal_iteratorIPSt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS4_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEEN5minja5ValueEES7_ISL_SaISL_EEEEET_SQ_NSt15iterator_traitsISQ_E15difference_typeE; std::prev<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>(__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,std::iterator_traits<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>::difference_type)
mov [rsp+68h+var_48], rax
mov [rsp+68h+var_51], 1
lea rdi, [rsp+68h+var_10]
lea rsi, [rsp+68h+var_48]
lea rdx, [rsp+68h+var_51]
call _ZNSt4pairIN9__gnu_cxx17__normal_iteratorIPS_IKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbEC2ISO_bTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISS_ST_EEEbE4typeELb1EEEOSS_OST_
loc_129362:
mov rax, [rsp+68h+var_10]
mov dl, [rsp+68h+var_8]
add rsp, 68h
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::emplace(
long long a1,
long long a2,
long long a3)
{
long long v3; // rax
char v5; // [rsp+17h] [rbp-51h] BYREF
long long v6; // [rsp+18h] [rbp-50h]
long long v7; // [rsp+20h] [rbp-48h] BYREF
char v8; // [rsp+2Fh] [rbp-39h] BYREF
long long v9; // [rsp+30h] [rbp-38h] BYREF
long long i; // [rsp+38h] [rbp-30h] BYREF
long long v11; // [rsp+40h] [rbp-28h]
long long v12; // [rsp+48h] [rbp-20h]
long long v13; // [rsp+50h] [rbp-18h]
long long v14; // [rsp+58h] [rbp-10h] BYREF
v13 = a1;
v12 = a2;
v11 = a3;
for ( i = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator++(&i) )
{
v9 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>(
(long long)&i,
(long long)&v9) )
break;
v3 = __gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator->((long long)&i);
if ( (std::equal_to<void>::operator()<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&,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&>(
a1 + 24,
v3,
v12) & 1) != 0 )
{
v8 = 0;
ZNSt4pairIN9__gnu_cxx17__normal_iteratorIPS_IKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbEC2IRSO_bTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIST_SU_EEEbE4typeELb1EEEOST_OSU_(
(long long)&v14,
&i,
&v8);
return v14;
}
}
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,minja::Value>(
a1,
v12,
v11);
v6 = std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::end(a1);
v7 = std::prev<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value> *,std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(
v6,
1LL);
v5 = 1;
ZNSt4pairIN9__gnu_cxx17__normal_iteratorIPS_IKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEN5minja5ValueEES6_ISK_SaISK_EEEEbEC2ISO_bTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISS_ST_EEEbE4typeELb1EEEOSS_OST_(
(long long)&v14,
&v7,
&v5);
return v14;
}
| |||
58,571
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&)
|
monkey531[P]llama/common/json.hpp
|
std::pair<iterator, bool> emplace(const key_type& key, T&& t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(key, std::forward<T>(t));
return {std::prev(this->end()), true};
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%rdi), %rbx
je 0x8f089
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8d3b4
testb %al, %al
jne 0x8f0a3
addq $0x60, %rbx
cmpq 0x8(%r14), %rbx
jne 0x8f070
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x8f0b4
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x8f0a5
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
cmp rbx, [rdi+8]
jz short loc_8F089
loc_8F070:
mov rdi, rbx
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jnz short loc_8F0A3
add rbx, 60h ; '`'
cmp rbx, [r14+8]
jnz short loc_8F070
loc_8F089:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRSF_SH_EEERSI_DpOT_; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_8F0A5
loc_8F0A3:
xor edx, edx
loc_8F0A5:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::emplace(
long long a1,
unsigned __int8 *a2,
long long a3,
__m128d a4)
{
unsigned __int8 *v5; // rbx
v5 = *(unsigned __int8 **)a1;
if ( *(_QWORD *)a1 == *(_QWORD *)(a1 + 8) )
{
LABEL_4:
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,minja::Value>(
a1,
a2,
a3);
return *(_QWORD *)(a1 + 8) - 96LL;
}
else
{
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v5, a2, a4) )
{
v5 += 96;
if ( v5 == *(unsigned __int8 **)(a1 + 8) )
goto LABEL_4;
}
}
return (long long)v5;
}
|
emplace:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
CMP RBX,qword ptr [RDI + 0x8]
JZ 0x0018f089
LAB_0018f070:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0018d3b4
TEST AL,AL
JNZ 0x0018f0a3
ADD RBX,0x60
CMP RBX,qword ptr [R14 + 0x8]
JNZ 0x0018f070
LAB_0018f089:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0018f0b4
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x0018f0a5
LAB_0018f0a3:
XOR EDX,EDX
LAB_0018f0a5:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, minja::Value&&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::emplace(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,basic_json *param_1,Value *param_2)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
int1 auVar4 [16];
pbVar3 = *(basic_json **)this;
if (pbVar3 != *(basic_json **)(this + 8)) {
do {
cVar1 = operator==(pbVar3,param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_0018f0a5;
}
pbVar3 = pbVar3 + 0x60;
} while (pbVar3 != *(basic_json **)(this + 8));
}
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,minja::Value>
((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,param_1,param_2);
pbVar3 = (basic_json *)(*(long *)(this + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0018f0a5:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = pbVar3;
return auVar4;
}
|
|
58,572
|
strmake
|
eloqsql/strings/strmake.c
|
char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
}
|
O3
|
c
|
strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rdi, %rdx
je 0xd7194
movb (%rsi,%rcx), %r8b
movb %r8b, (%rax,%rcx)
leaq 0x1(%rcx), %rdi
testb %r8b, %r8b
jne 0xd7179
jmp 0xd7198
movb $0x0, (%rax,%rcx)
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
|
strmake:
push rbp
mov rbp, rsp
mov rax, rdi
xor edi, edi
loc_D7179:
mov rcx, rdi
cmp rdx, rdi
jz short loc_D7194
mov r8b, [rsi+rcx]
mov [rax+rcx], r8b
lea rdi, [rcx+1]
test r8b, r8b
jnz short loc_D7179
jmp short loc_D7198
loc_D7194:
mov byte ptr [rax+rcx], 0
loc_D7198:
add rax, rcx
pop rbp
retn
|
long long strmake(long long a1, long long a2, long long a3)
{
long long v4; // rdi
long long v5; // rcx
char v6; // r8
v4 = 0LL;
while ( 1 )
{
v5 = v4;
if ( a3 == v4 )
break;
v6 = *(_BYTE *)(a2 + v4);
*(_BYTE *)(a1 + v4++) = v6;
if ( !v6 )
return v5 + a1;
}
*(_BYTE *)(a1 + v4) = 0;
return v5 + a1;
}
|
strmake:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR EDI,EDI
LAB_001d7179:
MOV RCX,RDI
CMP RDX,RDI
JZ 0x001d7194
MOV R8B,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],R8B
LEA RDI,[RCX + 0x1]
TEST R8B,R8B
JNZ 0x001d7179
JMP 0x001d7198
LAB_001d7194:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_001d7198:
ADD RAX,RCX
POP RBP
RET
|
long strmake(long param_1,long param_2,long param_3)
{
char cVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
lVar3 = lVar2;
if (param_3 == lVar3) {
*(int1 *)(param_1 + lVar3) = 0;
break;
}
cVar1 = *(char *)(param_2 + lVar3);
*(char *)(param_1 + lVar3) = cVar1;
lVar2 = lVar3 + 1;
} while (cVar1 != '\0');
return param_1 + lVar3;
}
|
|
58,573
|
ma_dynstr_append_quoted
|
eloqsql/libmariadb/libmariadb/ma_string.c
|
my_bool ma_dynstr_append_quoted(DYNAMIC_STRING *str,
const char *append, size_t len,
char quote)
{
size_t additional= str->alloc_increment;
size_t lim= additional;
uint i;
if (ma_dynstr_realloc(str, len + additional + 2))
return TRUE;
str->str[str->length++]= quote;
for (i= 0; i < len; i++)
{
register char c= append[i];
if (c == quote || c == '\\')
{
if (!lim)
{
if (ma_dynstr_realloc(str, additional))
return TRUE;
lim= additional;
}
lim--;
str->str[str->length++]= '\\';
}
str->str[str->length++]= c;
}
str->str[str->length++]= quote;
return FALSE;
}
|
O3
|
c
|
ma_dynstr_append_quoted:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rbx
leaq (%rdx,%rbx), %rsi
addq $0x2, %rsi
callq 0x824e5
movb $0x1, %cl
testb %al, %al
jne 0x826ca
movq %rbx, -0x38(%rbp)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl -0x2c(%rbp), %edx
movb %dl, (%rax,%rcx)
testq %r15, %r15
je 0x826b3
movq %r12, %rdi
movl $0x1, %r12d
xorl %eax, %eax
movq -0x38(%rbp), %rbx
movq %r15, -0x40(%rbp)
movb (%rdi,%rax), %r13b
cmpb -0x2c(%rbp), %r13b
setne %al
cmpb $0x5c, %r13b
setne %dl
testb %dl, %al
jne 0x82695
testq %rbx, %rbx
jne 0x8267f
movq %rdi, %r15
movq %r14, %rdi
movq -0x38(%rbp), %rbx
movq %rbx, %rsi
callq 0x824e5
movq %r15, %rdi
movq -0x40(%rbp), %r15
testb %al, %al
jne 0x826db
decq %rbx
movq (%r14), %rax
movq 0x8(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%r14)
movb $0x5c, (%rax,%rdx)
movq (%r14), %rax
movq 0x8(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%r14)
movb %r13b, (%rax,%rdx)
movl %r12d, %eax
incl %r12d
cmpq %r15, %rax
jb 0x82647
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movl -0x2c(%rbp), %edx
movb %dl, (%rax,%rcx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %cl
jmp 0x826ca
|
ma_dynstr_append_quoted:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_2C], ecx
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi+18h]
lea rsi, [rdx+rbx]
add rsi, 2
call ma_dynstr_realloc
mov cl, 1
test al, al
jnz loc_826CA
mov [rbp+var_38], rbx
mov rax, [r14]
mov rcx, [r14+8]
lea rdx, [rcx+1]
mov [r14+8], rdx
mov edx, [rbp+var_2C]
mov [rax+rcx], dl
test r15, r15
jz short loc_826B3
mov rdi, r12
mov r12d, 1
xor eax, eax
mov rbx, [rbp+var_38]
mov [rbp+var_40], r15
loc_82647:
mov r13b, [rdi+rax]
cmp r13b, byte ptr [rbp+var_2C]
setnz al
cmp r13b, 5Ch ; '\'
setnz dl
test al, dl
jnz short loc_82695
test rbx, rbx
jnz short loc_8267F
mov r15, rdi
mov rdi, r14
mov rbx, [rbp+var_38]
mov rsi, rbx
call ma_dynstr_realloc
mov rdi, r15
mov r15, [rbp+var_40]
test al, al
jnz short loc_826DB
loc_8267F:
dec rbx
mov rax, [r14]
mov rdx, [r14+8]
lea rsi, [rdx+1]
mov [r14+8], rsi
mov byte ptr [rax+rdx], 5Ch ; '\'
loc_82695:
mov rax, [r14]
mov rdx, [r14+8]
lea rsi, [rdx+1]
mov [r14+8], rsi
mov [rax+rdx], r13b
mov eax, r12d
inc r12d
cmp rax, r15
jb short loc_82647
loc_826B3:
mov rax, [r14]
mov rcx, [r14+8]
lea rdx, [rcx+1]
mov [r14+8], rdx
mov edx, [rbp+var_2C]
mov [rax+rcx], dl
xor ecx, ecx
loc_826CA:
mov eax, ecx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_826DB:
mov cl, 1
jmp short loc_826CA
|
long long ma_dynstr_append_quoted(long long *a1, long long a2, unsigned long long a3, char a4)
{
unsigned long long v4; // r15
long long v5; // rbx
bool v6; // al
unsigned int v7; // ecx
long long v8; // rax
long long v9; // rcx
unsigned int v10; // r12d
unsigned long long v11; // rax
char v12; // r13
long long v13; // rax
long long v14; // rdx
long long v15; // rax
long long v16; // rdx
long long v17; // rax
long long v18; // rcx
unsigned long long v20; // [rsp+0h] [rbp-40h]
long long v21; // [rsp+8h] [rbp-38h]
v4 = a3;
v5 = a1[3];
v6 = ma_dynstr_realloc(a1, a3 + v5 + 2);
LOBYTE(v7) = 1;
if ( !v6 )
{
v21 = v5;
v8 = *a1;
v9 = a1[1];
a1[1] = v9 + 1;
*(_BYTE *)(v8 + v9) = a4;
if ( v4 )
{
v10 = 1;
v11 = 0LL;
v20 = v4;
do
{
v12 = *(_BYTE *)(a2 + v11);
if ( v12 == 92 || v12 == a4 )
{
if ( !v5 )
{
v5 = v21;
v4 = v20;
if ( ma_dynstr_realloc(a1, v21) )
{
LOBYTE(v7) = 1;
return v7;
}
}
--v5;
v13 = *a1;
v14 = a1[1];
a1[1] = v14 + 1;
*(_BYTE *)(v13 + v14) = 92;
}
v15 = *a1;
v16 = a1[1];
a1[1] = v16 + 1;
*(_BYTE *)(v15 + v16) = v12;
v11 = v10++;
}
while ( v11 < v4 );
}
v17 = *a1;
v18 = a1[1];
a1[1] = v18 + 1;
*(_BYTE *)(v17 + v18) = a4;
return 0;
}
return v7;
}
|
ma_dynstr_append_quoted:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x2c],ECX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI + 0x18]
LEA RSI,[RDX + RBX*0x1]
ADD RSI,0x2
CALL 0x001824e5
MOV CL,0x1
TEST AL,AL
JNZ 0x001826ca
MOV qword ptr [RBP + -0x38],RBX
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
LEA RDX,[RCX + 0x1]
MOV qword ptr [R14 + 0x8],RDX
MOV EDX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX + RCX*0x1],DL
TEST R15,R15
JZ 0x001826b3
MOV RDI,R12
MOV R12D,0x1
XOR EAX,EAX
MOV RBX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],R15
LAB_00182647:
MOV R13B,byte ptr [RDI + RAX*0x1]
CMP R13B,byte ptr [RBP + -0x2c]
SETNZ AL
CMP R13B,0x5c
SETNZ DL
TEST AL,DL
JNZ 0x00182695
TEST RBX,RBX
JNZ 0x0018267f
MOV R15,RDI
MOV RDI,R14
MOV RBX,qword ptr [RBP + -0x38]
MOV RSI,RBX
CALL 0x001824e5
MOV RDI,R15
MOV R15,qword ptr [RBP + -0x40]
TEST AL,AL
JNZ 0x001826db
LAB_0018267f:
DEC RBX
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LEA RSI,[RDX + 0x1]
MOV qword ptr [R14 + 0x8],RSI
MOV byte ptr [RAX + RDX*0x1],0x5c
LAB_00182695:
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
LEA RSI,[RDX + 0x1]
MOV qword ptr [R14 + 0x8],RSI
MOV byte ptr [RAX + RDX*0x1],R13B
MOV EAX,R12D
INC R12D
CMP RAX,R15
JC 0x00182647
LAB_001826b3:
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [R14 + 0x8]
LEA RDX,[RCX + 0x1]
MOV qword ptr [R14 + 0x8],RDX
MOV EDX,dword ptr [RBP + -0x2c]
MOV byte ptr [RAX + RCX*0x1],DL
XOR ECX,ECX
LAB_001826ca:
MOV EAX,ECX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001826db:
MOV CL,0x1
JMP 0x001826ca
|
ulong ma_dynstr_append_quoted(long *param_1,long param_2,ulong param_3,int8 param_4)
{
char cVar1;
long lVar2;
long lVar3;
char cVar4;
char cVar5;
ulong uVar6;
int8 uVar7;
long lVar8;
long lVar9;
ulong uVar10;
bool bVar11;
lVar2 = param_1[3];
uVar7 = param_4;
cVar4 = ma_dynstr_realloc(param_1,param_3 + lVar2 + 2);
uVar6 = CONCAT71((int7)((ulong)uVar7 >> 8),1);
if (cVar4 == '\0') {
lVar8 = param_1[1];
param_1[1] = lVar8 + 1;
cVar4 = (char)param_4;
*(char *)(*param_1 + lVar8) = cVar4;
if (param_3 != 0) {
uVar6 = 0;
lVar9 = lVar2;
uVar10 = 1;
do {
cVar1 = *(char *)(param_2 + uVar6);
if (cVar1 == cVar4 || cVar1 == '\\') {
if (lVar9 == 0) {
cVar5 = ma_dynstr_realloc(param_1,lVar2);
lVar9 = lVar2;
if (cVar5 != '\0') {
uVar6 = CONCAT71((int7)((ulong)lVar8 >> 8),1);
goto LAB_001826ca;
}
}
lVar9 = lVar9 + -1;
lVar3 = param_1[1];
param_1[1] = lVar3 + 1;
*(int1 *)(*param_1 + lVar3) = 0x5c;
}
lVar3 = param_1[1];
param_1[1] = lVar3 + 1;
*(char *)(*param_1 + lVar3) = cVar1;
bVar11 = uVar10 < param_3;
uVar6 = uVar10;
uVar10 = (ulong)((int)uVar10 + 1);
} while (bVar11);
}
lVar2 = param_1[1];
param_1[1] = lVar2 + 1;
*(char *)(*param_1 + lVar2) = cVar4;
uVar6 = 0;
}
LAB_001826ca:
return uVar6 & 0xffffffff;
}
|
|
58,574
|
pow5mult
|
eloqsql/strings/dtoa.c
|
static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
}
|
O3
|
c
|
pow5mult:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r13
movl %esi, %eax
andl $0x3, %eax
je 0xd5065
decl %eax
leaq 0x286c96(%rip), %rcx # 0x35bce8
movl (%rcx,%rax,4), %esi
movq %r13, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xd54b2
movq %rax, %r13
cmpl $0x4, %r15d
jb 0xd514d
movq %rbx, -0x38(%rbp)
shrl $0x2, %r15d
movb $0x1, %cl
leaq 0x327190(%rip), %rbx # 0x3fc210
movq $0x0, -0x40(%rbp)
leaq 0x327211(%rip), %r12 # 0x3fc2a0
movl %ecx, %r14d
cmpq %r12, %rbx
setb %cl
movl %ecx, -0x2c(%rbp)
testb $0x1, %r15b
je 0xd50d0
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %r12
movq -0x38(%rbp), %r13
movq %r13, %rdx
callq 0xd515f
movq %rax, -0x48(%rbp)
movq %r12, %rdi
leaq 0x3271dc(%rip), %r12 # 0x3fc2a0
movq %r13, %rsi
callq 0xd5281
movq -0x48(%rbp), %r13
cmpl $0x2, %r15d
jb 0xd513b
shrl %r15d
testb $0x1, %r14b
je 0xd5100
cmpq %r12, %rbx
jb 0xd512f
movb $0x1, %r14b
jne 0xd509b
movq %r12, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
callq 0xd515f
movq %rax, %rbx
movl -0x2c(%rbp), %ecx
jmp 0xd508f
movq %rbx, %rdi
movq %rbx, %r14
movq %rbx, %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
callq 0xd515f
movq %rax, -0x40(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd5281
xorl %ecx, %ecx
movq -0x40(%rbp), %rbx
jmp 0xd508f
addq $0x18, %rbx
movl -0x2c(%rbp), %ecx
jmp 0xd508f
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xd514d
movq -0x38(%rbp), %rsi
callq 0xd5281
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
pow5mult:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r15d, esi
mov r13, rdi
mov eax, esi
and eax, 3
jz short loc_D5065
dec eax
lea rcx, pow5mult_p05
mov esi, [rcx+rax*4]
mov rdi, r13
xor edx, edx
mov rcx, rbx
call multadd
mov r13, rax
loc_D5065:
cmp r15d, 4
jb loc_D514D
mov [rbp+var_38], rbx
shr r15d, 2
mov cl, 1
lea rbx, p5_a
mov [rbp+var_40], 0
lea r12, off_3FC2A0
loc_D508F:
mov r14d, ecx
cmp rbx, r12
setb cl
mov [rbp+var_2C], ecx
loc_D509B:
test r15b, 1
jz short loc_D50D0
mov rdi, r13
mov rsi, rbx
mov r12, r13
mov r13, [rbp+var_38]
mov rdx, r13
call mult
mov [rbp+var_48], rax
mov rdi, r12
lea r12, off_3FC2A0
mov rsi, r13
call Bfree
mov r13, [rbp+var_48]
loc_D50D0:
cmp r15d, 2
jb short loc_D513B
shr r15d, 1
test r14b, 1
jz short loc_D5100
cmp rbx, r12
jb short loc_D512F
mov r14b, 1
jnz short loc_D509B
mov rdi, r12
mov rsi, r12
mov rdx, [rbp+var_38]
call mult
mov rbx, rax
mov ecx, [rbp+var_2C]
jmp short loc_D508F
loc_D5100:
mov rdi, rbx
mov r14, rbx
mov rsi, rbx
mov rbx, [rbp+var_38]
mov rdx, rbx
call mult
mov [rbp+var_40], rax
mov rdi, r14
mov rsi, rbx
call Bfree
xor ecx, ecx
mov rbx, [rbp+var_40]
jmp loc_D508F
loc_D512F:
add rbx, 18h
mov ecx, [rbp+var_2C]
jmp loc_D508F
loc_D513B:
mov rdi, [rbp+var_40]
test rdi, rdi
jz short loc_D514D
mov rsi, [rbp+var_38]
call Bfree
loc_D514D:
mov rax, r13
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long pow5mult(long long a1, unsigned int a2, long long a3, int a4)
{
long long v5; // r13
unsigned int v6; // r15d
_UNKNOWN **v7; // rbx
char v8; // r14
long long v10; // [rsp+8h] [rbp-48h]
long long v11; // [rsp+10h] [rbp-40h]
long long v12; // [rsp+18h] [rbp-38h]
int v13; // [rsp+24h] [rbp-2Ch]
v5 = a1;
if ( (a2 & 3) != 0 )
v5 = multadd(a1, pow5mult_p05[(a2 & 3) - 1], 0LL, a3);
if ( a2 >= 4 )
{
v12 = a3;
v6 = a2 >> 2;
LOBYTE(a4) = 1;
v7 = &p5_a;
v11 = 0LL;
LABEL_5:
v8 = a4;
LOBYTE(a4) = v7 < &off_3FC2A0;
v13 = a4;
while ( 1 )
{
if ( (v6 & 1) != 0 )
{
v10 = mult(v5, v7, v12);
Bfree(v5, v12);
v5 = v10;
}
if ( v6 < 2 )
break;
v6 >>= 1;
if ( (v8 & 1) == 0 )
{
v11 = mult(v7, v7, v12);
Bfree(v7, v12);
a4 = 0;
v7 = (_UNKNOWN **)v11;
goto LABEL_5;
}
if ( v7 < &off_3FC2A0 )
{
v7 += 3;
a4 = v13;
goto LABEL_5;
}
v8 = 1;
if ( v7 == &off_3FC2A0 )
{
v7 = (_UNKNOWN **)mult(&off_3FC2A0, &off_3FC2A0, v12);
a4 = v13;
goto LABEL_5;
}
}
if ( v11 )
Bfree(v11, v12);
}
return v5;
}
|
pow5mult:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R15D,ESI
MOV R13,RDI
MOV EAX,ESI
AND EAX,0x3
JZ 0x001d5065
DEC EAX
LEA RCX,[0x45bce8]
MOV ESI,dword ptr [RCX + RAX*0x4]
MOV RDI,R13
XOR EDX,EDX
MOV RCX,RBX
CALL 0x001d54b2
MOV R13,RAX
LAB_001d5065:
CMP R15D,0x4
JC 0x001d514d
MOV qword ptr [RBP + -0x38],RBX
SHR R15D,0x2
MOV CL,0x1
LEA RBX,[0x4fc210]
MOV qword ptr [RBP + -0x40],0x0
LEA R12,[0x4fc2a0]
LAB_001d508f:
MOV R14D,ECX
CMP RBX,R12
SETC CL
MOV dword ptr [RBP + -0x2c],ECX
LAB_001d509b:
TEST R15B,0x1
JZ 0x001d50d0
MOV RDI,R13
MOV RSI,RBX
MOV R12,R13
MOV R13,qword ptr [RBP + -0x38]
MOV RDX,R13
CALL 0x001d515f
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,R12
LEA R12,[0x4fc2a0]
MOV RSI,R13
CALL 0x001d5281
MOV R13,qword ptr [RBP + -0x48]
LAB_001d50d0:
CMP R15D,0x2
JC 0x001d513b
SHR R15D,0x1
TEST R14B,0x1
JZ 0x001d5100
CMP RBX,R12
JC 0x001d512f
MOV R14B,0x1
JNZ 0x001d509b
MOV RDI,R12
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001d515f
MOV RBX,RAX
MOV ECX,dword ptr [RBP + -0x2c]
JMP 0x001d508f
LAB_001d5100:
MOV RDI,RBX
MOV R14,RBX
MOV RSI,RBX
MOV RBX,qword ptr [RBP + -0x38]
MOV RDX,RBX
CALL 0x001d515f
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x001d5281
XOR ECX,ECX
MOV RBX,qword ptr [RBP + -0x40]
JMP 0x001d508f
LAB_001d512f:
ADD RBX,0x18
MOV ECX,dword ptr [RBP + -0x2c]
JMP 0x001d508f
LAB_001d513b:
MOV RDI,qword ptr [RBP + -0x40]
TEST RDI,RDI
JZ 0x001d514d
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001d5281
LAB_001d514d:
MOV RAX,R13
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
int1 *puVar1;
int8 uVar2;
bool bVar3;
bool bVar4;
int1 *local_48;
if ((param_2 & 3) != 0) {
param_1 = multadd(param_1,*(int4 *)(pow5mult_p05 + (ulong)((param_2 & 3) - 1) * 4),0,
param_3);
}
if (param_2 < 4) {
return param_1;
}
param_2 = param_2 >> 2;
local_48 = (int1 *)0x0;
puVar1 = p5_a;
bVar3 = true;
LAB_001d508f:
do {
bVar4 = puVar1 < (int1 *)0x4fc2a0;
uVar2 = param_1;
do {
param_1 = uVar2;
if ((param_2 & 1) != 0) {
param_1 = mult(uVar2,puVar1,param_3);
Bfree(uVar2,param_3);
}
if (param_2 < 2) {
if (local_48 == (int1 *)0x0) {
return param_1;
}
Bfree(local_48,param_3);
return param_1;
}
param_2 = param_2 >> 1;
if (!bVar3) {
local_48 = (int1 *)mult(puVar1,puVar1,param_3);
Bfree(puVar1,param_3);
bVar3 = false;
puVar1 = local_48;
goto LAB_001d508f;
}
if (puVar1 < (int1 *)0x4fc2a0) {
puVar1 = puVar1 + 0x18;
bVar3 = bVar4;
goto LAB_001d508f;
}
bVar3 = true;
uVar2 = param_1;
} while (puVar1 != (int1 *)0x4fc2a0);
puVar1 = (int1 *)mult(0x4fc2a0,0x4fc2a0,param_3);
bVar3 = bVar4;
} while( true );
}
|
|
58,575
|
change_key_cache_param
|
eloqsql/mysys/mf_keycache.c
|
void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
uint age_threshold)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->change_param(keycache->keycache_cb,
division_limit,
age_threshold);
pthread_mutex_unlock(&keycache->op_lock);
}
}
|
O0
|
c
|
change_key_cache_param:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xe4002
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq *%rax
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x2a1f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
change_key_cache_param:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_E4002
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+10h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov esi, [rbp+var_C]
mov edx, [rbp+var_10]
call rax
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_E4002:
add rsp, 10h
pop rbp
retn
|
long long change_key_cache_param(long long a1, unsigned int a2, unsigned int a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)(a1 + 16) + 16LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
|
change_key_cache_param:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001e4002
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a210
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV EDX,dword ptr [RBP + -0x10]
CALL RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x0012a1f0
LAB_001e4002:
ADD RSP,0x10
POP RBP
RET
|
void change_key_cache_param(long param_1,int4 param_2,int4 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x10))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
}
return;
}
|
|
58,576
|
compile_let_decl
|
fabiosvm[P]rak/src/compiler.c
|
static inline void compile_let_decl(RakCompiler *comp, RakError *err)
{
next(comp, err);
if (!match(comp, RAK_TOKEN_KIND_IDENT))
{
expected_token_error(err, RAK_TOKEN_KIND_IDENT, comp->lex.tok);
return;
}
RakToken tok = comp->lex.tok;
next(comp, err);
if (match(comp, RAK_TOKEN_KIND_EQ))
{
next(comp, err);
compile_expr(comp, err);
if (!rak_is_ok(err)) return;
consume(comp, RAK_TOKEN_KIND_SEMICOLON, err);
define_local(comp, tok, err);
return;
}
consume(comp, RAK_TOKEN_KIND_SEMICOLON, err);
emit_instr(comp, rak_push_nil_instr(), err);
if (!rak_is_ok(err)) return;
define_local(comp, tok, err);
}
|
O2
|
c
|
compile_let_decl:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27f8(%rdi), %r15
movq %r15, %rdi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x3c9f
leaq 0x2810(%r14), %r12
cmpl $0x2e, 0x2810(%r14)
jne 0x3c81
movq 0x10(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x3c9f
movl (%r12), %eax
cmpl $0x3, %eax
je 0x3cc2
cmpl $0xe, %eax
jne 0x3cab
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x3c9f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x400f
cmpb $0x1, (%rbx)
jne 0x3c9f
cmpl $0x3, (%r12)
jne 0x3cab
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
jmp 0x3ce0
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x3f9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
pushq $0x3
jmp 0x3c96
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5512
cmpb $0x1, (%rbx)
jne 0x3c9f
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3306
cmpb $0x1, (%rbx)
jne 0x3c9f
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x403f
jmp 0x3c9f
|
compile_let_decl:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rsi
mov r14, rdi
lea r15, [rdi+27F8h]
mov rdi, r15
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz loc_3C9F
lea r12, [r14+2810h]
cmp dword ptr [r14+2810h], 2Eh ; '.'
jnz short loc_3C81
mov rax, [r12+10h]
mov [rsp+58h+var_28], rax
movups xmm0, xmmword ptr [r12]
movaps [rsp+58h+var_38], xmm0
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_3C9F
mov eax, [r12]
cmp eax, 3
jz short loc_3CC2
cmp eax, 0Eh
jnz short loc_3CAB
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_3C9F
mov rdi, r14
mov rsi, rbx
call compile_expr
cmp byte ptr [rbx], 1
jnz short loc_3C9F
cmp dword ptr [r12], 3
jnz short loc_3CAB
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
jmp short loc_3CE0
loc_3C81:
mov rax, [r12+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+58h+var_58], xmm0
push 2Eh ; '.'
loc_3C96:
pop rsi
mov rdi, rbx
call expected_token_error
loc_3C9F:
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
loc_3CAB:
mov rax, [r12+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+58h+var_58], xmm0
push 3
jmp short loc_3C96
loc_3CC2:
mov rdi, r15
mov rsi, rbx
call rak_lexer_next
cmp byte ptr [rbx], 1
jnz short loc_3C9F
push 1
pop rsi
mov rdi, r14
mov rdx, rbx
call rak_chunk_append_instr
loc_3CE0:
cmp byte ptr [rbx], 1
jnz short loc_3C9F
mov rax, [rsp+58h+var_28]
mov [rsp+58h+var_48], rax
movaps xmm0, [rsp+58h+var_38]
movups [rsp+58h+var_58], xmm0
mov rdi, r14
mov rsi, rbx
call define_local
jmp short loc_3C9F
|
long long compile_let_decl(_QWORD *a1, char *a2)
{
_QWORD *v2; // r15
long long result; // rax
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
__int128 *v8; // r12
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // ecx
int v18; // r8d
int v19; // r9d
__int128 v20; // [rsp+20h] [rbp-38h]
long long v21; // [rsp+30h] [rbp-28h]
v2 = a1 + 1279;
result = rak_lexer_next(a1 + 1279, a2);
if ( *a2 == 1 )
{
v8 = (__int128 *)(a1 + 1282);
if ( *((_DWORD *)a1 + 2564) != 46 )
return expected_token_error((_DWORD)a2, 46, v4, v5, v6, v7, a1[1282], a1[1283], a1[1284]);
v21 = a1[1284];
v20 = *v8;
result = rak_lexer_next(v2, a2);
if ( *a2 != 1 )
return result;
if ( *(_DWORD *)v8 == 3 )
{
result = rak_lexer_next(v2, a2);
if ( *a2 != 1 )
return result;
result = rak_chunk_append_instr((long long)a1, 1, a2, v17, v18, v19);
goto LABEL_15;
}
if ( *(_DWORD *)v8 != 14 )
return expected_token_error((_DWORD)a2, 3, v9, v10, v11, v12, a1[1282], a1[1283], a1[1284]);
result = rak_lexer_next(v2, a2);
if ( *a2 == 1 )
{
result = compile_expr(a1, a2);
if ( *a2 == 1 )
{
if ( *(_DWORD *)v8 == 3 )
{
result = rak_lexer_next(v2, a2);
LABEL_15:
if ( *a2 == 1 )
return define_local((_DWORD)a1, (_DWORD)a2, v13, v14, v15, v16, v20, DWORD2(v20), v21);
return result;
}
return expected_token_error((_DWORD)a2, 3, v9, v10, v11, v12, a1[1282], a1[1283], a1[1284]);
}
}
}
return result;
}
|
compile_let_decl:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RSI
MOV R14,RDI
LEA R15,[RDI + 0x27f8]
MOV RDI,R15
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
LEA R12,[R14 + 0x2810]
CMP dword ptr [R14 + 0x2810],0x2e
JNZ 0x00103c81
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
MOV EAX,dword ptr [R12]
CMP EAX,0x3
JZ 0x00103cc2
CMP EAX,0xe
JNZ 0x00103cab
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
MOV RDI,R14
MOV RSI,RBX
CALL 0x0010400f
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
CMP dword ptr [R12],0x3
JNZ 0x00103cab
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
JMP 0x00103ce0
LAB_00103c81:
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
PUSH 0x2e
LAB_00103c96:
POP RSI
MOV RDI,RBX
CALL 0x00103f9d
LAB_00103c9f:
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00103cab:
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
PUSH 0x3
JMP 0x00103c96
LAB_00103cc2:
MOV RDI,R15
MOV RSI,RBX
CALL 0x00105512
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
PUSH 0x1
POP RSI
MOV RDI,R14
MOV RDX,RBX
CALL 0x00103306
LAB_00103ce0:
CMP byte ptr [RBX],0x1
JNZ 0x00103c9f
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0010403f
JMP 0x00103c9f
|
void compile_let_decl(long param_1,char *param_2)
{
long lVar1;
int iVar2;
int8 uStack_60;
lVar1 = param_1 + 0x27f8;
rak_lexer_next(lVar1);
if (*param_2 != '\x01') {
return;
}
if (*(int *)(param_1 + 0x2810) == 0x2e) {
rak_lexer_next(lVar1,param_2);
if (*param_2 != '\x01') {
return;
}
iVar2 = *(int *)(param_1 + 0x2810);
if (iVar2 == 3) {
rak_lexer_next(lVar1,param_2);
if (*param_2 != '\x01') {
return;
}
rak_chunk_append_instr(param_1,1,param_2);
LAB_00103ce0:
if (*param_2 != '\x01') {
return;
}
define_local(param_1,param_2);
return;
}
if (iVar2 == 0xe) {
rak_lexer_next(lVar1,param_2);
if (*param_2 != '\x01') {
return;
}
compile_expr(param_1,param_2);
if (*param_2 != '\x01') {
return;
}
if (*(int *)(param_1 + 0x2810) == 3) {
rak_lexer_next(lVar1,param_2);
goto LAB_00103ce0;
}
}
uStack_60 = 3;
}
else {
uStack_60 = 0x2e;
}
expected_token_error(param_2,uStack_60);
return;
}
|
|
58,577
|
my_strcasecmp_mb
|
eloqsql/strings/ctype-mb.c
|
int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
{
register uint32 l;
register const uchar *map=cs->to_upper;
while (*s && *t)
{
/* Pointing after the '\0' is safe here. */
if ((l=my_ismbchar(cs, s, s + cs->mbmaxlen)))
{
while (l--)
if (*s++ != *t++)
return 1;
}
else if (my_ci_charlen(cs, (const uchar *) t, (const uchar *) t + cs->mbmaxlen) > 1)
return 1;
else if (map[(uchar) *s++] != map[(uchar) *t++])
return 1;
}
/* At least one of '*s' and '*t' is zero here. */
return (*t != *s);
}
|
O0
|
c
|
my_strcasecmp_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x40231
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4023d
jmp 0x40323
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x3fea0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x402ad
jmp 0x40265
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
je 0x402ab
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x402a9
movl $0x1, -0x4(%rbp)
jmp 0x4033e
jmp 0x40265
jmp 0x4031e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x40350
cmpl $0x1, %eax
jle 0x402d9
movl $0x1, -0x4(%rbp)
jmp 0x4033e
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4031a
movl $0x1, -0x4(%rbp)
jmp 0x4033e
jmp 0x4031c
jmp 0x4031e
jmp 0x40210
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_strcasecmp_mb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+50h]
mov [rbp+var_30], rax
loc_40210:
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_31], al
jz short loc_40231
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_31], al
loc_40231:
mov al, [rbp+var_31]
test al, 1
jnz short loc_4023D
jmp loc_40323
loc_4023D:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_402AD
jmp short $+2
loc_40265:
mov eax, [rbp+var_24]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_24], ecx
cmp eax, 0
jz short loc_402AB
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1
mov [rbp+var_20], rdx
movsx ecx, byte ptr [rcx]
cmp eax, ecx
jz short loc_402A9
mov [rbp+var_4], 1
jmp loc_4033E
loc_402A9:
jmp short loc_40265
loc_402AB:
jmp short loc_4031E
loc_402AD:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_10]
mov eax, [rax+9Ch]
add rdx, rax
call my_ci_charlen_2
cmp eax, 1
jle short loc_402D9
mov [rbp+var_4], 1
jmp short loc_4033E
loc_402D9:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rsi, rdx
add rsi, 1
mov [rbp+var_20], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_4031A
mov [rbp+var_4], 1
jmp short loc_4033E
loc_4031A:
jmp short $+2
loc_4031C:
jmp short $+2
loc_4031E:
jmp loc_40210
loc_40323:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
mov rcx, [rbp+var_18]
movsx ecx, byte ptr [rcx]
cmp eax, ecx
setnz al
and al, 1
movzx eax, al
mov [rbp+var_4], eax
loc_4033E:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
_BOOL8 my_strcasecmp_mb(long long a1, unsigned __int8 *a2, unsigned __int8 *a3)
{
char *v4; // rax
char *v5; // rcx
unsigned __int8 *v6; // rcx
unsigned __int8 *v7; // rdx
bool v9; // [rsp+Fh] [rbp-31h]
long long v10; // [rsp+10h] [rbp-30h]
int v11; // [rsp+1Ch] [rbp-24h]
v10 = *(_QWORD *)(a1 + 80);
while ( 1 )
{
v9 = 0;
if ( *a2 )
v9 = *a3 != 0;
if ( !v9 )
break;
v11 = my_ismbchar_0(a1, (long long)a2, (long long)&a2[*(unsigned int *)(a1 + 156)]);
if ( v11 )
{
while ( v11-- )
{
v4 = (char *)a2++;
v5 = (char *)a3++;
if ( *v4 != *v5 )
return 1;
}
}
else
{
if ( (int)my_ci_charlen_2(a1, a3, &a3[*(unsigned int *)(a1 + 156)]) > 1 )
return 1;
v6 = a2++;
v7 = a3++;
if ( *(unsigned __int8 *)(v10 + *v6) != *(unsigned __int8 *)(v10 + *v7) )
return 1;
}
}
return *a3 != *a2;
}
|
my_strcasecmp_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x30],RAX
LAB_00140210:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x31],AL
JZ 0x00140231
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_00140231:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x0014023d
JMP 0x00140323
LAB_0014023d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x0013fea0
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x001402ad
JMP 0x00140265
LAB_00140265:
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x24],ECX
CMP EAX,0x0
JZ 0x001402ab
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOVSX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVSX ECX,byte ptr [RCX]
CMP EAX,ECX
JZ 0x001402a9
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014033e
LAB_001402a9:
JMP 0x00140265
LAB_001402ab:
JMP 0x0014031e
LAB_001402ad:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x00140350
CMP EAX,0x1
JLE 0x001402d9
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014033e
LAB_001402d9:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x20],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0014031a
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014033e
LAB_0014031a:
JMP 0x0014031c
LAB_0014031c:
JMP 0x0014031e
LAB_0014031e:
JMP 0x00140210
LAB_00140323:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RCX]
CMP EAX,ECX
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
LAB_0014033e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
bool my_strcasecmp_mb(long param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
long lVar3;
int iVar4;
bool bVar5;
int local_2c;
byte *local_28;
byte *local_20;
lVar3 = *(long *)(param_1 + 0x50);
local_28 = param_3;
local_20 = param_2;
do {
while( true ) {
bVar5 = false;
if (*local_20 != 0) {
bVar5 = *local_28 != 0;
}
if (!bVar5) {
return *local_28 != *local_20;
}
local_2c = my_ismbchar(param_1,local_20,local_20 + *(uint *)(param_1 + 0x9c));
if (local_2c == 0) break;
while (local_2c != 0) {
bVar1 = *local_20;
bVar2 = *local_28;
local_2c = local_2c + -1;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
if (bVar1 != bVar2) {
return true;
}
}
}
iVar4 = my_ci_charlen(param_1,local_28,local_28 + *(uint *)(param_1 + 0x9c));
if (1 < iVar4) {
return true;
}
bVar1 = *local_20;
bVar2 = *local_28;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
} while (*(char *)(lVar3 + (ulong)bVar1) == *(char *)(lVar3 + (ulong)bVar2));
return true;
}
|
|
58,578
|
my_strcasecmp_mb
|
eloqsql/strings/ctype-mb.c
|
int my_strcasecmp_mb(CHARSET_INFO * cs,const char *s, const char *t)
{
register uint32 l;
register const uchar *map=cs->to_upper;
while (*s && *t)
{
/* Pointing after the '\0' is safe here. */
if ((l=my_ismbchar(cs, s, s + cs->mbmaxlen)))
{
while (l--)
if (*s++ != *t++)
return 1;
}
else if (my_ci_charlen(cs, (const uchar *) t, (const uchar *) t + cs->mbmaxlen) > 1)
return 1;
else if (map[(uchar) *s++] != map[(uchar) *t++])
return 1;
}
/* At least one of '*s' and '*t' is zero here. */
return (*t != *s);
}
|
O3
|
c
|
my_strcasecmp_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x36617
cmpb $0x0, (%rbx)
je 0x36619
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %r12
movl 0x9c(%r14), %edx
addq %r15, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0xc0(%rax)
cmpl $0x2, %eax
jge 0x365dc
movl 0x9c(%r14), %edx
addq %rbx, %rdx
movq 0xb8(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xc0(%rax)
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
jg 0x36627
movzbl (%r15), %ecx
movb (%r12,%rcx), %cl
movzbl (%rbx), %edx
cmpb (%r12,%rdx), %cl
jne 0x36627
incq %r15
incq %rbx
jmp 0x36605
movl %eax, %eax
leaq (%r15,%rax), %rcx
leaq (%rbx,%rax), %rdx
xorl %esi, %esi
cmpl %esi, %eax
je 0x365ff
movb (%r15,%rsi), %dil
leaq 0x1(%rsi), %r8
cmpb (%rbx,%rsi), %dil
movq %r8, %rsi
je 0x365e8
jmp 0x36622
movq %rcx, %r15
movq %rdx, %rbx
movb (%r15), %cl
testb %cl, %cl
je 0x36617
cmpb $0x0, (%rbx)
jne 0x36578
jmp 0x36619
xorl %ecx, %ecx
xorl %eax, %eax
cmpb %cl, (%rbx)
setne %al
jmp 0x36627
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
my_strcasecmp_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov cl, [rsi]
test cl, cl
jz loc_36617
cmp byte ptr [rbx], 0
jz loc_36619
mov r15, rsi
mov r14, rdi
mov r12, [rdi+50h]
loc_36578:
mov edx, [r14+9Ch]
add rdx, r15
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, r15
call qword ptr [rax+0C0h]
cmp eax, 2
jge short loc_365DC
mov edx, [r14+9Ch]
add rdx, rbx
mov rax, [r14+0B8h]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+0C0h]
mov ecx, eax
mov eax, 1
cmp ecx, 1
jg short loc_36627
movzx ecx, byte ptr [r15]
mov cl, [r12+rcx]
movzx edx, byte ptr [rbx]
cmp cl, [r12+rdx]
jnz short loc_36627
inc r15
inc rbx
jmp short loc_36605
loc_365DC:
mov eax, eax
lea rcx, [r15+rax]
lea rdx, [rbx+rax]
xor esi, esi
loc_365E8:
cmp eax, esi
jz short loc_365FF
mov dil, [r15+rsi]
lea r8, [rsi+1]
cmp dil, [rbx+rsi]
mov rsi, r8
jz short loc_365E8
jmp short loc_36622
loc_365FF:
mov r15, rcx
mov rbx, rdx
loc_36605:
mov cl, [r15]
test cl, cl
jz short loc_36617
cmp byte ptr [rbx], 0
jnz loc_36578
jmp short loc_36619
loc_36617:
xor ecx, ecx
loc_36619:
xor eax, eax
cmp [rbx], cl
setnz al
jmp short loc_36627
loc_36622:
mov eax, 1
loc_36627:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
_BOOL8 my_strcasecmp_mb(long long a1, unsigned __int8 *a2, _BYTE *a3)
{
_BYTE *v3; // rbx
unsigned __int8 v4; // cl
unsigned __int8 *v5; // r15
long long v6; // r12
int v7; // eax
int v8; // ecx
_BOOL8 result; // rax
long long i; // rsi
v3 = a3;
v4 = *a2;
if ( *a2 )
{
if ( *a3 )
{
v5 = a2;
v6 = *(_QWORD *)(a1 + 80);
do
{
v7 = (*(long long ( **)(long long, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v5,
&v5[*(unsigned int *)(a1 + 156)]);
if ( v7 >= 2 )
{
for ( i = 0LL; v7 != (_DWORD)i; ++i )
{
if ( v5[i] != v3[i] )
return 1LL;
}
v5 += (unsigned int)v7;
v3 += (unsigned int)v7;
}
else
{
v8 = (*(long long ( **)(long long, _BYTE *, _BYTE *))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v3,
&v3[*(unsigned int *)(a1 + 156)]);
result = 1LL;
if ( v8 > 1 || *(_BYTE *)(v6 + *v5) != *(_BYTE *)(v6 + (unsigned __int8)*v3) )
return result;
++v5;
++v3;
}
v4 = *v5;
if ( !*v5 )
goto LABEL_16;
}
while ( *v3 );
}
}
else
{
LABEL_16:
v4 = 0;
}
return *v3 != v4;
}
|
my_strcasecmp_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV CL,byte ptr [RSI]
TEST CL,CL
JZ 0x00136617
CMP byte ptr [RBX],0x0
JZ 0x00136619
MOV R15,RSI
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x50]
LAB_00136578:
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,R15
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
JGE 0x001365dc
MOV EDX,dword ptr [R14 + 0x9c]
ADD RDX,RBX
MOV RAX,qword ptr [R14 + 0xb8]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0xc0]
MOV ECX,EAX
MOV EAX,0x1
CMP ECX,0x1
JG 0x00136627
MOVZX ECX,byte ptr [R15]
MOV CL,byte ptr [R12 + RCX*0x1]
MOVZX EDX,byte ptr [RBX]
CMP CL,byte ptr [R12 + RDX*0x1]
JNZ 0x00136627
INC R15
INC RBX
JMP 0x00136605
LAB_001365dc:
MOV EAX,EAX
LEA RCX,[R15 + RAX*0x1]
LEA RDX,[RBX + RAX*0x1]
XOR ESI,ESI
LAB_001365e8:
CMP EAX,ESI
JZ 0x001365ff
MOV DIL,byte ptr [R15 + RSI*0x1]
LEA R8,[RSI + 0x1]
CMP DIL,byte ptr [RBX + RSI*0x1]
MOV RSI,R8
JZ 0x001365e8
JMP 0x00136622
LAB_001365ff:
MOV R15,RCX
MOV RBX,RDX
LAB_00136605:
MOV CL,byte ptr [R15]
TEST CL,CL
JZ 0x00136617
CMP byte ptr [RBX],0x0
JNZ 0x00136578
JMP 0x00136619
LAB_00136617:
XOR ECX,ECX
LAB_00136619:
XOR EAX,EAX
CMP byte ptr [RBX],CL
SETNZ AL
JMP 0x00136627
LAB_00136622:
MOV EAX,0x1
LAB_00136627:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool my_strcasecmp_mb(long param_1,byte *param_2,byte *param_3)
{
byte *pbVar1;
byte *pbVar2;
long lVar3;
uint uVar4;
int iVar5;
byte bVar6;
byte *pbVar7;
long lVar8;
byte *pbVar9;
bVar6 = *param_2;
if (bVar6 == 0) {
LAB_00136617:
bVar6 = 0;
}
else if (*param_3 != 0) {
lVar3 = *(long *)(param_1 + 0x50);
pbVar7 = param_3;
do {
uVar4 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,param_2,param_2 + *(uint *)(param_1 + 0x9c));
if ((int)uVar4 < 2) {
iVar5 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,pbVar7,pbVar7 + *(uint *)(param_1 + 0x9c));
if (1 < iVar5) {
return true;
}
if (*(char *)(lVar3 + (ulong)*param_2) != *(char *)(lVar3 + (ulong)*pbVar7)) {
return true;
}
pbVar9 = param_2 + 1;
param_3 = pbVar7 + 1;
}
else {
pbVar9 = param_2 + uVar4;
param_3 = pbVar7 + uVar4;
lVar8 = 0;
while (uVar4 != (uint)lVar8) {
pbVar1 = param_2 + lVar8;
pbVar2 = pbVar7 + lVar8;
lVar8 = lVar8 + 1;
if (*pbVar1 != *pbVar2) {
return true;
}
}
}
bVar6 = *pbVar9;
if (bVar6 == 0) goto LAB_00136617;
pbVar7 = param_3;
param_2 = pbVar9;
} while (*param_3 != 0);
}
return *param_3 != bVar6;
}
|
|
58,579
|
expand_tilde
|
eloqsql/mysys/mf_pack.c
|
static char * expand_tilde(char **path)
{
if (path[0][0] == FN_LIBCHAR)
return home_dir; /* ~/ expanded to home */
#ifdef HAVE_GETPWNAM
{
char *str,save;
struct passwd *user_entry;
if (!(str=strchr(*path,FN_LIBCHAR)))
str=strend(*path);
save= *str; *str= '\0';
user_entry=getpwnam(*path);
*str=save;
endpwent();
if (user_entry)
{
*path=str;
return user_entry->pw_dir;
}
}
#endif
return (char *) 0;
}
|
O0
|
c
|
expand_tilde:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2d85e
leaq 0x355f56(%rip), %rax # 0x3837a8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d8df
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x240f0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2d889
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x75bf0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x241e0
movq %rax, -0x28(%rbp)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
callq 0x242c0
cmpq $0x0, -0x28(%rbp)
je 0x2d8d7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2d8df
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
expand_tilde:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_2D85E
lea rax, home_dir
mov rax, [rax]
mov [rbp+var_8], rax
jmp loc_2D8DF
loc_2D85E:
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 2Fh ; '/'
call _strchr
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2D889
mov rax, [rbp+var_10]
mov rdi, [rax]
call strend
mov [rbp+var_18], rax
loc_2D889:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rdi, [rax]
call _getpwnam
mov [rbp+var_28], rax
mov cl, [rbp+var_19]
mov rax, [rbp+var_18]
mov [rax], cl
call _endpwent
cmp [rbp+var_28], 0
jz short loc_2D8D7
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov [rbp+var_8], rax
jmp short loc_2D8DF
loc_2D8D7:
mov [rbp+var_8], 0
loc_2D8DF:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long expand_tilde(char **a1)
{
long long v2; // [rsp+8h] [rbp-28h]
char v3; // [rsp+17h] [rbp-19h]
char *v4; // [rsp+18h] [rbp-18h]
if ( **a1 == 47 )
return home_dir;
v4 = (char *)strchr(*a1, 47LL);
if ( !v4 )
v4 = (char *)strend(*a1);
v3 = *v4;
*v4 = 0;
v2 = getpwnam(*a1);
*v4 = v3;
endpwent();
if ( !v2 )
return 0LL;
*a1 = v4;
return *(_QWORD *)(v2 + 32);
}
|
expand_tilde:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0012d85e
LEA RAX,[0x4837a8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012d8df
LAB_0012d85e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2f
CALL 0x001240f0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012d889
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00175bf0
MOV qword ptr [RBP + -0x18],RAX
LAB_0012d889:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x001241e0
MOV qword ptr [RBP + -0x28],RAX
MOV CL,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
CALL 0x001242c0
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0012d8d7
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012d8df
LAB_0012d8d7:
MOV qword ptr [RBP + -0x8],0x0
LAB_0012d8df:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * expand_tilde(int8 *param_1)
{
char cVar1;
passwd *ppVar2;
char *local_20;
char *local_10;
if (*(char *)*param_1 == '/') {
local_10 = home_dir;
}
else {
local_20 = strchr((char *)*param_1,0x2f);
if (local_20 == (char *)0x0) {
local_20 = (char *)strend(*param_1);
}
cVar1 = *local_20;
*local_20 = '\0';
ppVar2 = getpwnam((char *)*param_1);
*local_20 = cVar1;
endpwent();
if (ppVar2 == (passwd *)0x0) {
local_10 = (char *)0x0;
}
else {
*param_1 = local_20;
local_10 = ppVar2->pw_dir;
}
}
return local_10;
}
|
|
58,580
|
clz64
|
bluesky950520[P]quickjs/tests/test_conv.c
|
static inline int clz64(uint64_t a)
{
#if defined(_MSC_VER) && !defined(__clang__)
#if INTPTR_MAX == INT64_MAX
unsigned long index;
_BitScanReverse64(&index, a);
return 63 - index;
#else
if (a >> 32)
return clz32((unsigned)(a >> 32));
else
return clz32((unsigned)a) + 32;
#endif
#else
return __builtin_clzll(a);
#endif
}
|
O0
|
c
|
clz64:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
retq
nopw %cs:(%rax,%rax)
|
clz64:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
bsr rax, rax
xor rax, 3Fh
retn
|
unsigned long long clz64(unsigned long long a1)
{
unsigned long long v1; // rax
_BitScanReverse64(&v1, a1);
return v1 ^ 0x3F;
}
|
clz64:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
BSR RAX,RAX
XOR RAX,0x3f
RET
|
ulong clz64(ulong param_1)
{
ulong uVar1;
uVar1 = 0x3f;
if (param_1 != 0) {
for (; param_1 >> uVar1 == 0; uVar1 = uVar1 - 1) {
}
}
return uVar1 ^ 0x3f;
}
|
|
58,581
|
mysql_handle_single_derived(LEX*, TABLE_LIST*, unsigned int)
|
eloqsql/sql/sql_derived.cc
|
bool
mysql_handle_single_derived(LEX *lex, TABLE_LIST *derived, uint phases)
{
bool res= FALSE;
uint8 allowed_phases= (derived->is_merged_derived() ? DT_PHASES_MERGE :
DT_PHASES_MATERIALIZE);
DBUG_ENTER("mysql_handle_single_derived");
DBUG_PRINT("enter", ("phases: 0x%x allowed: 0x%x alias: '%s'",
phases, allowed_phases,
(derived->alias.str ? derived->alias.str : "<NULL>")));
if (!lex->derived_tables)
DBUG_RETURN(FALSE);
if (derived->select_lex)
derived->select_lex->changed_elements|= TOUCHED_SEL_DERIVED;
else
DBUG_ASSERT(derived->prelocking_placeholder);
lex->thd->derived_tables_processing= TRUE;
for (uint phase= 0; phase < DT_PHASES; phase++)
{
uint phase_flag= DT_INIT << phase;
if (phase_flag > phases)
break;
if (!(phases & phase_flag))
continue;
/* Skip derived tables to which the phase isn't applicable. */
if (phase_flag != DT_PREPARE &&
!(allowed_phases & phase_flag))
continue;
if ((res= (*processors[phase])(lex->thd, lex, derived)))
break;
}
lex->thd->derived_tables_processing= FALSE;
DBUG_RETURN(res);
}
|
O0
|
cpp
|
mysql_handle_single_derived(LEX*, TABLE_LIST*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86ff10
movb %al, %dl
movl $0xe7, %eax
movl $0x9f, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0x1e(%rbp)
jmp 0x8a8b37
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1839(%rax)
jne 0x8a8b4f
jmp 0x8a8b46
movb $0x0, -0x1(%rbp)
jmp 0x8a8c33
movq -0x18(%rbp), %rax
cmpq $0x0, 0x190(%rax)
je 0x8a8b7a
movq -0x18(%rbp), %rax
movq 0x190(%rax), %rax
movzbl 0x415(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x415(%rax)
jmp 0x8a8b80
jmp 0x8a8b7c
jmp 0x8a8b7e
jmp 0x8a8b80
movq -0x10(%rbp), %rax
movq 0xde8(%rax), %rax
movb $0x1, 0x3fc7(%rax)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jae 0x8a8c19
movl -0x24(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x8a8bb6
jmp 0x8a8c19
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl $0x0, %eax
jne 0x8a8bc3
jmp 0x8a8c0e
cmpl $0x2, -0x28(%rbp)
je 0x8a8bd7
movzbl -0x1e(%rbp), %eax
andl -0x28(%rbp), %eax
cmpl $0x0, %eax
jne 0x8a8bd7
jmp 0x8a8c0e
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x12247cd(%rip), %rax # 0x1acd3b0
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq 0xde8(%rcx), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movb %al, %cl
andb $0x1, %cl
movb %cl, -0x1d(%rbp)
testb $0x1, %al
jne 0x8a8c0a
jmp 0x8a8c0c
jmp 0x8a8c19
jmp 0x8a8c0e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8a8b99
movq -0x10(%rbp), %rax
movq 0xde8(%rax), %rax
movb $0x0, 0x3fc7(%rax)
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
|
_Z27mysql_handle_single_derivedP3LEXP10TABLE_LISTj:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_1D], 0
mov rdi, [rbp+var_18]; this
call _ZNK10TABLE_LIST17is_merged_derivedEv; TABLE_LIST::is_merged_derived(void)
mov dl, al
mov eax, 0E7h
mov ecx, 9Fh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_1E], al
jmp short $+2
loc_8A8B37:
mov rax, [rbp+var_10]
cmp byte ptr [rax+1839h], 0
jnz short loc_8A8B4F
jmp short $+2
loc_8A8B46:
mov [rbp+var_1], 0
jmp loc_8A8C33
loc_8A8B4F:
mov rax, [rbp+var_18]
cmp qword ptr [rax+190h], 0
jz short loc_8A8B7A
mov rax, [rbp+var_18]
mov rax, [rax+190h]
movzx ecx, byte ptr [rax+415h]
or ecx, 2
mov [rax+415h], cl
jmp short loc_8A8B80
loc_8A8B7A:
jmp short $+2
loc_8A8B7C:
jmp short $+2
loc_8A8B7E:
jmp short $+2
loc_8A8B80:
mov rax, [rbp+var_10]
mov rax, [rax+0DE8h]
mov byte ptr [rax+3FC7h], 1
mov [rbp+var_24], 0
loc_8A8B99:
cmp [rbp+var_24], 8
jnb short loc_8A8C19
mov ecx, [rbp+var_24]
mov eax, 1
shl eax, cl
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jbe short loc_8A8BB6
jmp short loc_8A8C19
loc_8A8BB6:
mov eax, [rbp+var_1C]
and eax, [rbp+var_28]
cmp eax, 0
jnz short loc_8A8BC3
jmp short loc_8A8C0E
loc_8A8BC3:
cmp [rbp+var_28], 2
jz short loc_8A8BD7
movzx eax, [rbp+var_1E]
and eax, [rbp+var_28]
cmp eax, 0
jnz short loc_8A8BD7
jmp short loc_8A8C0E
loc_8A8BD7:
mov eax, [rbp+var_24]
mov ecx, eax
lea rax, processors
mov rax, (processors - 1ACD3B0h)[rax+rcx*8]
mov rcx, [rbp+var_10]
mov rdi, [rcx+0DE8h]; THD *
mov rsi, [rbp+var_10]; LEX *
mov rdx, [rbp+var_18]; TABLE_LIST *
call rax; mysql_derived_init(THD *,LEX *,TABLE_LIST *)
mov cl, al
and cl, 1
mov [rbp+var_1D], cl
test al, 1
jnz short loc_8A8C0A
jmp short loc_8A8C0C
loc_8A8C0A:
jmp short loc_8A8C19
loc_8A8C0C:
jmp short $+2
loc_8A8C0E:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_8A8B99
loc_8A8C19:
mov rax, [rbp+var_10]
mov rax, [rax+0DE8h]
mov byte ptr [rax+3FC7h], 0
mov al, [rbp+var_1D]
and al, 1
mov [rbp+var_1], al
loc_8A8C33:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
|
char mysql_handle_single_derived(LEX *a1, TABLE_LIST *a2, unsigned int a3)
{
bool is_merged_derived; // dl
char v4; // al
int v6; // [rsp+8h] [rbp-28h]
unsigned int i; // [rsp+Ch] [rbp-24h]
char v8; // [rsp+12h] [rbp-1Eh]
char v9; // [rsp+13h] [rbp-1Dh]
v9 = 0;
is_merged_derived = TABLE_LIST::is_merged_derived(a2);
v4 = -25;
if ( is_merged_derived )
v4 = -97;
v8 = v4;
if ( !*((_BYTE *)a1 + 6201) )
return 0;
if ( *((_QWORD *)a2 + 50) )
*(_BYTE *)(*((_QWORD *)a2 + 50) + 1045LL) |= 2u;
*(_BYTE *)(*((_QWORD *)a1 + 445) + 16327LL) = 1;
for ( i = 0; i < 8; ++i )
{
v6 = 1 << i;
if ( 1 << i > a3 )
break;
if ( (v6 & a3) != 0 && (v6 == 2 || ((unsigned __int8)v6 & (unsigned __int8)v8) != 0) )
{
v9 = processors[i](*((THD **)a1 + 445), a1, a2) & 1;
if ( v9 )
break;
}
}
*(_BYTE *)(*((_QWORD *)a1 + 445) + 16327LL) = 0;
return v9 & 1;
}
|
__cxx_global_var_init.8:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x264a9c0]
MOV ESI,0x1800000
CALL 0x008db900
POP RBP
RET
|
void __cxx_global_var_init_8(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_NO_ZEROS,0x1800000);
return;
}
|
|
58,582
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29])
|
ngxson[P]ggml-easy/ggml-easy.h
|
void debug_print(ggml_tensor * t, Params&&... params) {
std::string name = string_format(std::forward<Params>(params)...);
if (t->flags) {
// prevent renaming input/output tensor name by accident
t = ggml_cpy(gf_ctx, t, ggml_dup_tensor(gf_ctx, t));
}
mark_output(t, name.c_str());
printed_tensors.push_back({t, false});
}
|
O0
|
c
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29]):
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movb $0x0, %al
callq 0xbfd0
movq 0x78(%rsp), %rax
cmpl $0x0, 0x94(%rax)
je 0x22519
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x10(%rsp)
movq 0x78(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0xa4d0
movq %rax, 0x20(%rsp)
jmp 0x224d8
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xa710
movq %rax, 0x8(%rsp)
jmp 0x224f3
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x22519
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xa380
jmp 0x22575
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0xa220
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x22080
jmp 0x2253f
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x22800
jmp 0x22563
leaq 0x50(%rsp), %rdi
callq 0xa380
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xa930
nop
|
_ZN9ggml_easy3ctx11build_utils11debug_printIJRA19_KcEEEvP11ggml_tensorDpOT_:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_60], rax
mov rsi, [rsp+88h+var_18]
lea rdi, [rsp+88h+var_38]
mov al, 0
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
mov rax, [rsp+88h+var_10]
cmp dword ptr [rax+94h], 0
jz short loc_22519
mov rax, [rsp+88h+var_60]
mov rdi, [rax]
mov [rsp+88h+var_78], rdi
mov rsi, [rsp+88h+var_10]
mov [rsp+88h+var_70], rsi
call _ggml_dup_tensor
mov [rsp+88h+var_68], rax
jmp short $+2
loc_224D8:
mov rdx, [rsp+88h+var_68]
mov rsi, [rsp+88h+var_70]
mov rdi, [rsp+88h+var_78]
call _ggml_cpy
mov [rsp+88h+var_80], rax
jmp short $+2
loc_224F3:
mov rax, [rsp+88h+var_80]
mov [rsp+88h+var_10], rax
jmp short loc_22519
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_22575
loc_22519:
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_88], rax
lea rdi, [rsp+88h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+88h+var_60]
mov rsi, [rsp+88h+var_88]
mov rdx, rax
call _ZN9ggml_easy3ctx11build_utils11mark_outputEP11ggml_tensorPKc; ggml_easy::ctx::build_utils::mark_output(ggml_tensor *,char const*)
jmp short $+2
loc_2253F:
mov rdi, [rsp+88h+var_60]
add rdi, 10h
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_58], rax
mov [rsp+88h+var_50], 0
lea rsi, [rsp+88h+var_58]
call _ZNSt6vectorIN9ggml_easy3ctx14printed_tensorESaIS2_EE9push_backEOS2_; std::vector<ggml_easy::ctx::printed_tensor>::push_back(ggml_easy::ctx::printed_tensor&&)
jmp short $+2
loc_22563:
lea rdi, [rsp+88h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
add rsp, 88h
retn
loc_22575:
mov rdi, [rsp+arg_40]
call __Unwind_Resume
|
long long ggml_easy::ctx::build_utils::debug_print<char const(&)[19]>(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rax
char v16; // [rsp+0h] [rbp-88h]
long long v17; // [rsp+0h] [rbp-88h]
long long v18; // [rsp+10h] [rbp-78h]
long long v19; // [rsp+18h] [rbp-70h]
long long v20; // [rsp+20h] [rbp-68h]
long long v21; // [rsp+30h] [rbp-58h] BYREF
char v22; // [rsp+38h] [rbp-50h]
_BYTE v23[32]; // [rsp+50h] [rbp-38h] BYREF
long long v24; // [rsp+70h] [rbp-18h]
long long v25; // [rsp+78h] [rbp-10h]
_QWORD *v26; // [rsp+80h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
ggml_easy::string_format[abi:cxx11]((long long)v23, a3, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v16);
if ( *(_DWORD *)(v25 + 148) )
{
v18 = *a1;
v19 = v25;
v20 = ggml_dup_tensor();
v25 = ggml_cpy(v18, v19, v20);
}
v17 = v25;
v14 = std::string::c_str(v23);
ggml_easy::ctx::build_utils::mark_output((long long)a1, v17, v14);
v21 = v25;
v22 = 0;
std::vector<ggml_easy::ctx::printed_tensor>::push_back(a1 + 2, &v21);
return std::string::~string(v23);
}
|
debug_print<char_const(&)[19]>:
SUB RSP,0x88
MOV qword ptr [RSP + 0x80],RDI
MOV qword ptr [RSP + 0x78],RSI
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,qword ptr [RSP + 0x70]
LEA RDI,[RSP + 0x50]
MOV AL,0x0
CALL 0x0010bfd0
MOV RAX,qword ptr [RSP + 0x78]
CMP dword ptr [RAX + 0x94],0x0
JZ 0x00122519
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RDI
MOV RSI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x18],RSI
LAB_001224cc:
CALL 0x0010a4d0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001224d8
LAB_001224d8:
MOV RDX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0010a710
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001224f3
LAB_001224f3:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x78],RAX
JMP 0x00122519
LAB_00122519:
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x50]
CALL 0x0010a220
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP]
MOV RDX,RAX
CALL 0x00122080
JMP 0x0012253f
LAB_0012253f:
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x10
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x30],RAX
MOV byte ptr [RSP + 0x38],0x0
LEA RSI,[RSP + 0x30]
CALL 0x00122800
LAB_00122561:
JMP 0x00122563
LAB_00122563:
LEA RDI,[RSP + 0x50]
CALL 0x0010a380
ADD RSP,0x88
RET
|
/* void ggml_easy::ctx::build_utils::debug_print<char const (&) [19]>(ggml_tensor*, char const (&)
[19]) */
void __thiscall
ggml_easy::ctx::build_utils::debug_print<char_const(&)[19]>
(build_utils *this,ggml_tensor *param_1,char *param_2)
{
int8 uVar1;
ggml_tensor *pgVar2;
int8 uVar3;
char *pcVar4;
ggml_tensor *local_58;
int1 local_50;
string local_38 [32];
char *local_18;
ggml_tensor *local_10;
build_utils *local_8;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
string_format_abi_cxx11_((char *)local_38,param_2);
pgVar2 = local_10;
if (*(int *)(local_10 + 0x94) != 0) {
uVar1 = *(int8 *)this;
/* try { // try from 001224cc to 00122560 has its CatchHandler @ 001224ff */
uVar3 = ggml_dup_tensor();
local_10 = (ggml_tensor *)ggml_cpy(uVar1,pgVar2,uVar3);
}
pgVar2 = local_10;
pcVar4 = (char *)std::__cxx11::string::c_str();
mark_output(this,pgVar2,pcVar4);
local_58 = local_10;
local_50 = 0;
std::vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>>::
push_back((vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>> *
)(this + 0x10),(printed_tensor *)&local_58);
std::__cxx11::string::~string(local_38);
return;
}
|
|
58,583
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29])
|
ngxson[P]ggml-easy/ggml-easy.h
|
void debug_print(ggml_tensor * t, Params&&... params) {
std::string name = string_format(std::forward<Params>(params)...);
if (t->flags) {
// prevent renaming input/output tensor name by accident
t = ggml_cpy(gf_ctx, t, ggml_dup_tensor(gf_ctx, t));
}
mark_output(t, name.c_str());
printed_tensors.push_back({t, false});
}
|
O1
|
c
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29]):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
xorl %eax, %eax
callq 0x5b89
cmpl $0x0, 0x94(%r14)
je 0xc211
movq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4410
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4610
movq %rax, %r14
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbe94
movq %r14, (%rsp)
movb $0x0, 0x8(%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0xc242
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x18(%rbx)
jmp 0xc251
addq $0x10, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xc372
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc26c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4450
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc278
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc296
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4450
movq %rbx, %rdi
callq 0x47f0
|
_ZN9ggml_easy3ctx11build_utils11debug_printIJRA9_KcEEEvP11ggml_tensorDpOT_:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
mov rsi, rdx
xor eax, eax
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
cmp dword ptr [r14+94h], 0
jz short loc_C211
mov r15, [rbx]
mov rdi, r15
mov rsi, r14
call _ggml_dup_tensor
mov rdi, r15
mov rsi, r14
mov rdx, rax
call _ggml_cpy
mov r14, rax
loc_C211:
mov rdx, [rsp+48h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZN9ggml_easy3ctx11build_utils11mark_outputEP11ggml_tensorPKc; ggml_easy::ctx::build_utils::mark_output(ggml_tensor *,char const*)
mov qword ptr [rsp+48h+var_48], r14
mov byte ptr [rsp+48h+var_48+8], 0
mov rsi, [rbx+18h]
cmp rsi, [rbx+20h]
jz short loc_C242
movups xmm0, [rsp+48h+var_48]
movups xmmword ptr [rsi], xmm0
add qword ptr [rbx+18h], 10h
jmp short loc_C251
loc_C242:
add rbx, 10h
mov rdx, rsp
mov rdi, rbx
call _ZNSt6vectorIN9ggml_easy3ctx14printed_tensorESaIS2_EE17_M_realloc_insertIJS2_EEEvN9__gnu_cxx17__normal_iteratorIPS2_S4_EEDpOT_; std::vector<ggml_easy::ctx::printed_tensor>::_M_realloc_insert<ggml_easy::ctx::printed_tensor>(__gnu_cxx::__normal_iterator<ggml_easy::ctx::printed_tensor*,std::vector<ggml_easy::ctx::printed_tensor>>,ggml_easy::ctx::printed_tensor &&)
loc_C251:
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C26C
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C26C:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_C278:
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C296
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C296:
mov rdi, rbx
call __Unwind_Resume
|
void ggml_easy::ctx::build_utils::debug_print<char const(&)[9]>(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // r14
long long v15; // r15
long long v16; // rax
_OWORD *v17; // rsi
__int128 v18; // [rsp+0h] [rbp-48h] BYREF
long long *v19; // [rsp+10h] [rbp-38h] BYREF
long long v20; // [rsp+20h] [rbp-28h] BYREF
v14 = a2;
ggml_easy::string_format[abi:cxx11](&v19, a3, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
if ( *(_DWORD *)(a2 + 148) )
{
v15 = *a1;
v16 = ggml_dup_tensor(*a1, a2);
v14 = ggml_cpy(v15, a2, v16);
}
ggml_easy::ctx::build_utils::mark_output((long long)a1, v14, (long long)v19);
*(_QWORD *)&v18 = v14;
BYTE8(v18) = 0;
v17 = (_OWORD *)a1[3];
if ( v17 == (_OWORD *)a1[4] )
{
std::vector<ggml_easy::ctx::printed_tensor>::_M_realloc_insert<ggml_easy::ctx::printed_tensor>(a1 + 2, v17, &v18);
}
else
{
*v17 = v18;
a1[3] += 16LL;
}
if ( v19 != &v20 )
operator delete(v19, v20 + 1);
}
|
debug_print<char_const(&)[9]>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
MOV RSI,RDX
XOR EAX,EAX
CALL 0x00105b89
CMP dword ptr [R14 + 0x94],0x0
JZ 0x0010c211
MOV R15,qword ptr [RBX]
LAB_0010c1f5:
MOV RDI,R15
MOV RSI,R14
CALL 0x00104410
MOV RDI,R15
MOV RSI,R14
MOV RDX,RAX
CALL 0x00104610
MOV R14,RAX
LAB_0010c211:
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010be94
MOV qword ptr [RSP],R14
MOV byte ptr [RSP + 0x8],0x0
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,qword ptr [RBX + 0x20]
JZ 0x0010c242
MOVUPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RSI],XMM0
ADD qword ptr [RBX + 0x18],0x10
JMP 0x0010c251
LAB_0010c242:
ADD RBX,0x10
LAB_0010c246:
MOV RDX,RSP
MOV RDI,RBX
CALL 0x0010c372
LAB_0010c251:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0010c26c
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00104450
LAB_0010c26c:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* void ggml_easy::ctx::build_utils::debug_print<char const (&) [9]>(ggml_tensor*, char const (&)
[9]) */
void __thiscall
ggml_easy::ctx::build_utils::debug_print<char_const(&)[9]>
(build_utils *this,ggml_tensor *param_1,char *param_2)
{
int8 uVar1;
int8 *puVar2;
int8 uVar3;
ggml_tensor *local_48;
int1 uStack_40;
uint7 uStack_3f;
long *local_38 [2];
long local_28 [2];
string_format_abi_cxx11_((char *)local_38,param_2);
if (*(int *)(param_1 + 0x94) != 0) {
uVar1 = *(int8 *)this;
/* try { // try from 0010c1f5 to 0010c220 has its CatchHandler @ 0010c278 */
uVar3 = ggml_dup_tensor(uVar1,param_1);
param_1 = (ggml_tensor *)ggml_cpy(uVar1,param_1,uVar3);
}
mark_output(this,param_1,(char *)local_38[0]);
uStack_40 = 0;
puVar2 = *(int8 **)(this + 0x18);
local_48 = param_1;
if (puVar2 == *(int8 **)(this + 0x20)) {
/* try { // try from 0010c246 to 0010c250 has its CatchHandler @ 0010c276 */
std::vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>>::
_M_realloc_insert<ggml_easy::ctx::printed_tensor>
((vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>>
*)(this + 0x10),puVar2,&local_48);
}
else {
*puVar2 = param_1;
puVar2[1] = (ulong)uStack_3f << 8;
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 0x10;
}
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
return;
}
|
|
58,584
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29])
|
ngxson[P]ggml-easy/ggml-easy.h
|
void debug_print(ggml_tensor * t, Params&&... params) {
std::string name = string_format(std::forward<Params>(params)...);
if (t->flags) {
// prevent renaming input/output tensor name by accident
t = ggml_cpy(gf_ctx, t, ggml_dup_tensor(gf_ctx, t));
}
mark_output(t, name.c_str());
printed_tensors.push_back({t, false});
}
|
O3
|
c
|
void ggml_easy::ctx::build_utils::debug_print<char const (&) [29]>(ggml_tensor*, char const (&) [29]):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
xorl %eax, %eax
callq 0x5be1
cmpl $0x0, 0x94(%r14)
je 0xc2a3
movq (%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4410
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4610
movq %rax, %r14
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbf26
movq %r14, (%rsp)
movb $0x0, 0x8(%rsp)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0xc2d4
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x18(%rbx)
jmp 0xc2e3
addq $0x10, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xc404
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc2fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4450
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc30a
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc328
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4450
movq %rbx, %rdi
callq 0x47f0
|
_ZN9ggml_easy3ctx11build_utils11debug_printIJRA9_KcEEEvP11ggml_tensorDpOT_:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
mov rsi, rdx
xor eax, eax
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
cmp dword ptr [r14+94h], 0
jz short loc_C2A3
mov r15, [rbx]
mov rdi, r15
mov rsi, r14
call _ggml_dup_tensor
mov rdi, r15
mov rsi, r14
mov rdx, rax
call _ggml_cpy
mov r14, rax
loc_C2A3:
mov rdx, [rsp+48h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZN9ggml_easy3ctx11build_utils11mark_outputEP11ggml_tensorPKc; ggml_easy::ctx::build_utils::mark_output(ggml_tensor *,char const*)
mov qword ptr [rsp+48h+var_48], r14
mov byte ptr [rsp+48h+var_48+8], 0
mov rsi, [rbx+18h]
cmp rsi, [rbx+20h]
jz short loc_C2D4
movups xmm0, [rsp+48h+var_48]
movups xmmword ptr [rsi], xmm0
add qword ptr [rbx+18h], 10h
jmp short loc_C2E3
loc_C2D4:
add rbx, 10h
mov rdx, rsp
mov rdi, rbx
call _ZNSt6vectorIN9ggml_easy3ctx14printed_tensorESaIS2_EE17_M_realloc_insertIJS2_EEEvN9__gnu_cxx17__normal_iteratorIPS2_S4_EEDpOT_; std::vector<ggml_easy::ctx::printed_tensor>::_M_realloc_insert<ggml_easy::ctx::printed_tensor>(__gnu_cxx::__normal_iterator<ggml_easy::ctx::printed_tensor*,std::vector<ggml_easy::ctx::printed_tensor>>,ggml_easy::ctx::printed_tensor &&)
loc_C2E3:
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C2FE
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C2FE:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_C30A:
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C328
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C328:
mov rdi, rbx
call __Unwind_Resume
|
void ggml_easy::ctx::build_utils::debug_print<char const(&)[9]>(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // r14
long long v15; // r15
long long v16; // rax
_OWORD *v17; // rsi
__int128 v18; // [rsp+0h] [rbp-48h] BYREF
long long *v19; // [rsp+10h] [rbp-38h] BYREF
long long v20; // [rsp+20h] [rbp-28h] BYREF
v14 = a2;
ggml_easy::string_format[abi:cxx11](&v19, a3, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
if ( *(_DWORD *)(a2 + 148) )
{
v15 = *a1;
v16 = ggml_dup_tensor(*a1, a2);
v14 = ggml_cpy(v15, a2, v16);
}
ggml_easy::ctx::build_utils::mark_output((long long)a1, v14, (long long)v19);
*(_QWORD *)&v18 = v14;
BYTE8(v18) = 0;
v17 = (_OWORD *)a1[3];
if ( v17 == (_OWORD *)a1[4] )
{
std::vector<ggml_easy::ctx::printed_tensor>::_M_realloc_insert<ggml_easy::ctx::printed_tensor>(a1 + 2, v17, &v18);
}
else
{
*v17 = v18;
a1[3] += 16LL;
}
if ( v19 != &v20 )
operator delete(v19, v20 + 1);
}
|
debug_print<char_const(&)[9]>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
MOV RSI,RDX
XOR EAX,EAX
CALL 0x00105be1
CMP dword ptr [R14 + 0x94],0x0
JZ 0x0010c2a3
MOV R15,qword ptr [RBX]
LAB_0010c287:
MOV RDI,R15
MOV RSI,R14
CALL 0x00104410
MOV RDI,R15
MOV RSI,R14
MOV RDX,RAX
CALL 0x00104610
MOV R14,RAX
LAB_0010c2a3:
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010bf26
MOV qword ptr [RSP],R14
MOV byte ptr [RSP + 0x8],0x0
MOV RSI,qword ptr [RBX + 0x18]
CMP RSI,qword ptr [RBX + 0x20]
JZ 0x0010c2d4
MOVUPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RSI],XMM0
ADD qword ptr [RBX + 0x18],0x10
JMP 0x0010c2e3
LAB_0010c2d4:
ADD RBX,0x10
LAB_0010c2d8:
MOV RDX,RSP
MOV RDI,RBX
CALL 0x0010c404
LAB_0010c2e3:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0010c2fe
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x00104450
LAB_0010c2fe:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* void ggml_easy::ctx::build_utils::debug_print<char const (&) [9]>(ggml_tensor*, char const (&)
[9]) */
void __thiscall
ggml_easy::ctx::build_utils::debug_print<char_const(&)[9]>
(build_utils *this,ggml_tensor *param_1,char *param_2)
{
int8 uVar1;
int8 *puVar2;
int8 uVar3;
ggml_tensor *local_48;
int1 uStack_40;
uint7 uStack_3f;
long *local_38 [2];
long local_28 [2];
string_format_abi_cxx11_((char *)local_38,param_2);
if (*(int *)(param_1 + 0x94) != 0) {
uVar1 = *(int8 *)this;
/* try { // try from 0010c287 to 0010c2b2 has its CatchHandler @ 0010c30a */
uVar3 = ggml_dup_tensor(uVar1,param_1);
param_1 = (ggml_tensor *)ggml_cpy(uVar1,param_1,uVar3);
}
mark_output(this,param_1,(char *)local_38[0]);
uStack_40 = 0;
puVar2 = *(int8 **)(this + 0x18);
local_48 = param_1;
if (puVar2 == *(int8 **)(this + 0x20)) {
/* try { // try from 0010c2d8 to 0010c2e2 has its CatchHandler @ 0010c308 */
std::vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>>::
_M_realloc_insert<ggml_easy::ctx::printed_tensor>
((vector<ggml_easy::ctx::printed_tensor,std::allocator<ggml_easy::ctx::printed_tensor>>
*)(this + 0x10),puVar2,&local_48);
}
else {
*puVar2 = param_1;
puVar2[1] = (ulong)uStack_3f << 8;
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 0x10;
}
if (local_38[0] != local_28) {
operator_delete(local_38[0],local_28[0] + 1);
}
return;
}
|
|
58,585
|
my_getcputime
|
eloqsql/mysys/my_getsystime.c
|
ulonglong my_getcputime()
{
#ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec tp;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#elif defined(__NR_clock_gettime)
struct timespec tp;
if (syscall(__NR_clock_gettime, CLOCK_THREAD_CPUTIME_ID, &tp))
return 0;
return (ulonglong)tp.tv_sec*10000000+(ulonglong)tp.tv_nsec/100;
#endif /* CLOCK_THREAD_CPUTIME_ID */
return 0;
}
|
O3
|
c
|
my_getcputime:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x292d0
testl %eax, %eax
je 0x9fa24
xorl %eax, %eax
jmp 0x9fa4b
imulq $0x989680, -0x10(%rbp), %rcx # imm = 0x989680
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
movq %rdx, %rax
shrq $0x2, %rax
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
my_getcputime:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rsi, [rbp+var_10]
mov edi, 3
call _clock_gettime
test eax, eax
jz short loc_9FA24
xor eax, eax
jmp short loc_9FA4B
loc_9FA24:
imul rcx, [rbp+var_10], 989680h
mov rax, [rbp+var_8]
shr rax, 2
mov rdx, 28F5C28F5C28F5C3h
mul rdx
mov rax, rdx
shr rax, 2
add rax, rcx
loc_9FA4B:
add rsp, 10h
pop rbp
retn
|
unsigned long long my_getcputime()
{
long long v1; // [rsp+0h] [rbp-10h] BYREF
unsigned long long v2; // [rsp+8h] [rbp-8h]
if ( (unsigned int)clock_gettime(3LL, &v1) )
return 0LL;
else
return 10000000 * v1 + v2 / 0x64;
}
|
my_getcputime:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RSI,[RBP + -0x10]
MOV EDI,0x3
CALL 0x001292d0
TEST EAX,EAX
JZ 0x0019fa24
XOR EAX,EAX
JMP 0x0019fa4b
LAB_0019fa24:
IMUL RCX,qword ptr [RBP + -0x10],0x989680
MOV RAX,qword ptr [RBP + -0x8]
SHR RAX,0x2
MOV RDX,0x28f5c28f5c28f5c3
MUL RDX
MOV RAX,RDX
SHR RAX,0x2
ADD RAX,RCX
LAB_0019fa4b:
ADD RSP,0x10
POP RBP
RET
|
long my_getcputime(void)
{
int iVar1;
long lVar2;
timespec local_18;
iVar1 = clock_gettime(3,&local_18);
if (iVar1 == 0) {
lVar2 = (ulong)local_18.tv_nsec / 100 + local_18.tv_sec * 10000000;
}
else {
lVar2 = 0;
}
return lVar2;
}
|
|
58,586
|
gguf_writer::write(char const*) const
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void write(const char * val) const {
write(std::string(val));
}
|
O1
|
cpp
|
gguf_writer::write(char const*) const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x17d00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18210
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41eb6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17080
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41edc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17080
movq %rbx, %rdi
callq 0x17e30
|
_ZNK11gguf_writer5writeEPKc:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
mov rsi, r14
call __ZNK11gguf_writer5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; gguf_writer::write(std::string const&)
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_41EB6
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41EB6:
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_41EDC
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41EDC:
mov rdi, rbx
call __Unwind_Resume
|
void gguf_writer::write(gguf_writer *this, const char *a2)
{
char v2; // [rsp+7h] [rbp-31h] BYREF
void *v3[2]; // [rsp+8h] [rbp-30h] BYREF
long long v4; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(v3, a2, &v2);
gguf_writer::write(this, v3);
if ( v3[0] != &v4 )
operator delete(v3[0], v4 + 1);
}
|
write:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x00117d00
LAB_00141e90:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00118210
LAB_00141e9b:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00141eb6
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00117080
LAB_00141eb6:
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* gguf_writer::write(char const*) const */
void __thiscall gguf_writer::write(gguf_writer *this,char *param_1)
{
allocator local_31;
long *local_30 [2];
long local_20 [2];
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 00141e90 to 00141e9a has its CatchHandler @ 00141ebe */
write(this,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return;
}
|
|
58,587
|
Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long)
|
AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp
|
std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
}
|
O3
|
cpp
|
Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x5e2c8
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x17130
cmpq $0x100, %r14 # imm = 0x100
jb 0x584a8
movq 0x18(%rsp), %rdi
leaq 0x84dd4(%rip), %rsi # 0xdd239
movl $0x4, %edx
callq 0x17be0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movq %r14, %rsi
callq 0x17130
movq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rsi
movb $0x29, (%rsi)
movl $0x1, %edx
callq 0x17be0
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x17c70
leaq 0x10(%rsp), %rdi
callq 0x5e2f4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x584d2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5e2f4
movq %rbx, %rdi
callq 0x17740
nop
|
_ZN5Catch11StringMakerIyvE7convertB5cxx11Ey:
push r15
push r14
push rbx
sub rsp, 20h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+38h+var_28]
mov rdi, r15; this
call _ZN5Catch20ReusableStringStreamC2Ev; Catch::ReusableStringStream::ReusableStringStream(void)
mov rdi, [r15+8]
mov rsi, r14
call __ZNSo9_M_insertIyEERSoT_; std::ostream::_M_insert<ulong long>(ulong long)
cmp r14, 100h
jb short loc_584A8
mov rdi, [rsp+38h+var_20]
lea rsi, a0x; " (0x"
mov edx, 4
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+38h+var_20]
mov rax, [rdi]
mov rax, [rax-18h]
mov ecx, [rdi+rax+18h]
and ecx, 0FFFFFFB5h
or ecx, 8
mov [rdi+rax+18h], ecx
mov rsi, r14
call __ZNSo9_M_insertIyEERSoT_; std::ostream::_M_insert<ulong long>(ulong long)
mov rdi, [rsp+38h+var_20]
lea rsi, [rsp+38h+var_29]
mov byte ptr [rsi], 29h ; ')'
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_584A8:
mov rsi, [rsp+38h+var_20]
add rsi, 8
mov rdi, rbx
call __ZNKRSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+38h+var_28]; this
call _ZN5Catch20ReusableStringStreamD2Ev; Catch::ReusableStringStream::~ReusableStringStream()
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
jmp short $+2
loc_584D2:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN5Catch20ReusableStringStreamD2Ev; Catch::ReusableStringStream::~ReusableStringStream()
mov rdi, rbx
call __Unwind_Resume
|
long long Catch::StringMaker<unsigned long long,void>::convert[abi:cxx11](
long long a1,
unsigned long long a2,
double a3)
{
_QWORD *v4; // rdi
char v6; // [rsp+Fh] [rbp-29h] BYREF
_BYTE v7[8]; // [rsp+10h] [rbp-28h] BYREF
_QWORD *v8; // [rsp+18h] [rbp-20h]
Catch::ReusableStringStream::ReusableStringStream((Catch::ReusableStringStream *)v7);
std::ostream::_M_insert<unsigned long long>(v8, a2);
if ( a2 >= 0x100 )
{
std::__ostream_insert<char,std::char_traits<char>>(v8, " (0x", 4LL);
v4 = v8;
*(_DWORD *)((char *)v8 + *(_QWORD *)(*v8 - 24LL) + 24) = *(_DWORD *)((_BYTE *)v8 + *(_QWORD *)(*v8 - 24LL) + 24) & 0xFFFFFFB5 | 8;
std::ostream::_M_insert<unsigned long long>(v4, a2);
v6 = 41;
std::__ostream_insert<char,std::char_traits<char>>(v8, &v6, 1LL);
}
std::stringbuf::str(a1, v8 + 1, a3);
Catch::ReusableStringStream::~ReusableStringStream((Catch::ReusableStringStream *)v7);
return a1;
}
|
convert[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV RDI,R15
CALL 0x0015e2c8
MOV RDI,qword ptr [R15 + 0x8]
LAB_00158448:
MOV RSI,R14
CALL 0x00117130
CMP R14,0x100
JC 0x001584a8
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x1dd239]
MOV EDX,0x4
CALL 0x00117be0
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + -0x18]
MOV ECX,dword ptr [RDI + RAX*0x1 + 0x18]
AND ECX,0xffffffb5
OR ECX,0x8
MOV dword ptr [RDI + RAX*0x1 + 0x18],ECX
MOV RSI,R14
CALL 0x00117130
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],0x29
LAB_0015849e:
MOV EDX,0x1
CALL 0x00117be0
LAB_001584a8:
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,0x8
LAB_001584b1:
MOV RDI,RBX
CALL 0x00117c70
LAB_001584b9:
LEA RDI,[RSP + 0x10]
CALL 0x0015e2f4
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long) */
StringMaker<unsigned_long_long,void> * __thiscall
Catch::StringMaker<unsigned_long_long,void>::convert_abi_cxx11_
(StringMaker<unsigned_long_long,void> *this,ulonglong param_1)
{
char local_29;
ReusableStringStream local_28 [8];
ostream *local_20;
ReusableStringStream::ReusableStringStream(local_28);
/* try { // try from 00158448 to 00158490 has its CatchHandler @ 001584d2 */
std::ostream::_M_insert<unsigned_long_long>((ulonglong)local_20);
if (0xff < param_1) {
std::__ostream_insert<char,std::char_traits<char>>(local_20," (0x",4);
*(uint *)(local_20 + *(long *)(*(long *)local_20 + -0x18) + 0x18) =
*(uint *)(local_20 + *(long *)(*(long *)local_20 + -0x18) + 0x18) & 0xffffffb5 | 8;
std::ostream::_M_insert<unsigned_long_long>((ulonglong)local_20);
local_29 = ')';
/* try { // try from 0015849e to 001584a7 has its CatchHandler @ 001584d0 */
std::__ostream_insert<char,std::char_traits<char>>(local_20,&local_29,1);
}
/* try { // try from 001584b1 to 001584b8 has its CatchHandler @ 001584d2 */
std::__cxx11::stringbuf::str();
ReusableStringStream::~ReusableStringStream(local_28);
return this;
}
|
|
58,588
|
wait_for_lock
|
eloqsql/mysys/thr_lock.c
|
static enum enum_thr_lock_result
wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
my_bool in_wait_list, ulong lock_wait_timeout)
{
struct st_my_thread_var *thread_var= my_thread_var;
mysql_cond_t *cond= &thread_var->suspend;
struct timespec wait_timeout;
enum enum_thr_lock_result result= THR_LOCK_ABORTED;
PSI_stage_info old_stage;
my_bool use_wait_callbacks= FALSE;
DBUG_ENTER("wait_for_lock");
/*
One can use this to signal when a thread is going to wait for a lock.
See debug_sync.cc.
Beware of waiting for a signal here. The lock has acquired its mutex.
While waiting on a signal here, the locking thread could not acquire
the mutex to release the lock. One could lock up the table
completely.
In detail it works so: When thr_lock() tries to acquire a table
lock, it locks the lock->mutex, checks if it can have the lock, and
if not, it calls wait_for_lock(). Here it unlocks the table lock
while waiting on a condition. The sync point is located before this
wait for condition. If we have a waiting action here, we hold the
the table locks mutex all the time. Any attempt to look at the table
lock by another thread blocks it immediately on lock->mutex. This
can easily become an unexpected and unobvious blockage. So be
warned: Do not request a WAIT_FOR action for the 'wait_for_lock'
sync point unless you really know what you do.
*/
DEBUG_SYNC_C("wait_for_lock");
if (!in_wait_list)
{
(*wait->last)=data; /* Wait for lock */
data->prev= wait->last;
wait->last= &data->next;
}
statistic_increment(locks_waited, &THR_LOCK_lock);
/* Set up control struct to allow others to abort locks */
thread_var->current_mutex= &data->lock->mutex;
thread_var->current_cond= cond;
data->cond= cond;
proc_info_hook(NULL, &stage_waiting_for_table_level_lock,
&old_stage,
__func__, __FILE__, __LINE__);
/*
Since before_lock_wait potentially can create more threads to
scheduler work for, we don't want to call the before_lock_wait
callback unless it will really start to wait.
For similar reasons, we do not want to call before_lock_wait and
after_lock_wait for each lap around the loop, so we restrict
ourselves to call it before_lock_wait once before starting to wait
and once after the thread has exited the wait loop.
*/
if ((!thread_var->abort || in_wait_list) && before_lock_wait)
{
use_wait_callbacks= TRUE;
(*before_lock_wait)();
}
set_timespec(wait_timeout, lock_wait_timeout);
while (!thread_var->abort || in_wait_list)
{
int rc= mysql_cond_timedwait(cond, &data->lock->mutex, &wait_timeout);
/*
We must break the wait if one of the following occurs:
- the connection has been aborted (!thread_var->abort), but
this is not a delayed insert thread (in_wait_list). For a delayed
insert thread the proper action at shutdown is, apparently, to
acquire the lock and complete the insert.
- the lock has been granted (data->cond is set to NULL by the granter),
or the waiting has been aborted (additionally data->type is set to
TL_UNLOCK).
- the wait has timed out (rc == ETIMEDOUT)
Order of checks below is important to not report about timeout
if the predicate is true.
*/
if (data->cond == 0)
{
DBUG_PRINT("thr_lock", ("lock granted/aborted"));
break;
}
if (rc == ETIMEDOUT || rc == ETIME)
{
/* purecov: begin inspected */
DBUG_PRINT("thr_lock", ("lock timed out"));
result= THR_LOCK_WAIT_TIMEOUT;
break;
/* purecov: end */
}
}
/*
We call the after_lock_wait callback once the wait loop has
finished.
*/
if (after_lock_wait && use_wait_callbacks)
(*after_lock_wait)();
DBUG_PRINT("thr_lock", ("aborted: %d in_wait_list: %d",
thread_var->abort, in_wait_list));
if (data->cond || data->type == TL_UNLOCK)
{
if (data->cond) /* aborted or timed out */
{
if (((*data->prev)=data->next)) /* remove from wait-list */
data->next->prev= data->prev;
else
wait->last=data->prev;
data->type= TL_UNLOCK; /* No lock */
check_locks(data->lock, "killed or timed out wait_for_lock", data->type,
1);
wake_up_waiters(data->lock);
}
else
{
DBUG_PRINT("thr_lock", ("lock aborted"));
check_locks(data->lock, "aborted wait_for_lock", data->type, 0);
}
}
else
{
result= THR_LOCK_SUCCESS;
if (data->lock->get_status &&
(*data->lock->get_status)(data->status_param,
data->type == TL_WRITE_CONCURRENT_INSERT))
result= THR_LOCK_ABORTED;
check_locks(data->lock,"got wait_for_lock", data->type, 0);
}
mysql_mutex_unlock(&data->lock->mutex);
/* The following must be done after unlock of lock->mutex */
mysql_mutex_lock(&thread_var->mutex);
thread_var->current_mutex= 0;
thread_var->current_cond= 0;
mysql_mutex_unlock(&thread_var->mutex);
proc_info_hook(NULL, &old_stage, NULL, __func__, __FILE__, __LINE__);
DBUG_RETURN(result);
}
|
O0
|
c
|
wait_for_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
callq 0xf60c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x44(%rbp)
movb $0x0, -0x61(%rbp)
jmp 0xf928e
cmpb $0x0, -0x11(%rbp)
jne 0xf92c3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xb8a346(%rip), %rax # 0xc83610
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xb8a338(%rip), %rax # 0xc83610
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x18, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
xorl %eax, %eax
movl %eax, %edi
leaq 0x1c6560(%rip), %rsi # 0x2bf878
leaq -0x60(%rbp), %rdx
leaq 0x597b0(%rip), %rcx # 0x152ad3
leaq 0x5b35e(%rip), %r8 # 0x154688
movl $0x219, %r9d # imm = 0x219
leaq 0x1c68b9(%rip), %rax # 0x2bfbf0
callq *(%rax)
movq -0x28(%rbp), %rax
movl 0xe0(%rax), %eax
cmpl $0x0, %eax
je 0xf9351
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0xf9365
cmpq $0x0, 0xb8a2bf(%rip) # 0xc83618
je 0xf9365
movb $0x1, -0x61(%rbp)
callq *0xb8a2b3(%rip) # 0xc83618
jmp 0xf9367
callq 0xf00d0
movq %rax, -0x78(%rbp)
imulq $0x3e8, -0x78(%rbp), %rax # imm = 0x3E8
imulq $0x3b9aca00, -0x20(%rbp), %rcx # imm = 0x3B9ACA00
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
movq -0x70(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rdx, -0x38(%rbp)
jmp 0xf93ad
movq -0x28(%rbp), %rax
movl 0xe0(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x7d(%rbp)
je 0xf93ce
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x7d(%rbp)
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0xf93d7
jmp 0xf942c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdx
leaq 0x5b296(%rip), %rcx # 0x154688
movl $0x22e, %r8d # imm = 0x22E
callq 0xf9de0
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf9411
jmp 0xf940d
jmp 0xf940f
jmp 0xf942c
cmpl $0x6e, -0x7c(%rbp)
je 0xf941d
cmpl $0x3e, -0x7c(%rbp)
jne 0xf942a
jmp 0xf941f
jmp 0xf9421
movl $0x2, -0x44(%rbp)
jmp 0xf942c
jmp 0xf93ad
cmpq $0x0, 0xb8a1ec(%rip) # 0xc83620
je 0xf9445
movsbl -0x61(%rbp), %eax
cmpl $0x0, %eax
je 0xf9445
callq *0xb8a1db(%rip) # 0xc83620
jmp 0xf9447
jmp 0xf9449
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xf945e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0xf94ca
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xf94c2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xf9498
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0xf94a8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf7cc0
jmp 0xf94c8
jmp 0xf94c4
jmp 0xf94c6
jmp 0xf94c8
jmp 0xf9521
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0xb0(%rax)
je 0xf951f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xb0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x10(%rbp), %rcx
cmpl $0x8, 0x40(%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movsbl %cl, %esi
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0xf951f
movl $0x1, -0x44(%rbp)
jmp 0xf9521
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
callq 0xf7970
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
leaq 0x5b147(%rip), %rsi # 0x154688
movl $0x274, %edx # imm = 0x274
callq 0xf7900
movq -0x28(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
callq 0xf7970
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rsi
leaq 0x5954e(%rip), %rcx # 0x152ad3
leaq 0x5b0fc(%rip), %r8 # 0x154688
movl $0x279, %r9d # imm = 0x279
leaq 0x1c6657(%rip), %rax # 0x2bfbf0
movq %rdx, %rdi
callq *(%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
wait_for_lock:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov [rbp+var_20], rcx
call _my_thread_var
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rax, 8
mov [rbp+var_30], rax
mov [rbp+var_44], 1
mov [rbp+var_61], 0
jmp short $+2
loc_F928E:
cmp [rbp+var_11], 0
jnz short loc_F92C3
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rcx, [rbp+var_10]
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+8], rcx
loc_F92C3:
lea rax, locks_waited
mov rcx, [rax]
add rcx, 1
lea rax, locks_waited
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
add rcx, 18h
mov rax, [rbp+var_28]
mov [rax+98h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+0A0h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
xor eax, eax
mov edi, eax
lea rsi, stage_waiting_for_table_level_lock
lea rdx, [rbp+var_60]
lea rcx, aUnknown; "<unknown>"
lea r8, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 219h
lea rax, proc_info_hook
call qword ptr [rax]
mov rax, [rbp+var_28]
mov eax, [rax+0E0h]
cmp eax, 0
jz short loc_F9351
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_F9365
loc_F9351:
cmp cs:before_lock_wait, 0
jz short loc_F9365
mov [rbp+var_61], 1
call cs:before_lock_wait
loc_F9365:
jmp short $+2
loc_F9367:
call my_hrtime
mov [rbp+var_78], rax
imul rax, [rbp+var_78], 3E8h
imul rcx, [rbp+var_20], 3B9ACA00h
add rax, rcx
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_70]
mov ecx, 3B9ACA00h
xor edx, edx
div rcx
mov [rbp+var_38], rdx
jmp short $+2
loc_F93AD:
mov rax, [rbp+var_28]
mov ecx, [rax+0E0h]
mov al, 1
cmp ecx, 0
mov [rbp+var_7D], al
jz short loc_F93CE
movsx eax, [rbp+var_11]
cmp eax, 0
setnz al
mov [rbp+var_7D], al
loc_F93CE:
mov al, [rbp+var_7D]
test al, 1
jnz short loc_F93D7
jmp short loc_F942C
loc_F93D7:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_10]
mov rsi, [rax+18h]
add rsi, 18h
lea rdx, [rbp+var_40]
lea rcx, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r8d, 22Eh
call inline_mysql_cond_timedwait_2
mov [rbp+var_7C], eax
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jnz short loc_F9411
jmp short $+2
loc_F940D:
jmp short $+2
loc_F940F:
jmp short loc_F942C
loc_F9411:
cmp [rbp+var_7C], 6Eh ; 'n'
jz short loc_F941D
cmp [rbp+var_7C], 3Eh ; '>'
jnz short loc_F942A
loc_F941D:
jmp short $+2
loc_F941F:
jmp short $+2
loc_F9421:
mov [rbp+var_44], 2
jmp short loc_F942C
loc_F942A:
jmp short loc_F93AD
loc_F942C:
cmp cs:after_lock_wait, 0
jz short loc_F9445
movsx eax, [rbp+var_61]
cmp eax, 0
jz short loc_F9445
call cs:after_lock_wait
loc_F9445:
jmp short $+2
loc_F9447:
jmp short $+2
loc_F9449:
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jnz short loc_F945E
mov rax, [rbp+var_10]
cmp dword ptr [rax+40h], 0
jnz short loc_F94CA
loc_F945E:
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jz short loc_F94C2
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
mov [rcx], rax
cmp rax, 0
jz short loc_F9498
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax+10h], rcx
jmp short loc_F94A8
loc_F9498:
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_8]
mov [rax+8], rcx
loc_F94A8:
mov rax, [rbp+var_10]
mov dword ptr [rax+40h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
call wake_up_waiters
jmp short loc_F94C8
loc_F94C2:
jmp short $+2
loc_F94C4:
jmp short $+2
loc_F94C6:
jmp short $+2
loc_F94C8:
jmp short loc_F9521
loc_F94CA:
mov [rbp+var_44], 0
mov rax, [rbp+var_10]
mov rax, [rax+18h]
cmp qword ptr [rax+0B0h], 0
jz short loc_F951F
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov rax, [rax+0B0h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+28h]
mov rcx, [rbp+var_10]
cmp dword ptr [rcx+40h], 8
setz cl
and cl, 1
movzx ecx, cl
movsx esi, cl
call rax
movsx eax, al
cmp eax, 0
jz short loc_F951F
mov [rbp+var_44], 1
loc_F951F:
jmp short $+2
loc_F9521:
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
call inline_mysql_mutex_unlock_28
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 274h
call inline_mysql_mutex_lock_27
mov rax, [rbp+var_28]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_28]
mov qword ptr [rax+0A0h], 0
mov rdi, [rbp+var_28]
add rdi, 40h ; '@'
call inline_mysql_mutex_unlock_28
xor eax, eax
mov edx, eax
lea rsi, [rbp+var_60]
lea rcx, aUnknown; "<unknown>"
lea r8, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 279h
lea rax, proc_info_hook
mov rdi, rdx
call qword ptr [rax]
mov eax, [rbp+var_44]
mov [rbp+var_84], eax
mov eax, [rbp+var_84]
add rsp, 90h
pop rbp
retn
|
long long wait_for_lock(long long a1, const char *a2, char a3, long long a4)
{
long long v4; // rax
bool v6; // [rsp+13h] [rbp-7Dh]
int v7; // [rsp+14h] [rbp-7Ch]
unsigned long long v8; // [rsp+20h] [rbp-70h]
char v9; // [rsp+2Fh] [rbp-61h]
unsigned int v10; // [rsp+4Ch] [rbp-44h]
_QWORD v11[2]; // [rsp+50h] [rbp-40h] BYREF
long long v12; // [rsp+60h] [rbp-30h]
long long v13; // [rsp+68h] [rbp-28h]
long long v14; // [rsp+70h] [rbp-20h]
char v15; // [rsp+7Fh] [rbp-11h]
const char *v16; // [rsp+80h] [rbp-10h]
long long v17; // [rsp+88h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = my_thread_var(a1, a2);
v12 = v13 + 8;
v10 = 1;
v9 = 0;
if ( !v15 )
{
**(_QWORD **)(v17 + 8) = v16;
*((_QWORD *)v16 + 2) = *(_QWORD *)(v17 + 8);
*(_QWORD *)(v17 + 8) = v16 + 8;
}
++locks_waited;
*(_QWORD *)(v13 + 152) = *((_QWORD *)v16 + 3) + 24LL;
*(_QWORD *)(v13 + 160) = v12;
*((_QWORD *)v16 + 4) = v12;
proc_info_hook();
if ( (!*(_DWORD *)(v13 + 224) || v15) && before_lock_wait )
{
v9 = 1;
before_lock_wait(0LL, &stage_waiting_for_table_level_lock);
}
v8 = 1000000000 * v14 + 1000 * my_hrtime();
v11[0] = v8 / 0x3B9ACA00;
v11[1] = v8 % 0x3B9ACA00;
while ( 1 )
{
v6 = 1;
if ( *(_DWORD *)(v13 + 224) )
v6 = v15 != 0;
if ( !v6 )
break;
v7 = inline_mysql_cond_timedwait_2(
v12,
*((_QWORD *)v16 + 3) + 24LL,
v11,
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
558LL);
if ( !*((_QWORD *)v16 + 4) )
break;
if ( v7 == 110 || v7 == 62 )
{
v10 = 2;
break;
}
}
if ( after_lock_wait && v9 )
after_lock_wait();
if ( !*((_QWORD *)v16 + 4) && *((_DWORD *)v16 + 16) )
{
v10 = 0;
if ( *(_QWORD *)(*((_QWORD *)v16 + 3) + 176LL) )
v10 = (*(unsigned __int8 ( **)(_QWORD, bool))(*((_QWORD *)v16 + 3) + 176LL))(
*((_QWORD *)v16 + 5),
*((_DWORD *)v16 + 16) == 8) != 0;
}
else if ( *((_QWORD *)v16 + 4) )
{
v4 = *((_QWORD *)v16 + 1);
**((_QWORD **)v16 + 2) = v4;
if ( v4 )
*(_QWORD *)(*((_QWORD *)v16 + 1) + 16LL) = *((_QWORD *)v16 + 2);
else
*(_QWORD *)(v17 + 8) = *((_QWORD *)v16 + 2);
*((_DWORD *)v16 + 16) = 0;
wake_up_waiters(*((_QWORD *)v16 + 3));
}
inline_mysql_mutex_unlock_28(*((_QWORD *)v16 + 3) + 24LL);
inline_mysql_mutex_lock_27(v13 + 64, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x274u);
*(_QWORD *)(v13 + 152) = 0LL;
*(_QWORD *)(v13 + 160) = 0LL;
inline_mysql_mutex_unlock_28(v13 + 64);
proc_info_hook();
return v10;
}
|
wait_for_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],RCX
CALL 0x001f60c0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x44],0x1
MOV byte ptr [RBP + -0x61],0x0
JMP 0x001f928e
LAB_001f928e:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x001f92c3
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_001f92c3:
LEA RAX,[0xd83610]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0xd83610]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x98],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0xa0],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
XOR EAX,EAX
MOV EDI,EAX
LEA RSI,[0x3bf878]
LEA RDX,[RBP + -0x60]
LEA RCX,[0x252ad3]
LEA R8,[0x254688]
MOV R9D,0x219
LEA RAX,[0x3bfbf0]
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0xe0]
CMP EAX,0x0
JZ 0x001f9351
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x001f9365
LAB_001f9351:
CMP qword ptr [0x00d83618],0x0
JZ 0x001f9365
MOV byte ptr [RBP + -0x61],0x1
CALL qword ptr [0x00d83618]
LAB_001f9365:
JMP 0x001f9367
LAB_001f9367:
CALL 0x001f00d0
MOV qword ptr [RBP + -0x78],RAX
IMUL RAX,qword ptr [RBP + -0x78],0x3e8
IMUL RCX,qword ptr [RBP + -0x20],0x3b9aca00
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,0x3b9aca00
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x38],RDX
JMP 0x001f93ad
LAB_001f93ad:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0xe0]
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x7d],AL
JZ 0x001f93ce
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x7d],AL
LAB_001f93ce:
MOV AL,byte ptr [RBP + -0x7d]
TEST AL,0x1
JNZ 0x001f93d7
JMP 0x001f942c
LAB_001f93d7:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x18
LEA RDX,[RBP + -0x40]
LEA RCX,[0x254688]
MOV R8D,0x22e
CALL 0x001f9de0
MOV dword ptr [RBP + -0x7c],EAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x001f9411
JMP 0x001f940d
LAB_001f940d:
JMP 0x001f940f
LAB_001f940f:
JMP 0x001f942c
LAB_001f9411:
CMP dword ptr [RBP + -0x7c],0x6e
JZ 0x001f941d
CMP dword ptr [RBP + -0x7c],0x3e
JNZ 0x001f942a
LAB_001f941d:
JMP 0x001f941f
LAB_001f941f:
JMP 0x001f9421
LAB_001f9421:
MOV dword ptr [RBP + -0x44],0x2
JMP 0x001f942c
LAB_001f942a:
JMP 0x001f93ad
LAB_001f942c:
CMP qword ptr [0x00d83620],0x0
JZ 0x001f9445
MOVSX EAX,byte ptr [RBP + -0x61]
CMP EAX,0x0
JZ 0x001f9445
CALL qword ptr [0x00d83620]
LAB_001f9445:
JMP 0x001f9447
LAB_001f9447:
JMP 0x001f9449
LAB_001f9449:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x001f945e
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x40],0x0
JNZ 0x001f94ca
LAB_001f945e:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x001f94c2
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001f9498
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001f94a8
LAB_001f9498:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_001f94a8:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x001f7cc0
JMP 0x001f94c8
LAB_001f94c2:
JMP 0x001f94c4
LAB_001f94c4:
JMP 0x001f94c6
LAB_001f94c6:
JMP 0x001f94c8
LAB_001f94c8:
JMP 0x001f9521
LAB_001f94ca:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
CMP qword ptr [RAX + 0xb0],0x0
JZ 0x001f951f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0xb0]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP dword ptr [RCX + 0x40],0x8
SETZ CL
AND CL,0x1
MOVZX ECX,CL
MOVSX ESI,CL
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001f951f
MOV dword ptr [RBP + -0x44],0x1
LAB_001f951f:
JMP 0x001f9521
LAB_001f9521:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
CALL 0x001f7970
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
LEA RSI,[0x254688]
MOV EDX,0x274
CALL 0x001f7900
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0xa0],0x0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x40
CALL 0x001f7970
XOR EAX,EAX
MOV EDX,EAX
LEA RSI,[RBP + -0x60]
LEA RCX,[0x252ad3]
LEA R8,[0x254688]
MOV R9D,0x279
LEA RAX,[0x3bfbf0]
MOV RDI,RDX
CALL qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x84],EAX
MOV EAX,dword ptr [RBP + -0x84]
ADD RSP,0x90
POP RBP
RET
|
int4 wait_for_lock(long param_1,long param_2,char param_3,long param_4)
{
char cVar1;
int iVar2;
long lVar3;
ulong uVar4;
ulong extraout_RDX;
ulong extraout_RDX_00;
bool bVar5;
int1 local_68 [28];
int4 local_4c;
ulong local_48;
ulong local_40;
long local_38;
long local_30;
long local_28;
char local_19;
long local_18;
long local_10;
local_28 = param_4;
local_19 = param_3;
local_18 = param_2;
local_10 = param_1;
local_30 = _my_thread_var();
local_38 = local_30 + 8;
local_4c = 1;
bVar5 = false;
if (local_19 == '\0') {
**(long **)(local_10 + 8) = local_18;
*(int8 *)(local_18 + 0x10) = *(int8 *)(local_10 + 8);
*(long *)(local_10 + 8) = local_18 + 8;
}
locks_waited = locks_waited + 1;
*(long *)(local_30 + 0x98) = *(long *)(local_18 + 0x18) + 0x18;
*(long *)(local_30 + 0xa0) = local_38;
*(long *)(local_18 + 0x20) = local_38;
(*(code *)proc_info_hook)
(0,stage_waiting_for_table_level_lock,local_68,"<unknown>",
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x219);
if (((*(int *)(local_30 + 0xe0) == 0) || (local_19 != '\0')) && (before_lock_wait != (code *)0x0))
{
bVar5 = true;
(*before_lock_wait)();
}
lVar3 = my_hrtime();
uVar4 = lVar3 * 1000 + local_28 * 1000000000;
local_48 = uVar4 / 1000000000;
uVar4 = uVar4 % 1000000000;
local_40 = uVar4;
do {
if ((*(int *)(local_30 + 0xe0) != 0 && local_19 == '\0') ||
(iVar2 = inline_mysql_cond_timedwait
(local_38,*(long *)(local_18 + 0x18) + 0x18,&local_48,
"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x22e),
uVar4 = extraout_RDX, *(long *)(local_18 + 0x20) == 0)) goto LAB_001f942c;
} while ((iVar2 != 0x6e) && (iVar2 != 0x3e));
local_4c = 2;
LAB_001f942c:
if ((after_lock_wait != (code *)0x0) && (bVar5)) {
(*after_lock_wait)();
uVar4 = extraout_RDX_00;
}
if ((*(long *)(local_18 + 0x20) == 0) && (*(int *)(local_18 + 0x40) != 0)) {
local_4c = 0;
if ((*(long *)(*(long *)(local_18 + 0x18) + 0xb0) != 0) &&
(bVar5 = *(int *)(local_18 + 0x40) == 8,
cVar1 = (**(code **)(*(long *)(local_18 + 0x18) + 0xb0))
(*(int8 *)(local_18 + 0x28),bVar5,uVar4,bVar5), cVar1 != '\0')) {
local_4c = 1;
}
}
else if (*(long *)(local_18 + 0x20) != 0) {
lVar3 = *(long *)(local_18 + 8);
**(long **)(local_18 + 0x10) = lVar3;
if (lVar3 == 0) {
*(int8 *)(local_10 + 8) = *(int8 *)(local_18 + 0x10);
}
else {
*(int8 *)(*(long *)(local_18 + 8) + 0x10) = *(int8 *)(local_18 + 0x10);
}
*(int4 *)(local_18 + 0x40) = 0;
wake_up_waiters(*(int8 *)(local_18 + 0x18));
}
inline_mysql_mutex_unlock(*(long *)(local_18 + 0x18) + 0x18);
inline_mysql_mutex_lock
(local_30 + 0x40,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x274);
*(int8 *)(local_30 + 0x98) = 0;
*(int8 *)(local_30 + 0xa0) = 0;
inline_mysql_mutex_unlock(local_30 + 0x40);
(*(code *)proc_info_hook)
(0,local_68,0,"<unknown>","/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",
0x279);
return local_4c;
}
|
|
58,589
|
has_path
|
eloqsql/mysys/my_getwd.c
|
my_bool has_path(const char *name)
{
return MY_TEST(strchr(name, FN_LIBCHAR))
#if FN_LIBCHAR != '/'
|| MY_TEST(strchr(name, '/'))
#endif
#ifdef FN_DEVCHAR
|| MY_TEST(strchr(name, FN_DEVCHAR))
#endif
;
}
|
O0
|
c
|
has_path:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x24100
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
has_path:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
mov esi, 2Fh ; '/'
call _strchr
mov rdx, rax
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
add rsp, 10h
pop rbp
retn
|
_BOOL8 has_path(long long a1)
{
return strchr(a1, 47LL) != 0;
}
|
has_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x2f
CALL 0x00124100
MOV RDX,RAX
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
ADD RSP,0x10
POP RBP
RET
|
bool has_path(char *param_1)
{
char *pcVar1;
pcVar1 = strchr(param_1,0x2f);
return pcVar1 != (char *)0x0;
}
|
|
58,590
|
google::protobuf::FileDescriptorProto::ByteSizeLong() const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc
|
size_t FileDescriptorProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:google.protobuf.FileDescriptorProto)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated string dependency = 3;
total_size += 1 *
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.dependency_.size());
for (int i = 0, n = _impl_.dependency_.size(); i < n; i++) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
_impl_.dependency_.Get(i));
}
// repeated .google.protobuf.DescriptorProto message_type = 4;
total_size += 1UL * this->_internal_message_type_size();
for (const auto& msg : this->_impl_.message_type_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
total_size += 1UL * this->_internal_enum_type_size();
for (const auto& msg : this->_impl_.enum_type_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated .google.protobuf.ServiceDescriptorProto service = 6;
total_size += 1UL * this->_internal_service_size();
for (const auto& msg : this->_impl_.service_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated .google.protobuf.FieldDescriptorProto extension = 7;
total_size += 1UL * this->_internal_extension_size();
for (const auto& msg : this->_impl_.extension_) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// repeated int32 public_dependency = 10;
{
size_t data_size = ::_pbi::WireFormatLite::
Int32Size(this->_impl_.public_dependency_);
total_size += 1 *
::_pbi::FromIntSize(this->_internal_public_dependency_size());
total_size += data_size;
}
// repeated int32 weak_dependency = 11;
{
size_t data_size = ::_pbi::WireFormatLite::
Int32Size(this->_impl_.weak_dependency_);
total_size += 1 *
::_pbi::FromIntSize(this->_internal_weak_dependency_size());
total_size += data_size;
}
cached_has_bits = _impl_._has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
// optional string name = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_name());
}
// optional string package = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_package());
}
// optional string syntax = 12;
if (cached_has_bits & 0x00000004u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_syntax());
}
// optional .google.protobuf.FileOptions options = 8;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*_impl_.options_);
}
// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
if (cached_has_bits & 0x00000010u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*_impl_.source_code_info_);
}
}
return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}
|
O0
|
cpp
|
google::protobuf::FileDescriptorProto::ByteSizeLong() const:
subq $0xc8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0xa8(%rsp)
movl $0x0, 0xa4(%rsp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x1ccd80
movl %eax, %edi
callq 0xd53d0
movq (%rsp), %rdi
shlq $0x0, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl $0x0, 0xa0(%rsp)
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x1ccd80
movl %eax, 0x9c(%rsp)
movl 0xa0(%rsp), %eax
cmpl 0x9c(%rsp), %eax
jge 0xab690
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x8, %rdi
movl 0xa0(%rsp), %esi
callq 0x1ccd90
movq %rax, %rdi
callq 0xd53e0
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa0(%rsp)
jmp 0xab63d
movq (%rsp), %rdi
callq 0x807d0
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x0, %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
addq $0x10, %rax
addq $0x20, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x84270
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x842b0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x84310
testb $0x1, %al
jne 0xab70b
jmp 0xab746
leaq 0x88(%rsp), %rdi
callq 0x84330
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xd5400
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x84410
jmp 0xab6f0
movq (%rsp), %rdi
callq 0x86320
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x0, %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
addq $0x10, %rax
addq $0x38, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x84720
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x84760
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x847c0
testb $0x1, %al
jne 0xab7ac
jmp 0xab7e1
leaq 0x68(%rsp), %rdi
callq 0x847e0
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xd5420
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x84820
jmp 0xab797
movq (%rsp), %rdi
callq 0x86550
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x0, %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
addq $0x10, %rax
addq $0x50, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x83f80
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x83fc0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x84020
testb $0x1, %al
jne 0xab847
jmp 0xab87c
leaq 0x48(%rsp), %rdi
callq 0x84040
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd5440
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x84080
jmp 0xab832
movq (%rsp), %rdi
callq 0x80810
movl %eax, %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x0, %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
addq $0x10, %rax
addq $0x68, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x849d0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x84a10
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x84a70
testb $0x1, %al
jne 0xab8e2
jmp 0xab917
leaq 0x28(%rsp), %rdi
callq 0x84a90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd5460
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x84ab0
jmp 0xab8cd
movq (%rsp), %rdi
addq $0x10, %rdi
addq $0x80, %rdi
callq 0x1d91a0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x860c0
movl %eax, %edi
callq 0xd53d0
movq (%rsp), %rdi
shlq $0x0, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x10(%rsp), %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
addq $0x10, %rdi
addq $0x90, %rdi
callq 0x1d91a0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x86070
movl %eax, %edi
callq 0xd53d0
movq %rax, %rcx
movq (%rsp), %rax
shlq $0x0, %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
movq 0x8(%rsp), %rcx
addq 0xa8(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
addq $0x10, %rax
movq %rax, 0xc0(%rsp)
movl $0x0, 0xbc(%rsp)
movq 0xc0(%rsp), %rax
movslq 0xbc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
andl $0x1f, %eax
cmpl $0x0, %eax
je 0xabb0a
movl 0xa4(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xaba3a
movq (%rsp), %rdi
callq 0x80230
movq %rax, %rdi
callq 0xd53e0
addq $0x1, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa4(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xaba6e
movq (%rsp), %rdi
callq 0x83ea0
movq %rax, %rdi
callq 0xd53e0
addq $0x1, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa4(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xabaa2
movq (%rsp), %rdi
callq 0x85f90
movq %rax, %rdi
callq 0xd53e0
addq $0x1, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa4(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xabad5
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0xd5480
addq $0x1, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movl 0xa4(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xabb08
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
callq 0xd54a0
addq $0x1, %rax
addq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
jmp 0xabb0a
movq (%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq %rdi, %rdx
addq $0x10, %rdx
addq $0x4, %rdx
callq 0x13aa50
addq $0xc8, %rsp
retq
nop
|
_ZNK6google8protobuf19FileDescriptorProto12ByteSizeLongEv:
sub rsp, 0C8h
mov [rsp+0C8h+var_18], rdi
mov rdi, [rsp+0C8h+var_18]
mov [rsp+0C8h+var_C8], rdi
mov [rsp+0C8h+var_20], 0
mov [rsp+0C8h+var_24], 0
add rdi, 10h
add rdi, 8
call _ZNK6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4sizeEv; google::protobuf::RepeatedPtrField<std::string>::size(void)
mov edi, eax; this
call _ZN6google8protobuf8internal11FromIntSizeEi; google::protobuf::internal::FromIntSize(int)
mov rdi, [rsp+0C8h+var_C8]
shl rax, 0
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
mov [rsp+0C8h+var_28], 0
add rdi, 10h
add rdi, 8
call _ZNK6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4sizeEv; google::protobuf::RepeatedPtrField<std::string>::size(void)
mov [rsp+0C8h+var_2C], eax
loc_AB63D:
mov eax, [rsp+0C8h+var_28]
cmp eax, [rsp+0C8h+var_2C]
jge short loc_AB690
mov rdi, [rsp+0C8h+var_C8]
add rdi, 10h
add rdi, 8
mov esi, [rsp+0C8h+var_28]
call _ZNK6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE3GetEi; google::protobuf::RepeatedPtrField<std::string>::Get(int)
mov rdi, rax
call _ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::WireFormatLite::StringSize(std::string const&)
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
mov eax, [rsp+0C8h+var_28]
add eax, 1
mov [rsp+0C8h+var_28], eax
jmp short loc_AB63D
loc_AB690:
mov rdi, [rsp+0C8h+var_C8]; this
call _ZNK6google8protobuf19FileDescriptorProto27_internal_message_type_sizeEv; google::protobuf::FileDescriptorProto::_internal_message_type_size(void)
mov ecx, eax
mov rax, [rsp+0C8h+var_C8]
movsxd rcx, ecx
shl rcx, 0
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
add rax, 10h
add rax, 20h ; ' '
mov [rsp+0C8h+var_38], rax
mov rdi, [rsp+0C8h+var_38]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE5beginEv; google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::begin(void)
mov [rsp+0C8h+var_40], rax
mov rdi, [rsp+0C8h+var_38]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_15DescriptorProtoEE3endEv; google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::end(void)
mov [rsp+0C8h+var_48], rax
loc_AB6F0:
lea rdi, [rsp+0C8h+var_40]
lea rsi, [rsp+0C8h+var_48]
call _ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEES7_; google::protobuf::internal::operator!=(google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const> const&,google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const> const&)
test al, 1
jnz short loc_AB70B
jmp short loc_AB746
loc_AB70B:
lea rdi, [rsp+0C8h+var_40]
call _ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEdeEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const>::operator*(void)
mov [rsp+0C8h+var_50], rax
mov rdi, [rsp+0C8h+var_50]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_15DescriptorProtoEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::DescriptorProto>(google::protobuf::DescriptorProto const&)
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
lea rdi, [rsp+0C8h+var_40]
call _ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_15DescriptorProtoEEppEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const>::operator++(void)
jmp short loc_AB6F0
loc_AB746:
mov rdi, [rsp+0C8h+var_C8]; this
call _ZNK6google8protobuf19FileDescriptorProto24_internal_enum_type_sizeEv; google::protobuf::FileDescriptorProto::_internal_enum_type_size(void)
mov ecx, eax
mov rax, [rsp+0C8h+var_C8]
movsxd rcx, ecx
shl rcx, 0
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
add rax, 10h
add rax, 38h ; '8'
mov [rsp+0C8h+var_58], rax
mov rdi, [rsp+0C8h+var_58]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE5beginEv; google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::begin(void)
mov [rsp+0C8h+var_60], rax
mov rdi, [rsp+0C8h+var_58]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_19EnumDescriptorProtoEE3endEv; google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::end(void)
mov [rsp+0C8h+var_68], rax
loc_AB797:
lea rdi, [rsp+0C8h+var_60]
lea rsi, [rsp+0C8h+var_68]
call _ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEES7_; google::protobuf::internal::operator!=(google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const> const&,google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const> const&)
test al, 1
jnz short loc_AB7AC
jmp short loc_AB7E1
loc_AB7AC:
lea rdi, [rsp+0C8h+var_60]
call _ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEdeEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const>::operator*(void)
mov [rsp+0C8h+var_70], rax
mov rdi, [rsp+0C8h+var_70]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_19EnumDescriptorProtoEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::EnumDescriptorProto>(google::protobuf::EnumDescriptorProto const&)
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
lea rdi, [rsp+0C8h+var_60]
call _ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_19EnumDescriptorProtoEEppEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const>::operator++(void)
jmp short loc_AB797
loc_AB7E1:
mov rdi, [rsp+0C8h+var_C8]; this
call _ZNK6google8protobuf19FileDescriptorProto22_internal_service_sizeEv; google::protobuf::FileDescriptorProto::_internal_service_size(void)
mov ecx, eax
mov rax, [rsp+0C8h+var_C8]
movsxd rcx, ecx
shl rcx, 0
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
add rax, 10h
add rax, 50h ; 'P'
mov [rsp+0C8h+var_78], rax
mov rdi, [rsp+0C8h+var_78]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE5beginEv; google::protobuf::RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::begin(void)
mov [rsp+0C8h+var_80], rax
mov rdi, [rsp+0C8h+var_78]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_22ServiceDescriptorProtoEE3endEv; google::protobuf::RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::end(void)
mov [rsp+0C8h+var_88], rax
loc_AB832:
lea rdi, [rsp+0C8h+var_80]
lea rsi, [rsp+0C8h+var_88]
call _ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_22ServiceDescriptorProtoEEES7_; google::protobuf::internal::operator!=(google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const> const&,google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const> const&)
test al, 1
jnz short loc_AB847
jmp short loc_AB87C
loc_AB847:
lea rdi, [rsp+0C8h+var_80]
call _ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_22ServiceDescriptorProtoEEdeEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const>::operator*(void)
mov [rsp+0C8h+var_90], rax
mov rdi, [rsp+0C8h+var_90]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_22ServiceDescriptorProtoEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::ServiceDescriptorProto>(google::protobuf::ServiceDescriptorProto const&)
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
lea rdi, [rsp+0C8h+var_80]
call _ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_22ServiceDescriptorProtoEEppEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const>::operator++(void)
jmp short loc_AB832
loc_AB87C:
mov rdi, [rsp+0C8h+var_C8]; this
call _ZNK6google8protobuf19FileDescriptorProto24_internal_extension_sizeEv; google::protobuf::FileDescriptorProto::_internal_extension_size(void)
mov ecx, eax
mov rax, [rsp+0C8h+var_C8]
movsxd rcx, ecx
shl rcx, 0
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
add rax, 10h
add rax, 68h ; 'h'
mov [rsp+0C8h+var_98], rax
mov rdi, [rsp+0C8h+var_98]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE5beginEv; google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::begin(void)
mov [rsp+0C8h+var_A0], rax
mov rdi, [rsp+0C8h+var_98]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_20FieldDescriptorProtoEE3endEv; google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::end(void)
mov qword ptr [rsp+0C8h+var_A8], rax
loc_AB8CD:
lea rdi, [rsp+0C8h+var_A0]
lea rsi, [rsp+0C8h+var_A8]; int
call _ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNS0_20FieldDescriptorProtoEEES7_; google::protobuf::internal::operator!=(google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const> const&,google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const> const&)
test al, 1
jnz short loc_AB8E2
jmp short loc_AB917
loc_AB8E2:
lea rdi, [rsp+0C8h+var_A0]
call _ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNS0_20FieldDescriptorProtoEEdeEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const>::operator*(void)
mov [rsp+0C8h+var_B0], rax
mov rdi, [rsp+0C8h+var_B0]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_20FieldDescriptorProtoEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::FieldDescriptorProto>(google::protobuf::FieldDescriptorProto const&)
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
lea rdi, [rsp+0C8h+var_A0]
call _ZN6google8protobuf8internal19RepeatedPtrIteratorIKNS0_20FieldDescriptorProtoEEppEv; google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const>::operator++(void)
jmp short loc_AB8CD
loc_AB917:
mov rdi, [rsp+0C8h+var_C8]
add rdi, 10h
add rdi, 80h
call _ZN6google8protobuf8internal14WireFormatLite9Int32SizeERKNS0_13RepeatedFieldIiEE; google::protobuf::internal::WireFormatLite::Int32Size(google::protobuf::RepeatedField<int> const&)
mov rdi, [rsp+0C8h+var_C8]; this
mov [rsp+0C8h+var_B8], rax
call _ZNK6google8protobuf19FileDescriptorProto32_internal_public_dependency_sizeEv; google::protobuf::FileDescriptorProto::_internal_public_dependency_size(void)
mov edi, eax; this
call _ZN6google8protobuf8internal11FromIntSizeEi; google::protobuf::internal::FromIntSize(int)
mov rdi, [rsp+0C8h+var_C8]
shl rax, 0
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
mov rax, [rsp+0C8h+var_B8]
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
add rdi, 10h
add rdi, 90h
call _ZN6google8protobuf8internal14WireFormatLite9Int32SizeERKNS0_13RepeatedFieldIiEE; google::protobuf::internal::WireFormatLite::Int32Size(google::protobuf::RepeatedField<int> const&)
mov rdi, [rsp+0C8h+var_C8]; this
mov [rsp+0C8h+var_C0], rax
call _ZNK6google8protobuf19FileDescriptorProto30_internal_weak_dependency_sizeEv; google::protobuf::FileDescriptorProto::_internal_weak_dependency_size(void)
mov edi, eax; this
call _ZN6google8protobuf8internal11FromIntSizeEi; google::protobuf::internal::FromIntSize(int)
mov rcx, rax
mov rax, [rsp+0C8h+var_C8]
shl rcx, 0
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
mov rcx, [rsp+0C8h+var_C0]
add rcx, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rcx
add rax, 10h
mov [rsp+0C8h+var_8], rax
mov [rsp+0C8h+var_C], 0
mov rax, [rsp+0C8h+var_8]
movsxd rcx, [rsp+0C8h+var_C]
mov eax, [rax+rcx*4]
mov [rsp+0C8h+var_24], eax
mov eax, [rsp+0C8h+var_24]
and eax, 1Fh
cmp eax, 0
jz loc_ABB0A
mov eax, [rsp+0C8h+var_24]
and eax, 1
cmp eax, 0
jz short loc_ABA3A
mov rdi, [rsp+0C8h+var_C8]
call _ZNK6google8protobuf19FileDescriptorProto14_internal_nameB5cxx11Ev; google::protobuf::FileDescriptorProto::_internal_name(void)
mov rdi, rax
call _ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::WireFormatLite::StringSize(std::string const&)
add rax, 1
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
loc_ABA3A:
mov eax, [rsp+0C8h+var_24]
and eax, 2
cmp eax, 0
jz short loc_ABA6E
mov rdi, [rsp+0C8h+var_C8]
call _ZNK6google8protobuf19FileDescriptorProto17_internal_packageB5cxx11Ev; google::protobuf::FileDescriptorProto::_internal_package(void)
mov rdi, rax
call _ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::WireFormatLite::StringSize(std::string const&)
add rax, 1
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
loc_ABA6E:
mov eax, [rsp+0C8h+var_24]
and eax, 4
cmp eax, 0
jz short loc_ABAA2
mov rdi, [rsp+0C8h+var_C8]
call _ZNK6google8protobuf19FileDescriptorProto16_internal_syntaxB5cxx11Ev; google::protobuf::FileDescriptorProto::_internal_syntax(void)
mov rdi, rax
call _ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::WireFormatLite::StringSize(std::string const&)
add rax, 1
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
loc_ABAA2:
mov eax, [rsp+0C8h+var_24]
and eax, 8
cmp eax, 0
jz short loc_ABAD5
mov rax, [rsp+0C8h+var_C8]
mov rdi, [rax+0C8h]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_11FileOptionsEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::FileOptions>(google::protobuf::FileOptions const&)
add rax, 1
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
loc_ABAD5:
mov eax, [rsp+0C8h+var_24]
and eax, 10h
cmp eax, 0
jz short loc_ABB08
mov rax, [rsp+0C8h+var_C8]
mov rdi, [rax+0D0h]
call _ZN6google8protobuf8internal14WireFormatLite11MessageSizeINS0_14SourceCodeInfoEEEmRKT_; google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::SourceCodeInfo>(google::protobuf::SourceCodeInfo const&)
add rax, 1
add rax, [rsp+0C8h+var_20]
mov [rsp+0C8h+var_20], rax
loc_ABB08:
jmp short $+2
loc_ABB0A:
mov rdi, [rsp+0C8h+var_C8]; this
mov rsi, [rsp+0C8h+var_20]; unsigned __int64
mov rdx, rdi
add rdx, 10h
add rdx, 4; google::protobuf::internal::CachedSize *
call _ZNK6google8protobuf7Message29MaybeComputeUnknownFieldsSizeEmPNS0_8internal10CachedSizeE; google::protobuf::Message::MaybeComputeUnknownFieldsSize(ulong,google::protobuf::internal::CachedSize *)
add rsp, 0C8h
retn
|
long long google::protobuf::FileDescriptorProto::ByteSizeLong(
google::protobuf::FileDescriptorProto *this,
int a2)
{
unsigned int v2; // eax
long long v3; // rax
long long v4; // rax
int v5; // eax
long long v6; // rax
int v7; // eax
long long v8; // rax
int v9; // eax
long long v10; // rax
unsigned int v11; // eax
unsigned int v12; // eax
long long v13; // rax
long long v14; // rax
unsigned long long v15; // rax
long long v16; // rax
unsigned long long v17; // rax
long long v18; // rax
long long v19; // rax
long long v20; // rax
long long v22; // [rsp+8h] [rbp-C0h]
long long v23; // [rsp+10h] [rbp-B8h]
long long v24; // [rsp+18h] [rbp-B0h]
int v25[2]; // [rsp+20h] [rbp-A8h] BYREF
_QWORD v26[2]; // [rsp+28h] [rbp-A0h] BYREF
long long v27; // [rsp+38h] [rbp-90h]
long long v28; // [rsp+40h] [rbp-88h] BYREF
_QWORD v29[2]; // [rsp+48h] [rbp-80h] BYREF
long long v30; // [rsp+58h] [rbp-70h]
long long v31; // [rsp+60h] [rbp-68h] BYREF
_QWORD v32[2]; // [rsp+68h] [rbp-60h] BYREF
long long v33; // [rsp+78h] [rbp-50h]
long long v34; // [rsp+80h] [rbp-48h] BYREF
_QWORD v35[2]; // [rsp+88h] [rbp-40h] BYREF
int v36; // [rsp+9Ch] [rbp-2Ch]
unsigned int v37; // [rsp+A0h] [rbp-28h]
int v38; // [rsp+A4h] [rbp-24h]
unsigned long long v39; // [rsp+A8h] [rbp-20h]
google::protobuf::FileDescriptorProto *v40; // [rsp+B0h] [rbp-18h]
int v41; // [rsp+BCh] [rbp-Ch]
char *v42; // [rsp+C0h] [rbp-8h]
v40 = this;
v38 = 0;
v2 = google::protobuf::RepeatedPtrField<std::string>::size((char *)this + 24);
v39 = google::protobuf::internal::FromIntSize((google::protobuf::internal *)v2, a2);
v37 = 0;
v36 = google::protobuf::RepeatedPtrField<std::string>::size((char *)this + 24);
while ( (int)v37 < v36 )
{
v3 = google::protobuf::RepeatedPtrField<std::string>::Get((char *)this + 24, v37);
v39 += google::protobuf::internal::WireFormatLite::StringSize(v3);
++v37;
}
v39 += (int)google::protobuf::FileDescriptorProto::_internal_message_type_size(this);
v35[1] = (char *)this + 48;
v35[0] = google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::begin((google::protobuf::FileDescriptorProto *)((char *)this + 48));
v34 = google::protobuf::RepeatedPtrField<google::protobuf::DescriptorProto>::end((google::protobuf::FileDescriptorProto *)((char *)this + 48));
while ( google::protobuf::internal::operator!=(v35, &v34) )
{
v33 = google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const>::operator*((long long)v35);
v4 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::DescriptorProto>(v33);
v39 += v4;
google::protobuf::internal::RepeatedPtrIterator<google::protobuf::DescriptorProto const>::operator++(v35);
}
v5 = google::protobuf::FileDescriptorProto::_internal_enum_type_size(this);
v39 += v5;
v32[1] = (char *)this + 72;
v32[0] = google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::begin((google::protobuf::FileDescriptorProto *)((char *)this + 72));
v31 = google::protobuf::RepeatedPtrField<google::protobuf::EnumDescriptorProto>::end((google::protobuf::FileDescriptorProto *)((char *)this + 72));
while ( google::protobuf::internal::operator!=(v32, &v31) )
{
v30 = google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const>::operator*((long long)v32);
v6 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::EnumDescriptorProto>(v30);
v39 += v6;
google::protobuf::internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto const>::operator++(v32);
}
v7 = google::protobuf::FileDescriptorProto::_internal_service_size(this);
v39 += v7;
v29[1] = (char *)this + 96;
v29[0] = google::protobuf::RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::begin((google::protobuf::FileDescriptorProto *)((char *)this + 96));
v28 = google::protobuf::RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::end((google::protobuf::FileDescriptorProto *)((char *)this + 96));
while ( google::protobuf::internal::operator!=(v29, &v28) )
{
v27 = google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const>::operator*((long long)v29);
v8 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::ServiceDescriptorProto>(v27);
v39 += v8;
google::protobuf::internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto const>::operator++(v29);
}
v9 = google::protobuf::FileDescriptorProto::_internal_extension_size(this);
v39 += v9;
v26[1] = (char *)this + 120;
v26[0] = google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::begin((google::protobuf::FileDescriptorProto *)((char *)this + 120));
*(_QWORD *)v25 = google::protobuf::RepeatedPtrField<google::protobuf::FieldDescriptorProto>::end((google::protobuf::FileDescriptorProto *)((char *)this + 120));
while ( google::protobuf::internal::operator!=(v26, v25) )
{
v24 = google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const>::operator*((long long)v26);
v10 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::FieldDescriptorProto>(v24);
v39 += v10;
google::protobuf::internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto const>::operator++(v26);
}
v23 = google::protobuf::internal::WireFormatLite::Int32Size((char *)this + 144);
v11 = google::protobuf::FileDescriptorProto::_internal_public_dependency_size(this);
v39 += google::protobuf::internal::FromIntSize((google::protobuf::internal *)v11, (int)v25);
v39 += v23;
v22 = google::protobuf::internal::WireFormatLite::Int32Size((char *)this + 160);
v12 = google::protobuf::FileDescriptorProto::_internal_weak_dependency_size(this);
v39 += google::protobuf::internal::FromIntSize((google::protobuf::internal *)v12, (int)v25);
v39 += v22;
v42 = (char *)this + 16;
v41 = 0;
v38 = *((_DWORD *)this + 4);
if ( (v38 & 0x1F) != 0 )
{
if ( (v38 & 1) != 0 )
{
v13 = google::protobuf::FileDescriptorProto::_internal_name[abi:cxx11]((long long)this);
v14 = google::protobuf::internal::WireFormatLite::StringSize(v13);
v39 += v14 + 1;
}
if ( (v38 & 2) != 0 )
{
v15 = google::protobuf::FileDescriptorProto::_internal_package[abi:cxx11]((long long)this);
v16 = google::protobuf::internal::WireFormatLite::StringSize(v15);
v39 += v16 + 1;
}
if ( (v38 & 4) != 0 )
{
v17 = google::protobuf::FileDescriptorProto::_internal_syntax[abi:cxx11]((long long)this);
v18 = google::protobuf::internal::WireFormatLite::StringSize(v17);
v39 += v18 + 1;
}
if ( (v38 & 8) != 0 )
{
v19 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::FileOptions>(*((_QWORD *)this + 25));
v39 += v19 + 1;
}
if ( (v38 & 0x10) != 0 )
{
v20 = google::protobuf::internal::WireFormatLite::MessageSize<google::protobuf::SourceCodeInfo>(*((_QWORD *)this + 26));
v39 += v20 + 1;
}
}
return google::protobuf::Message::MaybeComputeUnknownFieldsSize(
this,
v39,
(google::protobuf::FileDescriptorProto *)((char *)this + 20));
}
|
ByteSizeLong:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb0],RDI
MOV RDI,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP],RDI
MOV qword ptr [RSP + 0xa8],0x0
MOV dword ptr [RSP + 0xa4],0x0
ADD RDI,0x10
ADD RDI,0x8
CALL 0x002ccd80
MOV EDI,EAX
CALL 0x001d53d0
MOV RDI,qword ptr [RSP]
SHL RAX,0x0
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
MOV dword ptr [RSP + 0xa0],0x0
ADD RDI,0x10
ADD RDI,0x8
CALL 0x002ccd80
MOV dword ptr [RSP + 0x9c],EAX
LAB_001ab63d:
MOV EAX,dword ptr [RSP + 0xa0]
CMP EAX,dword ptr [RSP + 0x9c]
JGE 0x001ab690
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x8
MOV ESI,dword ptr [RSP + 0xa0]
CALL 0x002ccd90
MOV RDI,RAX
CALL 0x001d53e0
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
MOV EAX,dword ptr [RSP + 0xa0]
ADD EAX,0x1
MOV dword ptr [RSP + 0xa0],EAX
JMP 0x001ab63d
LAB_001ab690:
MOV RDI,qword ptr [RSP]
CALL 0x001807d0
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOVSXD RCX,ECX
SHL RCX,0x0
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
ADD RAX,0x10
ADD RAX,0x20
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x00184270
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x90]
CALL 0x001842b0
MOV qword ptr [RSP + 0x80],RAX
LAB_001ab6f0:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x80]
CALL 0x00184310
TEST AL,0x1
JNZ 0x001ab70b
JMP 0x001ab746
LAB_001ab70b:
LEA RDI,[RSP + 0x88]
CALL 0x00184330
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001d5400
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x88]
CALL 0x00184410
JMP 0x001ab6f0
LAB_001ab746:
MOV RDI,qword ptr [RSP]
CALL 0x00186320
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOVSXD RCX,ECX
SHL RCX,0x0
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
ADD RAX,0x10
ADD RAX,0x38
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00184720
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x00184760
MOV qword ptr [RSP + 0x60],RAX
LAB_001ab797:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x60]
CALL 0x001847c0
TEST AL,0x1
JNZ 0x001ab7ac
JMP 0x001ab7e1
LAB_001ab7ac:
LEA RDI,[RSP + 0x68]
CALL 0x001847e0
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x001d5420
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x68]
CALL 0x00184820
JMP 0x001ab797
LAB_001ab7e1:
MOV RDI,qword ptr [RSP]
CALL 0x00186550
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOVSXD RCX,ECX
SHL RCX,0x0
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
ADD RAX,0x10
ADD RAX,0x50
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00183f80
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00183fc0
MOV qword ptr [RSP + 0x40],RAX
LAB_001ab832:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x40]
CALL 0x00184020
TEST AL,0x1
JNZ 0x001ab847
JMP 0x001ab87c
LAB_001ab847:
LEA RDI,[RSP + 0x48]
CALL 0x00184040
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001d5440
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x48]
CALL 0x00184080
JMP 0x001ab832
LAB_001ab87c:
MOV RDI,qword ptr [RSP]
CALL 0x00180810
MOV ECX,EAX
MOV RAX,qword ptr [RSP]
MOVSXD RCX,ECX
SHL RCX,0x0
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
ADD RAX,0x10
ADD RAX,0x68
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001849d0
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00184a10
MOV qword ptr [RSP + 0x20],RAX
LAB_001ab8cd:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x20]
CALL 0x00184a70
TEST AL,0x1
JNZ 0x001ab8e2
JMP 0x001ab917
LAB_001ab8e2:
LEA RDI,[RSP + 0x28]
CALL 0x00184a90
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001d5460
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x28]
CALL 0x00184ab0
JMP 0x001ab8cd
LAB_001ab917:
MOV RDI,qword ptr [RSP]
ADD RDI,0x10
ADD RDI,0x80
CALL 0x002d91a0
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001860c0
MOV EDI,EAX
CALL 0x001d53d0
MOV RDI,qword ptr [RSP]
SHL RAX,0x0
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
ADD RDI,0x10
ADD RDI,0x90
CALL 0x002d91a0
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00186070
MOV EDI,EAX
CALL 0x001d53d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
SHL RCX,0x0
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
MOV RCX,qword ptr [RSP + 0x8]
ADD RCX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RCX
ADD RAX,0x10
MOV qword ptr [RSP + 0xc0],RAX
MOV dword ptr [RSP + 0xbc],0x0
MOV RAX,qword ptr [RSP + 0xc0]
MOVSXD RCX,dword ptr [RSP + 0xbc]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RSP + 0xa4],EAX
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x1f
CMP EAX,0x0
JZ 0x001abb0a
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001aba3a
MOV RDI,qword ptr [RSP]
CALL 0x00180230
MOV RDI,RAX
CALL 0x001d53e0
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001aba3a:
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x2
CMP EAX,0x0
JZ 0x001aba6e
MOV RDI,qword ptr [RSP]
CALL 0x00183ea0
MOV RDI,RAX
CALL 0x001d53e0
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001aba6e:
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x4
CMP EAX,0x0
JZ 0x001abaa2
MOV RDI,qword ptr [RSP]
CALL 0x00185f90
MOV RDI,RAX
CALL 0x001d53e0
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001abaa2:
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001abad5
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xc8]
CALL 0x001d5480
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001abad5:
MOV EAX,dword ptr [RSP + 0xa4]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001abb08
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0xd0]
CALL 0x001d54a0
ADD RAX,0x1
ADD RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_001abb08:
JMP 0x001abb0a
LAB_001abb0a:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,RDI
ADD RDX,0x10
ADD RDX,0x4
CALL 0x0023aa50
ADD RSP,0xc8
RET
|
/* google::protobuf::FileDescriptorProto::ByteSizeLong() const */
void __thiscall google::protobuf::FileDescriptorProto::ByteSizeLong(FileDescriptorProto *this)
{
int iVar1;
long lVar2;
string *psVar3;
ulong uVar4;
FieldDescriptorProto *pFVar5;
long lVar6;
int8 local_a8;
int8 local_a0;
RepeatedPtrField<google::protobuf::FieldDescriptorProto> *local_98;
ServiceDescriptorProto *local_90;
int8 local_88;
int8 local_80;
RepeatedPtrField<google::protobuf::ServiceDescriptorProto> *local_78;
EnumDescriptorProto *local_70;
int8 local_68;
int8 local_60;
RepeatedPtrField<google::protobuf::EnumDescriptorProto> *local_58;
DescriptorProto *local_50;
int8 local_48;
int8 local_40;
RepeatedPtrField<google::protobuf::DescriptorProto> *local_38;
int local_2c;
int local_28;
uint local_24;
ulong local_20;
FileDescriptorProto *local_18;
int4 local_c;
FileDescriptorProto *local_8;
local_20 = 0;
local_24 = 0;
local_18 = this;
iVar1 = RepeatedPtrField<std::__cxx11::string>::size
((RepeatedPtrField<std::__cxx11::string> *)(this + 0x18));
lVar2 = internal::FromIntSize(iVar1);
local_20 = lVar2 + local_20;
local_28 = 0;
local_2c = RepeatedPtrField<std::__cxx11::string>::size
((RepeatedPtrField<std::__cxx11::string> *)(this + 0x18));
for (; local_28 < local_2c; local_28 = local_28 + 1) {
psVar3 = (string *)
RepeatedPtrField<std::__cxx11::string>::Get
((RepeatedPtrField<std::__cxx11::string> *)(this + 0x18),local_28);
lVar2 = internal::WireFormatLite::StringSize(psVar3);
local_20 = lVar2 + local_20;
}
iVar1 = _internal_message_type_size(this);
local_20 = (long)iVar1 + local_20;
local_38 = (RepeatedPtrField<google::protobuf::DescriptorProto> *)(this + 0x30);
local_40 = RepeatedPtrField<google::protobuf::DescriptorProto>::begin(local_38);
local_48 = RepeatedPtrField<google::protobuf::DescriptorProto>::end(local_38);
while (uVar4 = internal::operator!=
((RepeatedPtrIterator *)&local_40,(RepeatedPtrIterator *)&local_48),
(uVar4 & 1) != 0) {
local_50 = (DescriptorProto *)
internal::RepeatedPtrIterator<google::protobuf::DescriptorProto_const>::operator*
((RepeatedPtrIterator<google::protobuf::DescriptorProto_const> *)&local_40)
;
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::DescriptorProto>(local_50);
local_20 = uVar4 + local_20;
internal::RepeatedPtrIterator<google::protobuf::DescriptorProto_const>::operator++
((RepeatedPtrIterator<google::protobuf::DescriptorProto_const> *)&local_40);
}
iVar1 = _internal_enum_type_size(this);
local_20 = (long)iVar1 + local_20;
local_58 = (RepeatedPtrField<google::protobuf::EnumDescriptorProto> *)(this + 0x48);
local_60 = RepeatedPtrField<google::protobuf::EnumDescriptorProto>::begin(local_58);
local_68 = RepeatedPtrField<google::protobuf::EnumDescriptorProto>::end(local_58);
while (uVar4 = internal::operator!=
((RepeatedPtrIterator *)&local_60,(RepeatedPtrIterator *)&local_68),
(uVar4 & 1) != 0) {
local_70 = (EnumDescriptorProto *)
internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto_const>::operator*
((RepeatedPtrIterator<google::protobuf::EnumDescriptorProto_const> *)
&local_60);
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::EnumDescriptorProto>(local_70);
local_20 = uVar4 + local_20;
internal::RepeatedPtrIterator<google::protobuf::EnumDescriptorProto_const>::operator++
((RepeatedPtrIterator<google::protobuf::EnumDescriptorProto_const> *)&local_60);
}
iVar1 = _internal_service_size(this);
local_20 = (long)iVar1 + local_20;
local_78 = (RepeatedPtrField<google::protobuf::ServiceDescriptorProto> *)(this + 0x60);
local_80 = RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::begin(local_78);
local_88 = RepeatedPtrField<google::protobuf::ServiceDescriptorProto>::end(local_78);
while (uVar4 = internal::operator!=
((RepeatedPtrIterator *)&local_80,(RepeatedPtrIterator *)&local_88),
(uVar4 & 1) != 0) {
local_90 = (ServiceDescriptorProto *)
internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto_const>::
operator*((RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto_const> *)
&local_80);
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::ServiceDescriptorProto>
(local_90);
local_20 = uVar4 + local_20;
internal::RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto_const>::operator++
((RepeatedPtrIterator<google::protobuf::ServiceDescriptorProto_const> *)&local_80);
}
iVar1 = _internal_extension_size(this);
local_20 = (long)iVar1 + local_20;
local_98 = (RepeatedPtrField<google::protobuf::FieldDescriptorProto> *)(this + 0x78);
local_a0 = RepeatedPtrField<google::protobuf::FieldDescriptorProto>::begin(local_98);
local_a8 = RepeatedPtrField<google::protobuf::FieldDescriptorProto>::end(local_98);
while (uVar4 = internal::operator!=
((RepeatedPtrIterator *)&local_a0,(RepeatedPtrIterator *)&local_a8),
(uVar4 & 1) != 0) {
pFVar5 = (FieldDescriptorProto *)
internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto_const>::operator*
((RepeatedPtrIterator<google::protobuf::FieldDescriptorProto_const> *)
&local_a0);
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::FieldDescriptorProto>(pFVar5);
local_20 = uVar4 + local_20;
internal::RepeatedPtrIterator<google::protobuf::FieldDescriptorProto_const>::operator++
((RepeatedPtrIterator<google::protobuf::FieldDescriptorProto_const> *)&local_a0);
}
lVar2 = internal::WireFormatLite::Int32Size((RepeatedField *)(this + 0x90));
iVar1 = _internal_public_dependency_size(this);
lVar6 = internal::FromIntSize(iVar1);
local_20 = lVar2 + lVar6 + local_20;
lVar2 = internal::WireFormatLite::Int32Size((RepeatedField *)(this + 0xa0));
iVar1 = _internal_weak_dependency_size(this);
lVar6 = internal::FromIntSize(iVar1);
local_20 = lVar2 + lVar6 + local_20;
local_8 = this + 0x10;
local_c = 0;
local_24 = *(uint *)local_8;
if ((local_24 & 0x1f) != 0) {
if ((local_24 & 1) != 0) {
psVar3 = (string *)_internal_name_abi_cxx11_(this);
lVar2 = internal::WireFormatLite::StringSize(psVar3);
local_20 = lVar2 + 1 + local_20;
}
if ((local_24 & 2) != 0) {
psVar3 = (string *)_internal_package_abi_cxx11_(this);
lVar2 = internal::WireFormatLite::StringSize(psVar3);
local_20 = lVar2 + 1 + local_20;
}
if ((local_24 & 4) != 0) {
psVar3 = (string *)_internal_syntax_abi_cxx11_(this);
lVar2 = internal::WireFormatLite::StringSize(psVar3);
local_20 = lVar2 + 1 + local_20;
}
if ((local_24 & 8) != 0) {
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::FileOptions>
(*(FileOptions **)(this + 200));
local_20 = uVar4 + 1 + local_20;
}
if ((local_24 & 0x10) != 0) {
uVar4 = internal::WireFormatLite::MessageSize<google::protobuf::SourceCodeInfo>
(*(SourceCodeInfo **)(this + 0xd0));
local_20 = uVar4 + 1 + local_20;
}
}
Message::MaybeComputeUnknownFieldsSize((Message *)this,local_20,(CachedSize *)(this + 0x14));
return;
}
|
|
58,591
|
stbi_is_hdr_from_file
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
#ifndef STBI_NO_HDR
long pos = ftell(f);
int res;
stbi__context s;
stbi__start_file(&s,f);
res = stbi__hdr_test(&s);
fseek(f, pos, SEEK_SET);
return res;
#else
STBI_NOTUSED(f);
return 0;
#endif
}
|
O3
|
c
|
stbi_is_hdr_from_file:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
callq 0x1a050
movq %rax, %r14
movq 0x39c10(%rip), %rax # 0x59860
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x39bf0(%rip), %xmm0 # 0x59850
movups %xmm0, -0x28(%rcx)
movq %rbx, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%rcx)
movl $0x0, 0x80(%rcx)
movq %rcx, 0x98(%rcx)
movq %rcx, 0x88(%rcx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x32867
movq 0xc8(%r15), %rax
movq %rax, 0xd8(%r15)
movq %r15, %rdi
callq 0x1fbb3
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1b520
movl %ebp, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
stbi_is_hdr_from_file:
push rbp
push r15
push r14
push rbx
sub rsp, 0E8h
mov rbx, rdi
call _ftell
mov r14, rax
mov rax, cs:off_59860
lea rcx, [rsp+108h+var_C8]
mov [rcx-18h], rax
movups xmm0, xmmword ptr cs:_ZL21stbi__stdio_callbacks; stbi__stdio_callbacks
movups xmmword ptr [rcx-28h], xmm0
mov [rcx-10h], rbx
mov rax, 8000000001h
mov [rcx-8], rax
mov dword ptr [rcx+80h], 0
mov [rcx+98h], rcx
mov [rcx+88h], rcx
lea r15, [rsp+108h+var_100]
mov rdi, r15
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [r15+0C8h]
mov [r15+0D8h], rax
mov rdi, r15
call _ZL14stbi__hdr_testP13stbi__context; stbi__hdr_test(stbi__context *)
mov ebp, eax
mov rdi, rbx
mov rsi, r14
xor edx, edx
call _fseek
mov eax, ebp
add rsp, 0E8h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long stbi_is_hdr_from_file(long long a1)
{
long long v1; // r14
unsigned int v2; // ebp
_BYTE v4[16]; // [rsp+8h] [rbp-100h] BYREF
__int128 v5; // [rsp+18h] [rbp-F0h]
long long ( *v6)(void *); // [rsp+28h] [rbp-E0h]
long long v7; // [rsp+30h] [rbp-D8h]
long long v8; // [rsp+38h] [rbp-D0h]
_BYTE v9[128]; // [rsp+40h] [rbp-C8h] BYREF
int v10; // [rsp+C0h] [rbp-48h]
_BYTE *v11; // [rsp+C8h] [rbp-40h]
long long v12; // [rsp+D0h] [rbp-38h]
_BYTE *v13; // [rsp+D8h] [rbp-30h]
long long v14; // [rsp+E0h] [rbp-28h]
v1 = ftell(a1);
v6 = stbi__stdio_eof;
v5 = *(_OWORD *)&stbi__stdio_callbacks;
v7 = a1;
v8 = 0x8000000001LL;
v10 = 0;
v13 = v9;
v11 = v9;
stbi__refill_buffer(v4);
v14 = v12;
v2 = stbi__hdr_test((long long)v4);
fseek(a1, v1, 0LL);
return v2;
}
|
stbi_is_hdr_from_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xe8
MOV RBX,RDI
CALL 0x0011a050
MOV R14,RAX
MOV RAX,qword ptr [0x00159860]
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX + -0x18],RAX
MOVUPS XMM0,xmmword ptr [0x00159850]
MOVUPS xmmword ptr [RCX + -0x28],XMM0
MOV qword ptr [RCX + -0x10],RBX
MOV RAX,0x8000000001
MOV qword ptr [RCX + -0x8],RAX
MOV dword ptr [RCX + 0x80],0x0
MOV qword ptr [RCX + 0x98],RCX
MOV qword ptr [RCX + 0x88],RCX
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00132867
MOV RAX,qword ptr [R15 + 0xc8]
MOV qword ptr [R15 + 0xd8],RAX
MOV RDI,R15
CALL 0x0011fbb3
MOV EBP,EAX
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x0011b520
MOV EAX,EBP
ADD RSP,0xe8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 stbi_is_hdr_from_file(FILE *param_1)
{
int4 uVar1;
long __off;
stbi__context local_100 [40];
FILE *local_d8;
int8 local_d0;
int1 local_c8 [128];
int4 local_48;
int1 *local_40;
int8 local_38;
int1 *local_30;
int8 local_28;
__off = ftell(param_1);
local_40 = local_c8;
local_100[0x20] = (stbi__context)stbi__stdio_callbacks[0x10];
local_100[0x21] = (stbi__context)stbi__stdio_callbacks[0x11];
local_100[0x22] = (stbi__context)stbi__stdio_callbacks[0x12];
local_100[0x23] = (stbi__context)stbi__stdio_callbacks[0x13];
local_100[0x24] = (stbi__context)stbi__stdio_callbacks[0x14];
local_100[0x25] = (stbi__context)stbi__stdio_callbacks[0x15];
local_100[0x26] = (stbi__context)stbi__stdio_callbacks[0x16];
local_100[0x27] = (stbi__context)stbi__stdio_callbacks[0x17];
local_100[0x10] = (stbi__context)stbi__stdio_callbacks[0];
local_100[0x11] = (stbi__context)stbi__stdio_callbacks[1];
local_100[0x12] = (stbi__context)stbi__stdio_callbacks[2];
local_100[0x13] = (stbi__context)stbi__stdio_callbacks[3];
local_100[0x14] = (stbi__context)stbi__stdio_callbacks[4];
local_100[0x15] = (stbi__context)stbi__stdio_callbacks[5];
local_100[0x16] = (stbi__context)stbi__stdio_callbacks[6];
local_100[0x17] = (stbi__context)stbi__stdio_callbacks[7];
local_100[0x18] = (stbi__context)stbi__stdio_callbacks[8];
local_100[0x19] = (stbi__context)stbi__stdio_callbacks[9];
local_100[0x1a] = (stbi__context)stbi__stdio_callbacks[10];
local_100[0x1b] = (stbi__context)stbi__stdio_callbacks[0xb];
local_100[0x1c] = (stbi__context)stbi__stdio_callbacks[0xc];
local_100[0x1d] = (stbi__context)stbi__stdio_callbacks[0xd];
local_100[0x1e] = (stbi__context)stbi__stdio_callbacks[0xe];
local_100[0x1f] = (stbi__context)stbi__stdio_callbacks[0xf];
local_d0 = 0x8000000001;
local_48 = 0;
local_d8 = param_1;
local_30 = local_40;
stbi__refill_buffer(local_100);
local_28 = local_38;
uVar1 = stbi__hdr_test(local_100);
fseek(param_1,__off,0);
return uVar1;
}
|
|
58,592
|
trnman_destroy
|
eloqsql/storage/maria/trnman.c
|
void trnman_destroy()
{
DBUG_ENTER("trnman_destroy");
if (short_trid_to_active_trn == NULL) /* trnman already destroyed */
DBUG_VOID_RETURN;
DBUG_ASSERT(trid_to_trn.count == 0);
DBUG_ASSERT(trnman_active_transactions == 0);
DBUG_ASSERT(trnman_committed_transactions == 0);
DBUG_ASSERT(active_list_max.prev == &active_list_min);
DBUG_ASSERT(active_list_min.next == &active_list_max);
DBUG_ASSERT(committed_list_max.prev == &committed_list_min);
DBUG_ASSERT(committed_list_min.next == &committed_list_max);
while (pool)
{
TRN *trn= pool;
pool= pool->next;
DBUG_ASSERT(trn->wt == NULL);
mysql_mutex_destroy(&trn->state_lock);
my_free(trn);
}
lf_hash_destroy(&trid_to_trn);
DBUG_PRINT("info", ("mysql_mutex_destroy LOCK_trn_list"));
mysql_mutex_destroy(&LOCK_trn_list);
my_free(short_trid_to_active_trn+1);
short_trid_to_active_trn= NULL;
DBUG_VOID_RETURN;
}
|
O0
|
c
|
trnman_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x42b6f0(%rip) # 0x479010
jne 0x4d929
jmp 0x4d924
jmp 0x4d9bf
jmp 0x4d92b
jmp 0x4d92d
jmp 0x4d92f
jmp 0x4d931
jmp 0x4d933
jmp 0x4d935
jmp 0x4d937
jmp 0x4d939
jmp 0x4d93b
jmp 0x4d93d
jmp 0x4d93f
jmp 0x4d941
jmp 0x4d943
jmp 0x4d945
jmp 0x4d947
cmpq $0x0, 0x42b999(%rip) # 0x4792e8
je 0x4d988
movq 0x42b990(%rip), %rax # 0x4792e8
movq %rax, -0x8(%rbp)
movq 0x42b985(%rip), %rax # 0x4792e8
movq 0x68(%rax), %rax
movq %rax, 0x42b97a(%rip) # 0x4792e8
jmp 0x4d970
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x4d9d0
movq -0x8(%rbp), %rdi
callq 0xf4f60
jmp 0x4d947
leaq 0x42b969(%rip), %rdi # 0x4792f8
callq 0xfe830
jmp 0x4d996
leaq 0x42ba23(%rip), %rdi # 0x4793c0
callq 0x4d9d0
movq 0x42b667(%rip), %rdi # 0x479010
addq $0x8, %rdi
callq 0xf4f60
movq $0x0, 0x42b653(%rip) # 0x479010
jmp 0x4d9bf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
trnman_destroy:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:short_trid_to_active_trn, 0
jnz short loc_4D929
jmp short $+2
loc_4D924:
jmp loc_4D9BF
loc_4D929:
jmp short $+2
loc_4D92B:
jmp short $+2
loc_4D92D:
jmp short $+2
loc_4D92F:
jmp short $+2
loc_4D931:
jmp short $+2
loc_4D933:
jmp short $+2
loc_4D935:
jmp short $+2
loc_4D937:
jmp short $+2
loc_4D939:
jmp short $+2
loc_4D93B:
jmp short $+2
loc_4D93D:
jmp short $+2
loc_4D93F:
jmp short $+2
loc_4D941:
jmp short $+2
loc_4D943:
jmp short $+2
loc_4D945:
jmp short $+2
loc_4D947:
cmp cs:pool, 0
jz short loc_4D988
mov rax, cs:pool
mov [rbp+var_8], rax
mov rax, cs:pool
mov rax, [rax+68h]
mov cs:pool, rax
jmp short $+2
loc_4D970:
mov rdi, [rbp+var_8]
add rdi, 10h
call inline_mysql_mutex_destroy_2
mov rdi, [rbp+var_8]
call my_free
jmp short loc_4D947
loc_4D988:
lea rdi, trid_to_trn
call lf_hash_destroy
jmp short $+2
loc_4D996:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_destroy_2
mov rdi, cs:short_trid_to_active_trn
add rdi, 8
call my_free
mov cs:short_trid_to_active_trn, 0
jmp short $+2
loc_4D9BF:
add rsp, 10h
pop rbp
retn
|
long long trnman_destroy()
{
long long result; // rax
long long v1; // [rsp+8h] [rbp-8h]
if ( short_trid_to_active_trn )
{
while ( pool )
{
v1 = pool;
pool = *(_QWORD *)(pool + 104);
inline_mysql_mutex_destroy_2(v1 + 16);
my_free(v1);
}
lf_hash_destroy(&trid_to_trn);
inline_mysql_mutex_destroy_2(&LOCK_trn_list);
result = my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0LL;
}
return result;
}
|
trnman_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP qword ptr [0x00579010],0x0
JNZ 0x0014d929
JMP 0x0014d924
LAB_0014d924:
JMP 0x0014d9bf
LAB_0014d929:
JMP 0x0014d92b
LAB_0014d92b:
JMP 0x0014d92d
LAB_0014d92d:
JMP 0x0014d92f
LAB_0014d92f:
JMP 0x0014d931
LAB_0014d931:
JMP 0x0014d933
LAB_0014d933:
JMP 0x0014d935
LAB_0014d935:
JMP 0x0014d937
LAB_0014d937:
JMP 0x0014d939
LAB_0014d939:
JMP 0x0014d93b
LAB_0014d93b:
JMP 0x0014d93d
LAB_0014d93d:
JMP 0x0014d93f
LAB_0014d93f:
JMP 0x0014d941
LAB_0014d941:
JMP 0x0014d943
LAB_0014d943:
JMP 0x0014d945
LAB_0014d945:
JMP 0x0014d947
LAB_0014d947:
CMP qword ptr [0x005792e8],0x0
JZ 0x0014d988
MOV RAX,qword ptr [0x005792e8]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [0x005792e8]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [0x005792e8],RAX
JMP 0x0014d970
LAB_0014d970:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x10
CALL 0x0014d9d0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f4f60
JMP 0x0014d947
LAB_0014d988:
LEA RDI,[0x5792f8]
CALL 0x001fe830
JMP 0x0014d996
LAB_0014d996:
LEA RDI,[0x5793c0]
CALL 0x0014d9d0
MOV RDI,qword ptr [0x00579010]
ADD RDI,0x8
CALL 0x001f4f60
MOV qword ptr [0x00579010],0x0
JMP 0x0014d9bf
LAB_0014d9bf:
ADD RSP,0x10
POP RBP
RET
|
void trnman_destroy(void)
{
long lVar1;
long lVar2;
if (short_trid_to_active_trn != 0) {
while (lVar1 = pool, pool != 0) {
lVar2 = pool + 0x10;
pool = *(long *)(pool + 0x68);
inline_mysql_mutex_destroy(lVar2);
my_free(lVar1);
}
lf_hash_destroy(trid_to_trn);
inline_mysql_mutex_destroy(LOCK_trn_list);
my_free(short_trid_to_active_trn + 8);
short_trid_to_active_trn = 0;
}
return;
}
|
|
58,593
|
sd_log_cb(sd_log_level_t, char const*, void*)
|
7CodeWizard[P]stablediffusion/examples/cli/main.cpp
|
void sd_log_cb(enum sd_log_level_t level, const char* log, void* data) {
SDParams* params = (SDParams*)data;
if (!params->verbose && level <= SD_LOG_DEBUG) {
return;
}
if (level <= SD_LOG_INFO) {
fputs(log, stdout);
fflush(stdout);
} else {
fputs(log, stderr);
fflush(stderr);
}
}
|
O0
|
cpp
|
sd_log_cb(sd_log_level_t, char const*, void*):
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x160(%rax)
jne 0x12c93
cmpl $0x0, 0x24(%rsp)
jg 0x12c93
jmp 0x12ce2
cmpl $0x1, 0x24(%rsp)
jg 0x12cbf
movq 0x18(%rsp), %rdi
movq 0x1c5282(%rip), %rax # 0x1d7f28
movq (%rax), %rsi
callq 0xb890
movq 0x1c5273(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
jmp 0x12ce2
movq 0x18(%rsp), %rdi
movq 0x1c52dd(%rip), %rax # 0x1d7fa8
movq (%rax), %rsi
callq 0xb890
movq 0x1c52ce(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
callq 0xb8e0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
|
_Z9sd_log_cb14sd_log_level_tPKcPv:
sub rsp, 28h
mov [rsp+28h+var_4], edi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_20]
test byte ptr [rax+160h], 1
jnz short loc_12C93
cmp [rsp+28h+var_4], 0
jg short loc_12C93
jmp short loc_12CE2
loc_12C93:
cmp [rsp+28h+var_4], 1
jg short loc_12CBF
mov rdi, [rsp+28h+var_10]
mov rax, cs:stdout_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
jmp short loc_12CE2
loc_12CBF:
mov rdi, [rsp+28h+var_10]
mov rax, cs:stderr_ptr
mov rsi, [rax]
call _fputs
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fflush
loc_12CE2:
add rsp, 28h
retn
|
long long sd_log_cb(int a1, long long a2, long long a3)
{
long long result; // rax
result = a3;
if ( (*(_BYTE *)(a3 + 352) & 1) != 0 || a1 > 0 )
{
if ( a1 > 1 )
{
fputs(a2, stderr);
return fflush(stderr);
}
else
{
fputs(a2, stdout);
return fflush(stdout);
}
}
return result;
}
|
sd_log_cb:
SUB RSP,0x28
MOV dword ptr [RSP + 0x24],EDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
TEST byte ptr [RAX + 0x160],0x1
JNZ 0x00112c93
CMP dword ptr [RSP + 0x24],0x0
JG 0x00112c93
JMP 0x00112ce2
LAB_00112c93:
CMP dword ptr [RSP + 0x24],0x1
JG 0x00112cbf
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [0x002d7f28]
MOV RSI,qword ptr [RAX]
CALL 0x0010b890
MOV RAX,qword ptr [0x002d7f28]
MOV RDI,qword ptr [RAX]
CALL 0x0010b8e0
JMP 0x00112ce2
LAB_00112cbf:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [0x002d7fa8]
MOV RSI,qword ptr [RAX]
CALL 0x0010b890
MOV RAX,qword ptr [0x002d7fa8]
MOV RDI,qword ptr [RAX]
CALL 0x0010b8e0
LAB_00112ce2:
ADD RSP,0x28
RET
|
/* sd_log_cb(sd_log_level_t, char const*, void*) */
void sd_log_cb(int param_1,char *param_2,long param_3)
{
if (((*(byte *)(param_3 + 0x160) & 1) != 0) || (0 < param_1)) {
if (param_1 < 2) {
fputs(param_2,*(FILE **)PTR_stdout_002d7f28);
fflush(*(FILE **)PTR_stdout_002d7f28);
}
else {
fputs(param_2,*(FILE **)PTR_stderr_002d7fa8);
fflush(*(FILE **)PTR_stderr_002d7fa8);
}
}
return;
}
|
|
58,594
|
sd_log_cb(sd_log_level_t, char const*, void*)
|
7CodeWizard[P]stablediffusion/examples/cli/main.cpp
|
void sd_log_cb(enum sd_log_level_t level, const char* log, void* data) {
SDParams* params = (SDParams*)data;
if (!params->verbose && level <= SD_LOG_DEBUG) {
return;
}
if (level <= SD_LOG_INFO) {
fputs(log, stdout);
fflush(stdout);
} else {
fputs(log, stderr);
fflush(stderr);
}
}
|
O1
|
cpp
|
sd_log_cb(sd_log_level_t, char const*, void*):
testl %edi, %edi
jg 0x1e491
cmpb $0x0, 0x160(%rdx)
jne 0x1e491
retq
pushq %rbx
cmpl $0x1, %edi
jg 0x1e4b5
movq 0xd8aba(%rip), %rbx # 0xf6f58
movq (%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xa670
movq (%rbx), %rdi
popq %rbx
jmp 0xa6e0
movq 0xd8afc(%rip), %rbx # 0xf6fb8
jmp 0x1e49e
|
_Z9sd_log_cb14sd_log_level_tPKcPv:
test edi, edi
jg short loc_1E491
cmp byte ptr [rdx+160h], 0
jnz short loc_1E491
retn
loc_1E491:
push rbx
cmp edi, 1
jg short loc_1E4B5
mov rbx, cs:stdout_ptr
loc_1E49E:
mov rax, [rbx]
mov rdi, rsi
mov rsi, rax
call _fputs
mov rdi, [rbx]
pop rbx
jmp _fflush
loc_1E4B5:
mov rbx, cs:stderr_ptr
jmp short loc_1E49E
|
long long sd_log_cb(int a1, long long a2, long long a3)
{
_QWORD *v3; // rbx
long long result; // rax
if ( a1 > 0 || *(_BYTE *)(a3 + 352) )
{
if ( a1 > 1 )
v3 = &stderr;
else
v3 = &stdout;
fputs(a2, *v3);
return fflush(*v3);
}
return result;
}
| |||
58,595
|
OpenGL_Init_3_1
|
SDL3Lite/dependencies/OpenGL.h
|
void OpenGL_Init_3_1()
{
glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)OpenGL_Load("glDrawArraysInstanced");
glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)OpenGL_Load("glDrawElementsInstanced");
glTexBuffer = (PFNGLTEXBUFFERPROC)OpenGL_Load("glTexBuffer");
glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)OpenGL_Load("glPrimitiveRestartIndex");
glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)OpenGL_Load("glCopyBufferSubData");
glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)OpenGL_Load("glGetUniformIndices");
glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)OpenGL_Load("glGetActiveUniformsiv");
glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)OpenGL_Load("glGetActiveUniformName");
glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)OpenGL_Load("glGetUniformBlockIndex");
glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)OpenGL_Load("glGetActiveUniformBlockiv");
glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)OpenGL_Load("glGetActiveUniformBlockName");
glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)OpenGL_Load("glUniformBlockBinding");
}
|
O0
|
c
|
OpenGL_Init_3_1:
pushq %rbp
movq %rsp, %rbp
leaq 0x53a8(%rip), %rdi # 0x17723
callq 0xf380
movq %rax, 0xb0f9(%rip) # 0x1d480
leaq 0x53ab(%rip), %rdi # 0x17739
callq 0xf380
movq %rax, 0xb0ee(%rip) # 0x1d488
leaq 0x53b0(%rip), %rdi # 0x17751
callq 0xf380
movq %rax, 0xb0e3(%rip) # 0x1d490
leaq 0x53a9(%rip), %rdi # 0x1775d
callq 0xf380
movq %rax, 0xb0d8(%rip) # 0x1d498
leaq 0x53ae(%rip), %rdi # 0x17775
callq 0xf380
movq %rax, 0xb0cd(%rip) # 0x1d4a0
leaq 0x53af(%rip), %rdi # 0x17789
callq 0xf380
movq %rax, 0xb0c2(%rip) # 0x1d4a8
leaq 0x53b0(%rip), %rdi # 0x1779d
callq 0xf380
movq %rax, 0xb0b7(%rip) # 0x1d4b0
leaq 0x53b3(%rip), %rdi # 0x177b3
callq 0xf380
movq %rax, 0xb0ac(%rip) # 0x1d4b8
leaq 0x53b7(%rip), %rdi # 0x177ca
callq 0xf380
movq %rax, 0xb0a1(%rip) # 0x1d4c0
leaq 0x53bb(%rip), %rdi # 0x177e1
callq 0xf380
movq %rax, 0xb096(%rip) # 0x1d4c8
leaq 0x53c2(%rip), %rdi # 0x177fb
callq 0xf380
movq %rax, 0xb08b(%rip) # 0x1d4d0
leaq 0x53cb(%rip), %rdi # 0x17817
callq 0xf380
movq %rax, 0xb080(%rip) # 0x1d4d8
popq %rbp
retq
nopw (%rax,%rax)
|
OpenGL_Init_3_1:
push rbp
mov rbp, rsp
lea rdi, aGldrawarraysin_2; "glDrawArraysInstanced"
call OpenGL_Load
mov cs:glDrawArraysInstanced, rax
lea rdi, aGldrawelements_7; "glDrawElementsInstanced"
call OpenGL_Load
mov cs:glDrawElementsInstanced, rax
lea rdi, aGltexbuffer_0; "glTexBuffer"
call OpenGL_Load
mov cs:glTexBuffer, rax
lea rdi, aGlprimitiveres_0; "glPrimitiveRestartIndex"
call OpenGL_Load
mov cs:glPrimitiveRestartIndex, rax
lea rdi, aGlcopybuffersu_0; "glCopyBufferSubData"
call OpenGL_Load
mov cs:glCopyBufferSubData, rax
lea rdi, aGlgetuniformin_0; "glGetUniformIndices"
call OpenGL_Load
mov cs:glGetUniformIndices, rax
lea rdi, aGlgetactiveuni_5; "glGetActiveUniformsiv"
call OpenGL_Load
mov cs:glGetActiveUniformsiv, rax
lea rdi, aGlgetactiveuni_6; "glGetActiveUniformName"
call OpenGL_Load
mov cs:glGetActiveUniformName, rax
lea rdi, aGlgetuniformbl_0; "glGetUniformBlockIndex"
call OpenGL_Load
mov cs:glGetUniformBlockIndex, rax
lea rdi, aGlgetactiveuni_7; "glGetActiveUniformBlockiv"
call OpenGL_Load
mov cs:glGetActiveUniformBlockiv, rax
lea rdi, aGlgetactiveuni_8; "glGetActiveUniformBlockName"
call OpenGL_Load
mov cs:glGetActiveUniformBlockName, rax
lea rdi, aGluniformblock_0; "glUniformBlockBinding"
call OpenGL_Load
mov cs:glUniformBlockBinding, rax
pop rbp
retn
|
long long OpenGL_Init_3_1()
{
long long result; // rax
glDrawArraysInstanced = OpenGL_Load("glDrawArraysInstanced");
glDrawElementsInstanced = OpenGL_Load("glDrawElementsInstanced");
glTexBuffer = OpenGL_Load("glTexBuffer");
glPrimitiveRestartIndex = OpenGL_Load("glPrimitiveRestartIndex");
glCopyBufferSubData = OpenGL_Load("glCopyBufferSubData");
glGetUniformIndices = OpenGL_Load("glGetUniformIndices");
glGetActiveUniformsiv = OpenGL_Load("glGetActiveUniformsiv");
glGetActiveUniformName = OpenGL_Load("glGetActiveUniformName");
glGetUniformBlockIndex = OpenGL_Load("glGetUniformBlockIndex");
glGetActiveUniformBlockiv = OpenGL_Load("glGetActiveUniformBlockiv");
glGetActiveUniformBlockName = OpenGL_Load("glGetActiveUniformBlockName");
result = OpenGL_Load("glUniformBlockBinding");
glUniformBlockBinding = result;
return result;
}
|
OpenGL_Init_3_1:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x117723]
CALL 0x0010f380
MOV qword ptr [0x0011d480],RAX
LEA RDI,[0x117739]
CALL 0x0010f380
MOV qword ptr [0x0011d488],RAX
LEA RDI,[0x117751]
CALL 0x0010f380
MOV qword ptr [0x0011d490],RAX
LEA RDI,[0x11775d]
CALL 0x0010f380
MOV qword ptr [0x0011d498],RAX
LEA RDI,[0x117775]
CALL 0x0010f380
MOV qword ptr [0x0011d4a0],RAX
LEA RDI,[0x117789]
CALL 0x0010f380
MOV qword ptr [0x0011d4a8],RAX
LEA RDI,[0x11779d]
CALL 0x0010f380
MOV qword ptr [0x0011d4b0],RAX
LEA RDI,[0x1177b3]
CALL 0x0010f380
MOV qword ptr [0x0011d4b8],RAX
LEA RDI,[0x1177ca]
CALL 0x0010f380
MOV qword ptr [0x0011d4c0],RAX
LEA RDI,[0x1177e1]
CALL 0x0010f380
MOV qword ptr [0x0011d4c8],RAX
LEA RDI,[0x1177fb]
CALL 0x0010f380
MOV qword ptr [0x0011d4d0],RAX
LEA RDI,[0x117817]
CALL 0x0010f380
MOV qword ptr [0x0011d4d8],RAX
POP RBP
RET
|
void OpenGL_Init_3_1(void)
{
glDrawArraysInstanced = OpenGL_Load("glDrawArraysInstanced");
glDrawElementsInstanced = OpenGL_Load("glDrawElementsInstanced");
glTexBuffer = OpenGL_Load("glTexBuffer");
glPrimitiveRestartIndex = OpenGL_Load("glPrimitiveRestartIndex");
glCopyBufferSubData = OpenGL_Load("glCopyBufferSubData");
glGetUniformIndices = OpenGL_Load("glGetUniformIndices");
glGetActiveUniformsiv = OpenGL_Load("glGetActiveUniformsiv");
glGetActiveUniformName = OpenGL_Load("glGetActiveUniformName");
glGetUniformBlockIndex = OpenGL_Load("glGetUniformBlockIndex");
glGetActiveUniformBlockiv = OpenGL_Load("glGetActiveUniformBlockiv");
glGetActiveUniformBlockName = OpenGL_Load("glGetActiveUniformBlockName");
glUniformBlockBinding = OpenGL_Load("glUniformBlockBinding");
return;
}
|
|
58,596
|
google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(google::protobuf::io::Printer*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/string_field.cc
|
void ImmutableStringFieldGenerator::GenerateBuilderParsingCode(
io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
"$name$_ = input.readStringRequireUtf8();\n"
"$set_has_field_bit_builder$\n");
} else {
printer->Print(variables_,
"$name$_ = input.readBytes();\n"
"$set_has_field_bit_builder$\n");
}
}
|
O0
|
cpp
|
google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(google::protobuf::io::Printer*) const:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rdi
callq 0x78030
testb $0x1, %al
jne 0x1c6b46
jmp 0x1c6b61
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x18, %rsi
leaq 0x22a725(%rip), %rdx # 0x3f127f
callq 0x3235f0
jmp 0x1c6b7a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x18, %rsi
leaq 0x22a750(%rip), %rdx # 0x3f12c5
callq 0x3235f0
addq $0x18, %rsp
retq
nop
|
_ZNK6google8protobuf8compiler4java29ImmutableStringFieldGenerator26GenerateBuilderParsingCodeEPNS0_2io7PrinterE:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov rdi, [rax+8]; this
call _ZN6google8protobuf8compiler4java9CheckUtf8EPKNS0_15FieldDescriptorE; google::protobuf::compiler::java::CheckUtf8(google::protobuf::FieldDescriptor const*)
test al, 1
jnz short loc_1C6B46
jmp short loc_1C6B61
loc_1C6B46:
mov rsi, [rsp+18h+var_18]
mov rdi, [rsp+18h+var_10]
add rsi, 18h
lea rdx, aNameInputReads; "$name$_ = input.readStringRequireUtf8()"...
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
jmp short loc_1C6B7A
loc_1C6B61:
mov rsi, [rsp+18h+var_18]
mov rdi, [rsp+18h+var_10]
add rsi, 18h
lea rdx, aNameInputReadb; "$name$_ = input.readBytes();\n$set_has_"...
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
loc_1C6B7A:
add rsp, 18h
retn
| ||||
58,597
|
google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(google::protobuf::io::Printer*) const
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/string_field.cc
|
void ImmutableStringFieldGenerator::GenerateBuilderParsingCode(
io::Printer* printer) const {
if (CheckUtf8(descriptor_)) {
printer->Print(variables_,
"$name$_ = input.readStringRequireUtf8();\n"
"$set_has_field_bit_builder$\n");
} else {
printer->Print(variables_,
"$name$_ = input.readBytes();\n"
"$set_has_field_bit_builder$\n");
}
}
|
O3
|
cpp
|
google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(google::protobuf::io::Printer*) const:
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rcx
cmpb $0x3, 0x3(%rcx)
jne 0xe7dcc
leaq 0xfa3cb(%rip), %rdx # 0x1e2195
jmp 0xe7de9
movq 0x78(%rcx), %rcx
leaq 0xfa3be(%rip), %rdi # 0x1e2195
leaq 0xfa3fd(%rip), %rdx # 0x1e21db
cmpb $0x0, 0x9a(%rcx)
cmovneq %rdi, %rdx
addq $0x18, %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x16cd32
|
_ZNK6google8protobuf8compiler4java29ImmutableStringFieldGenerator26GenerateBuilderParsingCodeEPNS0_2io7PrinterE:
mov rax, rdi
mov rcx, [rdi+8]
mov rcx, [rcx+10h]
cmp byte ptr [rcx+3], 3
jnz short loc_E7DCC
lea rdx, aNameInputReads; "$name$_ = input.readStringRequireUtf8()"...
jmp short loc_E7DE9
loc_E7DCC:
mov rcx, [rcx+78h]
lea rdi, aNameInputReads; "$name$_ = input.readStringRequireUtf8()"...
lea rdx, aNameInputReadb; "$name$_ = input.readBytes();\n$set_has_"...
cmp byte ptr [rcx+9Ah], 0
cmovnz rdx, rdi
loc_E7DE9:
add rax, 18h
mov rdi, rsi; this
mov rsi, rax
jmp _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
|
long long google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(
google::protobuf::compiler::java::ImmutableStringFieldGenerator *this,
google::protobuf::io::Printer *a2,
long long a3,
long long a4,
long long a5,
long long a6,
void *a7,
int a8,
char a9,
int a10,
int a11,
int a12,
int a13,
int a14,
int a15,
void *a16,
int a17,
char a18)
{
return google::protobuf::io::Printer::Print(a2, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
}
|
GenerateBuilderParsingCode:
MOV RAX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RCX + 0x10]
CMP byte ptr [RCX + 0x3],0x3
JNZ 0x001e7dcc
LEA RDX,[0x2e2195]
JMP 0x001e7de9
LAB_001e7dcc:
MOV RCX,qword ptr [RCX + 0x78]
LEA RDI,[0x2e2195]
LEA RDX,[0x2e21db]
CMP byte ptr [RCX + 0x9a],0x0
CMOVNZ RDX,RDI
LAB_001e7de9:
ADD RAX,0x18
MOV RDI,RSI
MOV RSI,RAX
JMP 0x0026cd32
|
/* google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode(google::protobuf::io::Printer*)
const */
void __thiscall
google::protobuf::compiler::java::ImmutableStringFieldGenerator::GenerateBuilderParsingCode
(ImmutableStringFieldGenerator *this,Printer *param_1)
{
char *pcVar1;
if (*(char *)(*(long *)(*(long *)(this + 8) + 0x10) + 3) == '\x03') {
pcVar1 = "$name$_ = input.readStringRequireUtf8();\n$set_has_field_bit_builder$\n";
}
else {
pcVar1 = "$name$_ = input.readBytes();\n$set_has_field_bit_builder$\n";
if (*(char *)(*(long *)(*(long *)(*(long *)(this + 8) + 0x10) + 0x78) + 0x9a) != '\0') {
pcVar1 = "$name$_ = input.readStringRequireUtf8();\n$set_has_field_bit_builder$\n";
}
}
io::Printer::Print(param_1,(map *)(this + 0x18),pcVar1);
return;
}
|
|
58,598
|
ma_read_bitmap_page
|
eloqsql/storage/maria/ma_bitmap.c
|
static my_bool _ma_read_bitmap_page(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
MARIA_SHARE *share= info->s;
my_bool res;
DBUG_ENTER("_ma_read_bitmap_page");
DBUG_PRINT("enter", ("page: %lld data_file_length: %lld",
(longlong) page,
(longlong) share->state.state.data_file_length));
DBUG_ASSERT(page % bitmap->pages_covered == 0);
DBUG_ASSERT(!bitmap->changed);
bitmap->page= page;
if ((page + 1) * bitmap->block_size > share->state.state.data_file_length)
{
/* Inexistent or half-created page */
res= _ma_bitmap_create_missing(info, bitmap, page);
if (!res)
adjust_total_size(info, page);
DBUG_RETURN(res);
}
adjust_total_size(info, page);
bitmap->full_head_size= bitmap->full_tail_size= 0;
DBUG_ASSERT(share->pagecache->block_size == bitmap->block_size);
res= pagecache_read(share->pagecache,
&bitmap->file, page, 0,
bitmap->map, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED, 0) == NULL;
if (!res)
{
/* Calculate used_size */
const uchar *data, *end= bitmap->map;
for (data= bitmap->map + bitmap->total_size; --data >= end && *data == 0; )
{}
bitmap->used_size= (uint) ((data + 1) - end);
DBUG_ASSERT(bitmap->used_size <= bitmap->total_size);
}
else
{
_ma_set_fatal_error(info, my_errno);
}
/*
We can't check maria_bitmap_marker here as if the bitmap page
previously had a true checksum and the user switched mode to not checksum
this may have any value, except maria_normal_page_marker.
Using maria_normal_page_marker gives us a protection against bugs
when running without any checksums.
*/
#ifndef DBUG_OFF
if (!res)
{
memcpy(bitmap->map + bitmap->block_size, bitmap->map, bitmap->block_size);
_ma_check_bitmap(bitmap);
}
#endif
DBUG_RETURN(res);
}
|
O0
|
c
|
ma_read_bitmap_page:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3f081
jmp 0x3f083
jmp 0x3f085
jmp 0x3f087
jmp 0x3f089
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x134(%rcx), %ecx
imulq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x3f0e9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3f200
movb %al, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x3f0dc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3f480
jmp 0x3f0de
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3f1f4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3f480
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0x3f10e
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x54cf0
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x3f1d4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x128(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jb 0x3f1ad
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x3f1b6
jmp 0x3f1b8
jmp 0x3f186
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x3f1d2
jmp 0x3f1ec
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x122520
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x70210
jmp 0x3f1ee
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
_ma_read_bitmap_page:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_3F081:
jmp short $+2
loc_3F083:
jmp short $+2
loc_3F085:
jmp short $+2
loc_3F087:
jmp short $+2
loc_3F089:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
add rax, 1
mov rcx, [rbp+var_18]
mov ecx, [rcx+134h]
imul rax, rcx
mov rcx, [rbp+var_28]
cmp rax, [rcx+40h]
jbe short loc_3F0E9
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _ma_bitmap_create_missing
mov [rbp+var_29], al
cmp [rbp+var_29], 0
jnz short loc_3F0DC
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call adjust_total_size
loc_3F0DC:
jmp short $+2
loc_3F0DE:
mov al, [rbp+var_29]
mov [rbp+var_1], al
jmp loc_3F1F4
loc_3F0E9:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call adjust_total_size
mov rax, [rbp+var_18]
mov dword ptr [rax+2Ch], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+28h], 0
jmp short $+2
loc_3F10E:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_18]
add rsi, 40h ; '@'
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
mov r8, [rax+8]
xor ecx, ecx
mov r9d, 1
xor eax, eax
mov [rsp+60h+var_60], 0
mov [rsp+60h+var_58], 0
call pagecache_read
cmp rax, 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_29], al
cmp [rbp+var_29], 0
jnz short loc_3F1D4
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov ecx, [rcx+128h]
add rax, rcx
mov [rbp+var_38], rax
loc_3F186:
mov rcx, [rbp+var_38]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rcx
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jb short loc_3F1AD
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
cmp eax, 0
setz al
mov [rbp+var_41], al
loc_3F1AD:
mov al, [rbp+var_41]
test al, 1
jnz short loc_3F1B6
jmp short loc_3F1B8
loc_3F1B6:
jmp short loc_3F186
loc_3F1B8:
mov rax, [rbp+var_38]
add rax, 1
mov rcx, [rbp+var_40]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+24h], ecx
jmp short $+2
loc_3F1D2:
jmp short loc_3F1EC
loc_3F1D4:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
call _my_thread_var
mov rdi, [rbp+var_50]
mov esi, [rax]
call _ma_set_fatal_error
loc_3F1EC:
jmp short $+2
loc_3F1EE:
mov al, [rbp+var_29]
mov [rbp+var_1], al
loc_3F1F4:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
|
bool ma_read_bitmap_page(long long *a1, long long a2, long long a3)
{
long long v3; // rax
unsigned int *v4; // rax
bool v6; // [rsp+1Fh] [rbp-41h]
unsigned long long v7; // [rsp+20h] [rbp-40h]
_BYTE *v8; // [rsp+28h] [rbp-38h]
char missing; // [rsp+37h] [rbp-29h]
bool v10; // [rsp+37h] [rbp-29h]
long long v11; // [rsp+38h] [rbp-28h]
v11 = *a1;
*(_QWORD *)(a2 + 16) = a3;
if ( (unsigned long long)*(unsigned int *)(a2 + 308) * (a3 + 1) <= *(_QWORD *)(v11 + 64) )
{
adjust_total_size(a1, a3);
*(_DWORD *)(a2 + 44) = 0;
*(_DWORD *)(a2 + 40) = 0;
v3 = pagecache_read(*(_QWORD *)(v11 + 1536), (int)a2 + 64, a3, 0, *(_QWORD *)(a2 + 8), 1, 0, 0LL);
v10 = v3 == 0;
if ( v3 )
{
v7 = *(_QWORD *)(a2 + 8);
v8 = (_BYTE *)(*(unsigned int *)(a2 + 296) + v7);
do
{
--v8;
v6 = 0;
if ( (unsigned long long)v8 >= v7 )
v6 = *v8 == 0;
}
while ( v6 );
*(_DWORD *)(a2 + 36) = (_DWORD)v8 + 1 - v7;
}
else
{
v4 = (unsigned int *)my_thread_var();
ma_set_fatal_error(a1, *v4);
}
return v10;
}
else
{
missing = ma_bitmap_create_missing(a1, a2, a3);
if ( !missing )
adjust_total_size(a1, a3);
return missing;
}
}
|
_ma_read_bitmap_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0013f081
LAB_0013f081:
JMP 0x0013f083
LAB_0013f083:
JMP 0x0013f085
LAB_0013f085:
JMP 0x0013f087
LAB_0013f087:
JMP 0x0013f089
LAB_0013f089:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x134]
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x40]
JBE 0x0013f0e9
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0013f200
MOV byte ptr [RBP + -0x29],AL
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x0013f0dc
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013f480
LAB_0013f0dc:
JMP 0x0013f0de
LAB_0013f0de:
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0x1],AL
JMP 0x0013f1f4
LAB_0013f0e9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x0013f480
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x2c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x28],0x0
JMP 0x0013f10e
LAB_0013f10e:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x40
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RAX + 0x8]
XOR ECX,ECX
MOV R9D,0x1
XOR EAX,EAX
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
CALL 0x00154cf0
CMP RAX,0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x29],AL
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x0013f1d4
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x128]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
LAB_0013f186:
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,-0x1
MOV qword ptr [RBP + -0x38],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JC 0x0013f1ad
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_0013f1ad:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0013f1b6
JMP 0x0013f1b8
LAB_0013f1b6:
JMP 0x0013f186
LAB_0013f1b8:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x24],ECX
JMP 0x0013f1d2
LAB_0013f1d2:
JMP 0x0013f1ec
LAB_0013f1d4:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
CALL 0x00222520
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RAX]
CALL 0x00170210
LAB_0013f1ec:
JMP 0x0013f1ee
LAB_0013f1ee:
MOV AL,byte ptr [RBP + -0x29]
MOV byte ptr [RBP + -0x1],AL
LAB_0013f1f4:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int8 _ma_read_bitmap_page(long *param_1,long param_2,long param_3)
{
ulong uVar1;
ulong uVar2;
int8 uVar3;
int7 uVar6;
long lVar4;
int4 *puVar5;
bool bVar7;
char *local_40;
char local_9;
lVar4 = *param_1;
*(long *)(param_2 + 0x10) = param_3;
uVar2 = (param_3 + 1) * (ulong)*(uint *)(param_2 + 0x134);
uVar1 = *(ulong *)(lVar4 + 0x40);
if (uVar2 < uVar1 || uVar2 - uVar1 == 0) {
adjust_total_size(param_1,param_3);
*(int4 *)(param_2 + 0x2c) = 0;
*(int4 *)(param_2 + 0x28) = 0;
lVar4 = pagecache_read(*(int8 *)(lVar4 + 0x600),param_2 + 0x40,param_3,0,
*(int8 *)(param_2 + 8),1,0,0);
local_9 = lVar4 == 0;
if ((bool)local_9) {
puVar5 = (int4 *)_my_thread_var();
param_2 = _ma_set_fatal_error(param_1,*puVar5);
}
else {
local_40 = (char *)(*(long *)(param_2 + 8) + (ulong)*(uint *)(param_2 + 0x128));
do {
local_40 = local_40 + -1;
bVar7 = false;
if (*(char **)(param_2 + 8) <= local_40) {
bVar7 = *local_40 == '\0';
}
} while (bVar7);
*(int *)(param_2 + 0x24) = ((int)local_40 + 1) - (int)*(char **)(param_2 + 8);
}
uVar6 = (int7)((ulong)param_2 >> 8);
}
else {
uVar3 = _ma_bitmap_create_missing(param_1,param_2,param_3);
local_9 = (char)uVar3;
if (local_9 == '\0') {
uVar3 = adjust_total_size(param_1,param_3);
}
uVar6 = (int7)((ulong)uVar3 >> 8);
}
return CONCAT71(uVar6,local_9);
}
|
|
58,599
|
void google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::FieldDescriptor>(google::protobuf::FieldDescriptor::OptionsType const&, google::protobuf::FieldDescriptor*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::internal::FlatAllocator&)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc
|
void DescriptorBuilder::AllocateOptions(
const typename DescriptorT::OptionsType& orig_options,
DescriptorT* descriptor, int options_field_tag,
const std::string& option_name, internal::FlatAllocator& alloc) {
std::vector<int> options_path;
descriptor->GetLocationPath(&options_path);
options_path.push_back(options_field_tag);
AllocateOptionsImpl(descriptor->full_name(), descriptor->full_name(),
orig_options, descriptor, options_path, option_name,
alloc);
}
|
O0
|
cpp
|
void google::protobuf::DescriptorBuilder::AllocateOptions<google::protobuf::FieldDescriptor>(google::protobuf::FieldDescriptor::OptionsType const&, google::protobuf::FieldDescriptor*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::internal::FlatAllocator&):
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x112bb0
movq 0x28(%rsp), %rsi
movq 0x70(%rsp), %rdi
callq 0x24f990
jmp 0x286a74
leaq 0x40(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x92800
jmp 0x286a85
movq 0x70(%rsp), %rdi
callq 0x2869c0
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2869c0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x58(%rsp), %r10
movq %rsp, %rax
movq %r10, 0x8(%rax)
movq %r9, (%rax)
leaq 0x40(%rsp), %r9
callq 0x2ab8a0
jmp 0x286ad5
leaq 0x40(%rsp), %rdi
callq 0xf7d30
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xf7d30
movq 0x38(%rsp), %rdi
callq 0x90db0
nopl (%rax)
|
_ZN6google8protobuf17DescriptorBuilder15AllocateOptionsINS0_16MethodDescriptorEEEvRKNT_11OptionsTypeEPS4_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS0_8internal13FlatAllocatorE:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov [rsp+88h+var_1C], ecx
mov [rsp+88h+var_28], r8
mov [rsp+88h+var_30], r9
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_68], rax
lea rdi, [rsp+88h+var_48]
mov [rsp+88h+var_60], rdi
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rsi, [rsp+88h+var_60]
mov rdi, [rsp+88h+var_18]
call _ZNK6google8protobuf16MethodDescriptor15GetLocationPathEPSt6vectorIiSaIiEE; google::protobuf::MethodDescriptor::GetLocationPath(std::vector<int> *)
jmp short $+2
loc_286A74:
lea rdi, [rsp+88h+var_48]
lea rsi, [rsp+88h+var_1C]
call __ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
jmp short $+2
loc_286A85:
mov rdi, [rsp+88h+var_18]
call _ZNK6google8protobuf16MethodDescriptor9full_nameB5cxx11Ev; google::protobuf::MethodDescriptor::full_name(void)
mov [rsp+88h+var_70], rax
mov rdi, [rsp+88h+var_18]
call _ZNK6google8protobuf16MethodDescriptor9full_nameB5cxx11Ev; google::protobuf::MethodDescriptor::full_name(void)
mov rdi, [rsp+88h+var_68]
mov rsi, [rsp+88h+var_70]
mov rdx, rax
mov rcx, [rsp+88h+var_10]
mov r8, [rsp+88h+var_18]
mov r9, [rsp+88h+var_28]
mov r10, [rsp+88h+var_30]
mov rax, rsp
mov [rax+8], r10
mov [rax], r9
lea r9, [rsp+88h+var_48]
call _ZN6google8protobuf17DescriptorBuilder19AllocateOptionsImplINS0_16MethodDescriptorEEEvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESB_RKNT_11OptionsTypeEPSC_RKSt6vectorIiSaIiEESB_RNS0_8internal13FlatAllocatorE; google::protobuf::DescriptorBuilder::AllocateOptionsImpl<google::protobuf::MethodDescriptor>(std::string const&,std::string const&,google::protobuf::MethodDescriptor::OptionsType const&,google::protobuf::MethodDescriptor::OptionsType*,std::vector<int> const&,std::string const&,google::protobuf::internal::FlatAllocator &)
jmp short $+2
loc_286AD5:
lea rdi, [rsp+88h+var_48]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
add rsp, 88h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.