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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
1,600 | testing::internal::FilePath::FileOrDirectoryExists() const | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-filepath.cc | bool FilePath::FileOrDirectoryExists() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(pathname_.c_str(), &file_stat) == 0;
#endif // GTEST_OS_WINDOWS_MOBILE
} | O0 | cpp | testing::internal::FilePath::FileOrDirectoryExists() const:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x14390
movq 0x8(%rsp), %rdi
callq 0x1acc0
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0xe35a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK7testing8internal8FilePath21FileOrDirectoryExistsEv:
sub rsp, 0A8h
mov [rsp+0A8h+var_8], rdi
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_A0], rax
lea rdi, [rsp+0A8h+var_98]
xor esi, esi
mov edx, 90h
call _memset
mov rdi, [rsp+0A8h+var_A0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
lea rsi, [rsp+0A8h+var_98]
call _ZN7testing8internal5posix4StatEPKcP4stat; testing::internal::posix::Stat(char const*,stat *)
cmp eax, 0
setz al
and al, 1
add rsp, 0A8h
retn
| bool testing::internal::FilePath::FileOrDirectoryExists(testing::internal::FilePath *this)
{
long long v1; // rax
_BYTE v3[144]; // [rsp+10h] [rbp-98h] BYREF
testing::internal::FilePath *v4; // [rsp+A0h] [rbp-8h]
v4 = this;
memset(v3, 0LL, sizeof(v3));
v1 = std::string::c_str((long long)this);
return (unsigned int)testing::internal::posix::Stat(v1, v3) == 0;
}
| FileOrDirectoryExists:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
MOV EDX,0x90
CALL 0x00114390
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011acc0
MOV RDI,RAX
LEA RSI,[RSP + 0x10]
CALL 0x001e35a0
CMP EAX,0x0
SETZ AL
AND AL,0x1
ADD RSP,0xa8
RET
|
/* testing::internal::FilePath::FileOrDirectoryExists() const */
bool __thiscall testing::internal::FilePath::FileOrDirectoryExists(FilePath *this)
{
int iVar1;
char *pcVar2;
stat local_98;
FilePath *local_8;
local_8 = this;
memset(&local_98,0,0x90);
pcVar2 = (char *)std::__cxx11::string::c_str((string *)this);
iVar1 = posix::Stat(pcVar2,&local_98);
return iVar1 == 0;
}
|
|
1,601 | my_hash_first_from_hash_value | eloqsql/mysys/hash.c | uchar* my_hash_first_from_hash_value(const HASH *hash,
my_hash_value_type hash_value,
const uchar *key,
size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
DBUG_ENTER("my_hash_first_from_hash_value");
if (hash->records)
{
uint flag= 1;
uint idx= my_hash_mask(hash_value,
hash->blength, hash->records);
do
{
pos= dynamic_element(&hash->array,idx,HASH_LINK*);
if (!hashcmp(hash,pos,key,length))
{
DBUG_PRINT("exit",("found key at %d",idx));
*current_record= idx;
DBUG_RETURN (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (my_hash_rec_mask(pos, hash->blength, hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
*current_record= NO_RECORD;
DBUG_RETURN(0);
} | O0 | c | my_hash_first_from_hash_value:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xde28c
movl $0x1, -0x3c(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde2b0
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xde300
cmpl $0x0, %eax
jne 0xde247
jmp 0xde22e
jmp 0xde230
movl -0x40(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xde29e
cmpl $0x0, -0x3c(%rbp)
je 0xde276
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0xde3a0
cmpl -0x40(%rbp), %eax
je 0xde274
jmp 0xde28a
jmp 0xde276
jmp 0xde278
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $-0x1, %eax
jne 0xde1fc
jmp 0xde28c
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_hash_first_from_hash_value:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz loc_DE28C
mov [rbp+var_3C], 1
mov edi, [rbp+var_14]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov [rbp+var_40], eax
loc_DE1FC:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov ecx, [rbp+var_40]
shl rcx, 4
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call hashcmp
cmp eax, 0
jnz short loc_DE247
jmp short $+2
loc_DE22E:
jmp short $+2
loc_DE230:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_30]
mov [rax], ecx
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_DE29E
loc_DE247:
cmp [rbp+var_3C], 0
jz short loc_DE276
mov [rbp+var_3C], 0
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_rec_mask
cmp eax, [rbp+var_40]
jz short loc_DE274
jmp short loc_DE28A
loc_DE274:
jmp short $+2
loc_DE276:
jmp short $+2
loc_DE278:
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_40], eax
cmp eax, 0FFFFFFFFh
jnz loc_DE1FC
loc_DE28A:
jmp short $+2
loc_DE28C:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
mov [rbp+var_8], 0
loc_DE29E:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_hash_first_from_hash_value(_QWORD *a1, unsigned int a2, long long a3, long long a4, unsigned int *a5)
{
unsigned int v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h]
if ( a1[3] )
{
v7 = 1;
v6 = my_hash_mask(a2, a1[2], a1[3]);
while ( 1 )
{
v8 = 16LL * v6 + a1[5];
if ( !(unsigned int)hashcmp(a1, v8, a3, a4) )
break;
if ( !v7 || (v7 = 0, (unsigned int)my_hash_rec_mask(v8, a1[2], a1[3]) == v6) )
{
v6 = *(_DWORD *)v8;
if ( *(_DWORD *)v8 != -1 )
continue;
}
goto LABEL_8;
}
*a5 = v6;
return *(_QWORD *)(v8 + 8);
}
else
{
LABEL_8:
*a5 = -1;
return 0LL;
}
}
| my_hash_first_from_hash_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001de28c
MOV dword ptr [RBP + -0x3c],0x1
MOV EDI,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de2b0
MOV dword ptr [RBP + -0x40],EAX
LAB_001de1fc:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV ECX,dword ptr [RBP + -0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x001de300
CMP EAX,0x0
JNZ 0x001de247
JMP 0x001de22e
LAB_001de22e:
JMP 0x001de230
LAB_001de230:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001de29e
LAB_001de247:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x001de276
MOV dword ptr [RBP + -0x3c],0x0
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x001de3a0
CMP EAX,dword ptr [RBP + -0x40]
JZ 0x001de274
JMP 0x001de28a
LAB_001de274:
JMP 0x001de276
LAB_001de276:
JMP 0x001de278
LAB_001de278:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
CMP EAX,-0x1
JNZ 0x001de1fc
LAB_001de28a:
JMP 0x001de28c
LAB_001de28c:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
MOV qword ptr [RBP + -0x8],0x0
LAB_001de29e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
my_hash_first_from_hash_value
(long param_1,int4 param_2,int8 param_3,int8 param_4,uint *param_5)
{
bool bVar1;
int iVar2;
uint uVar3;
uint *puVar4;
uint local_48;
if (*(long *)(param_1 + 0x18) != 0) {
bVar1 = true;
local_48 = my_hash_mask(param_2,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18))
;
do {
puVar4 = (uint *)(*(long *)(param_1 + 0x28) + (ulong)local_48 * 0x10);
iVar2 = hashcmp(param_1,puVar4,param_3,param_4);
if (iVar2 == 0) {
*param_5 = local_48;
return *(int8 *)(puVar4 + 2);
}
if (bVar1) {
bVar1 = false;
uVar3 = my_hash_rec_mask(puVar4,*(int8 *)(param_1 + 0x10),
*(int8 *)(param_1 + 0x18));
if (uVar3 != local_48) break;
}
local_48 = *puVar4;
} while (local_48 != 0xffffffff);
}
*param_5 = 0xffffffff;
return 0;
}
|
|
1,602 | cr_union1 | bluesky950520[P]quickjs/libunicode.c | int cr_union1(CharRange *cr, const uint32_t *b_pt, int b_len)
{
CharRange a = *cr;
int ret;
cr->len = 0;
cr->size = 0;
cr->points = NULL;
ret = cr_op(cr, a.points, a.len, b_pt, b_len, CR_OP_UNION);
cr_free(&a);
return ret;
} | O1 | c | cr_union1:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %rcx
movl (%rdi), %edx
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x986fe
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r15
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| cr_union1:
push rbp
push r15
push r14
push rbx
push rax
mov r8d, edx
mov rcx, rsi
mov edx, [rdi]
mov rbx, [rdi+8]
mov r14, [rdi+10h]
mov r15, [rdi+18h]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rsi, rbx
xor r9d, r9d
call cr_op
mov ebp, eax
mov rdi, r14
mov rsi, rbx
xor edx, edx
call r15
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long cr_union1(unsigned long long a1, long long a2, int a3)
{
int v4; // edx
long long v5; // rbx
long long v6; // r14
void ( *v7)(long long, long long, _QWORD); // r15
unsigned int v8; // ebp
v4 = *(_DWORD *)a1;
v5 = *(_QWORD *)(a1 + 8);
v6 = *(_QWORD *)(a1 + 16);
v7 = *(void ( **)(long long, long long, _QWORD))(a1 + 24);
*(_OWORD *)a1 = 0LL;
v8 = cr_op(a1, v5, v4, a2, a3, 0);
v7(v6, v5, 0LL);
return v8;
}
| |||
1,603 | cr_union1 | bluesky950520[P]quickjs/libunicode.c | int cr_union1(CharRange *cr, const uint32_t *b_pt, int b_len)
{
CharRange a = *cr;
int ret;
cr->len = 0;
cr->size = 0;
cr->points = NULL;
ret = cr_op(cr, a.points, a.len, b_pt, b_len, CR_OP_UNION);
cr_free(&a);
return ret;
} | O2 | c | cr_union1:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %rcx
movl (%rdi), %edx
movq 0x8(%rdi), %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x7f4b5
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r15
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| cr_union1:
push rbp
push r15
push r14
push rbx
push rax
mov r8d, edx
mov rcx, rsi
mov edx, [rdi]
mov rbx, [rdi+8]
mov r14, [rdi+10h]
mov r15, [rdi+18h]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rsi, rbx
xor r9d, r9d
call cr_op
mov ebp, eax
mov rdi, r14
mov rsi, rbx
xor edx, edx
call r15
mov eax, ebp
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long cr_union1(long long a1, long long a2, int a3)
{
int v4; // edx
long long v5; // rbx
long long v6; // r14
void ( *v7)(long long, long long, _QWORD); // r15
unsigned int v8; // ebp
v4 = *(_DWORD *)a1;
v5 = *(_QWORD *)(a1 + 8);
v6 = *(_QWORD *)(a1 + 16);
v7 = *(void ( **)(long long, long long, _QWORD))(a1 + 24);
*(_OWORD *)a1 = 0LL;
v8 = cr_op((const char *)a1, v5, v4, a2, a3, 0);
v7(v6, v5, 0LL);
return v8;
}
| cr_union1:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R8D,EDX
MOV RCX,RSI
MOV EDX,dword ptr [RDI]
MOV RBX,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI + 0x10]
MOV R15,qword ptr [RDI + 0x18]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RSI,RBX
XOR R9D,R9D
CALL 0x0017f4b5
MOV EBP,EAX
MOV RDI,R14
MOV RSI,RBX
XOR EDX,EDX
CALL R15
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 cr_union1(int8 *param_1,int8 param_2,int4 param_3)
{
int8 uVar1;
int8 uVar2;
code *pcVar3;
int4 uVar4;
uVar4 = *(int4 *)param_1;
uVar1 = param_1[1];
uVar2 = param_1[2];
pcVar3 = (code *)param_1[3];
*param_1 = 0;
param_1[1] = 0;
uVar4 = cr_op(param_1,uVar1,uVar4,param_2,param_3,0);
(*pcVar3)(uVar2,uVar1,0);
return uVar4;
}
|
|
1,604 | host_get_storage | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static evmc_bytes32 host_get_storage(void* context, const evmc_address* addr, const evmc_bytes32* key) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("get_storage for account", addr);
debug_print_bytes32("get_storage key", key);
evmc_bytes32 result = {0};
changed_storage_t* storage = get_changed_storage(ctx, addr->bytes, key->bytes);
if (storage)
memcpy(result.bytes, storage->value, 32);
else
get_src_storage(ctx, addr->bytes, key->bytes, result.bytes);
debug_print_bytes32("get_storage result", &result);
return result;
} | O0 | c | host_get_storage:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xafc45(%rip), %rdi # 0xdd894
callq 0x2db70
movq -0x18(%rbp), %rsi
leaq 0xafc4d(%rip), %rdi # 0xdd8ac
callq 0x2db80
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x231c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e700
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2dcb9
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, (%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x30(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x38(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x2dcce
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2e790
movq -0x30(%rbp), %rsi
leaq 0xafbe3(%rip), %rdi # 0xdd8bc
callq 0x2db80
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| host_get_storage:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_30], rdi
mov [rbp+var_38], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
mov [rbp+var_18], rcx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rsi, [rbp+var_10]
lea rdi, aGetStorageForA; "get_storage for account"
call debug_print_address
mov rsi, [rbp+var_18]
lea rdi, aGetStorageKey; "get_storage key"
call debug_print_bytes32
mov rdi, [rbp+var_30]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call get_changed_storage
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_2DCB9
mov rax, [rbp+var_30]
mov rcx, [rbp+var_28]
mov rdx, [rcx+20h]
mov [rax], rdx
mov rdx, [rcx+28h]
mov [rax+8], rdx
mov rdx, [rcx+30h]
mov [rax+10h], rdx
mov rcx, [rcx+38h]
mov [rax+18h], rcx
jmp short loc_2DCCE
loc_2DCB9:
mov rcx, [rbp+var_30]
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call get_src_storage
loc_2DCCE:
mov rsi, [rbp+var_30]
lea rdi, aGetStorageResu; "get_storage result"
call debug_print_bytes32
mov rax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
| _QWORD * host_get_storage(_QWORD *a1, long long a2, long long a3, long long a4)
{
_QWORD *changed_storage; // [rsp+18h] [rbp-28h]
debug_print_address();
debug_print_bytes32();
memset(a1, 0LL, 32LL);
changed_storage = (_QWORD *)get_changed_storage(a2, a3, a4);
if ( changed_storage )
{
*a1 = changed_storage[4];
a1[1] = changed_storage[5];
a1[2] = changed_storage[6];
a1[3] = changed_storage[7];
}
else
{
get_src_storage(a2, a3, a4, a1);
}
debug_print_bytes32();
return a1;
}
| host_get_storage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x1dd894]
CALL 0x0012db70
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x1dd8ac]
CALL 0x0012db80
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x001231c0
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0012e700
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0012dcb9
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RCX + 0x20]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x30]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x38]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x0012dcce
LAB_0012dcb9:
MOV RCX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0012e790
LAB_0012dcce:
MOV RSI,qword ptr [RBP + -0x30]
LEA RDI,[0x1dd8bc]
CALL 0x0012db80
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
|
int8 *
host_get_storage(int8 *param_1,int8 param_2,int8 param_3,int8 param_4)
{
long lVar1;
debug_print_address("get_storage for account",param_3);
debug_print_bytes32("get_storage key");
memset(param_1,0,0x20);
lVar1 = get_changed_storage(param_2,param_3,param_4);
if (lVar1 == 0) {
get_src_storage(param_2,param_3,param_4,param_1);
}
else {
*param_1 = *(int8 *)(lVar1 + 0x20);
param_1[1] = *(int8 *)(lVar1 + 0x28);
param_1[2] = *(int8 *)(lVar1 + 0x30);
param_1[3] = *(int8 *)(lVar1 + 0x38);
}
debug_print_bytes32("get_storage result",param_1);
return param_1;
}
|
|
1,605 | my_fstat | eloqsql/mysys/my_lib.c | int my_fstat(File Filedes, MY_STAT *stat_area,
myf MyFlags __attribute__((unused)))
{
DBUG_ENTER("my_fstat");
DBUG_PRINT("my",("fd: %d MyFlags: %lu", Filedes, MyFlags));
#ifdef _WIN32
DBUG_RETURN(my_win_fstat(Filedes, stat_area));
#elif defined HAVE_valgrind
{
int s= fstat(Filedes, stat_area);
if (!s)
MSAN_STAT_WORKAROUND(stat_area);
DBUG_RETURN(s);
}
#else
DBUG_RETURN(fstat(Filedes, (struct stat *) stat_area));
#endif
} | O3 | c | my_fstat:
pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x29580
nopl (%rax)
| my_fstat:
push rbp
mov rbp, rsp
pop rbp
jmp _fstat64
| long long my_fstat()
{
return fstat64();
}
| my_fstat:
PUSH RBP
MOV RBP,RSP
POP RBP
JMP 0x00129580
|
void my_fstat(int param_1,stat64 *param_2)
{
fstat64(param_1,param_2);
return;
}
|
|
1,606 | LefDefParser::defiRow::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiRowTrack.cpp | void defiRow::clear() {
int i;
for (i = 0; i < numProps_; i++) {
free(propNames_[i]);
free(propValues_[i]);
propDValues_[i] = 0;
}
hasDo_ = 0;
hasDoStep_ = 0;
numProps_ = 0;
} | O0 | cpp | LefDefParser::defiRow::clear():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x60(%rcx), %eax
jge 0x2e565
movq (%rsp), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x70(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x78(%rax), %rax
movslq 0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2e50a
movq (%rsp), %rax
movl $0x0, 0x58(%rax)
movl $0x0, 0x5c(%rax)
movl $0x0, 0x60(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser7defiRow5clearEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov [rsp+18h+var_C], 0
loc_2E50A:
mov rcx, [rsp+18h+var_18]
mov eax, [rsp+18h+var_C]
cmp eax, [rcx+60h]
jge short loc_2E565
mov rax, [rsp+18h+var_18]
mov rax, [rax+68h]
movsxd rcx, [rsp+18h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+18h+var_18]
mov rax, [rax+70h]
movsxd rcx, [rsp+18h+var_C]
mov rdi, [rax+rcx*8]
call _free
mov rax, [rsp+18h+var_18]
mov rax, [rax+78h]
movsxd rcx, [rsp+18h+var_C]
xorps xmm0, xmm0
movsd qword ptr [rax+rcx*8], xmm0
mov eax, [rsp+18h+var_C]
add eax, 1
mov [rsp+18h+var_C], eax
jmp short loc_2E50A
loc_2E565:
mov rax, [rsp+18h+var_18]
mov dword ptr [rax+58h], 0
mov dword ptr [rax+5Ch], 0
mov dword ptr [rax+60h], 0
add rsp, 18h
retn
| LefDefParser::defiRow * LefDefParser::defiRow::clear(LefDefParser::defiRow *this)
{
LefDefParser::defiRow *result; // rax
int i; // [rsp+Ch] [rbp-Ch]
for ( i = 0; i < *((_DWORD *)this + 24); ++i )
{
free(*(_QWORD *)(*((_QWORD *)this + 13) + 8LL * i));
free(*(_QWORD *)(*((_QWORD *)this + 14) + 8LL * i));
*(_QWORD *)(*((_QWORD *)this + 15) + 8LL * i) = 0LL;
}
result = this;
*((_DWORD *)this + 22) = 0;
*((_DWORD *)this + 23) = 0;
*((_DWORD *)this + 24) = 0;
return result;
}
| clear:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV dword ptr [RSP + 0xc],0x0
LAB_0012e50a:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,dword ptr [RCX + 0x60]
JGE 0x0012e565
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x68]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x70]
MOVSXD RCX,dword ptr [RSP + 0xc]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x78]
MOVSXD RCX,dword ptr [RSP + 0xc]
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + RCX*0x8],XMM0
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0012e50a
LAB_0012e565:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x58],0x0
MOV dword ptr [RAX + 0x5c],0x0
MOV dword ptr [RAX + 0x60],0x0
ADD RSP,0x18
RET
|
/* LefDefParser::defiRow::clear() */
void __thiscall LefDefParser::defiRow::clear(defiRow *this)
{
int local_c;
for (local_c = 0; local_c < *(int *)(this + 0x60); local_c = local_c + 1) {
free(*(void **)(*(long *)(this + 0x68) + (long)local_c * 8));
free(*(void **)(*(long *)(this + 0x70) + (long)local_c * 8));
*(int8 *)(*(long *)(this + 0x78) + (long)local_c * 8) = 0;
}
*(int4 *)(this + 0x58) = 0;
*(int4 *)(this + 0x5c) = 0;
*(int4 *)(this + 0x60) = 0;
return;
}
|
|
1,607 | my_charpos_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
} | O3 | c | my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0x4b275
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r13
movq %rbx, %r12
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jle 0x4b26e
movl %eax, %eax
addq %rax, %r12
decq %r15
jne 0x4b247
jmp 0x4b275
addq $0x2, %r14
movq %r14, %r12
subq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_charpos_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r12, rsi
test rcx, rcx
jz short loc_4B275
mov r15, rcx
mov r14, rdx
mov r13, rdi
mov r12, rbx
loc_4B247:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r14
call qword ptr [rax+0C0h]
cmp eax, 1
jle short loc_4B26E
mov eax, eax
add r12, rax
dec r15
jnz short loc_4B247
jmp short loc_4B275
loc_4B26E:
add r14, 2
mov r12, r14
loc_4B275:
sub r12, rbx
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r12
long long v5; // r15
int v7; // eax
v4 = a2;
if ( a4 )
{
v5 = a4;
v4 = a2;
while ( 1 )
{
v7 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, v4, a3);
if ( v7 <= 1 )
break;
v4 += (unsigned int)v7;
if ( !--v5 )
return v4 - a2;
}
v4 = a3 + 2;
}
return v4 - a2;
}
| my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R12,RSI
TEST RCX,RCX
JZ 0x0014b275
MOV R15,RCX
MOV R14,RDX
MOV R13,RDI
MOV R12,RBX
LAB_0014b247:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R14
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JLE 0x0014b26e
MOV EAX,EAX
ADD R12,RAX
DEC R15
JNZ 0x0014b247
JMP 0x0014b275
LAB_0014b26e:
ADD R14,0x2
MOV R12,R14
LAB_0014b275:
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_utf16(long param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long lVar2;
lVar2 = param_2;
if (param_4 != 0) {
do {
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,lVar2,param_3);
if ((int)uVar1 < 2) {
lVar2 = param_3 + 2;
break;
}
lVar2 = lVar2 + (ulong)uVar1;
param_4 = param_4 + -1;
} while (param_4 != 0);
}
return lVar2 - param_2;
}
|
|
1,608 | resize_simple_key_cache | eloqsql/mysys/mf_keycache.c | static
int resize_simple_key_cache(SIMPLE_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 blocks= 0;
DBUG_ENTER("resize_simple_key_cache");
DBUG_ASSERT(keycache->key_cache_inited);
/*
Note that the cache_lock mutex and the resize_queue are left untouched.
We do not lose the cache_lock and will release it only at the end of
this function.
*/
if (prepare_resize_simple_key_cache(keycache, 0))
goto finish;
/* The following will work even if use_mem is 0 */
blocks= init_simple_key_cache(keycache, key_cache_block_size, use_mem,
division_limit, age_threshold,
changed_blocks_hash_size);
finish:
finish_resize_simple_key_cache(keycache);
DBUG_RETURN(blocks);
} | O0 | c | resize_simple_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0xe5627
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xe63a0
cmpl $0x0, %eax
je 0xe5639
jmp 0xe5657
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0xe4fd0
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe64c0
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| resize_simple_key_cache:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov [rbp+var_24], r9d
mov [rbp+var_28], 0
jmp short $+2
loc_E5627:
mov rdi, [rbp+var_8]
xor esi, esi
call prepare_resize_simple_key_cache
cmp eax, 0
jz short loc_E5639
jmp short loc_E5657
loc_E5639:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_1C]
mov r8d, [rbp+var_20]
mov r9d, [rbp+var_24]
call init_simple_key_cache
mov [rbp+var_28], eax
loc_E5657:
mov rdi, [rbp+var_8]
call finish_resize_simple_key_cache
mov eax, [rbp+var_28]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add rsp, 30h
pop rbp
retn
| long long resize_simple_key_cache(
long long a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
unsigned int a5,
unsigned int a6,
double a7)
{
unsigned int inited; // [rsp+8h] [rbp-28h]
inited = 0;
if ( !(unsigned int)prepare_resize_simple_key_cache(a1, 0LL) )
inited = init_simple_key_cache(a1, a2, a3, a4, a5, a6, a7);
finish_resize_simple_key_cache(a1);
return inited;
}
| resize_simple_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV dword ptr [RBP + -0x24],R9D
MOV dword ptr [RBP + -0x28],0x0
JMP 0x001e5627
LAB_001e5627:
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x001e63a0
CMP EAX,0x0
JZ 0x001e5639
JMP 0x001e5657
LAB_001e5639:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
MOV R8D,dword ptr [RBP + -0x20]
MOV R9D,dword ptr [RBP + -0x24]
CALL 0x001e4fd0
MOV dword ptr [RBP + -0x28],EAX
LAB_001e5657:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001e64c0
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD RSP,0x30
POP RBP
RET
|
int4
resize_simple_key_cache
(int8 param_1,int4 param_2,int8 param_3,int4 param_4,
int4 param_5,int4 param_6)
{
int iVar1;
int4 local_30;
local_30 = 0;
iVar1 = prepare_resize_simple_key_cache(param_1,0);
if (iVar1 == 0) {
local_30 = init_simple_key_cache(param_1,param_2,param_3,param_4,param_5,param_6);
}
finish_resize_simple_key_cache(param_1);
return local_30;
}
|
|
1,609 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1c8e3e(%rip), %rax # 0x2bf098
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a360
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init_4:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init_4(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3bf098]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a360
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
|
|
1,610 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O2 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [9], 0>(char const (&) [9]):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0xae36b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x488e9
testb %al, %al
jne 0xae368
addq $0x30, %r14
jmp 0xae34a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_AE34A:
mov rax, [r15+8]
cmp r14, rax
jz short loc_AE36B
mov rdi, r14
mov rsi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_AE368
add r14, 30h ; '0'
jmp short loc_AE34A
loc_AE368:
mov rax, r14
loc_AE36B:
pop rbx
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long *a1)
{
long long i; // r14
long long result; // rax
for ( i = *a1; ; i += 48LL )
{
result = a1[1];
if ( i == result )
break;
if ( std::operator==<char>(i) )
return i;
}
return result;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_001ae34a:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x001ae36b
MOV RDI,R14
MOV RSI,RBX
CALL 0x001488e9
TEST AL,AL
JNZ 0x001ae368
ADD R14,0x30
JMP 0x001ae34a
LAB_001ae368:
MOV RAX,R14
LAB_001ae36b:
POP RBX
POP R14
POP R15
RET
|
string * _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(int8 *param_1,char *param_2)
{
bool bVar1;
string *psVar2;
string *psVar3;
psVar3 = (string *)*param_1;
while ((psVar2 = (string *)param_1[1], psVar3 != (string *)param_1[1] &&
(bVar1 = std::operator==(psVar3,param_2), psVar2 = psVar3, !bVar1))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
|
|
1,611 | google::protobuf::EnumDescriptorProto::_internal_mutable_options() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.h | inline ::PROTOBUF_NAMESPACE_ID::EnumOptions* EnumDescriptorProto::_internal_mutable_options() {
_impl_._has_bits_[0] |= 0x00000002u;
if (_impl_.options_ == nullptr) {
auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::EnumOptions>(GetArenaForAllocation());
_impl_.options_ = p;
}
return _impl_.options_;
} | O0 | c | google::protobuf::EnumDescriptorProto::_internal_mutable_options():
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x68(%rax)
jne 0x81836
movq (%rsp), %rdi
callq 0x80180
movq %rax, %rdi
callq 0x81850
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
movq 0x68(%rax), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN6google8protobuf19EnumDescriptorProto25_internal_mutable_optionsEv:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_28], rax
mov rcx, rax
add rcx, 10h
mov [rsp+28h+var_8], rcx
mov [rsp+28h+var_C], 0
mov rcx, [rsp+28h+var_8]
movsxd rdx, [rsp+28h+var_C]
mov esi, [rcx+rdx*4]
or esi, 2
mov [rcx+rdx*4], esi
cmp qword ptr [rax+68h], 0
jnz short loc_81836
mov rdi, [rsp+28h+var_28]; this
call _ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv; google::protobuf::MessageLite::GetArenaForAllocation(void)
mov rdi, rax; int
call _ZN6google8protobuf11MessageLite18CreateMaybeMessageINS0_11EnumOptionsEEEPT_PNS0_5ArenaE; google::protobuf::MessageLite::CreateMaybeMessage<google::protobuf::EnumOptions>(google::protobuf::Arena *)
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov [rsp+28h+var_20], rcx
mov rcx, [rsp+28h+var_20]
mov [rax+68h], rcx
loc_81836:
mov rax, [rsp+28h+var_28]
mov rax, [rax+68h]
add rsp, 28h
retn
| long long google::protobuf::EnumDescriptorProto::_internal_mutable_options(
google::protobuf::EnumDescriptorProto *this)
{
int ArenaForAllocation; // eax
*((_DWORD *)this + 4) |= 2u;
if ( !*((_QWORD *)this + 13) )
{
ArenaForAllocation = google::protobuf::MessageLite::GetArenaForAllocation(this);
*((_QWORD *)this + 13) = google::protobuf::MessageLite::CreateMaybeMessage<google::protobuf::EnumOptions>(ArenaForAllocation);
}
return *((_QWORD *)this + 13);
}
| _internal_mutable_options:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RCX,RAX
ADD RCX,0x10
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x1c],0x0
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x1c]
MOV ESI,dword ptr [RCX + RDX*0x4]
OR ESI,0x2
MOV dword ptr [RCX + RDX*0x4],ESI
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x00181836
MOV RDI,qword ptr [RSP]
CALL 0x00180180
MOV RDI,RAX
CALL 0x00181850
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x68],RCX
LAB_00181836:
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x68]
ADD RSP,0x28
RET
|
/* google::protobuf::EnumDescriptorProto::_internal_mutable_options() */
int8 __thiscall
google::protobuf::EnumDescriptorProto::_internal_mutable_options(EnumDescriptorProto *this)
{
Arena *pAVar1;
EnumOptions *pEVar2;
*(uint *)(this + 0x10) = *(uint *)(this + 0x10) | 2;
if (*(long *)(this + 0x68) == 0) {
pAVar1 = (Arena *)MessageLite::GetArenaForAllocation((MessageLite *)this);
pEVar2 = MessageLite::CreateMaybeMessage<google::protobuf::EnumOptions>(pAVar1);
*(EnumOptions **)(this + 0x68) = pEVar2;
}
return *(int8 *)(this + 0x68);
}
|
|
1,612 | JS_Throw | bluesky950520[P]quickjs/quickjs.c | JSValue JS_Throw(JSContext *ctx, JSValue obj)
{
JSRuntime *rt = ctx->rt;
JS_FreeValue(ctx, rt->current_exception);
rt->current_exception = obj;
return JS_EXCEPTION;
} | O3 | c | JS_Throw:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18(%rdi), %r15
movq 0xf8(%r15), %rdx
cmpl $-0x9, %edx
jb 0x22b89
movq 0xf0(%r15), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x22b89
movq %r15, %rdi
callq 0x219cc
movq %r14, 0xf0(%r15)
movq %rbx, 0xf8(%r15)
movl $0x6, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
| JS_Throw:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, [rdi+18h]
mov rdx, [r15+0F8h]
cmp edx, 0FFFFFFF7h
jb short loc_22B89
mov rsi, [r15+0F0h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_22B89
mov rdi, r15
call js_free_value_rt
loc_22B89:
mov [r15+0F0h], r14
mov [r15+0F8h], rbx
mov edx, 6
xor eax, eax
pop rbx
pop r14
pop r15
retn
| long long JS_Throw(long long a1, long long a2, long long a3)
{
long long v5; // r15
long long v6; // rdx
_QWORD *v7; // rsi
int v8; // eax
v5 = *(_QWORD *)(a1 + 24);
v6 = *(_QWORD *)(v5 + 248);
if ( (unsigned int)v6 >= 0xFFFFFFF7 )
{
v7 = *(_QWORD **)(v5 + 240);
v8 = (*(_DWORD *)v7)--;
if ( v8 <= 1 )
js_free_value_rt(v5, v7, v6);
}
*(_QWORD *)(v5 + 240) = a2;
*(_QWORD *)(v5 + 248) = a3;
return 0LL;
}
| JS_Throw:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,qword ptr [RDI + 0x18]
MOV RDX,qword ptr [R15 + 0xf8]
CMP EDX,-0x9
JC 0x00122b89
MOV RSI,qword ptr [R15 + 0xf0]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00122b89
MOV RDI,R15
CALL 0x001219cc
LAB_00122b89:
MOV qword ptr [R15 + 0xf0],R14
MOV qword ptr [R15 + 0xf8],RBX
MOV EDX,0x6
XOR EAX,EAX
POP RBX
POP R14
POP R15
RET
|
int1 [16] JS_Throw(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
long lVar2;
lVar2 = *(long *)(param_1 + 0x18);
if (0xfffffff6 < (uint)*(int8 *)(lVar2 + 0xf8)) {
iVar1 = **(int **)(lVar2 + 0xf0);
**(int **)(lVar2 + 0xf0) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(lVar2);
}
}
*(int8 *)(lVar2 + 0xf0) = param_2;
*(int8 *)(lVar2 + 0xf8) = param_3;
return ZEXT816(6) << 0x40;
}
|
|
1,613 | (anonymous namespace)::PrefixAttacher(std::ostream&, nglog::LogMessage const&, void*) | ng-log[P]ng-log/src/logging_unittest.cc | void PrefixAttacher(std::ostream& s, const LogMessage& m, void* data) {
// Assert that `data` contains the expected contents before producing the
// prefix (otherwise causing the tests to fail):
if (data == nullptr || *static_cast<string*>(data) != "good data") {
return;
}
s << GetLogSeverityName(m.severity())[0] << setw(4) << 1900 + m.time().year()
<< setw(2) << 1 + m.time().month() << setw(2) << m.time().day() << ' '
<< setw(2) << m.time().hour() << ':' << setw(2) << m.time().min() << ':'
<< setw(2) << m.time().sec() << "." << setw(6) << m.time().usec() << ' '
<< setfill(' ') << setw(5) << m.thread_id() << setfill('0') << ' '
<< m.basename() << ':' << m.line() << "]";
} | O1 | cpp | (anonymous namespace)::PrefixAttacher(std::ostream&, nglog::LogMessage const&, void*):
testq %rdx, %rdx
je 0xeb17
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x238c1(%rip), %rsi # 0x320d6
movq %rdx, %rdi
callq 0x8150
testl %eax, %eax
jne 0xeb0b
movq %rbx, %rdi
callq 0x1b174
movl %eax, %edi
callq 0x19db0
movb (%rax), %al
leaq 0x9(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x8720
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq $0x4, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl $0x76c, %esi # imm = 0x76C
addl 0x14(%rax), %esi
movq %r14, %rdi
callq 0x8b90
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movl $0x2, %r15d
movq %r15, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl 0x10(%rax), %esi
incl %esi
movq %r14, %rdi
callq 0x8b90
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r15, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl 0xc(%rax), %esi
movq %r14, %rdi
callq 0x8b90
movb $0x20, %bpl
leaq 0xa(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r15, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x8b90
movb $0x3a, %r12b
leaq 0xb(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r15, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl 0x4(%rax), %esi
movq %r14, %rdi
callq 0x8b90
leaq 0xc(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %r15, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movl (%rax), %esi
movq %r14, %rdi
callq 0x8b90
movq %rax, %r14
leaq 0x2787b(%rip), %rsi # 0x361f0
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x6, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b1ae
movq 0x40(%rax), %rsi
movq %r14, %rdi
callq 0x85d0
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0xe9f0
movq %r15, %rdi
movl $0x20, %esi
callq 0x85e0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x20, 0xe0(%r15)
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x1b18c
movq (%rax), %rsi
testq %rsi, %rsi
je 0xea25
movq %r14, %rdi
callq 0x8400
movq %rax, %r14
jmp 0xea39
leaq 0x24967(%rip), %rsi # 0x33393
movl $0x24, %edx
movq %r14, %rdi
callq 0x8720
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0xea6b
movq %r15, %rdi
movl $0x20, %esi
callq 0x85e0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
leaq 0xe(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x8720
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b1a2
testq %rax, %rax
je 0xeab3
movq %rax, %r15
movq %rax, %rdi
callq 0x8270
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8720
jmp 0xeacd
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x8b60
leaq 0xf(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x8720
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b180
movq %r14, %rdi
movl %eax, %esi
callq 0x8b90
leaq 0x24a9f(%rip), %rsi # 0x3359d
movl $0x1, %edx
movq %rax, %rdi
callq 0x8720
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN12_GLOBAL__N_114PrefixAttacherERSoRKN5nglog10LogMessageEPv:
test rdx, rdx
jz locret_EB17
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14, rdi
lea rsi, aGoodData; "good data"
mov rdi, rdx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jnz loc_EB0B
mov rdi, rbx; this
call _ZNK5nglog10LogMessage8severityEv; nglog::LogMessage::severity(void)
mov edi, eax
call _ZN5nglog18GetLogSeverityNameENS_11LogSeverityE; nglog::GetLogSeverityName(nglog::LogSeverity)
mov al, [rax]
lea rsi, [rsp+38h+var_2F]
mov [rsi], al
mov edx, 1
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov qword ptr [r14+rax+10h], 4
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, 76Ch
add esi, [rax+14h]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov r15d, 2
mov [r14+rax+10h], r15
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, [rax+10h]
inc esi
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov [r14+rax+10h], r15
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, [rax+0Ch]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
mov bpl, 20h ; ' '
lea rsi, [rsp+38h+var_2E]
mov [rsi], bpl
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov [r14+rax+10h], r15
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, [rax+8]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
mov r12b, 3Ah ; ':'
lea rsi, [rsp+38h+var_2D]
mov [rsi], r12b
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov [r14+rax+10h], r15
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, [rax+4]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, [rsp+38h+var_2C]
mov [rsi], r12b
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
mov [r14+rax+10h], r15
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov esi, [rax]
mov rdi, r14
call __ZNSolsEi; std::ostream::operator<<(int)
mov r14, rax
lea rsi, aSectionNameSIs+50h; "."
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [r14]
mov rax, [rax-18h]
mov qword ptr [r14+rax+10h], 6
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4timeEv; nglog::LogMessage::time(void)
mov rsi, [rax+40h]
mov rdi, r14
call __ZNSo9_M_insertIlEERSoT_; std::ostream::_M_insert<long>(long)
lea rsi, [rsp+38h+var_2B]
mov [rsi], bpl
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rax, [rax-18h]
lea r15, [r14+rax]
cmp byte ptr [r14+rax+0E1h], 0
jnz short loc_E9F0
mov rdi, r15
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r15+0E0h], al
mov byte ptr [r15+0E1h], 1
loc_E9F0:
mov byte ptr [r15+0E0h], 20h ; ' '
mov rax, [r14]
mov rax, [rax-18h]
mov qword ptr [r14+rax+10h], 5
mov rdi, rbx; this
call _ZNK5nglog10LogMessage9thread_idEv; nglog::LogMessage::thread_id(void)
mov rsi, [rax]
test rsi, rsi
jz short loc_EA25
mov rdi, r14
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r14, rax
jmp short loc_EA39
loc_EA25:
lea rsi, aThreadIdOfANon; "thread::id of a non-executing thread"
mov edx, 24h ; '$'
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_EA39:
mov rax, [r14]
mov rax, [rax-18h]
lea r15, [r14+rax]
cmp byte ptr [r14+rax+0E1h], 0
jnz short loc_EA6B
mov rdi, r15
mov esi, 20h ; ' '
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
mov [r15+0E0h], al
mov byte ptr [r15+0E1h], 1
loc_EA6B:
mov byte ptr [r15+0E0h], 30h ; '0'
lea rsi, [rsp+38h+var_2A]
mov byte ptr [rsi], 20h ; ' '
mov edx, 1
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rdi, rbx; this
call _ZNK5nglog10LogMessage8basenameEv; nglog::LogMessage::basename(void)
test rax, rax
jz short loc_EAB3
mov r15, rax
mov rdi, rax
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_EACD
loc_EAB3:
mov rax, [r14]
mov rax, [rax-18h]
mov rdi, r14
add rdi, rax
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_EACD:
lea rsi, [rsp+38h+var_29]
mov byte ptr [rsi], 3Ah ; ':'
mov edx, 1
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rdi, rbx; this
call _ZNK5nglog10LogMessage4lineEv; nglog::LogMessage::line(void)
mov rdi, r14
mov esi, eax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aTmpTmpSize1+19h; "]"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_EB0B:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
locret_EB17:
retn
| void `anonymous namespace'::PrefixAttacher(
_anonymous_namespace_ *this,
std::ostream *a2,
const nglog::LogMessage *a3,
void *a4)
{
unsigned int v5; // eax
_QWORD *v6; // r14
long long v7; // rax
_QWORD *v8; // r14
long long v9; // rax
_QWORD *v10; // r14
long long v11; // rax
long long v12; // rax
_QWORD *v13; // r14
long long v14; // rax
long long v15; // rax
_QWORD *v16; // r14
long long v17; // rax
long long v18; // rax
_QWORD *v19; // r14
unsigned int *v20; // rax
_QWORD *v21; // r14
long long v22; // rax
long long v23; // rax
_QWORD *v24; // r14
long long v25; // rax
char *v26; // r15
long long v27; // rsi
long long v28; // rax
char *v29; // r15
_QWORD *v30; // r14
long long v31; // rax
long long v32; // r15
long long v33; // rax
long long v34; // r14
unsigned int v35; // eax
long long v36; // rax
char v37; // [rsp+1h] [rbp-2Fh] BYREF
char v38; // [rsp+2h] [rbp-2Eh] BYREF
char v39; // [rsp+3h] [rbp-2Dh] BYREF
char v40; // [rsp+4h] [rbp-2Ch] BYREF
char v41; // [rsp+5h] [rbp-2Bh] BYREF
char v42; // [rsp+6h] [rbp-2Ah] BYREF
char v43[41]; // [rsp+7h] [rbp-29h] BYREF
if ( a3 && !(unsigned int)std::string::compare(a3, "good data") )
{
v5 = nglog::LogMessage::severity(a2);
v37 = *(_BYTE *)nglog::GetLogSeverityName(v5);
v6 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(this, &v37, 1LL);
*(_QWORD *)((char *)v6 + *(_QWORD *)(*v6 - 24LL) + 16) = 4LL;
v7 = nglog::LogMessage::time(a2);
v8 = (_QWORD *)std::ostream::operator<<(v6, (unsigned int)(*(_DWORD *)(v7 + 20) + 1900));
*(_QWORD *)((char *)v8 + *(_QWORD *)(*v8 - 24LL) + 16) = 2LL;
v9 = nglog::LogMessage::time(a2);
v10 = (_QWORD *)std::ostream::operator<<(v8, (unsigned int)(*(_DWORD *)(v9 + 16) + 1));
*(_QWORD *)((char *)v10 + *(_QWORD *)(*v10 - 24LL) + 16) = 2LL;
v11 = nglog::LogMessage::time(a2);
v12 = std::ostream::operator<<(v10, *(unsigned int *)(v11 + 12));
v38 = 32;
v13 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v12, &v38, 1LL);
*(_QWORD *)((char *)v13 + *(_QWORD *)(*v13 - 24LL) + 16) = 2LL;
v14 = nglog::LogMessage::time(a2);
v15 = std::ostream::operator<<(v13, *(unsigned int *)(v14 + 8));
v39 = 58;
v16 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v15, &v39, 1LL);
*(_QWORD *)((char *)v16 + *(_QWORD *)(*v16 - 24LL) + 16) = 2LL;
v17 = nglog::LogMessage::time(a2);
v18 = std::ostream::operator<<(v16, *(unsigned int *)(v17 + 4));
v40 = 58;
v19 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v18, &v40, 1LL);
*(_QWORD *)((char *)v19 + *(_QWORD *)(*v19 - 24LL) + 16) = 2LL;
v20 = (unsigned int *)nglog::LogMessage::time(a2);
v21 = (_QWORD *)std::ostream::operator<<(v19, *v20);
std::__ostream_insert<char,std::char_traits<char>>(v21, ".", 1LL);
*(_QWORD *)((char *)v21 + *(_QWORD *)(*v21 - 24LL) + 16) = 6LL;
v22 = nglog::LogMessage::time(a2);
v23 = std::ostream::_M_insert<long>(v21, *(_QWORD *)(v22 + 64));
v41 = 32;
v24 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v23, &v41, 1LL);
v25 = *(_QWORD *)(*v24 - 24LL);
v26 = (char *)v24 + v25;
if ( !*((_BYTE *)v24 + v25 + 225) )
{
v26[224] = std::ios::widen((char *)v24 + v25, 32LL);
v26[225] = 1;
}
v26[224] = 32;
*(_QWORD *)((char *)v24 + *(_QWORD *)(*v24 - 24LL) + 16) = 5LL;
v27 = *(_QWORD *)nglog::LogMessage::thread_id(a2);
if ( v27 )
v24 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v24, v27);
else
std::__ostream_insert<char,std::char_traits<char>>(v24, "thread::id of a non-executing thread", 36LL);
v28 = *(_QWORD *)(*v24 - 24LL);
v29 = (char *)v24 + v28;
if ( !*((_BYTE *)v24 + v28 + 225) )
{
v29[224] = std::ios::widen((char *)v24 + v28, 32LL);
v29[225] = 1;
}
v29[224] = 48;
v42 = 32;
v30 = (_QWORD *)std::__ostream_insert<char,std::char_traits<char>>(v24, &v42, 1LL);
v31 = nglog::LogMessage::basename(a2);
if ( v31 )
{
v32 = v31;
v33 = strlen(v31);
std::__ostream_insert<char,std::char_traits<char>>(v30, v32, v33);
}
else
{
std::ios::clear(
(char *)v30 + *(_QWORD *)(*v30 - 24LL),
*(_DWORD *)((char *)v30 + *(_QWORD *)(*v30 - 24LL) + 32) | 1u);
}
v43[0] = 58;
v34 = std::__ostream_insert<char,std::char_traits<char>>(v30, v43, 1LL);
v35 = nglog::LogMessage::line(a2);
v36 = std::ostream::operator<<(v34, v35);
std::__ostream_insert<char,std::char_traits<char>>(v36, "]", 1LL);
}
}
| PrefixAttacher:
TEST RDX,RDX
JZ 0x0010eb17
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14,RDI
LEA RSI,[0x1320d6]
MOV RDI,RDX
CALL 0x00108150
TEST EAX,EAX
JNZ 0x0010eb0b
MOV RDI,RBX
CALL 0x0011b174
MOV EDI,EAX
CALL 0x00119db0
MOV AL,byte ptr [RAX]
LEA RSI,[RSP + 0x9]
MOV byte ptr [RSI],AL
MOV EDX,0x1
MOV RDI,R14
CALL 0x00108720
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],0x4
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,0x76c
ADD ESI,dword ptr [RAX + 0x14]
MOV RDI,R14
CALL 0x00108b90
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV R15D,0x2
MOV qword ptr [R14 + RAX*0x1 + 0x10],R15
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,dword ptr [RAX + 0x10]
INC ESI
MOV RDI,R14
CALL 0x00108b90
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],R15
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,dword ptr [RAX + 0xc]
MOV RDI,R14
CALL 0x00108b90
MOV BPL,0x20
LEA RSI,[RSP + 0xa]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],R15
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,dword ptr [RAX + 0x8]
MOV RDI,R14
CALL 0x00108b90
MOV R12B,0x3a
LEA RSI,[RSP + 0xb]
MOV byte ptr [RSI],R12B
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],R15
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,dword ptr [RAX + 0x4]
MOV RDI,R14
CALL 0x00108b90
LEA RSI,[RSP + 0xc]
MOV byte ptr [RSI],R12B
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],R15
MOV RDI,RBX
CALL 0x0011b1ae
MOV ESI,dword ptr [RAX]
MOV RDI,R14
CALL 0x00108b90
MOV R14,RAX
LEA RSI,[0x1361f0]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],0x6
MOV RDI,RBX
CALL 0x0011b1ae
MOV RSI,qword ptr [RAX + 0x40]
MOV RDI,R14
CALL 0x001085d0
LEA RSI,[RSP + 0xd]
MOV byte ptr [RSI],BPL
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + -0x18]
LEA R15,[R14 + RAX*0x1]
CMP byte ptr [R14 + RAX*0x1 + 0xe1],0x0
JNZ 0x0010e9f0
MOV RDI,R15
MOV ESI,0x20
CALL 0x001085e0
MOV byte ptr [R15 + 0xe0],AL
MOV byte ptr [R15 + 0xe1],0x1
LAB_0010e9f0:
MOV byte ptr [R15 + 0xe0],0x20
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [R14 + RAX*0x1 + 0x10],0x5
MOV RDI,RBX
CALL 0x0011b18c
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x0010ea25
MOV RDI,R14
CALL 0x00108400
MOV R14,RAX
JMP 0x0010ea39
LAB_0010ea25:
LEA RSI,[0x133393]
MOV EDX,0x24
MOV RDI,R14
CALL 0x00108720
LAB_0010ea39:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
LEA R15,[R14 + RAX*0x1]
CMP byte ptr [R14 + RAX*0x1 + 0xe1],0x0
JNZ 0x0010ea6b
MOV RDI,R15
MOV ESI,0x20
CALL 0x001085e0
MOV byte ptr [R15 + 0xe0],AL
MOV byte ptr [R15 + 0xe1],0x1
LAB_0010ea6b:
MOV byte ptr [R15 + 0xe0],0x30
LEA RSI,[RSP + 0xe]
MOV byte ptr [RSI],0x20
MOV EDX,0x1
MOV RDI,R14
CALL 0x00108720
MOV R14,RAX
MOV RDI,RBX
CALL 0x0011b1a2
TEST RAX,RAX
JZ 0x0010eab3
MOV R15,RAX
MOV RDI,RAX
CALL 0x00108270
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00108720
JMP 0x0010eacd
LAB_0010eab3:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R14
ADD RDI,RAX
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00108b60
LAB_0010eacd:
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],0x3a
MOV EDX,0x1
MOV RDI,R14
CALL 0x00108720
MOV R14,RAX
MOV RDI,RBX
CALL 0x0011b180
MOV RDI,R14
MOV ESI,EAX
CALL 0x00108b90
LEA RSI,[0x13359d]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x00108720
LAB_0010eb0b:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
LAB_0010eb17:
RET
|
/* (anonymous namespace)::PrefixAttacher(std::ostream&, nglog::LogMessage const&, void*) */
void (anonymous_namespace)::PrefixAttacher(ostream *param_1,LogMessage *param_2,void *param_3)
{
ostream oVar1;
int iVar2;
int4 uVar3;
char *pcVar4;
ostream *poVar5;
long lVar6;
int *piVar7;
ostream *poVar8;
long *plVar9;
size_t sVar10;
char local_2f [7];
if ((param_3 != (void *)0x0) &&
(iVar2 = std::__cxx11::string::compare((char *)param_3), iVar2 == 0)) {
uVar3 = nglog::LogMessage::severity(param_2);
pcVar4 = (char *)nglog::GetLogSeverityName(uVar3);
local_2f[0] = *pcVar4;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(param_1,local_2f,1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 4;
lVar6 = nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*(int *)(lVar6 + 0x14) + 0x76c);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 2;
lVar6 = nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*(int *)(lVar6 + 0x10) + 1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 2;
lVar6 = nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*(int *)(lVar6 + 0xc));
local_2f[1] = 0x20;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(poVar5,local_2f + 1,1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 2;
lVar6 = nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*(int *)(lVar6 + 8));
local_2f[2] = 0x3a;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(poVar5,local_2f + 2,1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 2;
lVar6 = nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*(int *)(lVar6 + 4));
local_2f[3] = 0x3a;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(poVar5,local_2f + 3,1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 2;
piVar7 = (int *)nglog::LogMessage::time(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,*piVar7);
std::__ostream_insert<char,std::char_traits<char>>(poVar5,".",1);
*(int8 *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x10) = 6;
nglog::LogMessage::time(param_2);
poVar5 = std::ostream::_M_insert<long>((long)poVar5);
local_2f[4] = 0x20;
poVar8 = std::__ostream_insert<char,std::char_traits<char>>(poVar5,local_2f + 4,1);
poVar5 = poVar8 + *(long *)(*(long *)poVar8 + -0x18);
if (poVar8[*(long *)(*(long *)poVar8 + -0x18) + 0xe1] == (ostream)0x0) {
oVar1 = (ostream)std::ios::widen((char)poVar5);
poVar5[0xe0] = oVar1;
poVar5[0xe1] = (ostream)0x1;
}
poVar5[0xe0] = (ostream)0x20;
*(int8 *)(poVar8 + *(long *)(*(long *)poVar8 + -0x18) + 0x10) = 5;
plVar9 = (long *)nglog::LogMessage::thread_id(param_2);
if (*plVar9 == 0) {
std::__ostream_insert<char,std::char_traits<char>>
(poVar8,"thread::id of a non-executing thread",0x24);
}
else {
poVar8 = std::ostream::_M_insert<unsigned_long>((ulong)poVar8);
}
poVar5 = poVar8 + *(long *)(*(long *)poVar8 + -0x18);
if (poVar8[*(long *)(*(long *)poVar8 + -0x18) + 0xe1] == (ostream)0x0) {
oVar1 = (ostream)std::ios::widen((char)poVar5);
poVar5[0xe0] = oVar1;
poVar5[0xe1] = (ostream)0x1;
}
poVar5[0xe0] = (ostream)0x30;
local_2f[5] = 0x20;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(poVar8,local_2f + 5,1);
pcVar4 = (char *)nglog::LogMessage::basename(param_2);
if (pcVar4 == (char *)0x0) {
std::ios::clear(poVar5 + *(long *)(*(long *)poVar5 + -0x18),
*(uint *)(poVar5 + *(long *)(*(long *)poVar5 + -0x18) + 0x20) | 1);
}
else {
sVar10 = strlen(pcVar4);
std::__ostream_insert<char,std::char_traits<char>>(poVar5,pcVar4,sVar10);
}
local_2f[6] = 0x3a;
poVar5 = std::__ostream_insert<char,std::char_traits<char>>(poVar5,local_2f + 6,1);
iVar2 = nglog::LogMessage::line(param_2);
poVar5 = (ostream *)std::ostream::operator<<(poVar5,iVar2);
std::__ostream_insert<char,std::char_traits<char>>(poVar5,"]",1);
}
return;
}
|
|
1,614 | add_scope_var | bluesky950520[P]quickjs/quickjs.c | static int add_scope_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name,
JSVarKindEnum var_kind)
{
int idx = add_var(ctx, fd, name);
if (idx >= 0) {
JSVarDef *vd = &fd->vars[idx];
vd->var_kind = var_kind;
vd->scope_level = fd->scope_level;
vd->scope_next = fd->scope_first;
fd->scopes[fd->scope_level].first = idx;
fd->scope_first = idx;
}
return idx;
} | O0 | c | add_scope_var:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0xa44e0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0xadbd8
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movl 0x10(%rsp), %eax
movb %al, %cl
movq (%rsp), %rax
movzbl %cl, %edx
movl 0xc(%rax), %ecx
andl $0xf, %edx
shll $0x4, %edx
andl $0xffffff0f, %ecx # imm = 0xFFFFFF0F
orl %edx, %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movl 0xe8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movl 0xec(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rax
movq 0xf8(%rax), %rax
movq 0x18(%rsp), %rcx
movslq 0xe8(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xec(%rax)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| add_scope_var:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_14], edx
mov [rsp+28h+var_18], ecx
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
mov edx, [rsp+28h+var_14]
call add_var
mov [rsp+28h+var_1C], eax
cmp [rsp+28h+var_1C], 0
jl loc_ADBD8
mov rax, [rsp+28h+var_10]
mov rax, [rax+90h]
movsxd rcx, [rsp+28h+var_1C]
shl rcx, 4
add rax, rcx
mov [rsp+28h+var_28], rax
mov eax, [rsp+28h+var_18]
mov cl, al
mov rax, [rsp+28h+var_28]
movzx edx, cl
mov ecx, [rax+0Ch]
and edx, 0Fh
shl edx, 4
and ecx, 0FFFFFF0Fh
or ecx, edx
mov [rax+0Ch], ecx
mov rax, [rsp+28h+var_10]
mov ecx, [rax+0E8h]
mov rax, [rsp+28h+var_28]
mov [rax+4], ecx
mov rax, [rsp+28h+var_10]
mov ecx, [rax+0ECh]
mov rax, [rsp+28h+var_28]
mov [rax+8], ecx
mov edx, [rsp+28h+var_1C]
mov rax, [rsp+28h+var_10]
mov rax, [rax+0F8h]
mov rcx, [rsp+28h+var_10]
movsxd rcx, dword ptr [rcx+0E8h]
mov [rax+rcx*8+4], edx
mov ecx, [rsp+28h+var_1C]
mov rax, [rsp+28h+var_10]
mov [rax+0ECh], ecx
loc_ADBD8:
mov eax, [rsp+28h+var_1C]
add rsp, 28h
retn
| long long add_scope_var(
long long a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v15; // [rsp+0h] [rbp-28h]
int v16; // [rsp+Ch] [rbp-1Ch]
char v17; // [rsp+10h] [rbp-18h]
v17 = a4;
v16 = add_var(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( v16 >= 0 )
{
v15 = (_DWORD *)(16LL * v16 + *(_QWORD *)(a2 + 144));
v15[3] = (16 * (v17 & 0xF)) | v15[3] & 0xFFFFFF0F;
v15[1] = *(_DWORD *)(a2 + 232);
v15[2] = *(_DWORD *)(a2 + 236);
*(_DWORD *)(*(_QWORD *)(a2 + 248) + 8LL * *(int *)(a2 + 232) + 4) = v16;
*(_DWORD *)(a2 + 236) = v16;
}
return (unsigned int)v16;
}
| add_scope_var:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],EDX
MOV dword ptr [RSP + 0x10],ECX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x14]
CALL 0x001a44e0
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x0
JL 0x001adbd8
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + 0xc]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP],RAX
MOV EAX,dword ptr [RSP + 0x10]
MOV CL,AL
MOV RAX,qword ptr [RSP]
MOVZX EDX,CL
MOV ECX,dword ptr [RAX + 0xc]
AND EDX,0xf
SHL EDX,0x4
AND ECX,0xffffff0f
OR ECX,EDX
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RSP + 0x18]
MOV ECX,dword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RSP + 0x18]
MOV ECX,dword ptr [RAX + 0xec]
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x8],ECX
MOV EDX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RCX + 0xe8]
MOV dword ptr [RAX + RCX*0x8 + 0x4],EDX
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX + 0xec],ECX
LAB_001adbd8:
MOV EAX,dword ptr [RSP + 0xc]
ADD RSP,0x28
RET
|
int add_scope_var(int8 param_1,long param_2,int4 param_3,uint param_4)
{
int iVar1;
long lVar2;
iVar1 = add_var(param_1,param_2,param_3);
if (-1 < iVar1) {
lVar2 = *(long *)(param_2 + 0x90) + (long)iVar1 * 0x10;
*(uint *)(lVar2 + 0xc) = *(uint *)(lVar2 + 0xc) & 0xffffff0f | (param_4 & 0xf) << 4;
*(int4 *)(lVar2 + 4) = *(int4 *)(param_2 + 0xe8);
*(int4 *)(lVar2 + 8) = *(int4 *)(param_2 + 0xec);
*(int *)(*(long *)(param_2 + 0xf8) + 4 + (long)*(int *)(param_2 + 0xe8) * 8) = iVar1;
*(int *)(param_2 + 0xec) = iVar1;
}
return iVar1;
}
|
|
1,615 | add_scope_var | bluesky950520[P]quickjs/quickjs.c | static int add_scope_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name,
JSVarKindEnum var_kind)
{
int idx = add_var(ctx, fd, name);
if (idx >= 0) {
JSVarDef *vd = &fd->vars[idx];
vd->var_kind = var_kind;
vd->scope_level = fd->scope_level;
vd->scope_next = fd->scope_first;
fd->scopes[fd->scope_level].first = idx;
fd->scope_first = idx;
}
return idx;
} | O2 | c | add_scope_var:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
callq 0x5418b
testl %eax, %eax
js 0x5a0cd
movq 0x90(%rbx), %rcx
movl %eax, %edx
shlq $0x4, %rdx
shll $0x4, %ebp
movzbl %bpl, %esi
movl $0xffffff0f, %edi # imm = 0xFFFFFF0F
andl 0xc(%rcx,%rdx), %edi
orl %esi, %edi
movl %edi, 0xc(%rcx,%rdx)
movq 0xe8(%rbx), %rsi
movq %rsi, 0x4(%rcx,%rdx)
movq 0xf8(%rbx), %rcx
movslq %esi, %rdx
movl %eax, 0x4(%rcx,%rdx,8)
movl %eax, 0xec(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| add_scope_var:
push rbp
push rbx
push rax
mov ebp, ecx
mov rbx, rsi
call add_var
test eax, eax
js short loc_5A0CD
mov rcx, [rbx+90h]
mov edx, eax
shl rdx, 4
shl ebp, 4
movzx esi, bpl
mov edi, 0FFFFFF0Fh
and edi, [rcx+rdx+0Ch]
or edi, esi
mov [rcx+rdx+0Ch], edi
mov rsi, [rbx+0E8h]
mov [rcx+rdx+4], rsi
mov rcx, [rbx+0F8h]
movsxd rdx, esi
mov [rcx+rdx*8+4], eax
mov [rbx+0ECh], eax
loc_5A0CD:
add rsp, 8
pop rbx
pop rbp
retn
| long long add_scope_var(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // bp
long long result; // rax
long long v17; // rcx
long long v18; // rdx
long long v19; // rsi
v14 = a4;
result = add_var(a1, a2, a3, a4, a7, a8, a9, a10, a11, a12, a13, a14, a5, a6);
if ( (int)result >= 0 )
{
v17 = *(_QWORD *)(a2 + 144);
v18 = 16LL * (unsigned int)result;
*(_DWORD *)(v17 + v18 + 12) = (unsigned __int8)(16 * v14) | *(_DWORD *)(v17 + v18 + 12) & 0xFFFFFF0F;
v19 = *(_QWORD *)(a2 + 232);
*(_QWORD *)(v17 + v18 + 4) = v19;
*(_DWORD *)(*(_QWORD *)(a2 + 248) + 8LL * (int)v19 + 4) = result;
*(_DWORD *)(a2 + 236) = result;
}
return result;
}
| add_scope_var:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOV RBX,RSI
CALL 0x0015418b
TEST EAX,EAX
JS 0x0015a0cd
MOV RCX,qword ptr [RBX + 0x90]
MOV EDX,EAX
SHL RDX,0x4
SHL EBP,0x4
MOVZX ESI,BPL
MOV EDI,0xffffff0f
AND EDI,dword ptr [RCX + RDX*0x1 + 0xc]
OR EDI,ESI
MOV dword ptr [RCX + RDX*0x1 + 0xc],EDI
MOV RSI,qword ptr [RBX + 0xe8]
MOV qword ptr [RCX + RDX*0x1 + 0x4],RSI
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,ESI
MOV dword ptr [RCX + RDX*0x8 + 0x4],EAX
MOV dword ptr [RBX + 0xec],EAX
LAB_0015a0cd:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void add_scope_var(int8 param_1,long param_2,int8 param_3,uint param_4)
{
long lVar1;
int8 uVar2;
uint uVar3;
long lVar4;
uVar3 = add_var();
if (-1 < (int)uVar3) {
lVar1 = *(long *)(param_2 + 0x90);
lVar4 = (ulong)uVar3 * 0x10;
*(uint *)(lVar1 + 0xc + lVar4) =
*(uint *)(lVar1 + 0xc + lVar4) & 0xffffff0f | (param_4 & 0xf) << 4;
uVar2 = *(int8 *)(param_2 + 0xe8);
*(int8 *)(lVar1 + 4 + lVar4) = uVar2;
*(uint *)(*(long *)(param_2 + 0xf8) + 4 + (long)(int)uVar2 * 8) = uVar3;
*(uint *)(param_2 + 0xec) = uVar3;
}
return;
}
|
|
1,616 | ma_setup_live_state | eloqsql/storage/maria/ma_state.c | my_bool _ma_setup_live_state(MARIA_HA *info)
{
TRN *trn;
MARIA_SHARE *share= info->s;
MARIA_USED_TABLES *tables;
MARIA_STATE_HISTORY *history;
DBUG_ENTER("_ma_setup_live_state");
DBUG_PRINT("enter", ("info: %p", info));
DBUG_ASSERT(share->lock_key_trees);
if (maria_create_trn_hook(info))
DBUG_RETURN(1);
trn= info->trn;
for (tables= (MARIA_USED_TABLES*) trn->used_tables;
tables;
tables= tables->next)
{
if (tables->share == share)
{
/* Table is already used by transaction */
goto end;
}
}
/* Table was not used before, create new table state entry */
if (!(tables= (MARIA_USED_TABLES*) my_malloc(PSI_INSTRUMENT_ME,
sizeof(*tables), MYF(MY_WME | MY_ZEROFILL))))
DBUG_RETURN(1);
tables->next= trn->used_tables;
trn->used_tables= tables;
tables->share= share;
mysql_mutex_lock(&share->intern_lock);
share->in_trans++;
DBUG_PRINT("info", ("share: %p in_trans: %d",
share, share->in_trans));
history= share->state_history;
/*
We must keep share locked to ensure that we don't access a history
link that is deleted by concurrently running checkpoint.
It's enough to compare trids here (instead of calling
tranman_can_read_from) as history->trid is a commit_trid
*/
while (trn->trid <= history->trid)
history= history->next;
mysql_mutex_unlock(&share->intern_lock);
/* The current item can't be deleted as it's the first one visible for us */
tables->state_start= tables->state_current= history->state;
tables->state_current.changed= tables->state_current.no_transid= 0;
DBUG_PRINT("info", ("records: %ld", (ulong) tables->state_start.records));
end:
info->state_start= &tables->state_start;
info->state= &tables->state_current;
info->used_tables= tables;
tables->use_count++;
/*
Mark in transaction state if we are not using transid (versioning)
on rows. If not, then we will in _ma_trnman_end_trans_hook()
ensure that the state is visible for all at end of transaction
*/
tables->state_current.no_transid|= !(info->row_flag & ROW_FLAG_TRANSID);
DBUG_PRINT("exit", ("tables: %p info->state: %p", tables, info->state));
DBUG_RETURN(0);
} | O3 | c | ma_setup_live_state:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x3c4d25(%rip), %rax # 0x3fcfd8
callq *(%rax)
movb $0x1, %r15b
testl %eax, %eax
jne 0x383e6
movq 0x8(%rbx), %rax
leaq 0x58(%rax), %r13
movq %r13, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x382de
cmpq %r12, 0x8(%r14)
jne 0x382cb
jmp 0x383b8
movq %rax, -0x30(%rbp)
movl $0x88, %esi
movl $0x30, %edx
xorl %edi, %edi
callq 0x9fdb1
testq %rax, %rax
je 0x383e6
movq %rax, %r14
movq (%r13), %rax
movq %rax, (%r14)
movq %r14, (%r13)
movq %r12, 0x8(%r14)
leaq 0x8f0(%r12), %r13
cmpq $0x0, 0x930(%r12)
jne 0x383f8
movq %r13, %rdi
callq 0x29220
incl 0x7ac(%r12)
leaq 0x450(%r12), %r15
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq (%r15), %r15
cmpq 0x8(%r15), %rax
jbe 0x38345
movq 0x930(%r12), %rdi
testq %rdi, %rdi
jne 0x38411
movq %r13, %rdi
callq 0x291e0
movups 0x10(%r15), %xmm0
movups 0x20(%r15), %xmm1
movups 0x30(%r15), %xmm2
movups %xmm0, 0x10(%r14)
movups %xmm1, 0x20(%r14)
movups %xmm2, 0x30(%r14)
movq 0x40(%r15), %rax
movq %rax, 0x40(%r14)
movq 0x40(%r15), %rax
movups 0x10(%r15), %xmm0
movups 0x20(%r15), %xmm1
movups 0x30(%r15), %xmm2
movups %xmm2, 0x68(%r14)
movups %xmm0, 0x48(%r14)
movq %rax, 0x78(%r14)
movups %xmm1, 0x58(%r14)
andb $-0x4, 0x44(%r14)
leaq 0x48(%r14), %rax
movq %rax, 0x60(%rbx)
leaq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movq %r14, 0x68(%rbx)
incl 0x80(%r14)
movb 0x618(%rbx), %al
notb %al
addb %al, %al
andb $0x2, %al
orb %al, 0x44(%r14)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa12ef(%rip), %rsi # 0xd96ee
movq %r13, %rdi
movl $0x59, %edx
callq 0x2eb8f
jmp 0x3832d
leaq 0x34dbf8(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x3835f
| _ma_setup_live_state:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi]
lea rax, maria_create_trn_hook
call qword ptr [rax]
mov r15b, 1
test eax, eax
jnz loc_383E6
mov rax, [rbx+8]
lea r13, [rax+58h]
mov r14, r13
loc_382CB:
mov r14, [r14]
test r14, r14
jz short loc_382DE
cmp [r14+8], r12
jnz short loc_382CB
jmp loc_383B8
loc_382DE:
mov [rbp+var_30], rax
mov esi, 88h
mov edx, 30h ; '0'
xor edi, edi
call my_malloc
test rax, rax
jz loc_383E6
mov r14, rax
mov rax, [r13+0]
mov [r14], rax
mov [r13+0], r14
mov [r14+8], r12
lea r13, [r12+8F0h]
cmp qword ptr [r12+930h], 0
jnz loc_383F8
mov rdi, r13
call _pthread_mutex_lock
loc_3832D:
inc dword ptr [r12+7ACh]
lea r15, [r12+450h]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
loc_38345:
mov r15, [r15]
cmp rax, [r15+8]
jbe short loc_38345
mov rdi, [r12+930h]
test rdi, rdi
jnz loc_38411
loc_3835F:
mov rdi, r13
call _pthread_mutex_unlock
movups xmm0, xmmword ptr [r15+10h]
movups xmm1, xmmword ptr [r15+20h]
movups xmm2, xmmword ptr [r15+30h]
movups xmmword ptr [r14+10h], xmm0
movups xmmword ptr [r14+20h], xmm1
movups xmmword ptr [r14+30h], xmm2
mov rax, [r15+40h]
mov [r14+40h], rax
mov rax, [r15+40h]
movups xmm0, xmmword ptr [r15+10h]
movups xmm1, xmmword ptr [r15+20h]
movups xmm2, xmmword ptr [r15+30h]
movups xmmword ptr [r14+68h], xmm2
movups xmmword ptr [r14+48h], xmm0
mov [r14+78h], rax
movups xmmword ptr [r14+58h], xmm1
and byte ptr [r14+44h], 0FCh
loc_383B8:
lea rax, [r14+48h]
mov [rbx+60h], rax
lea rax, [r14+10h]
mov [rbx+20h], rax
mov [rbx+68h], r14
inc dword ptr [r14+80h]
mov al, [rbx+618h]
not al
add al, al
and al, 2
or [r14+44h], al
xor r15d, r15d
loc_383E6:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_383F8:
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 59h ; 'Y'
call psi_mutex_lock
jmp loc_3832D
loc_38411:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_3835F
| long long ma_setup_live_state(long long *a1)
{
unsigned int v1; // r15d
long long v2; // r12
_QWORD *v3; // r13
_QWORD *v4; // r14
_QWORD *v5; // rax
long long *v6; // r15
__int128 v7; // xmm1
__int128 v8; // xmm2
long long v9; // rax
__int128 v10; // xmm0
__int128 v11; // xmm1
long long v13; // [rsp+0h] [rbp-30h]
v2 = *a1;
LOBYTE(v1) = 1;
if ( !(unsigned int)maria_create_trn_hook(a1) )
{
v3 = (_QWORD *)(a1[1] + 88);
v4 = v3;
while ( 1 )
{
v4 = (_QWORD *)*v4;
if ( !v4 )
break;
if ( v4[1] == v2 )
goto LABEL_14;
}
v13 = a1[1];
v5 = (_QWORD *)my_malloc(0LL, 136LL, 48LL);
if ( !v5 )
return v1;
v4 = v5;
*v5 = *v3;
*v3 = v5;
v5[1] = v2;
if ( *(_QWORD *)(v2 + 2352) )
psi_mutex_lock(v2 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0x59u);
else
pthread_mutex_lock(v2 + 2288);
++*(_DWORD *)(v2 + 1964);
v6 = (long long *)(v2 + 1104);
do
v6 = (long long *)*v6;
while ( *(_QWORD *)(v13 + 120) <= (unsigned long long)v6[1] );
if ( *(_QWORD *)(v2 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(v2 + 2288);
v7 = *((_OWORD *)v6 + 2);
v8 = *((_OWORD *)v6 + 3);
*((_OWORD *)v4 + 1) = *((_OWORD *)v6 + 1);
*((_OWORD *)v4 + 2) = v7;
*((_OWORD *)v4 + 3) = v8;
v4[8] = v6[8];
v9 = v6[8];
v10 = *((_OWORD *)v6 + 1);
v11 = *((_OWORD *)v6 + 2);
*(_OWORD *)(v4 + 13) = *((_OWORD *)v6 + 3);
*(_OWORD *)(v4 + 9) = v10;
v4[15] = v9;
*(_OWORD *)(v4 + 11) = v11;
*((_BYTE *)v4 + 68) &= 0xFCu;
LABEL_14:
a1[12] = (long long)(v4 + 9);
a1[4] = (long long)(v4 + 2);
a1[13] = (long long)v4;
++*((_DWORD *)v4 + 32);
*((_BYTE *)v4 + 68) |= (2 * ~*((_BYTE *)a1 + 1560)) & 2;
return 0;
}
return v1;
}
| _ma_setup_live_state:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI]
LEA RAX,[0x4fcfd8]
CALL qword ptr [RAX]
MOV R15B,0x1
TEST EAX,EAX
JNZ 0x001383e6
MOV RAX,qword ptr [RBX + 0x8]
LEA R13,[RAX + 0x58]
MOV R14,R13
LAB_001382cb:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x001382de
CMP qword ptr [R14 + 0x8],R12
JNZ 0x001382cb
JMP 0x001383b8
LAB_001382de:
MOV qword ptr [RBP + -0x30],RAX
MOV ESI,0x88
MOV EDX,0x30
XOR EDI,EDI
CALL 0x0019fdb1
TEST RAX,RAX
JZ 0x001383e6
MOV R14,RAX
MOV RAX,qword ptr [R13]
MOV qword ptr [R14],RAX
MOV qword ptr [R13],R14
MOV qword ptr [R14 + 0x8],R12
LEA R13,[R12 + 0x8f0]
CMP qword ptr [R12 + 0x930],0x0
JNZ 0x001383f8
MOV RDI,R13
CALL 0x00129220
LAB_0013832d:
INC dword ptr [R12 + 0x7ac]
LEA R15,[R12 + 0x450]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
LAB_00138345:
MOV R15,qword ptr [R15]
CMP RAX,qword ptr [R15 + 0x8]
JBE 0x00138345
MOV RDI,qword ptr [R12 + 0x930]
TEST RDI,RDI
JNZ 0x00138411
LAB_0013835f:
MOV RDI,R13
CALL 0x001291e0
MOVUPS XMM0,xmmword ptr [R15 + 0x10]
MOVUPS XMM1,xmmword ptr [R15 + 0x20]
MOVUPS XMM2,xmmword ptr [R15 + 0x30]
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOVUPS xmmword ptr [R14 + 0x20],XMM1
MOVUPS xmmword ptr [R14 + 0x30],XMM2
MOV RAX,qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV RAX,qword ptr [R15 + 0x40]
MOVUPS XMM0,xmmword ptr [R15 + 0x10]
MOVUPS XMM1,xmmword ptr [R15 + 0x20]
MOVUPS XMM2,xmmword ptr [R15 + 0x30]
MOVUPS xmmword ptr [R14 + 0x68],XMM2
MOVUPS xmmword ptr [R14 + 0x48],XMM0
MOV qword ptr [R14 + 0x78],RAX
MOVUPS xmmword ptr [R14 + 0x58],XMM1
AND byte ptr [R14 + 0x44],0xfc
LAB_001383b8:
LEA RAX,[R14 + 0x48]
MOV qword ptr [RBX + 0x60],RAX
LEA RAX,[R14 + 0x10]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x68],R14
INC dword ptr [R14 + 0x80]
MOV AL,byte ptr [RBX + 0x618]
NOT AL
ADD AL,AL
AND AL,0x2
OR byte ptr [R14 + 0x44],AL
XOR R15D,R15D
LAB_001383e6:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001383f8:
LEA RSI,[0x1d96ee]
MOV RDI,R13
MOV EDX,0x59
CALL 0x0012eb8f
JMP 0x0013832d
LAB_00138411:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0013835f
|
ulong _ma_setup_live_state(long *param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
int iVar7;
long *plVar8;
int8 unaff_R15;
ulong uVar9;
long *plVar10;
lVar1 = *param_1;
iVar7 = (*maria_create_trn_hook)();
uVar9 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if (iVar7 != 0) {
LAB_001383e6:
return uVar9 & 0xffffffff;
}
lVar2 = param_1[1];
plVar10 = (long *)(lVar2 + 0x58);
plVar8 = plVar10;
while (plVar8 = (long *)*plVar8, plVar8 != (long *)0x0) {
if (plVar8[1] == lVar1) goto LAB_001383b8;
}
plVar8 = (long *)my_malloc(0,0x88,0x30);
if (plVar8 == (long *)0x0) goto LAB_001383e6;
*plVar8 = *plVar10;
*plVar10 = (long)plVar8;
plVar8[1] = lVar1;
__mutex = (pthread_mutex_t *)(lVar1 + 0x8f0);
if (*(long *)(lVar1 + 0x930) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0x59)
;
}
*(int *)(lVar1 + 0x7ac) = *(int *)(lVar1 + 0x7ac) + 1;
plVar10 = (long *)(lVar1 + 0x450);
do {
plVar10 = (long *)*plVar10;
} while (*(ulong *)(lVar2 + 0x78) <= (ulong)plVar10[1]);
if (*(long *)(lVar1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar1 = plVar10[3];
lVar2 = plVar10[4];
lVar3 = plVar10[5];
lVar4 = plVar10[6];
lVar5 = plVar10[7];
plVar8[2] = plVar10[2];
plVar8[3] = lVar1;
plVar8[4] = lVar2;
plVar8[5] = lVar3;
plVar8[6] = lVar4;
plVar8[7] = lVar5;
plVar8[8] = plVar10[8];
lVar1 = plVar10[8];
lVar2 = plVar10[2];
lVar3 = plVar10[3];
lVar4 = plVar10[4];
lVar5 = plVar10[5];
lVar6 = plVar10[7];
plVar8[0xd] = plVar10[6];
plVar8[0xe] = lVar6;
plVar8[9] = lVar2;
plVar8[10] = lVar3;
plVar8[0xf] = lVar1;
plVar8[0xb] = lVar4;
plVar8[0xc] = lVar5;
*(byte *)((long)plVar8 + 0x44) = *(byte *)((long)plVar8 + 0x44) & 0xfc;
LAB_001383b8:
param_1[0xc] = (long)(plVar8 + 9);
param_1[4] = (long)(plVar8 + 2);
param_1[0xd] = (long)plVar8;
*(int *)(plVar8 + 0x10) = (int)plVar8[0x10] + 1;
*(byte *)((long)plVar8 + 0x44) =
*(byte *)((long)plVar8 + 0x44) | ~*(byte *)(param_1 + 0xc3) * '\x02' & 2;
uVar9 = 0;
goto LAB_001383e6;
}
|
|
1,617 | bindigits | eloqsql/storage/myisam/myisampack.c | static char *bindigits(ulonglong value, uint bits)
{
static char digits[72];
char *ptr= digits;
uint idx= bits;
DBUG_ASSERT(idx < sizeof(digits));
while (idx)
*(ptr++)= '0' + ((char) (value >> (--idx)) & (char) 1);
*ptr= '\0';
return digits;
} | O0 | c | bindigits:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x3cda1e(%rip), %rax # 0x3fd7f0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2fdde
jmp 0x2fde0
cmpl $0x0, -0x1c(%rbp)
je 0x2fe16
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movl %ecx, %ecx
shrq %cl, %rax
movsbl %al, %eax
andl $0x1, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x2fde0
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
leaq 0x3cd9cc(%rip), %rax # 0x3fd7f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| bindigits:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
lea rax, bindigits_digits
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
jmp short $+2
loc_2FDDE:
jmp short $+2
loc_2FDE0:
cmp [rbp+var_1C], 0
jz short loc_2FE16
mov rax, [rbp+var_8]
mov ecx, [rbp+var_1C]
add ecx, 0FFFFFFFFh
mov [rbp+var_1C], ecx
mov ecx, ecx
shr rax, cl
movsx eax, al
and eax, 1
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 1
mov [rbp+var_18], rdx
mov [rax], cl
jmp short loc_2FDE0
loc_2FE16:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
lea rax, bindigits_digits
pop rbp
retn
| void * bindigits(unsigned long long a1, int a2)
{
_BYTE *v2; // rax
_BYTE *v5; // [rsp+4h] [rbp-18h]
v5 = &bindigits_digits;
while ( a2 )
{
--a2;
v2 = v5++;
*v2 = ((a1 >> a2) & 1) + 48;
}
*v5 = 0;
return &bindigits_digits;
}
| bindigits:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
LEA RAX,[0x4fd7f0]
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0012fdde
LAB_0012fdde:
JMP 0x0012fde0
LAB_0012fde0:
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012fe16
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x1c]
ADD ECX,-0x1
MOV dword ptr [RBP + -0x1c],ECX
MOV ECX,ECX
SHR RAX,CL
MOVSX EAX,AL
AND EAX,0x1
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x0012fde0
LAB_0012fe16:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LEA RAX,[0x4fd7f0]
POP RBP
RET
|
int1 * bindigits(ulong param_1,int param_2)
{
int local_24;
char *local_20;
local_20 = &bindigits_digits;
local_24 = param_2;
while (local_24 != 0) {
local_24 = local_24 + -1;
*local_20 = ((byte)(param_1 >> ((byte)local_24 & 0x3f)) & 1) + 0x30;
local_20 = local_20 + 1;
}
*local_20 = '\0';
return &bindigits_digits;
}
|
|
1,618 | LefDefParser::lefiNonDefault::propValue(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp | const char *
lefiNonDefault::propValue(int index) const
{
char msg[160];
if (index < 0 || index >= numProps_) {
sprintf(msg, "ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d", index, numProps_);
lefiError(0, 1408, msg);
return 0;
}
return values_[index];
} | O3 | cpp | LefDefParser::lefiNonDefault::propValue(int) const:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %edx
testl %esi, %esi
setns %al
movl 0xf0(%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x2ce5b
movq 0x100(%rdi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x2ce80
leaq 0x31b88(%rip), %rsi # 0x5e9ea
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x580, %esi # imm = 0x580
movq %r14, %rdx
callq 0x33d78
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
| _ZNK12LefDefParser14lefiNonDefault9propValueEi:
push r14
push rbx
sub rsp, 0A8h
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi+0F0h]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_2CE5B
mov rax, [rdi+100h]
mov ecx, edx
mov rbx, [rax+rcx*8]
jmp short loc_2CE80
loc_2CE5B:
lea rsi, aErrorLefpars14_9; "ERROR (LEFPARS-1408): The index number "...
xor ebx, ebx
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 580h; int
mov rdx, r14; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
loc_2CE80:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r14
retn
| long long LefDefParser::lefiNonDefault::propValue(LefDefParser::lefiNonDefault *this, signed int a2)
{
int v2; // ecx
long long v3; // rbx
const char *v4; // rcx
_BYTE v6[184]; // [rsp+0h] [rbp-B8h] BYREF
v2 = *((_DWORD *)this + 60);
if ( v2 > a2 && a2 >= 0 )
return *(_QWORD *)(*((_QWORD *)this + 32) + 8LL * (unsigned int)a2);
v3 = 0LL;
sprintf(
v6,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\n"
"Valid index is from 0 to %d",
a2,
v2);
LefDefParser::lefiError(0LL, 1408, (int)v6, v4);
return v3;
}
| propValue:
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI + 0xf0]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x0012ce5b
MOV RAX,qword ptr [RDI + 0x100]
MOV ECX,EDX
MOV RBX,qword ptr [RAX + RCX*0x8]
JMP 0x0012ce80
LAB_0012ce5b:
LEA RSI,[0x15e9ea]
XOR EBX,EBX
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x580
MOV RDX,R14
CALL 0x00133d78
LAB_0012ce80:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R14
RET
|
/* LefDefParser::lefiNonDefault::propValue(int) const */
int8 __thiscall LefDefParser::lefiNonDefault::propValue(lefiNonDefault *this,int param_1)
{
int8 uVar1;
char acStack_b8 [168];
if (param_1 < 0 || *(int *)(this + 0xf0) <= param_1) {
uVar1 = 0;
sprintf(acStack_b8,
"ERROR (LEFPARS-1408): The index number %d given for the NONDEFAULT PROPERTY is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x580,acStack_b8);
}
else {
uVar1 = *(int8 *)(*(long *)(this + 0x100) + (ulong)(uint)param_1 * 8);
}
return uVar1;
}
|
|
1,619 | my_charpos_mb | eloqsql/strings/ctype-mb.c | size_t my_charpos_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end, size_t length)
{
const char *start= pos;
while (length && pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs, pos, end)) ? mb_len : 1;
length--;
}
return (size_t) (length ? end+2-start : pos-start);
} | O0 | c | my_charpos_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2d(%rbp)
je 0xe47ea
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xe47f3
jmp 0xe483c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe3c60
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0xe4814
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xe481e
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xe481e
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe47d0
cmpq $0x0, -0x20(%rbp)
je 0xe4858
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0xe4867
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_charpos_mb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_E47D0:
xor eax, eax
cmp [rbp+var_20], 0
mov [rbp+var_2D], al
jz short loc_E47EA
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
setb al
mov [rbp+var_2D], al
loc_E47EA:
mov al, [rbp+var_2D]
test al, 1
jnz short loc_E47F3
jmp short loc_E483C
loc_E47F3:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_0
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_E4814
mov eax, [rbp+var_2C]
mov [rbp+var_34], eax
jmp short loc_E481E
loc_E4814:
mov eax, 1
mov [rbp+var_34], eax
jmp short $+2
loc_E481E:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp short loc_E47D0
loc_E483C:
cmp [rbp+var_20], 0
jz short loc_E4858
mov rax, [rbp+var_18]
add rax, 2
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_40], rax
jmp short loc_E4867
loc_E4858:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
mov [rbp+var_40], rax
loc_E4867:
mov rax, [rbp+var_40]
add rsp, 40h
pop rbp
retn
| unsigned long long my_charpos_mb(long long a1, unsigned long long a2, unsigned long long a3, long long a4)
{
unsigned int v6; // [rsp+Ch] [rbp-34h]
bool v7; // [rsp+13h] [rbp-2Dh]
unsigned int v8; // [rsp+14h] [rbp-2Ch]
unsigned long long v11; // [rsp+30h] [rbp-10h]
v11 = a2;
while ( 1 )
{
v7 = 0;
if ( a4 )
v7 = v11 < a3;
if ( !v7 )
break;
v8 = my_ismbchar_0(a1, v11, a3);
if ( v8 )
v6 = v8;
else
v6 = 1;
v11 += v6;
--a4;
}
if ( a4 )
return a3 + 2 - a2;
else
return v11 - a2;
}
| my_charpos_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_001e47d0:
XOR EAX,EAX
CMP qword ptr [RBP + -0x20],0x0
MOV byte ptr [RBP + -0x2d],AL
JZ 0x001e47ea
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
SETC AL
MOV byte ptr [RBP + -0x2d],AL
LAB_001e47ea:
MOV AL,byte ptr [RBP + -0x2d]
TEST AL,0x1
JNZ 0x001e47f3
JMP 0x001e483c
LAB_001e47f3:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001e3c60
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x001e4814
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001e481e
LAB_001e4814:
MOV EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001e481e
LAB_001e481e:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e47d0
LAB_001e483c:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e4858
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001e4867
LAB_001e4858:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001e4867:
MOV RAX,qword ptr [RBP + -0x40]
ADD RSP,0x40
POP RBP
RET
|
long my_charpos_mb(int8 param_1,ulong param_2,ulong param_3,long param_4)
{
long local_48;
uint local_3c;
long local_28;
ulong local_18;
local_18 = param_2;
for (local_28 = param_4; local_28 != 0 && local_18 < param_3; local_28 = local_28 + -1) {
local_3c = my_ismbchar(param_1,local_18,param_3);
if (local_3c == 0) {
local_3c = 1;
}
local_18 = local_18 + local_3c;
}
if (local_28 == 0) {
local_48 = local_18 - param_2;
}
else {
local_48 = (param_3 + 2) - param_2;
}
return local_48;
}
|
|
1,620 | google::protobuf::internal::ExtensionSet::Extension::SpaceUsedExcludingSelfLong() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set_heavy.cc | size_t ExtensionSet::Extension::SpaceUsedExcludingSelfLong() const {
size_t total_size = 0;
if (is_repeated) {
switch (cpp_type(type)) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
total_size += sizeof(*repeated_##LOWERCASE##_value) + \
repeated_##LOWERCASE##_value->SpaceUsedExcludingSelfLong(); \
break
HANDLE_TYPE(INT32, int32_t);
HANDLE_TYPE(INT64, int64_t);
HANDLE_TYPE(UINT32, uint32_t);
HANDLE_TYPE(UINT64, uint64_t);
HANDLE_TYPE(FLOAT, float);
HANDLE_TYPE(DOUBLE, double);
HANDLE_TYPE(BOOL, bool);
HANDLE_TYPE(ENUM, enum);
HANDLE_TYPE(STRING, string);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_MESSAGE:
// repeated_message_value is actually a RepeatedPtrField<MessageLite>,
// but MessageLite has no SpaceUsedLong(), so we must directly call
// RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong() with a different
// type handler.
total_size += sizeof(*repeated_message_value) +
RepeatedMessage_SpaceUsedExcludingSelfLong(
reinterpret_cast<internal::RepeatedPtrFieldBase*>(
repeated_message_value));
break;
}
} else {
switch (cpp_type(type)) {
case FieldDescriptor::CPPTYPE_STRING:
total_size += sizeof(*string_value) +
StringSpaceUsedExcludingSelfLong(*string_value);
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (is_lazy) {
total_size += lazymessage_value->SpaceUsedLong();
} else {
total_size += down_cast<Message*>(message_value)->SpaceUsedLong();
}
break;
default:
// No extra storage costs for primitive types.
break;
}
}
return total_size;
} | O0 | cpp | google::protobuf::internal::ExtensionSet::Extension::SpaceUsedExcludingSelfLong() const:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
testb $0x1, 0x9(%rax)
je 0x55ef5f
movq 0x10(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x55f400
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x9, %eax
ja 0x55ef5a
movq 0x8(%rsp), %rax
leaq 0x9d626(%rip), %rcx # 0x5fc448
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3d8720
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3dddb0
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3db280
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3e0920
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3e34b0
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3e6000
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3d5aa0
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3d8720
addq $0x10, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3e8610
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55ef5a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x5611b0
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55eff1
movq 0x10(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x55f400
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
subl $0x9, %eax
je 0x55ef85
jmp 0x55ef7a
movl 0x4(%rsp), %eax
subl $0xa, %eax
je 0x55efa2
jmp 0x55efed
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3bf0d0
addq $0x20, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55efef
movq 0x10(%rsp), %rax
movb 0xa(%rax), %al
shrb $0x4, %al
testb $0x1, %al
je 0x55efcb
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55efeb
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x5611c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x70(%rax)
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x55efef
jmp 0x55efef
jmp 0x55eff1
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| _ZNK6google8protobuf8internal12ExtensionSet9Extension26SpaceUsedExcludingSelfLongEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_18], rax
mov [rsp+28h+var_10], 0
test byte ptr [rax+9], 1
jz loc_55EF5F
mov rax, [rsp+28h+var_18]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal8cpp_typeEh; google::protobuf::internal::cpp_type(uchar)
dec eax; switch 10 cases
mov ecx, eax
mov [rsp+28h+var_20], rcx
sub eax, 9
ja def_55EE29; jumptable 000000000055EE29 default case
mov rax, [rsp+28h+var_20]
lea rcx, jpt_55EE29
movsxd rax, ds:(jpt_55EE29 - 5FC448h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_55EE2B:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 1
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIiE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<int>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp def_55EE29; jumptable 000000000055EE29 default case
loc_55EE4B:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 2
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIlE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<long>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp def_55EE29; jumptable 000000000055EE29 default case
loc_55EE6B:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 3
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIjE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<uint>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp def_55EE29; jumptable 000000000055EE29 default case
loc_55EE8B:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 4
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldImE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<ulong>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp def_55EE29; jumptable 000000000055EE29 default case
loc_55EEAB:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 6
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIfE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<float>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp def_55EE29; jumptable 000000000055EE29 default case
loc_55EECB:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 5
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIdE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<double>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short def_55EE29; jumptable 000000000055EE29 default case
loc_55EEE8:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 7
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIbE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<bool>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short def_55EE29; jumptable 000000000055EE29 default case
loc_55EF05:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 8
mov rdi, [rax]
call _ZNK6google8protobuf13RepeatedFieldIiE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedField<int>::SpaceUsedExcludingSelfLong(void)
add rax, 10h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short def_55EE29; jumptable 000000000055EE29 default case
loc_55EF22:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 9
mov rdi, [rax]
call _ZNK6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE26SpaceUsedExcludingSelfLongEv; google::protobuf::RepeatedPtrField<std::string>::SpaceUsedExcludingSelfLong(void)
add rax, 18h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short def_55EE29; jumptable 000000000055EE29 default case
loc_55EF3F:
mov rax, [rsp+28h+var_18]; jumptable 000000000055EE29 case 10
mov rdi, [rax]; this
call _ZN6google8protobuf8internal12ExtensionSet42RepeatedMessage_SpaceUsedExcludingSelfLongEPNS1_20RepeatedPtrFieldBaseE; google::protobuf::internal::ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelfLong(google::protobuf::internal::RepeatedPtrFieldBase *)
add rax, 18h
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
def_55EE29:
jmp loc_55EFF1; jumptable 000000000055EE29 default case
loc_55EF5F:
mov rax, [rsp+28h+var_18]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal8cpp_typeEh; google::protobuf::internal::cpp_type(uchar)
mov ecx, eax
mov [rsp+28h+var_24], ecx
sub eax, 9
jz short loc_55EF85
jmp short $+2
loc_55EF7A:
mov eax, [rsp+28h+var_24]
sub eax, 0Ah
jz short loc_55EFA2
jmp short loc_55EFED
loc_55EF85:
mov rax, [rsp+28h+var_18]
mov rdi, [rax]
call _ZN6google8protobuf8internal32StringSpaceUsedExcludingSelfLongERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::internal::StringSpaceUsedExcludingSelfLong(std::string const&)
add rax, 20h ; ' '
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short loc_55EFEF
loc_55EFA2:
mov rax, [rsp+28h+var_18]
mov al, [rax+0Ah]
shr al, 4
test al, 1
jz short loc_55EFCB
mov rax, [rsp+28h+var_18]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+60h]
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
jmp short loc_55EFEB
loc_55EFCB:
mov rax, [rsp+28h+var_18]
mov rdi, [rax]
call _ZN6google8protobuf8internal9down_castIPNS0_7MessageENS0_11MessageLiteEEET_PT0_; google::protobuf::internal::down_cast<google::protobuf::Message *,google::protobuf::MessageLite>(google::protobuf::MessageLite *)
mov rdi, rax
mov rax, [rdi]
call qword ptr [rax+70h]
add rax, [rsp+28h+var_10]
mov [rsp+28h+var_10], rax
loc_55EFEB:
jmp short loc_55EFEF
loc_55EFED:
jmp short $+2
loc_55EFEF:
jmp short $+2
loc_55EFF1:
mov rax, [rsp+28h+var_10]
add rsp, 28h
retn
| long long google::protobuf::internal::ExtensionSet::Extension::SpaceUsedExcludingSelfLong(
google::protobuf::internal::ExtensionSet::Extension *this,
google::protobuf::internal::RepeatedPtrFieldBase *a2)
{
int v2; // eax
long long v3; // rax
long long v5; // [rsp+18h] [rbp-10h]
v5 = 0LL;
if ( (*((_BYTE *)this + 9) & 1) != 0 )
{
switch ( (unsigned int)google::protobuf::internal::cpp_type(
(google::protobuf::internal *)*((unsigned __int8 *)this + 8),
(unsigned __int8)a2) )
{
case 1u:
case 8u:
v5 = google::protobuf::RepeatedField<int>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 2u:
v5 = google::protobuf::RepeatedField<long>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 3u:
v5 = google::protobuf::RepeatedField<unsigned int>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 4u:
v5 = google::protobuf::RepeatedField<unsigned long>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 5u:
v5 = google::protobuf::RepeatedField<double>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 6u:
v5 = google::protobuf::RepeatedField<float>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 7u:
v5 = google::protobuf::RepeatedField<bool>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 16;
break;
case 9u:
v5 = google::protobuf::RepeatedPtrField<std::string>::SpaceUsedExcludingSelfLong(*(_QWORD *)this) + 24;
break;
case 0xAu:
v5 = google::protobuf::internal::ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelfLong(
*(google::protobuf::internal::ExtensionSet **)this,
a2)
+ 24;
break;
default:
return v5;
}
}
else
{
v2 = google::protobuf::internal::cpp_type(
(google::protobuf::internal *)*((unsigned __int8 *)this + 8),
(unsigned __int8)a2);
if ( v2 == 9 )
{
return google::protobuf::internal::StringSpaceUsedExcludingSelfLong(*(_QWORD *)this) + 32;
}
else if ( v2 == 10 )
{
if ( (*((_BYTE *)this + 10) & 0x10) != 0 )
{
return (*(long long ( **)(_QWORD))(**(_QWORD **)this + 96LL))(*(_QWORD *)this);
}
else
{
v3 = google::protobuf::internal::down_cast<google::protobuf::Message *,google::protobuf::MessageLite>(*(_QWORD *)this);
return (*(long long ( **)(long long))(*(_QWORD *)v3 + 112LL))(v3);
}
}
}
return v5;
}
| operator():
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDX
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RSP]
MOV RDX,qword ptr [RAX]
CALL 0x0055cc00
AND AL,0x1
ADD RSP,0x18
RET
|
/* bool
__gnu_cxx::__ops::_Iter_comp_iter<google::protobuf::DynamicMapSorter::MapEntryMessageComparator>::TEMPNAMEPLACEHOLDERVALUE(google::protobuf::Message
const**, google::protobuf::Message const**) */
bool __thiscall
__gnu_cxx::__ops::_Iter_comp_iter<google::protobuf::DynamicMapSorter::MapEntryMessageComparator>::
operator()(_Iter_comp_iter<google::protobuf::DynamicMapSorter::MapEntryMessageComparator> *this,
Message **param_1,Message **param_2)
{
byte bVar1;
bVar1 = google::protobuf::DynamicMapSorter::MapEntryMessageComparator::operator()
((MapEntryMessageComparator *)this,*param_1,*param_2);
return (bool)(bVar1 & 1);
}
|
|
1,621 | my_strnncollsp_8bit_bin | eloqsql/strings/ctype-bin.c | static int my_strnncollsp_8bit_bin(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *end;
size_t length;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
return ((int) a[-1] - (int) b[-1]);
}
return a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
} | O3 | c | my_strnncollsp_8bit_bin:
pushq %rbp
movq %rsp, %rbp
cmpq %r8, %rdx
movq %r8, %rdi
cmovbq %rdx, %rdi
leaq (%rsi,%rdi), %r9
cmpq %r9, %rsi
jae 0xac77d
movzbl (%rsi), %eax
incq %rsi
movzbl (%rcx), %r10d
incq %rcx
cmpb %r10b, %al
je 0xac761
subl %r10d, %eax
jmp 0xac784
xorl %eax, %eax
cmpq %r8, %rdx
jne 0xac786
popq %rbp
retq
jae 0xac7a3
subq %rdi, %r8
je 0xac784
xorl %edx, %edx
xorl %eax, %eax
cmpb $0x20, (%rcx,%rdx)
jb 0xac7be
jne 0xac7c5
incq %rdx
cmpq %rdx, %r8
jne 0xac791
jmp 0xac784
subq %rdi, %rdx
je 0xac784
xorl %ecx, %ecx
xorl %eax, %eax
cmpb $0x20, (%rsi,%rcx)
jb 0xac7c5
jne 0xac7be
incq %rcx
cmpq %rcx, %rdx
jne 0xac7ac
jmp 0xac784
movl $0x1, %eax
jmp 0xac784
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0xac784
| my_strnncollsp_8bit_bin:
push rbp
mov rbp, rsp
cmp rdx, r8
mov rdi, r8
cmovb rdi, rdx
lea r9, [rsi+rdi]
loc_AC761:
cmp rsi, r9
jnb short loc_AC77D
movzx eax, byte ptr [rsi]
inc rsi
movzx r10d, byte ptr [rcx]
inc rcx
cmp al, r10b
jz short loc_AC761
sub eax, r10d
jmp short loc_AC784
loc_AC77D:
xor eax, eax
cmp rdx, r8
jnz short loc_AC786
loc_AC784:
pop rbp
retn
loc_AC786:
jnb short loc_AC7A3
sub r8, rdi
jz short loc_AC784
xor edx, edx
xor eax, eax
loc_AC791:
cmp byte ptr [rcx+rdx], 20h ; ' '
jb short loc_AC7BE
jnz short loc_AC7C5
inc rdx
cmp r8, rdx
jnz short loc_AC791
jmp short loc_AC784
loc_AC7A3:
sub rdx, rdi
jz short loc_AC784
xor ecx, ecx
xor eax, eax
loc_AC7AC:
cmp byte ptr [rsi+rcx], 20h ; ' '
jb short loc_AC7C5
jnz short loc_AC7BE
inc rcx
cmp rdx, rcx
jnz short loc_AC7AC
jmp short loc_AC784
loc_AC7BE:
mov eax, 1
jmp short loc_AC784
loc_AC7C5:
mov eax, 0FFFFFFFFh
jmp short loc_AC784
| long long my_strnncollsp_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned long long v5; // rdi
unsigned __int8 *v6; // r9
int v7; // eax
int v8; // r10d
long long result; // rax
unsigned long long v10; // r8
long long v11; // rdx
unsigned long long v12; // rdx
long long v13; // rcx
v5 = a5;
if ( a3 < a5 )
v5 = a3;
v6 = &a2[v5];
while ( a2 < v6 )
{
v7 = *a2++;
v8 = *a4++;
if ( (_BYTE)v7 != (_BYTE)v8 )
return (unsigned int)(v7 - v8);
}
result = 0LL;
if ( a3 != a5 )
{
if ( a3 >= a5 )
{
v12 = a3 - v5;
if ( v12 )
{
v13 = 0LL;
result = 0LL;
while ( a2[v13] >= 0x20u )
{
if ( a2[v13] != 32 )
return 1LL;
if ( v12 == ++v13 )
return result;
}
return 0xFFFFFFFFLL;
}
}
else
{
v10 = a5 - v5;
if ( v10 )
{
v11 = 0LL;
result = 0LL;
while ( a4[v11] >= 0x20u )
{
if ( a4[v11] != 32 )
return 0xFFFFFFFFLL;
if ( v10 == ++v11 )
return result;
}
return 1LL;
}
}
}
return result;
}
| my_strnncollsp_8bit_bin:
PUSH RBP
MOV RBP,RSP
CMP RDX,R8
MOV RDI,R8
CMOVC RDI,RDX
LEA R9,[RSI + RDI*0x1]
LAB_001ac761:
CMP RSI,R9
JNC 0x001ac77d
MOVZX EAX,byte ptr [RSI]
INC RSI
MOVZX R10D,byte ptr [RCX]
INC RCX
CMP AL,R10B
JZ 0x001ac761
SUB EAX,R10D
JMP 0x001ac784
LAB_001ac77d:
XOR EAX,EAX
CMP RDX,R8
JNZ 0x001ac786
LAB_001ac784:
POP RBP
RET
LAB_001ac786:
JNC 0x001ac7a3
SUB R8,RDI
JZ 0x001ac784
XOR EDX,EDX
XOR EAX,EAX
LAB_001ac791:
CMP byte ptr [RCX + RDX*0x1],0x20
JC 0x001ac7be
JNZ 0x001ac7c5
INC RDX
CMP R8,RDX
JNZ 0x001ac791
JMP 0x001ac784
LAB_001ac7a3:
SUB RDX,RDI
JZ 0x001ac784
XOR ECX,ECX
XOR EAX,EAX
LAB_001ac7ac:
CMP byte ptr [RSI + RCX*0x1],0x20
JC 0x001ac7c5
JNZ 0x001ac7be
INC RCX
CMP RDX,RCX
JNZ 0x001ac7ac
JMP 0x001ac784
LAB_001ac7be:
MOV EAX,0x1
JMP 0x001ac784
LAB_001ac7c5:
MOV EAX,0xffffffff
JMP 0x001ac784
|
int my_strnncollsp_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte bVar3;
long lVar4;
ulong uVar5;
uVar5 = param_5;
if (param_3 < param_5) {
uVar5 = param_3;
}
pbVar1 = param_2 + uVar5;
while (param_2 < pbVar1) {
bVar2 = *param_2;
param_2 = param_2 + 1;
bVar3 = *param_4;
param_4 = param_4 + 1;
if (bVar2 != bVar3) {
return (uint)bVar2 - (uint)bVar3;
}
}
if (param_3 == param_5) {
return 0;
}
if (param_3 < param_5) {
if (param_5 == uVar5) {
return 0;
}
lVar4 = 0;
while( true ) {
if (param_4[lVar4] < 0x20) {
return 1;
}
if (param_4[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_5 - uVar5 == lVar4) {
return 0;
}
}
return -1;
}
if (param_3 != uVar5) {
lVar4 = 0;
while( true ) {
if (param_2[lVar4] < 0x20) {
return -1;
}
if (param_2[lVar4] != 0x20) break;
lVar4 = lVar4 + 1;
if (param_3 - uVar5 == lVar4) {
return 0;
}
}
return 1;
}
return 0;
}
|
|
1,622 | translog_get_sent_to_disk | eloqsql/storage/maria/ma_loghandler.c | static LSN translog_get_sent_to_disk()
{
register LSN lsn;
DBUG_ENTER("translog_get_sent_to_disk");
mysql_mutex_lock(&log_descriptor.sent_to_disk_lock);
lsn= log_descriptor.sent_to_disk;
DBUG_PRINT("info", ("sent to disk up to " LSN_FMT, LSN_IN_PARTS(lsn)));
mysql_mutex_unlock(&log_descriptor.sent_to_disk_lock);
DBUG_RETURN(lsn);
} | O3 | c | translog_get_sent_to_disk:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0xb95c82(%rip) # 0xc014a0
jne 0x6b855
leaq 0xb95c39(%rip), %rdi # 0xc01460
callq 0x291d0
movq 0xb95c0d(%rip), %rbx # 0xc01440
movq 0xb95c66(%rip), %rdi # 0xc014a0
testq %rdi, %rdi
jne 0x6b85c
leaq 0xb95c1a(%rip), %rdi # 0xc01460
callq 0x291a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2d368
jmp 0x6b82c
leaq 0x31b7ed(%rip), %rax # 0x387050
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x6b83f
| translog_get_sent_to_disk:
push rbp
mov rbp, rsp
push rbx
push rax
cmp cs:qword_C014A0, 0
jnz short loc_6B855
lea rdi, unk_C01460
call _pthread_mutex_lock
loc_6B82C:
mov rbx, cs:qword_C01440
mov rdi, cs:qword_C014A0
test rdi, rdi
jnz short loc_6B85C
loc_6B83F:
lea rdi, unk_C01460
call _pthread_mutex_unlock
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn
loc_6B855:
call translog_get_sent_to_disk_cold_1
jmp short loc_6B82C
loc_6B85C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_6B83F
| long long translog_get_sent_to_disk(long long a1)
{
long long v1; // rbx
if ( qword_C014A0 )
translog_get_sent_to_disk_cold_1(a1);
else
pthread_mutex_lock(&unk_C01460);
v1 = qword_C01440;
if ( qword_C014A0 )
((void ( *)(long long))PSI_server[44])(qword_C014A0);
pthread_mutex_unlock(&unk_C01460);
return v1;
}
| translog_get_sent_to_disk:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP qword ptr [0x00d014a0],0x0
JNZ 0x0016b855
LEA RDI,[0xd01460]
CALL 0x001291d0
LAB_0016b82c:
MOV RBX,qword ptr [0x00d01440]
MOV RDI,qword ptr [0x00d014a0]
TEST RDI,RDI
JNZ 0x0016b85c
LAB_0016b83f:
LEA RDI,[0xd01460]
CALL 0x001291a0
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0016b855:
CALL 0x0012d368
JMP 0x0016b82c
LAB_0016b85c:
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0016b83f
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 translog_get_sent_to_disk(void)
{
int8 uVar1;
if (DAT_00d014a0 == 0) {
pthread_mutex_lock((pthread_mutex_t *)&DAT_00d01460);
}
else {
translog_get_sent_to_disk_cold_1();
}
uVar1 = _DAT_00d01440;
if (DAT_00d014a0 != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)&DAT_00d01460);
return uVar1;
}
|
|
1,623 | my_copy_fix_mb | eloqsql/strings/ctype-mb.c | size_t
my_copy_fix_mb(CHARSET_INFO *cs,
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t well_formed_nchars;
size_t well_formed_length;
size_t fixed_length;
size_t min_length= MY_MIN(src_length, dst_length);
well_formed_nchars= my_ci_well_formed_char_length(cs, src, src + min_length,
nchars, status);
DBUG_ASSERT(well_formed_nchars <= nchars);
well_formed_length= status->m_source_end_pos - src;
if (well_formed_length)
memmove(dst, src, well_formed_length);
if (!status->m_well_formed_error_pos)
return well_formed_length;
fixed_length= my_append_fix_badly_formed_tail(cs,
dst + well_formed_length,
dst + dst_length,
src + well_formed_length,
src + src_length,
nchars - well_formed_nchars,
status);
return well_formed_length + fixed_length;
} | O3 | c | my_copy_fix_mb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x10(%rbp), %rbx
cmpq %rdx, %r8
movq %r8, -0x58(%rbp)
cmovbq %r8, %rdx
addq %rcx, %rdx
movq 0xb8(%rdi), %rax
movq %rdi, -0x40(%rbp)
movq %rcx, %rsi
movq %r9, -0x30(%rbp)
movq %r9, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq %rax, %r14
movq (%rbx), %rbx
subq %r15, %rbx
je 0x59961
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x265b0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x59a50
leaq (%rbx,%r13), %rax
movq %rbx, -0x50(%rbp)
addq %r15, %rbx
movq -0x30(%rbp), %rcx
cmpq %r14, %rcx
movq %rax, -0x48(%rbp)
je 0x59a36
addq %r12, %r13
movq %r13, -0x38(%rbp)
addq -0x58(%rbp), %r15
subq %rcx, %r14
movq %rax, %r13
movq %r15, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %rbx, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
testl %eax, %eax
jle 0x599dc
movl %eax, %r15d
leaq (%r15,%r13), %r12
cmpq -0x38(%rbp), %r12
ja 0x59a3b
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x26290
movq %r12, %r13
jmp 0x59a24
setne %al
cmpq %r15, %rbx
setae %cl
testb %al, %cl
jne 0x59a3b
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x599f8
movq %rbx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq 0xb8(%rdi), %rax
movl $0x3f, %esi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
callq *0x30(%rax)
testl %eax, %eax
jle 0x59a3b
movl %eax, %eax
addq %rax, %r13
movl $0x1, %r15d
movq %r13, %r12
addq %r15, %rbx
incq %r14
movq -0x30(%rbp), %r15
jne 0x599a1
jmp 0x59a3e
movq %rax, %r12
jmp 0x59a3e
movq %r13, %r12
movq 0x10(%rbp), %rax
movq %rbx, (%rax)
movq -0x50(%rbp), %rbx
subq -0x48(%rbp), %rbx
addq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_copy_fix_mb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rcx
mov r12, rdx
mov r13, rsi
mov rbx, [rbp+arg_0]
cmp r8, rdx
mov [rbp+var_58], r8
cmovb rdx, r8
add rdx, rcx
mov rax, [rdi+0B8h]
mov [rbp+var_40], rdi
mov rsi, rcx
mov [rbp+var_30], r9
mov rcx, r9
mov r8, rbx
call qword ptr [rax+0C8h]
mov r14, rax
mov rbx, [rbx]
sub rbx, r15
jz short loc_59961
mov rdi, r13
mov rsi, r15
mov rdx, rbx
call _memmove
loc_59961:
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jz loc_59A50
lea rax, [rbx+r13]
mov [rbp+var_50], rbx
add rbx, r15
mov rcx, [rbp+var_30]
cmp rcx, r14
mov [rbp+var_48], rax
jz loc_59A36
add r13, r12
mov [rbp+var_38], r13
add r15, [rbp+var_58]
sub r14, rcx
mov r13, rax
mov [rbp+var_30], r15
loc_599A1:
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov rsi, rbx
mov rdx, r15
call qword ptr [rax+0C0h]
test eax, eax
jle short loc_599DC
mov r15d, eax
lea r12, [r15+r13]
cmp r12, [rbp+var_38]
ja short loc_59A3B
mov rdi, r13
mov rsi, rbx
mov rdx, r15
call _memcpy
mov r13, r12
jmp short loc_59A24
loc_599DC:
setnz al
cmp rbx, r15
setnb cl
test cl, al
jnz short loc_59A3B
mov rax, [rbp+arg_0]
cmp qword ptr [rax+8], 0
jnz short loc_599F8
mov [rax+8], rbx
loc_599F8:
mov rdi, [rbp+var_40]
mov rax, [rdi+0B8h]
mov esi, 3Fh ; '?'
mov rdx, r13
mov rcx, [rbp+var_38]
call qword ptr [rax+30h]
test eax, eax
jle short loc_59A3B
mov eax, eax
add r13, rax
mov r15d, 1
mov r12, r13
loc_59A24:
add rbx, r15
inc r14
mov r15, [rbp+var_30]
jnz loc_599A1
jmp short loc_59A3E
loc_59A36:
mov r12, rax
jmp short loc_59A3E
loc_59A3B:
mov r12, r13
loc_59A3E:
mov rax, [rbp+arg_0]
mov [rax], rbx
mov rbx, [rbp+var_50]
sub rbx, [rbp+var_48]
add rbx, r12
loc_59A50:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long my_copy_fix_mb(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
long long a6,
unsigned long long *a7)
{
unsigned long long v8; // r12
long long v9; // r14
long long v10; // rbx
unsigned long long v11; // rax
unsigned long long v12; // rbx
unsigned long long v13; // r15
long long v14; // r14
long long v15; // r13
unsigned int v16; // eax
long long v17; // r15
unsigned long long v18; // r12
int v19; // eax
long long v22; // [rsp+10h] [rbp-50h]
unsigned long long v23; // [rsp+18h] [rbp-48h]
unsigned long long v24; // [rsp+28h] [rbp-38h]
unsigned long long v26; // [rsp+30h] [rbp-30h]
v8 = a3;
if ( a5 < a3 )
a3 = a5;
v9 = (*(long long ( **)(long long, long long, unsigned long long, long long, unsigned long long *))(*(_QWORD *)(a1 + 184)
+ 200LL))(
a1,
a4,
a4 + a3,
a6,
a7);
v10 = *a7 - a4;
if ( v10 )
memmove(a2, a4, v10);
if ( !a7[1] )
return v10;
v11 = v10 + a2;
v22 = v10;
v12 = a4 + v10;
v23 = v11;
if ( a6 == v9 )
{
v18 = v11;
goto LABEL_20;
}
v24 = v8 + a2;
v13 = a5 + a4;
v14 = v9 - a6;
v15 = v11;
v26 = v13;
while ( 1 )
{
v16 = (*(long long ( **)(long long, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v12,
v13);
if ( (int)v16 <= 0 )
break;
v17 = v16;
v18 = v16 + v15;
if ( v18 > v24 )
goto LABEL_19;
memcpy(v15, v12, v16);
v15 = v18;
LABEL_16:
v12 += v17;
++v14;
v13 = v26;
if ( !v14 )
goto LABEL_20;
}
if ( v16 == 0 || v12 < v13 )
{
if ( !a7[1] )
a7[1] = v12;
v19 = (*(long long ( **)(long long, long long, long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
63LL,
v15,
v24);
if ( v19 > 0 )
{
v15 += (unsigned int)v19;
v17 = 1LL;
v18 = v15;
goto LABEL_16;
}
}
LABEL_19:
v18 = v15;
LABEL_20:
*a7 = v12;
return v18 + v22 - v23;
}
| my_copy_fix_mb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RCX
MOV R12,RDX
MOV R13,RSI
MOV RBX,qword ptr [RBP + 0x10]
CMP R8,RDX
MOV qword ptr [RBP + -0x58],R8
CMOVC RDX,R8
ADD RDX,RCX
MOV RAX,qword ptr [RDI + 0xb8]
MOV qword ptr [RBP + -0x40],RDI
MOV RSI,RCX
MOV qword ptr [RBP + -0x30],R9
MOV RCX,R9
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R14,RAX
MOV RBX,qword ptr [RBX]
SUB RBX,R15
JZ 0x00159961
MOV RDI,R13
MOV RSI,R15
MOV RDX,RBX
CALL 0x001265b0
LAB_00159961:
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00159a50
LEA RAX,[RBX + R13*0x1]
MOV qword ptr [RBP + -0x50],RBX
ADD RBX,R15
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,R14
MOV qword ptr [RBP + -0x48],RAX
JZ 0x00159a36
ADD R13,R12
MOV qword ptr [RBP + -0x38],R13
ADD R15,qword ptr [RBP + -0x58]
SUB R14,RCX
MOV R13,RAX
MOV qword ptr [RBP + -0x30],R15
LAB_001599a1:
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,RBX
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
TEST EAX,EAX
JLE 0x001599dc
MOV R15D,EAX
LEA R12,[R15 + R13*0x1]
CMP R12,qword ptr [RBP + -0x38]
JA 0x00159a3b
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R15
CALL 0x00126290
MOV R13,R12
JMP 0x00159a24
LAB_001599dc:
SETNZ AL
CMP RBX,R15
SETNC CL
TEST CL,AL
JNZ 0x00159a3b
MOV RAX,qword ptr [RBP + 0x10]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x001599f8
MOV qword ptr [RAX + 0x8],RBX
LAB_001599f8:
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RDI + 0xb8]
MOV ESI,0x3f
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RAX + 0x30]
TEST EAX,EAX
JLE 0x00159a3b
MOV EAX,EAX
ADD R13,RAX
MOV R15D,0x1
MOV R12,R13
LAB_00159a24:
ADD RBX,R15
INC R14
MOV R15,qword ptr [RBP + -0x30]
JNZ 0x001599a1
JMP 0x00159a3e
LAB_00159a36:
MOV R12,RAX
JMP 0x00159a3e
LAB_00159a3b:
MOV R12,R13
LAB_00159a3e:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RBX
MOV RBX,qword ptr [RBP + -0x50]
SUB RBX,qword ptr [RBP + -0x48]
ADD RBX,R12
LAB_00159a50:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
size_t my_copy_fix_mb(long param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
long param_6,long *param_7)
{
void *pvVar1;
uint uVar2;
long lVar3;
size_t __n;
void *__src;
void *__dest;
ulong uVar4;
uVar4 = param_3;
if (param_5 < param_3) {
uVar4 = param_5;
}
lVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 200))
(param_1,param_4,uVar4 + (long)param_4,param_6,param_7);
__n = *param_7 - (long)param_4;
if (__n != 0) {
memmove(param_2,param_4,__n);
}
if (param_7[1] != 0) {
pvVar1 = (void *)(__n + (long)param_2);
__src = (void *)(__n + (long)param_4);
__dest = pvVar1;
if (param_6 != lVar3) {
lVar3 = lVar3 - param_6;
do {
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))
(param_1,__src,(void *)((long)param_4 + param_5));
if ((int)uVar2 < 1) {
if ((void *)((long)param_4 + param_5) <= __src && uVar2 != 0) break;
if (param_7[1] == 0) {
param_7[1] = (long)__src;
}
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,0x3f,__dest,(void *)((long)param_2 + param_3));
if ((int)uVar2 < 1) break;
__dest = (void *)((long)__dest + (ulong)uVar2);
uVar4 = 1;
}
else {
uVar4 = (ulong)uVar2;
if ((void *)((long)param_2 + param_3) < (void *)(uVar4 + (long)__dest)) break;
memcpy(__dest,__src,uVar4);
__dest = (void *)(uVar4 + (long)__dest);
}
__src = (void *)((long)__src + uVar4);
lVar3 = lVar3 + 1;
} while (lVar3 != 0);
}
*param_7 = (long)__src;
__n = (__n - (long)pvVar1) + (long)__dest;
}
return __n;
}
|
|
1,624 | coro::context::context() | tinyCoroLab/src/context.cpp | context::context() noexcept
{
m_id = ginfo.context_id.fetch_add(1, std::memory_order_relaxed);
} | O0 | cpp | coro::context::context():
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6ad70
movq (%rsp), %rdi
addq $0x20240, %rdi # imm = 0x20240
callq 0x6ae70
leaq 0x36022(%rip), %rax # 0xa05c0
movq %rax, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x24(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x6a5ec
movq 0x10(%rsp), %rax
leaq 0x4c9d(%rip), %rcx # 0x6f280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6a649
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6a649
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6a649
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6a649
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
movq (%rsp), %rax
movl 0x20(%rsp), %ecx
movl %ecx, 0x20248(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
| _ZN4coro7contextC2Ev:
sub rsp, 38h
mov [rsp+38h+var_20], rdi
mov rdi, [rsp+38h+var_20]; this
mov [rsp+38h+var_38], rdi
call _ZN4coro6detail6engineC2Ev; coro::detail::engine::engine(void)
mov rdi, [rsp+38h+var_38]
add rdi, 20240h
call _ZNSt10unique_ptrISt7jthreadSt14default_deleteIS0_EEC2IS2_vEEv; std::unique_ptr<std::jthread>::unique_ptr<std::default_delete<std::jthread>,void>(void)
lea rax, _ZN4coro6detail5ginfoE; coro::detail::ginfo
mov [rsp+38h+var_8], rax
mov [rsp+38h+var_C], 1
mov [rsp+38h+var_10], 0
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_30], rax
mov eax, [rsp+38h+var_10]
mov ecx, [rsp+38h+var_C]
mov [rsp+38h+var_14], ecx
dec eax; switch 5 cases
mov ecx, eax
mov [rsp+38h+var_28], rcx
sub eax, 4
ja short def_6A5EA; jumptable 000000000006A5EA default case
mov rax, [rsp+38h+var_28]
lea rcx, jpt_6A5EA
movsxd rax, ds:(jpt_6A5EA - 6F280h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_6A5EA:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006A5EA default case
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6A649
loc_6A5FF:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006A5EA cases 1,2
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6A649
loc_6A612:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006A5EA case 3
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6A649
loc_6A625:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006A5EA case 4
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6A649
loc_6A638:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006A5EA case 5
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
loc_6A649:
mov rax, [rsp+38h+var_38]
mov ecx, [rsp+38h+var_18]
mov [rax+20248h], ecx
add rsp, 38h
retn
| coro::context * coro::context::context(coro::context *this)
{
coro::context *result; // rax
coro::detail::engine::engine(this);
std::unique_ptr<std::jthread>::unique_ptr<std::default_delete<std::jthread>,void>((char *)this + 131648);
result = this;
*((_DWORD *)this + 32914) = _InterlockedExchangeAdd(&coro::detail::ginfo, 1u);
return result;
}
| context:
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RDI
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RDI
CALL 0x0016ad70
MOV RDI,qword ptr [RSP]
ADD RDI,0x20240
CALL 0x0016ae70
LEA RAX,[0x1a05c0]
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x2c],0x1
MOV dword ptr [RSP + 0x28],0x0
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x24],ECX
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x10],RCX
SUB EAX,0x4
JA 0x0016a5ec
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[0x16f280]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
LAB_0016a5ec:
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x24]
XADD.LOCK dword ptr [RCX],EAX
MOV dword ptr [RSP + 0x20],EAX
JMP 0x0016a649
LAB_0016a649:
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x20248],ECX
ADD RSP,0x38
RET
|
/* WARNING: Removing unreachable block (ram,0x0016a5d7) */
/* coro::context::context() */
void __thiscall coro::context::context(context *this)
{
int iVar1;
detail::engine::engine((engine *)this);
std::unique_ptr<std::jthread,std::default_delete<std::jthread>>::
unique_ptr<std::default_delete<std::jthread>,void>
((unique_ptr<std::jthread,std::default_delete<std::jthread>> *)(this + 0x20240));
LOCK();
UNLOCK();
iVar1 = detail::ginfo + 1;
*(int *)(this + 0x20248) = detail::ginfo;
detail::ginfo = iVar1;
return;
}
|
|
1,625 | Catch::XmlWriter::endElement(Catch::XmlFormatting) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
m_indent = m_indent.substr(0, m_indent.size() - 2);
if( m_tagIsOpen ) {
m_os << "/>";
m_tagIsOpen = false;
} else {
newlineIfNecessary();
if (shouldIndent(fmt)) {
m_os << m_indent;
}
m_os << "</" << m_tags.back() << '>';
}
m_os << std::flush;
applyFormatting(fmt);
m_tags.pop_back();
return *this;
} | O3 | cpp | Catch::XmlWriter::endElement(Catch::XmlFormatting):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x28(%rdi), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x77522
movq %r14, %rdi
movq %r15, %rsi
callq 0x1816c
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x18d22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17150
cmpb $0x1, (%rbx)
jne 0x18d3f
movq 0x40(%rbx), %rdi
leaq 0xc51b5(%rip), %rsi # 0xddee7
pushq $0x2
popq %rdx
callq 0x17be0
movb $0x0, (%rbx)
jmp 0x18d9b
movq %rbx, %rdi
callq 0x6465c
testb $0x1, %bpl
je 0x18d5e
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x17be0
movq 0x40(%rbx), %r14
leaq 0xc5181(%rip), %rsi # 0xddeea
pushq $0x2
popq %rdx
movq %r14, %rdi
callq 0x17be0
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0x17be0
leaq 0x8(%rsp), %rsi
movb $0x3e, (%rsi)
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x17be0
movq 0x40(%rbx), %rdi
callq 0x17590
shrb %bpl
andb $0x1, %bpl
movb %bpl, 0x1(%rbx)
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x18dd3
movq (%rax), %rsi
incq %rsi
callq 0x17150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN5Catch9XmlWriter10endElementENS_13XmlFormattingE:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov ebp, esi
mov rbx, rdi
lea r14, [rdi+20h]
mov rcx, [rdi+28h]
add rcx, 0FFFFFFFFFFFFFFFEh
lea r15, [rsp+48h+var_40]
mov rdi, r15
mov rsi, r14
xor edx, edx
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, r14
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
lea rax, [rsp+48h+var_30]
cmp rdi, rax
jz short loc_18D22
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_18D22:
cmp byte ptr [rbx], 1
jnz short loc_18D3F
mov rdi, [rbx+40h]
lea rsi, asc_DDEE7; "/>"
push 2
pop rdx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov byte ptr [rbx], 0
jmp short loc_18D9B
loc_18D3F:
mov rdi, rbx; this
call _ZN5Catch9XmlWriter18newlineIfNecessaryEv; Catch::XmlWriter::newlineIfNecessary(void)
test bpl, 1
jz short loc_18D5E
mov rdi, [rbx+40h]
mov rsi, [rbx+20h]
mov rdx, [rbx+28h]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_18D5E:
mov r14, [rbx+40h]
lea rsi, asc_DDEEA; "</"
push 2
pop rdx
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rbx+10h]
mov rsi, [rax-20h]
mov rdx, [rax-18h]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, [rsp+48h+var_40]
mov byte ptr [rsi], 3Eh ; '>'
push 1
pop rdx
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_18D9B:
mov rdi, [rbx+40h]; this
call __ZNSo5flushEv; std::ostream::flush(void)
shr bpl, 1
and bpl, 1
mov [rbx+1], bpl
mov rax, [rbx+10h]
lea rcx, [rax-20h]
mov [rbx+10h], rcx
mov rdi, [rax-20h]; void *
add rax, 0FFFFFFFFFFFFFFF0h
cmp rdi, rax
jz short loc_18DD3
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_18DD3:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
| Catch::XmlWriter * Catch::XmlWriter::endElement(Catch::XmlWriter *this, char a2)
{
long long v3; // r14
long long v4; // rax
long long v5; // rax
_QWORD *v6; // rdi
_QWORD *v7; // rax
void *v9[2]; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+18h] [rbp-30h] BYREF
std::string::substr(v9, (char *)this + 32, 0LL, *((_QWORD *)this + 5) - 2LL);
std::string::operator=((_QWORD *)this + 4, (long long)v9);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
if ( *(_BYTE *)this == 1 )
{
std::__ostream_insert<char,std::char_traits<char>>(*((_QWORD *)this + 8), "/>", 2LL);
*(_BYTE *)this = 0;
}
else
{
Catch::XmlWriter::newlineIfNecessary(this);
if ( (a2 & 1) != 0 )
std::__ostream_insert<char,std::char_traits<char>>(
*((_QWORD *)this + 8),
*((_QWORD *)this + 4),
*((_QWORD *)this + 5));
v3 = *((_QWORD *)this + 8);
std::__ostream_insert<char,std::char_traits<char>>(v3, "</", 2LL);
v4 = std::__ostream_insert<char,std::char_traits<char>>(
v3,
*(_QWORD *)(*((_QWORD *)this + 2) - 32LL),
*(_QWORD *)(*((_QWORD *)this + 2) - 24LL));
LOBYTE(v9[0]) = 62;
std::__ostream_insert<char,std::char_traits<char>>(v4, v9, 1LL);
}
std::ostream::flush(*((std::ostream **)this + 8));
*((_BYTE *)this + 1) = (a2 & 2) != 0;
v5 = *((_QWORD *)this + 2);
*((_QWORD *)this + 2) = v5 - 32;
v6 = *(_QWORD **)(v5 - 32);
v7 = (_QWORD *)(v5 - 16);
if ( v6 != v7 )
operator delete(v6, *v7 + 1LL);
return this;
}
| endElement:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV EBP,ESI
MOV RBX,RDI
LEA R14,[RDI + 0x20]
MOV RCX,qword ptr [RDI + 0x28]
ADD RCX,-0x2
LEA R15,[RSP + 0x8]
MOV RDI,R15
MOV RSI,R14
XOR EDX,EDX
CALL 0x00177522
MOV RDI,R14
MOV RSI,R15
CALL 0x0011816c
MOV RDI,qword ptr [R15]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00118d22
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00117150
LAB_00118d22:
CMP byte ptr [RBX],0x1
JNZ 0x00118d3f
MOV RDI,qword ptr [RBX + 0x40]
LEA RSI,[0x1ddee7]
PUSH 0x2
POP RDX
CALL 0x00117be0
MOV byte ptr [RBX],0x0
JMP 0x00118d9b
LAB_00118d3f:
MOV RDI,RBX
CALL 0x0016465c
TEST BPL,0x1
JZ 0x00118d5e
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RBX + 0x28]
CALL 0x00117be0
LAB_00118d5e:
MOV R14,qword ptr [RBX + 0x40]
LEA RSI,[0x1ddeea]
PUSH 0x2
POP RDX
MOV RDI,R14
CALL 0x00117be0
MOV RAX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RAX + -0x20]
MOV RDX,qword ptr [RAX + -0x18]
MOV RDI,R14
CALL 0x00117be0
LEA RSI,[RSP + 0x8]
MOV byte ptr [RSI],0x3e
PUSH 0x1
POP RDX
MOV RDI,RAX
CALL 0x00117be0
LAB_00118d9b:
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x00117590
SHR BPL,0x1
AND BPL,0x1
MOV byte ptr [RBX + 0x1],BPL
MOV RAX,qword ptr [RBX + 0x10]
LEA RCX,[RAX + -0x20]
MOV qword ptr [RBX + 0x10],RCX
MOV RDI,qword ptr [RAX + -0x20]
ADD RAX,-0x10
CMP RDI,RAX
JZ 0x00118dd3
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00117150
LAB_00118dd3:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* Catch::XmlWriter::endElement(Catch::XmlFormatting) */
XmlWriter * __thiscall Catch::XmlWriter::endElement(XmlWriter *this,byte param_2)
{
long lVar1;
ostream *poVar2;
string local_40;
int7 uStack_3f;
long local_30 [2];
std::__cxx11::string::substr((ulong)&local_40,(ulong)(this + 0x20));
std::__cxx11::string::operator=((string *)(this + 0x20),&local_40);
if ((long *)CONCAT71(uStack_3f,local_40) != local_30) {
operator_delete((long *)CONCAT71(uStack_3f,local_40),local_30[0] + 1);
}
if (*this == (XmlWriter)0x1) {
std::__ostream_insert<char,std::char_traits<char>>(*(ostream **)(this + 0x40),"/>",2);
*this = (XmlWriter)0x0;
}
else {
newlineIfNecessary(this);
if ((param_2 & 1) != 0) {
std::__ostream_insert<char,std::char_traits<char>>
(*(ostream **)(this + 0x40),*(char **)(this + 0x20),*(long *)(this + 0x28));
}
poVar2 = *(ostream **)(this + 0x40);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"</",2);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
(poVar2,*(char **)(*(long *)(this + 0x10) + -0x20),
*(long *)(*(long *)(this + 0x10) + -0x18));
local_40 = (string)0x3e;
std::__ostream_insert<char,std::char_traits<char>>(poVar2,(char *)&local_40,1);
}
std::ostream::flush();
this[1] = (XmlWriter)(param_2 >> 1 & 1);
lVar1 = *(long *)(this + 0x10);
*(long *)(this + 0x10) = lVar1 + -0x20;
if (*(long **)(lVar1 + -0x20) != (long *)(lVar1 + -0x10)) {
operator_delete(*(long **)(lVar1 + -0x20),*(long *)(lVar1 + -0x10) + 1);
}
return this;
}
|
|
1,626 | GAParameterZ80Reg8::match(GAParserOperand*, int) | goodasm/galangz80.cpp | int GAParameterZ80Reg8::match(GAParserOperand *op, int len){
if(op->prefix!=this->prefix)
return 0; //Wrong type.
if(op->value.length()!=1)
return 0; //Wrong size.
char c=op->value[0].toLatin1();
switch(c){
//FIXME: The Z80 Register Order might be B, C, D, E, H, L, [HL], A
case 'b':
case 'c':
case 'd':
case 'e':
//case 'f': //Illegal
case 'h':
case 'l': // Usually overloaded?
case 'a':
return 1; //Legal register name.
default:
return 0; //Not an 8-bit register name.
}
} | O3 | cpp | GAParameterZ80Reg8::match(GAParserOperand*, int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rsi
callq 0x53180
testb $0x1, %al
jne 0xca25a
jmp 0xca263
movl $0x0, -0x4(%rbp)
jmp 0xca2d0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xf8b0
cmpq $0x1, %rax
je 0xca27f
movl $0x0, -0x4(%rbp)
jmp 0xca2d0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x346f0
movq %rax, %rdi
callq 0x3be50
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
movl %eax, -0x24(%rbp)
addl $-0x61, %eax
subl $0x5, %eax
jb 0xca2c0
jmp 0xca2ac
movl -0x24(%rbp), %eax
subl $0x68, %eax
je 0xca2c0
jmp 0xca2b6
movl -0x24(%rbp), %eax
subl $0x6c, %eax
jne 0xca2c9
jmp 0xca2c0
movl $0x1, -0x4(%rbp)
jmp 0xca2d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN18GAParameterZ80Reg85matchEP15GAParserOperandi:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rsi, [rbp+var_10]
mov rdi, [rbp+var_18]
add rsi, 8
call _ZneRK7QStringS1_; operator!=(QString const&,QString const&)
test al, 1
jnz short loc_CA25A
jmp short loc_CA263
loc_CA25A:
mov [rbp+var_4], 0
jmp short loc_CA2D0
loc_CA263:
mov rdi, [rbp+var_18]
add rdi, 18h; this
call _ZNK7QString6lengthEv; QString::length(void)
cmp rax, 1
jz short loc_CA27F
mov [rbp+var_4], 0
jmp short loc_CA2D0
loc_CA27F:
mov rdi, [rbp+var_18]
add rdi, 18h
xor eax, eax
mov esi, eax
call _ZN7QStringixEx; QString::operator[](long long)
mov rdi, rax; this
call _ZNK5QChar8toLatin1Ev; QChar::toLatin1(void)
mov [rbp+var_1D], al
movsx eax, [rbp+var_1D]
mov [rbp+var_24], eax
add eax, 0FFFFFF9Fh
sub eax, 5
jb short loc_CA2C0
jmp short $+2
loc_CA2AC:
mov eax, [rbp+var_24]
sub eax, 68h ; 'h'
jz short loc_CA2C0
jmp short $+2
loc_CA2B6:
mov eax, [rbp+var_24]
sub eax, 6Ch ; 'l'
jnz short loc_CA2C9
jmp short $+2
loc_CA2C0:
mov [rbp+var_4], 1
jmp short loc_CA2D0
loc_CA2C9:
mov [rbp+var_4], 0
loc_CA2D0:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| _BOOL8 GAParameterZ80Reg8::match(GAParameterZ80Reg8 *this, GAParserOperand *a2)
{
QChar *v2; // rax
int v4; // [rsp+Ch] [rbp-24h]
if ( operator!=(a2, (GAParameterZ80Reg8 *)((char *)this + 8)) )
{
return 0;
}
else if ( QString::length((GAParserOperand *)((char *)a2 + 24)) == 1 )
{
v2 = (QChar *)QString::operator[]((GAParserOperand *)((char *)a2 + 24), 0LL);
v4 = QChar::toLatin1(v2);
return (unsigned int)(v4 - 97) < 5 || v4 == 104 || v4 == 108;
}
else
{
return 0;
}
}
| match:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RSI,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RBP + -0x18]
ADD RSI,0x8
CALL 0x00153180
TEST AL,0x1
JNZ 0x001ca25a
JMP 0x001ca263
LAB_001ca25a:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001ca2d0
LAB_001ca263:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x0010f8b0
CMP RAX,0x1
JZ 0x001ca27f
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001ca2d0
LAB_001ca27f:
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001346f0
MOV RDI,RAX
CALL 0x0013be50
MOV byte ptr [RBP + -0x1d],AL
MOVSX EAX,byte ptr [RBP + -0x1d]
MOV dword ptr [RBP + -0x24],EAX
ADD EAX,-0x61
SUB EAX,0x5
JC 0x001ca2c0
JMP 0x001ca2ac
LAB_001ca2ac:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x68
JZ 0x001ca2c0
JMP 0x001ca2b6
LAB_001ca2b6:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x6c
JNZ 0x001ca2c9
JMP 0x001ca2c0
LAB_001ca2c0:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001ca2d0
LAB_001ca2c9:
MOV dword ptr [RBP + -0x4],0x0
LAB_001ca2d0:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
/* GAParameterZ80Reg8::match(GAParserOperand*, int) */
int4 GAParameterZ80Reg8::match(GAParserOperand *param_1,int param_2)
{
char cVar1;
int iVar2;
ulong uVar3;
long lVar4;
QChar *this;
int4 in_register_00000034;
QString *pQVar5;
int4 local_c;
pQVar5 = (QString *)CONCAT44(in_register_00000034,param_2);
uVar3 = ::operator!=(pQVar5,(QString *)(param_1 + 8));
if ((uVar3 & 1) == 0) {
lVar4 = QString::length(pQVar5 + 0x18);
if (lVar4 == 1) {
this = (QChar *)QString::operator[](pQVar5 + 0x18,0);
cVar1 = QChar::toLatin1(this);
iVar2 = (int)cVar1;
if (((iVar2 - 0x61U < 5) || (iVar2 == 0x68)) || (iVar2 == 0x6c)) {
local_c = 1;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
1,627 | lf_hash_iterate | eloqsql/mysys/lf_hash.cc | int lf_hash_iterate(LF_HASH *hash, LF_PINS *pins,
my_hash_walk_action action, void *argument)
{
CURSOR cursor;
uint bucket= 0;
int res;
LF_SLIST **el;
el= (LF_SLIST **)lf_dynarray_lvalue(&hash->array, bucket);
if (unlikely(!el))
return 0; /* if there's no bucket==0, the hash is empty */
if (*el == NULL && unlikely(initialize_bucket(hash, el, bucket, pins)))
return 0; /* if there's no bucket==0, the hash is empty */
res= l_find(el, 0, 0, (uchar*)argument, 0, &cursor, pins, action);
lf_unpin(pins, 2);
lf_unpin(pins, 1);
lf_unpin(pins, 0);
return res;
} | O0 | cpp | lf_hash_iterate:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0xc7c30
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xc8f92
movl $0x0, -0x4(%rbp)
jmp 0xc9041
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc8fc1
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x44(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0xc8670
cmpl $0x0, %eax
je 0xc8fc1
movl $0x0, -0x4(%rbp)
jmp 0xc9041
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r10
movq -0x20(%rbp), %rax
xorl %edx, %edx
movl %edx, %r8d
xorl %edx, %edx
leaq -0x40(%rbp), %r9
movq %r8, %rsi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xc9050
movl %eax, -0x48(%rbp)
jmp 0xc8ff2
jmp 0xc8ff4
movq -0x18(%rbp), %rcx
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
xchgq %rax, 0x10(%rcx)
jmp 0xc900a
jmp 0xc900c
jmp 0xc900e
movq -0x18(%rbp), %rcx
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
xchgq %rax, 0x8(%rcx)
jmp 0xc9024
jmp 0xc9026
jmp 0xc9028
movq -0x18(%rbp), %rcx
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
xchgq %rax, (%rcx)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| lf_hash_iterate:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_44], 0
mov rdi, [rbp+var_10]
mov esi, [rbp+var_44]
call lf_dynarray_lvalue
mov [rbp+var_50], rax
cmp [rbp+var_50], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_C8F92
mov [rbp+var_4], 0
jmp loc_C9041
loc_C8F92:
mov rax, [rbp+var_50]
cmp qword ptr [rax], 0
jnz short loc_C8FC1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_50]
mov edx, [rbp+var_44]
mov rcx, [rbp+var_18]
call _ZL17initialize_bucketP10st_lf_hashPP8LF_SLISTjP7LF_PINS; initialize_bucket(st_lf_hash *,LF_SLIST **,uint,LF_PINS *)
cmp eax, 0
jz short loc_C8FC1
mov [rbp+var_4], 0
jmp loc_C9041
loc_C8FC1:
mov rdi, [rbp+var_50]
mov rcx, [rbp+var_28]
mov r10, [rbp+var_18]
mov rax, [rbp+var_20]
xor edx, edx
mov r8d, edx
xor edx, edx
lea r9, [rbp+var_40]
mov rsi, r8
mov [rsp+80h+var_80], r10
mov [rsp+80h+var_78], rax
call _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E; l_find(LF_SLIST **,charset_info_st const*,uint,uchar const*,ulong,CURSOR *,LF_PINS *,char (*)(void *,void *))
mov [rbp+var_48], eax
jmp short $+2
loc_C8FF2:
jmp short $+2
loc_C8FF4:
mov rcx, [rbp+var_18]
mov [rbp+var_58], 0
mov rax, [rbp+var_58]
xchg rax, [rcx+10h]
jmp short $+2
loc_C900A:
jmp short $+2
loc_C900C:
jmp short $+2
loc_C900E:
mov rcx, [rbp+var_18]
mov [rbp+var_60], 0
mov rax, [rbp+var_60]
xchg rax, [rcx+8]
jmp short $+2
loc_C9024:
jmp short $+2
loc_C9026:
jmp short $+2
loc_C9028:
mov rcx, [rbp+var_18]
mov [rbp+var_68], 0
mov rax, [rbp+var_68]
xchg rax, [rcx]
mov eax, [rbp+var_48]
mov [rbp+var_4], eax
loc_C9041:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long lf_hash_iterate(long long a1, volatile long long *a2, long long a3, long long a4)
{
volatile signed long long *v5; // [rsp+30h] [rbp-50h]
unsigned int v6; // [rsp+38h] [rbp-48h]
char v7; // [rsp+40h] [rbp-40h] BYREF
long long v8; // [rsp+58h] [rbp-28h]
long long v9; // [rsp+60h] [rbp-20h]
volatile long long *v10; // [rsp+68h] [rbp-18h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v5 = (volatile signed long long *)lf_dynarray_lvalue(a1, 0);
if ( v5 )
{
if ( *v5 || !(unsigned int)initialize_bucket(v11, v5, 0, (long long)v10) )
{
v6 = l_find((_DWORD)v5, 0, 0, v8, 0, (unsigned int)&v7, (long long)v10, v9);
_InterlockedExchange64(v10 + 2, 0LL);
_InterlockedExchange64(v10 + 1, 0LL);
_InterlockedExchange64(v10, 0LL);
return v6;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
| lf_hash_iterate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
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 dword ptr [RBP + -0x44],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x44]
CALL 0x001c7c30
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x50],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001c8f92
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c9041
LAB_001c8f92:
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RAX],0x0
JNZ 0x001c8fc1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x44]
MOV RCX,qword ptr [RBP + -0x18]
CALL 0x001c8670
CMP EAX,0x0
JZ 0x001c8fc1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001c9041
LAB_001c8fc1:
MOV RDI,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x28]
MOV R10,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
XOR EDX,EDX
MOV R8D,EDX
XOR EDX,EDX
LEA R9,[RBP + -0x40]
MOV RSI,R8
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
CALL 0x001c9050
MOV dword ptr [RBP + -0x48],EAX
JMP 0x001c8ff2
LAB_001c8ff2:
JMP 0x001c8ff4
LAB_001c8ff4:
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],0x0
MOV RAX,qword ptr [RBP + -0x58]
XCHG qword ptr [RCX + 0x10],RAX
JMP 0x001c900a
LAB_001c900a:
JMP 0x001c900c
LAB_001c900c:
JMP 0x001c900e
LAB_001c900e:
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],0x0
MOV RAX,qword ptr [RBP + -0x60]
XCHG qword ptr [RCX + 0x8],RAX
JMP 0x001c9024
LAB_001c9024:
JMP 0x001c9026
LAB_001c9026:
JMP 0x001c9028
LAB_001c9028:
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],0x0
MOV RAX,qword ptr [RBP + -0x68]
XCHG qword ptr [RCX],RAX
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x4],EAX
LAB_001c9041:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
lf_hash_iterate(st_lf_hash *param_1,LF_PINS *param_2,_func_char_void_ptr_void_ptr *param_3,
uchar *param_4)
{
int iVar1;
LF_SLIST **ppLVar2;
CURSOR local_48 [24];
uchar *local_30;
_func_char_void_ptr_void_ptr *local_28;
LF_PINS *local_20;
st_lf_hash *local_18;
int4 local_c;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
ppLVar2 = (LF_SLIST **)lf_dynarray_lvalue(param_1,0);
if (ppLVar2 == (LF_SLIST **)0x0) {
local_c = 0;
}
else {
if ((*ppLVar2 == (LF_SLIST *)0x0) &&
(iVar1 = initialize_bucket(local_18,ppLVar2,0,local_20), iVar1 != 0)) {
return 0;
}
local_c = l_find(ppLVar2,(charset_info_st *)0x0,0,local_30,0,local_48,local_20,local_28);
LOCK();
*(int8 *)(local_20 + 0x10) = 0;
UNLOCK();
LOCK();
*(int8 *)(local_20 + 8) = 0;
UNLOCK();
LOCK();
*(int8 *)local_20 = 0;
UNLOCK();
}
return local_c;
}
|
|
1,628 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O0 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2dedf
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x26b40
movq -0x18(%rbp), %rdx
movl (%rax), %ecx
movl $0x14, %edi
movl $0x844, %esi # imm = 0x844
movl $0x3c, %r8d
movb $0x0, %al
callq 0x305e0
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2df12
movl $0x14, %edi
leaq 0x4e329(%rip), %rsi # 0x7c224
movl $0x844, %edx # imm = 0x844
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
movb $0x0, %al
callq 0x30730
movl $0x3c, %edi
callq 0x24200
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| wait_for_free_space:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jnz short loc_2DEDF
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
call _my_thread_var
mov rdx, [rbp+var_18]
mov ecx, [rax]
mov edi, 14h
mov esi, 844h
mov r8d, 3Ch ; '<'
mov al, 0
call my_error
loc_2DEDF:
mov eax, [rbp+var_C]
mov ecx, 0Ah
cdq
idiv ecx
cmp edx, 0
jnz short loc_2DF12
mov edi, 14h
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov ecx, 3Ch ; '<'
mov r8d, 258h
mov al, 0
call my_printf_error
loc_2DF12:
mov edi, 3Ch ; '<'
call _sleep
add rsp, 20h
pop rbp
retn
| long long wait_for_free_space(int a1, int a2, long long a3, long long a4, long long a5, int a6)
{
_DWORD *v6; // rax
int v7; // r9d
if ( !a2 )
{
v6 = (_DWORD *)my_thread_var();
my_error(20, 2116, a1, *v6, 60, v7);
}
if ( !(a2 % 10) )
my_printf_error(20, (unsigned int)"Retry in %d secs. Message reprinted in %d secs", 2116, 60, 600, a6);
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0012dedf
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CALL 0x00126b40
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX]
MOV EDI,0x14
MOV ESI,0x844
MOV R8D,0x3c
MOV AL,0x0
CALL 0x001305e0
LAB_0012dedf:
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,0xa
CDQ
IDIV ECX
CMP EDX,0x0
JNZ 0x0012df12
MOV EDI,0x14
LEA RSI,[0x17c224]
MOV EDX,0x844
MOV ECX,0x3c
MOV R8D,0x258
MOV AL,0x0
CALL 0x00130730
LAB_0012df12:
MOV EDI,0x3c
CALL 0x00124200
ADD RSP,0x20
POP RBP
RET
|
void wait_for_free_space(int8 param_1,int param_2)
{
int4 *puVar1;
if (param_2 == 0) {
puVar1 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar1,0x3c);
}
if (param_2 % 10 == 0) {
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
}
sleep(0x3c);
return;
}
|
|
1,629 | rlLoadTextureCubemap | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount)
{
unsigned int id = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
int mipSize = size;
// NOTE: Added pointer math separately from function to avoid UBSAN complaining
unsigned char *dataPtr = NULL;
if (data != NULL) dataPtr = (unsigned char *)data;
unsigned int dataSize = rlGetPixelDataSize(size, size, format);
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_CUBE_MAP, id);
unsigned int glInternalFormat, glFormat, glType;
rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
if (glInternalFormat != 0)
{
// Load cubemap faces/mipmaps
for (int i = 0; i < 6*mipmapCount; i++)
{
int mipmapLevel = i/6;
int face = i%6;
if (data == NULL)
{
if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
{
if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) ||
(format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) ||
(format == RL_PIXELFORMAT_UNCOMPRESSED_R16) ||
(format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, glFormat, glType, NULL);
}
else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format");
}
else
{
if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, glFormat, glType, (unsigned char *)dataPtr + face*dataSize);
else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, dataSize, (unsigned char *)dataPtr + face*dataSize);
}
#if defined(GRAPHICS_API_OPENGL_33)
if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
{
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
{
#if defined(GRAPHICS_API_OPENGL_21)
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
#elif defined(GRAPHICS_API_OPENGL_33)
GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
#endif
glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
}
#endif
if (face == 5)
{
mipSize /= 2;
if (data != NULL) dataPtr += dataSize*6; // Increment data pointer to next mipmap
// Security check for NPOT textures
if (mipSize < 1) mipSize = 1;
dataSize = rlGetPixelDataSize(mipSize, mipSize, format);
}
}
}
// Set cubemap texture sampling parameters
if (mipmapCount > 1) glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
else glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#if defined(GRAPHICS_API_OPENGL_33)
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0
#endif
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
#endif
if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size);
else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture");
return id;
} | O1 | c | rlLoadTextureCubemap:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x14(%rsp), %rbx
movl $0x0, (%rbx)
movl $0x1, %edi
movq %rbx, %rsi
callq *0xd9a5d(%rip) # 0x13f9e0
movl (%rbx), %esi
movl $0x8513, %edi # imm = 0x8513
callq *0xd9300(%rip) # 0x13f290
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x65bcc
cmpl $0x0, (%rbx)
sete %al
movq %r14, 0x28(%rsp)
testl %r14d, %r14d
setle %cl
orb %al, %cl
jne 0x6616b
movl 0x4(%rsp), %r14d
movl %r14d, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0x65b6e
movl %eax, %r12d
movq 0x28(%rsp), %rax
addl %eax, %eax
leal (%rax,%rax,2), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovll %eax, %ecx
movl %ecx, 0x24(%rsp)
movq %r15, 0x18(%rsp)
xorl %r13d, %r13d
movl %r13d, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rax, %rsi
shrq $0x22, %rsi
leal (%rsi,%rsi), %eax
leal (%rax,%rax,2), %eax
movl %r13d, %ebx
subl %eax, %ebx
negl %eax
testq %r15, %r15
je 0x66060
leal (%rax,%r13), %edi
addl $0x8515, %edi # imm = 0x8515
movl 0x10(%rsp), %edx
cmpl $0xd, %ebp
jg 0x66087
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %r10d
movl %ebx, %r11d
imull %r12d, %r11d
addq 0x18(%rsp), %r11
subq $0x8, %rsp
movl %r14d, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
pushq %r11
pushq %r10
pushq %rax
callq *0xda816(%rip) # 0x140870
addq $0x20, %rsp
jmp 0x660bd
cmpl $0xd, %ebp
jg 0x660aa
ja 0x66140
movl $0x2d00, %ecx # imm = 0x2D00
btl %ebp, %ecx
jae 0x66140
movl $0x4, %edi
leaq 0x7f03a(%rip), %rsi # 0xe50bf
jmp 0x660b6
movl %ebx, %eax
imull %r12d, %eax
addq 0x18(%rsp), %rax
movl %r14d, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r12
callq *0xd9424(%rip) # 0x13f4c8
addq $0x10, %rsp
jmp 0x660bd
movl $0x4, %edi
leaq 0x7f03a(%rip), %rsi # 0xe50f0
xorl %eax, %eax
callq 0xbfa73
cmpl $0x2, %ebp
je 0x660d0
cmpl $0x1, %ebp
jne 0x660f1
movaps 0x7d352(%rip), %xmm0 # 0xe3420
jmp 0x660d7
movaps 0x7d359(%rip), %xmm0 # 0xe3430
movaps %xmm0, 0x30(%rsp)
movl $0x8513, %edi # imm = 0x8513
movl $0x8e46, %esi # imm = 0x8E46
leaq 0x30(%rsp), %rdx
callq *0xda7c7(%rip) # 0x1408b8
addl $-0x5, %ebx
jne 0x66130
movl %r14d, %ebx
shrl $0x1f, %ebx
addl %r14d, %ebx
sarl %ebx
addl %r12d, %r12d
testq %r15, %r15
leal (%r12,%r12,2), %eax
cmoveq %r15, %rax
addq %rax, 0x18(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovll %eax, %ebx
movl %ebx, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x65b6e
movl %eax, %r12d
movl %ebx, %r14d
incl %r13d
cmpl %r13d, 0x24(%rsp)
jne 0x65ff8
jmp 0x6616b
leal (%rax,%r13), %edi
addl $0x8515, %edi # imm = 0x8515
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %r10d
subq $0x8, %rsp
movl %r14d, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
pushq $0x0
jmp 0x66051
cmpl $0x2, 0x28(%rsp)
movl $0x2703, %edx # imm = 0x2703
movl $0x2601, %eax # imm = 0x2601
cmovll %eax, %edx
movl $0x8513, %edi # imm = 0x8513
movl $0x2801, %esi # imm = 0x2801
callq *0xda723(%rip) # 0x1408b0
movl $0x8513, %edi # imm = 0x8513
movl $0x2800, %esi # imm = 0x2800
movl $0x2601, %edx # imm = 0x2601
callq *0xda70e(%rip) # 0x1408b0
movl $0x8513, %edi # imm = 0x8513
movl $0x2802, %esi # imm = 0x2802
movl $0x812f, %edx # imm = 0x812F
callq *0xda6f9(%rip) # 0x1408b0
movl $0x8513, %edi # imm = 0x8513
movl $0x2803, %esi # imm = 0x2803
movl $0x812f, %edx # imm = 0x812F
callq *0xda6e4(%rip) # 0x1408b0
movl $0x8513, %edi # imm = 0x8513
movl $0x8072, %esi # imm = 0x8072
movl $0x812f, %edx # imm = 0x812F
callq *0xda6cf(%rip) # 0x1408b0
movl $0x8513, %edi # imm = 0x8513
xorl %esi, %esi
callq *0xd90a2(%rip) # 0x13f290
movl 0x14(%rsp), %edx
testl %edx, %edx
je 0x66212
leaq 0x7ef37(%rip), %rsi # 0xe5134
movl $0x3, %edi
movl 0x4(%rsp), %ecx
movl %ecx, %r8d
xorl %eax, %eax
callq 0xbfa73
jmp 0x66225
leaq 0x7ef58(%rip), %rsi # 0xe5171
movl $0x4, %edi
xorl %eax, %eax
callq 0xbfa73
movl 0x14(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| rlLoadTextureCubemap:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14d, ecx
mov ebp, edx
mov [rsp+78h+var_74], esi
mov r15, rdi
lea rbx, [rsp+78h+var_64]
mov dword ptr [rbx], 0
mov edi, 1
mov rsi, rbx
call cs:glad_glGenTextures
mov esi, [rbx]
mov edi, 8513h
call cs:glad_glBindTexture
lea rbx, [rsp+78h+var_68]
lea rdx, [rsp+78h+var_6C]
lea rcx, [rsp+78h+var_70]
mov edi, ebp
mov rsi, rbx
call rlGetGlTextureFormats
cmp dword ptr [rbx], 0
setz al
mov [rsp+78h+var_50], r14
test r14d, r14d
setle cl
or cl, al
jnz loc_6616B
mov r14d, [rsp+78h+var_74]
mov edi, r14d
mov esi, r14d
mov edx, ebp
call rlGetPixelDataSize
mov r12d, eax
mov rax, [rsp+78h+var_50]
add eax, eax
lea ecx, [rax+rax*2]
cmp ecx, 2
mov eax, 1
cmovl ecx, eax
mov [rsp+78h+var_54], ecx
mov [rsp+78h+var_60], r15
xor r13d, r13d
loc_65FF8:
mov esi, r13d
mov eax, 0AAAAAAABh
imul rsi, rax
shr rsi, 22h
lea eax, [rsi+rsi]
lea eax, [rax+rax*2]
mov ebx, r13d
sub ebx, eax
neg eax
test r15, r15
jz short loc_66060
lea edi, [rax+r13]
add edi, 8515h
mov edx, [rsp+78h+var_68]
cmp ebp, 0Dh
jg short loc_66087
mov eax, [rsp+78h+var_6C]
mov r10d, [rsp+78h+var_70]
mov r11d, ebx
imul r11d, r12d
add r11, [rsp+78h+var_60]
sub rsp, 8
mov ecx, r14d
mov r8d, r14d
xor r9d, r9d
push r11
loc_66051:
push r10
push rax
call cs:glad_glTexImage2D
add rsp, 20h
jmp short loc_660BD
loc_66060:
cmp ebp, 0Dh
jg short loc_660AA
ja loc_66140
mov ecx, 2D00h
bt ecx, ebp
jnb loc_66140
mov edi, 4
lea rsi, aTexturesCubema; "TEXTURES: Cubemap requested format not "...
jmp short loc_660B6
loc_66087:
mov eax, ebx
imul eax, r12d
add rax, [rsp+78h+var_60]
mov ecx, r14d
mov r8d, r14d
xor r9d, r9d
push rax
push r12
call cs:glad_glCompressedTexImage2D
add rsp, 10h
jmp short loc_660BD
loc_660AA:
mov edi, 4
lea rsi, aTexturesEmptyC; "TEXTURES: Empty cubemap creation does n"...
loc_660B6:
xor eax, eax
call TraceLog
loc_660BD:
cmp ebp, 2
jz short loc_660D0
cmp ebp, 1
jnz short loc_660F1
movaps xmm0, cs:xmmword_E3420
jmp short loc_660D7
loc_660D0:
movaps xmm0, cs:xmmword_E3430
loc_660D7:
movaps [rsp+78h+var_48], xmm0
mov edi, 8513h
mov esi, 8E46h
lea rdx, [rsp+78h+var_48]
call cs:glad_glTexParameteriv
loc_660F1:
add ebx, 0FFFFFFFBh
jnz short loc_66130
mov ebx, r14d
shr ebx, 1Fh
add ebx, r14d
sar ebx, 1
add r12d, r12d
test r15, r15
lea eax, [r12+r12*2]
cmovz rax, r15
add [rsp+78h+var_60], rax
cmp ebx, 2
mov eax, 1
cmovl ebx, eax
mov edi, ebx
mov esi, ebx
mov edx, ebp
call rlGetPixelDataSize
mov r12d, eax
mov r14d, ebx
loc_66130:
inc r13d
cmp [rsp+78h+var_54], r13d
jnz loc_65FF8
jmp short loc_6616B
loc_66140:
lea edi, [rax+r13]
add edi, 8515h
mov edx, [rsp+78h+var_68]
mov eax, [rsp+78h+var_6C]
mov r10d, [rsp+78h+var_70]
sub rsp, 8
mov ecx, r14d
mov r8d, r14d
xor r9d, r9d
push 0
jmp loc_66051
loc_6616B:
cmp dword ptr [rsp+78h+var_50], 2
mov edx, 2703h
mov eax, 2601h
cmovl edx, eax
mov edi, 8513h
mov esi, 2801h
call cs:glad_glTexParameteri
mov edi, 8513h
mov esi, 2800h
mov edx, 2601h
call cs:glad_glTexParameteri
mov edi, 8513h
mov esi, 2802h
mov edx, 812Fh
call cs:glad_glTexParameteri
mov edi, 8513h
mov esi, 2803h
mov edx, 812Fh
call cs:glad_glTexParameteri
mov edi, 8513h
mov esi, 8072h
mov edx, 812Fh
call cs:glad_glTexParameteri
mov edi, 8513h
xor esi, esi
call cs:glad_glBindTexture
mov edx, [rsp+78h+var_64]
test edx, edx
jz short loc_66212
lea rsi, aTextureIdICube; "TEXTURE: [ID %i] Cubemap texture loaded"...
mov edi, 3
mov ecx, [rsp+78h+var_74]
mov r8d, ecx
xor eax, eax
call TraceLog
jmp short loc_66225
loc_66212:
lea rsi, aTextureFailedT_1; "TEXTURE: Failed to load cubemap texture"
mov edi, 4
xor eax, eax
call TraceLog
loc_66225:
mov eax, [rsp+78h+var_64]
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long rlLoadTextureCubemap(long long a1, int a2, int a3, unsigned int a4)
{
long long v4; // r14
int v7; // r8d
int v8; // r9d
unsigned int v9; // r14d
int v10; // edx
int v11; // r8d
int v12; // r9d
long long PixelDataSize; // r12
int v14; // ecx
unsigned int i; // r13d
unsigned long long v16; // rsi
unsigned int v17; // ebx
int v18; // eax
long long v19; // rdi
const char *v20; // rsi
__int128 v21; // xmm0
int v22; // ebx
long long v23; // rax
long long v24; // rdx
int v25; // ecx
int v26; // r8d
int v27; // r9d
unsigned int v30; // [rsp+8h] [rbp-70h] BYREF
unsigned int v31; // [rsp+Ch] [rbp-6Ch] BYREF
unsigned int v32; // [rsp+10h] [rbp-68h] BYREF
unsigned int v33; // [rsp+14h] [rbp-64h] BYREF
long long v34; // [rsp+18h] [rbp-60h]
int v35; // [rsp+24h] [rbp-54h]
long long v36; // [rsp+28h] [rbp-50h]
__int128 v37[4]; // [rsp+30h] [rbp-48h] BYREF
v4 = a4;
v33 = 0;
glad_glGenTextures(1LL, &v33);
glad_glBindTexture(34067LL, v33);
rlGetGlTextureFormats(a3, &v32, &v31, &v30, v7, v8);
v36 = v4;
if ( v32 != 0 && (int)v4 > 0 )
{
v9 = a2;
PixelDataSize = (unsigned int)rlGetPixelDataSize(a2, a2, a3);
v14 = 6 * v36;
if ( 6 * (int)v36 < 2 )
v14 = 1;
v35 = v14;
v34 = a1;
for ( i = 0; v35 != i; ++i )
{
v16 = i / 6uLL;
v17 = i % 6;
v18 = -6 * v16;
if ( a1 )
{
v19 = v18 + i + 34069;
if ( a3 > 13 )
glad_glCompressedTexImage2D(
v19,
v16,
v32,
v9,
v9,
0LL,
PixelDataSize,
v34 + (unsigned int)PixelDataSize * v17);
else
glad_glTexImage2D(v19, v16, v32, v9, v9, 0LL, v31, v30, v34 + (unsigned int)PixelDataSize * v17);
}
else
{
if ( a3 > 13 )
{
v20 = "TEXTURES: Empty cubemap creation does not support compressed format";
goto LABEL_15;
}
if ( (unsigned int)a3 <= 0xD )
{
v14 = 11520;
if ( _bittest(&v14, a3) )
{
v20 = "TEXTURES: Cubemap requested format not supported";
LABEL_15:
TraceLog(4, (_DWORD)v20, v10, v14, v11, v12);
goto LABEL_16;
}
}
glad_glTexImage2D(v18 + i + 34069, v16, v32, v9, v9, 0LL, v31, v30, 0LL);
}
LABEL_16:
if ( a3 == 2 )
{
v21 = xmmword_E3430;
goto LABEL_20;
}
if ( a3 == 1 )
{
v21 = xmmword_E3420;
LABEL_20:
v37[0] = v21;
glad_glTexParameteriv(34067LL, 36422LL, v37);
}
if ( v17 == 5 )
{
v22 = (int)v9 / 2;
v23 = (unsigned int)(6 * PixelDataSize);
if ( !a1 )
v23 = 0LL;
v34 += v23;
if ( v22 < 2 )
v22 = 1;
PixelDataSize = (unsigned int)rlGetPixelDataSize(v22, v22, a3);
v9 = v22;
}
}
}
v24 = 9987LL;
if ( (int)v36 < 2 )
v24 = 9729LL;
glad_glTexParameteri(34067LL, 10241LL, v24);
glad_glTexParameteri(34067LL, 10240LL, 9729LL);
glad_glTexParameteri(34067LL, 10242LL, 33071LL);
glad_glTexParameteri(34067LL, 10243LL, 33071LL);
glad_glTexParameteri(34067LL, 32882LL, 33071LL);
glad_glBindTexture(34067LL, 0LL);
if ( v33 )
TraceLog(3, (unsigned int)"TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", v33, a2, a2, v27);
else
TraceLog(4, (unsigned int)"TEXTURE: Failed to load cubemap texture", 0, v25, v26, v27);
return v33;
}
| rlLoadTextureCubemap:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14D,ECX
MOV EBP,EDX
MOV dword ptr [RSP + 0x4],ESI
MOV R15,RDI
LEA RBX,[RSP + 0x14]
MOV dword ptr [RBX],0x0
MOV EDI,0x1
MOV RSI,RBX
CALL qword ptr [0x0023f9e0]
MOV ESI,dword ptr [RBX]
MOV EDI,0x8513
CALL qword ptr [0x0023f290]
LEA RBX,[RSP + 0x10]
LEA RDX,[RSP + 0xc]
LEA RCX,[RSP + 0x8]
MOV EDI,EBP
MOV RSI,RBX
CALL 0x00165bcc
CMP dword ptr [RBX],0x0
SETZ AL
MOV qword ptr [RSP + 0x28],R14
TEST R14D,R14D
SETLE CL
OR CL,AL
JNZ 0x0016616b
MOV R14D,dword ptr [RSP + 0x4]
MOV EDI,R14D
MOV ESI,R14D
MOV EDX,EBP
CALL 0x00165b6e
MOV R12D,EAX
MOV RAX,qword ptr [RSP + 0x28]
ADD EAX,EAX
LEA ECX,[RAX + RAX*0x2]
CMP ECX,0x2
MOV EAX,0x1
CMOVL ECX,EAX
MOV dword ptr [RSP + 0x24],ECX
MOV qword ptr [RSP + 0x18],R15
XOR R13D,R13D
LAB_00165ff8:
MOV ESI,R13D
MOV EAX,0xaaaaaaab
IMUL RSI,RAX
SHR RSI,0x22
LEA EAX,[RSI + RSI*0x1]
LEA EAX,[RAX + RAX*0x2]
MOV EBX,R13D
SUB EBX,EAX
NEG EAX
TEST R15,R15
JZ 0x00166060
LEA EDI,[RAX + R13*0x1]
ADD EDI,0x8515
MOV EDX,dword ptr [RSP + 0x10]
CMP EBP,0xd
JG 0x00166087
MOV EAX,dword ptr [RSP + 0xc]
MOV R10D,dword ptr [RSP + 0x8]
MOV R11D,EBX
IMUL R11D,R12D
ADD R11,qword ptr [RSP + 0x18]
SUB RSP,0x8
MOV ECX,R14D
MOV R8D,R14D
XOR R9D,R9D
PUSH R11
LAB_00166051:
PUSH R10
PUSH RAX
CALL qword ptr [0x00240870]
ADD RSP,0x20
JMP 0x001660bd
LAB_00166060:
CMP EBP,0xd
JG 0x001660aa
JA 0x00166140
MOV ECX,0x2d00
BT ECX,EBP
JNC 0x00166140
MOV EDI,0x4
LEA RSI,[0x1e50bf]
JMP 0x001660b6
LAB_00166087:
MOV EAX,EBX
IMUL EAX,R12D
ADD RAX,qword ptr [RSP + 0x18]
MOV ECX,R14D
MOV R8D,R14D
XOR R9D,R9D
PUSH RAX
PUSH R12
CALL qword ptr [0x0023f4c8]
ADD RSP,0x10
JMP 0x001660bd
LAB_001660aa:
MOV EDI,0x4
LEA RSI,[0x1e50f0]
LAB_001660b6:
XOR EAX,EAX
CALL 0x001bfa73
LAB_001660bd:
CMP EBP,0x2
JZ 0x001660d0
CMP EBP,0x1
JNZ 0x001660f1
MOVAPS XMM0,xmmword ptr [0x001e3420]
JMP 0x001660d7
LAB_001660d0:
MOVAPS XMM0,xmmword ptr [0x001e3430]
LAB_001660d7:
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV EDI,0x8513
MOV ESI,0x8e46
LEA RDX,[RSP + 0x30]
CALL qword ptr [0x002408b8]
LAB_001660f1:
ADD EBX,-0x5
JNZ 0x00166130
MOV EBX,R14D
SHR EBX,0x1f
ADD EBX,R14D
SAR EBX,0x1
ADD R12D,R12D
TEST R15,R15
LEA EAX,[R12 + R12*0x2]
CMOVZ RAX,R15
ADD qword ptr [RSP + 0x18],RAX
CMP EBX,0x2
MOV EAX,0x1
CMOVL EBX,EAX
MOV EDI,EBX
MOV ESI,EBX
MOV EDX,EBP
CALL 0x00165b6e
MOV R12D,EAX
MOV R14D,EBX
LAB_00166130:
INC R13D
CMP dword ptr [RSP + 0x24],R13D
JNZ 0x00165ff8
JMP 0x0016616b
LAB_00166140:
LEA EDI,[RAX + R13*0x1]
ADD EDI,0x8515
MOV EDX,dword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0xc]
MOV R10D,dword ptr [RSP + 0x8]
SUB RSP,0x8
MOV ECX,R14D
MOV R8D,R14D
XOR R9D,R9D
PUSH 0x0
JMP 0x00166051
LAB_0016616b:
CMP dword ptr [RSP + 0x28],0x2
MOV EDX,0x2703
MOV EAX,0x2601
CMOVL EDX,EAX
MOV EDI,0x8513
MOV ESI,0x2801
CALL qword ptr [0x002408b0]
MOV EDI,0x8513
MOV ESI,0x2800
MOV EDX,0x2601
CALL qword ptr [0x002408b0]
MOV EDI,0x8513
MOV ESI,0x2802
MOV EDX,0x812f
CALL qword ptr [0x002408b0]
MOV EDI,0x8513
MOV ESI,0x2803
MOV EDX,0x812f
CALL qword ptr [0x002408b0]
MOV EDI,0x8513
MOV ESI,0x8072
MOV EDX,0x812f
CALL qword ptr [0x002408b0]
MOV EDI,0x8513
XOR ESI,ESI
CALL qword ptr [0x0023f290]
MOV EDX,dword ptr [RSP + 0x14]
TEST EDX,EDX
JZ 0x00166212
LEA RSI,[0x1e5134]
MOV EDI,0x3
MOV ECX,dword ptr [RSP + 0x4]
MOV R8D,ECX
XOR EAX,EAX
CALL 0x001bfa73
JMP 0x00166225
LAB_00166212:
LEA RSI,[0x1e5171]
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001bfa73
LAB_00166225:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int rlLoadTextureCubemap(long param_1,int param_2,uint param_3,uint param_4)
{
int iVar1;
int iVar2;
ulong uVar3;
int8 uVar4;
int iVar5;
int iVar6;
char *pcVar7;
long lVar8;
int iVar9;
int4 uVar10;
int4 uVar11;
int4 uVar12;
int4 uVar13;
int4 local_70;
int4 local_6c;
int local_68;
int local_64;
long local_60;
uint local_54;
ulong local_50;
int4 local_48;
int4 uStack_44;
int4 uStack_40;
int4 uStack_3c;
local_64 = 0;
(*glad_glGenTextures)(1,&local_64);
(*glad_glBindTexture)(0x8513,local_64);
rlGetGlTextureFormats(param_3,&local_68,&local_6c,&local_70);
local_50 = (ulong)param_4;
if (0 < (int)param_4 && local_68 != 0) {
iVar1 = rlGetPixelDataSize(param_2,param_2,param_3);
local_54 = (int)local_50 * 6;
if ((int)local_54 < 2) {
local_54 = 1;
}
uVar3 = 0;
iVar6 = param_2;
local_60 = param_1;
do {
iVar9 = (int)uVar3;
iVar2 = (int)(uVar3 / 6);
iVar5 = iVar9 + iVar2 * -6;
iVar2 = iVar2 * -6;
if (param_1 == 0) {
if ((int)param_3 < 0xe) {
if ((0xd < param_3) || ((0x2d00U >> (param_3 & 0x1f) & 1) == 0)) {
iVar2 = iVar2 + iVar9 + 0x8515;
lVar8 = 0;
goto LAB_00166051;
}
pcVar7 = "TEXTURES: Cubemap requested format not supported";
}
else {
pcVar7 = "TEXTURES: Empty cubemap creation does not support compressed format";
}
TraceLog(4,pcVar7);
}
else {
iVar2 = iVar2 + iVar9 + 0x8515;
if ((int)param_3 < 0xe) {
lVar8 = (ulong)(uint)(iVar5 * iVar1) + local_60;
LAB_00166051:
(*glad_glTexImage2D)(iVar2,uVar3 / 6,local_68,iVar6,iVar6,0,local_6c,local_70,lVar8);
}
else {
(*glad_glCompressedTexImage2D)
(iVar2,uVar3 / 6,local_68,iVar6,iVar6,0,iVar1,
(ulong)(uint)(iVar5 * iVar1) + local_60);
}
}
uVar10 = _DAT_001e3430;
uVar11 = _UNK_001e3434;
uVar12 = _UNK_001e3438;
uVar13 = _UNK_001e343c;
if ((param_3 == 2) ||
(uVar10 = _DAT_001e3420, uVar11 = _UNK_001e3424, uVar12 = _UNK_001e3428,
uVar13 = _UNK_001e342c, param_3 == 1)) {
local_48 = uVar10;
uStack_44 = uVar11;
uStack_40 = uVar12;
uStack_3c = uVar13;
(*glad_glTexParameteriv)(0x8513,0x8e46,&local_48);
}
if (iVar5 == 5) {
iVar6 = iVar6 / 2;
uVar3 = (ulong)(uint)(iVar1 * 6);
if (param_1 == 0) {
uVar3 = 0;
}
local_60 = local_60 + uVar3;
if (iVar6 < 2) {
iVar6 = 1;
}
iVar1 = rlGetPixelDataSize(iVar6,iVar6,param_3);
}
uVar3 = (ulong)(iVar9 + 1U);
} while (local_54 != iVar9 + 1U);
}
uVar4 = 0x2703;
if ((int)local_50 < 2) {
uVar4 = 0x2601;
}
(*glad_glTexParameteri)(0x8513,0x2801,uVar4);
(*glad_glTexParameteri)(0x8513,0x2800,0x2601);
(*glad_glTexParameteri)(0x8513,0x2802,0x812f);
(*glad_glTexParameteri)(0x8513,0x2803,0x812f);
(*glad_glTexParameteri)(0x8513,0x8072,0x812f);
(*glad_glBindTexture)(0x8513,0);
if (local_64 == 0) {
TraceLog(4,"TEXTURE: Failed to load cubemap texture");
}
else {
TraceLog(3,"TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)",local_64,param_2,
param_2);
}
return local_64;
}
|
|
1,630 | my_getwd | eloqsql/mysys/my_getwd.c | int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
} | O3 | c | my_getwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x58ac1
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x355b50(%rip), %rax # 0x3ae5b0
cmpb $0x0, (%rax)
je 0x58a7b
decq %rdx
leaq 0x355b41(%rip), %rsi # 0x3ae5b0
movq %r14, %rdi
callq 0x8f640
xorl %ebx, %ebx
jmp 0x58ac1
cmpq $0x1, %rdx
je 0x58ac1
addl $-0x2, %edx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x281a0
testb $0x10, %r15b
je 0x58ace
testq %rax, %rax
jne 0x58ace
callq 0x28050
movq %rax, %r14
movl (%rax), %r15d
callq 0x5be8e
movl %r15d, (%rax)
movl (%r14), %edx
movl $0x4, %esi
movl $0x10, %edi
xorl %eax, %eax
callq 0x586b7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x8f5f8
cmpb $0x2f, -0x1(%rax)
je 0x58ae1
movw $0x2f, (%rax)
leaq 0x355ac8(%rip), %rdi # 0x3ae5b0
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rsi
jmp 0x58a72
| my_getwd:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, 0FFFFFFFFh
test rsi, rsi
jz short loc_58AC1
mov r15, rdx
mov rdx, rsi
mov r14, rdi
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_58A7B
dec rdx
lea rsi, curr_dir
mov rdi, r14
loc_58A72:
call strmake
xor ebx, ebx
jmp short loc_58AC1
loc_58A7B:
cmp rdx, 1
jz short loc_58AC1
add edx, 0FFFFFFFEh
mov rdi, r14
mov rsi, rdx
call _getcwd
test r15b, 10h
jz short loc_58ACE
test rax, rax
jnz short loc_58ACE
call ___errno_location
mov r14, rax
mov r15d, [rax]
call _my_thread_var
mov [rax], r15d
mov edx, [r14]
mov esi, 4
mov edi, 10h
xor eax, eax
call my_error
loc_58AC1:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_58ACE:
mov rdi, r14
call strend
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_58AE1
mov word ptr [rax], 2Fh ; '/'
loc_58AE1:
lea rdi, curr_dir
mov edx, 1FFh
mov rsi, r14
jmp short loc_58A72
| long long my_getwd(_BYTE *a1, long long a2, char a3)
{
unsigned int v3; // ebx
_BYTE *v5; // r14
long long v6; // rdx
_BYTE *v7; // rsi
long long v8; // rax
unsigned int *v9; // r14
unsigned int v10; // r15d
_WORD *v12; // rax
v3 = -1;
if ( a2 )
{
v5 = a1;
if ( curr_dir[0] )
{
v6 = a2 - 1;
v7 = curr_dir;
}
else
{
if ( a2 == 1 )
return v3;
v8 = getcwd(a1, (unsigned int)(a2 - 2));
if ( (a3 & 0x10) != 0 && !v8 )
{
v9 = (unsigned int *)__errno_location(a1);
v10 = *v9;
*(_DWORD *)my_thread_var(a1) = v10;
my_error(0x10u, 4LL, *v9);
return v3;
}
v12 = (_WORD *)strend(a1);
if ( *((_BYTE *)v12 - 1) != 47 )
*v12 = 47;
a1 = curr_dir;
v6 = 511LL;
v7 = v5;
}
strmake(a1, v7, v6);
return 0;
}
return v3;
}
| my_getwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
TEST RSI,RSI
JZ 0x00158ac1
MOV R15,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RAX,[0x4ae5b0]
CMP byte ptr [RAX],0x0
JZ 0x00158a7b
DEC RDX
LEA RSI,[0x4ae5b0]
MOV RDI,R14
LAB_00158a72:
CALL 0x0018f640
XOR EBX,EBX
JMP 0x00158ac1
LAB_00158a7b:
CMP RDX,0x1
JZ 0x00158ac1
ADD EDX,-0x2
MOV RDI,R14
MOV RSI,RDX
CALL 0x001281a0
TEST R15B,0x10
JZ 0x00158ace
TEST RAX,RAX
JNZ 0x00158ace
CALL 0x00128050
MOV R14,RAX
MOV R15D,dword ptr [RAX]
CALL 0x0015be8e
MOV dword ptr [RAX],R15D
MOV EDX,dword ptr [R14]
MOV ESI,0x4
MOV EDI,0x10
XOR EAX,EAX
CALL 0x001586b7
LAB_00158ac1:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00158ace:
MOV RDI,R14
CALL 0x0018f5f8
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x00158ae1
MOV word ptr [RAX],0x2f
LAB_00158ae1:
LEA RDI,[0x4ae5b0]
MOV EDX,0x1ff
MOV RSI,R14
JMP 0x00158a72
|
int8 my_getwd(char *param_1,long param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int *piVar4;
int2 *puVar5;
char *pcVar6;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 == 1) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if (((param_3 & 0x10) != 0) && (pcVar2 == (char *)0x0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar5 = (int2 *)strend(param_1);
if (*(char *)((long)puVar5 + -1) != '/') {
*puVar5 = 0x2f;
}
pcVar6 = &curr_dir;
param_2 = 0x1ff;
pcVar2 = param_1;
}
else {
param_2 = param_2 + -1;
pcVar2 = &curr_dir;
pcVar6 = param_1;
}
strmake(pcVar6,pcVar2,param_2);
return 0;
}
|
|
1,631 | find_private_class_field | bluesky950520[P]quickjs/quickjs.c | static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
JSAtom name, int scope_level)
{
int idx;
idx = fd->scopes[scope_level].first;
while (idx != -1) {
if (fd->vars[idx].scope_level != scope_level)
break;
if (fd->vars[idx].var_name == name)
return idx;
idx = fd->vars[idx].scope_next;
}
return -1;
} | O0 | c | find_private_class_field:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl %ecx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0xf8(%rax), %rax
movslq -0x20(%rsp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x24(%rsp)
cmpl $-0x1, -0x24(%rsp)
je 0xae310
movq -0x18(%rsp), %rax
movq 0x90(%rax), %rax
movslq -0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x20(%rsp), %eax
je 0xae2c5
jmp 0xae310
movq -0x18(%rsp), %rax
movq 0x90(%rax), %rax
movslq -0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rsp), %eax
jne 0xae2ef
movl -0x24(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xae318
movq -0x18(%rsp), %rax
movq 0x90(%rax), %rax
movslq -0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rsp)
jmp 0xae29b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopl (%rax)
| find_private_class_field:
mov [rsp+var_10], rdi
mov [rsp+var_18], rsi
mov [rsp+var_1C], edx
mov [rsp+var_20], ecx
mov rax, [rsp+var_18]
mov rax, [rax+0F8h]
movsxd rcx, [rsp+var_20]
mov eax, [rax+rcx*8+4]
mov [rsp+var_24], eax
loc_AE29B:
cmp [rsp+var_24], 0FFFFFFFFh
jz short loc_AE310
mov rax, [rsp+var_18]
mov rax, [rax+90h]
movsxd rcx, [rsp+var_24]
shl rcx, 4
add rax, rcx
mov eax, [rax+4]
cmp eax, [rsp+var_20]
jz short loc_AE2C5
jmp short loc_AE310
loc_AE2C5:
mov rax, [rsp+var_18]
mov rax, [rax+90h]
movsxd rcx, [rsp+var_24]
shl rcx, 4
add rax, rcx
mov eax, [rax]
cmp eax, [rsp+var_1C]
jnz short loc_AE2EF
mov eax, [rsp+var_24]
mov [rsp+var_4], eax
jmp short loc_AE318
loc_AE2EF:
mov rax, [rsp+var_18]
mov rax, [rax+90h]
movsxd rcx, [rsp+var_24]
shl rcx, 4
add rax, rcx
mov eax, [rax+8]
mov [rsp+var_24], eax
jmp short loc_AE29B
loc_AE310:
mov [rsp+var_4], 0FFFFFFFFh
loc_AE318:
mov eax, [rsp+var_4]
retn
| long long find_private_class_field(long long a1, long long a2, int a3, int a4)
{
unsigned int i; // [rsp+0h] [rbp-24h]
for ( i = *(_DWORD *)(*(_QWORD *)(a2 + 248) + 8LL * a4 + 4);
i != -1 && *(_DWORD *)(16LL * (int)i + *(_QWORD *)(a2 + 144) + 4) == a4;
i = *(_DWORD *)(16LL * (int)i + *(_QWORD *)(a2 + 144) + 8) )
{
if ( *(_DWORD *)(16LL * (int)i + *(_QWORD *)(a2 + 144)) == a3 )
return i;
}
return (unsigned int)-1;
}
| find_private_class_field:
MOV qword ptr [RSP + -0x10],RDI
MOV qword ptr [RSP + -0x18],RSI
MOV dword ptr [RSP + -0x1c],EDX
MOV dword ptr [RSP + -0x20],ECX
MOV RAX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RSP + -0x20]
MOV EAX,dword ptr [RAX + RCX*0x8 + 0x4]
MOV dword ptr [RSP + -0x24],EAX
LAB_001ae29b:
CMP dword ptr [RSP + -0x24],-0x1
JZ 0x001ae310
MOV RAX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
CMP EAX,dword ptr [RSP + -0x20]
JZ 0x001ae2c5
JMP 0x001ae310
LAB_001ae2c5:
MOV RAX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RSP + -0x1c]
JNZ 0x001ae2ef
MOV EAX,dword ptr [RSP + -0x24]
MOV dword ptr [RSP + -0x4],EAX
JMP 0x001ae318
LAB_001ae2ef:
MOV RAX,qword ptr [RSP + -0x18]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RSP + -0x24],EAX
JMP 0x001ae29b
LAB_001ae310:
MOV dword ptr [RSP + -0x4],0xffffffff
LAB_001ae318:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
int find_private_class_field(int8 param_1,long param_2,int param_3,int param_4)
{
int local_24;
local_24 = *(int *)(*(long *)(param_2 + 0xf8) + 4 + (long)param_4 * 8);
while ((local_24 != -1 &&
(*(int *)(*(long *)(param_2 + 0x90) + (long)local_24 * 0x10 + 4) == param_4))) {
if (*(int *)(*(long *)(param_2 + 0x90) + (long)local_24 * 0x10) == param_3) {
return local_24;
}
local_24 = *(int *)(*(long *)(param_2 + 0x90) + (long)local_24 * 0x10 + 8);
}
return -1;
}
|
|
1,632 | find_private_class_field | bluesky950520[P]quickjs/quickjs.c | static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
JSAtom name, int scope_level)
{
int idx;
idx = fd->scopes[scope_level].first;
while (idx != -1) {
if (fd->vars[idx].scope_level != scope_level)
break;
if (fd->vars[idx].var_name == name)
return idx;
idx = fd->vars[idx].scope_next;
}
return -1;
} | O2 | c | find_private_class_field:
movq 0xf8(%rdi), %rax
movslq %edx, %rcx
leaq (%rax,%rcx,8), %r9
addq $0x4, %r9
pushq $-0x1
popq %rax
movslq (%r9), %rcx
cmpq $-0x1, %rcx
je 0x5a1ac
movq 0x90(%rdi), %r8
movq %rcx, %r9
shlq $0x4, %r9
cmpl %edx, 0x4(%r8,%r9)
jne 0x5a1ac
addq %r9, %r8
leaq 0x8(%r8), %r9
cmpl %esi, (%r8)
jne 0x5a180
movl %ecx, %eax
retq
| find_private_class_field:
mov rax, [rdi+0F8h]
movsxd rcx, edx
lea r9, [rax+rcx*8]
add r9, 4
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_5A180:
movsxd rcx, dword ptr [r9]
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz short locret_5A1AC
mov r8, [rdi+90h]
mov r9, rcx
shl r9, 4
cmp [r8+r9+4], edx
jnz short locret_5A1AC
add r8, r9
lea r9, [r8+8]
cmp [r8], esi
jnz short loc_5A180
mov eax, ecx
locret_5A1AC:
retn
| long long find_private_class_field(long long a1, int a2, int a3)
{
int *v3; // r9
long long result; // rax
long long v5; // rcx
long long v6; // r8
_DWORD *v7; // r8
v3 = (int *)(*(_QWORD *)(a1 + 248) + 8LL * a3 + 4);
result = -1LL;
while ( 1 )
{
v5 = *v3;
if ( v5 == -1 )
break;
v6 = *(_QWORD *)(a1 + 144);
if ( *(_DWORD *)(v6 + 16 * v5 + 4) != a3 )
break;
v7 = (_DWORD *)(16 * v5 + v6);
v3 = v7 + 2;
if ( *v7 == a2 )
return (unsigned int)v5;
}
return result;
}
| find_private_class_field:
MOV RAX,qword ptr [RDI + 0xf8]
MOVSXD RCX,EDX
LEA R9,[RAX + RCX*0x8]
ADD R9,0x4
PUSH -0x1
POP RAX
LAB_0015a180:
MOVSXD RCX,dword ptr [R9]
CMP RCX,-0x1
JZ 0x0015a1ac
MOV R8,qword ptr [RDI + 0x90]
MOV R9,RCX
SHL R9,0x4
CMP dword ptr [R8 + R9*0x1 + 0x4],EDX
JNZ 0x0015a1ac
ADD R8,R9
LEA R9,[R8 + 0x8]
CMP dword ptr [R8],ESI
JNZ 0x0015a180
MOV EAX,ECX
LAB_0015a1ac:
RET
|
ulong find_private_class_field(long param_1,int param_2,int param_3)
{
uint uVar1;
int *piVar2;
uint *puVar3;
long lVar4;
puVar3 = (uint *)(*(long *)(param_1 + 0xf8) + (long)param_3 * 8 + 4);
while( true ) {
uVar1 = *puVar3;
if ((long)(int)uVar1 == -1) {
return 0xffffffffffffffff;
}
lVar4 = (long)(int)uVar1 * 0x10;
if (*(int *)(*(long *)(param_1 + 0x90) + 4 + lVar4) != param_3) break;
piVar2 = (int *)(*(long *)(param_1 + 0x90) + lVar4);
puVar3 = (uint *)(piVar2 + 2);
if (*piVar2 == param_2) {
return (ulong)uVar1;
}
}
return 0xffffffffffffffff;
}
|
|
1,633 | rtree_find_next | eloqsql/storage/myisam/rt_index.c | int rtree_find_next(MI_INFO *info, uint keynr, uint search_flag)
{
my_off_t root;
uint nod_cmp_flag;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
/*
At the moment index can only properly handle the
MBR_INTERSECT, so we use it for all sorts of queries.
TODO: better searsh for CONTAINS/WITHIN.
*/
search_flag= nod_cmp_flag= MBR_INTERSECT;
if (info->update & HA_STATE_DELETED)
return rtree_find_first(info, keynr, info->lastkey, info->lastkey_length,
search_flag);
if (!info->buff_used)
{
uchar *key= info->int_keypos;
while (key < info->int_maxpos)
{
if (!rtree_key_cmp(keyinfo->seg, info->first_mbr_key, key,
info->last_rkey_length, search_flag))
{
uchar *after_key = key + keyinfo->keylength;
info->lastpos= _mi_dpos(info, 0, after_key);
memcpy(info->lastkey, key, info->lastkey_length);
if (after_key < info->int_maxpos)
info->int_keypos= after_key;
else
info->buff_used= 1;
return 0;
}
key+= keyinfo->keylength;
}
}
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
/*
TODO better search for CONTAINS/WITHIN.
nod_cmp_flag= (((search_flag & (MBR_EQUAL | MBR_WITHIN)) ?
MBR_WITHIN : MBR_INTERSECT));
*/
return rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root, 0);
} | O3 | c | rtree_find_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x8, 0x1d0(%rdi)
jne 0x8d112
movq (%rbx), %rax
movl %esi, %r13d
imulq $0x70, %r13, %r14
addq 0x218(%rax), %r14
cmpb $0x0, 0x33d(%rbx)
jne 0x8d0e6
movq 0x128(%rbx), %r15
cmpq 0x130(%rbx), %r15
jae 0x8d0e6
movq 0x28(%r14), %rdi
movq 0x118(%rbx), %rsi
movl 0x1dc(%rbx), %ecx
movq %r15, %rdx
movl $0x400, %r8d # imm = 0x400
callq 0x8e73c
movzwl 0x12(%r14), %r12d
addq %r15, %r12
testl %eax, %eax
je 0x8d158
movq %r12, %r15
cmpq 0x130(%rbx), %r12
jb 0x8d0a8
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq (%rax,%r13,8), %rdx
cmpq $-0x1, %rdx
je 0x8d135
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cde7
movq 0x108(%rbx), %rdx
movl 0x1d8(%rbx), %ecx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cd54
callq 0xa4ab2
movl $0x89, (%rax)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x879d9
movq %rax, 0x170(%rbx)
movq 0x108(%rbx), %rdi
movl 0x1d8(%rbx), %edx
movq %r15, %rsi
callq 0x29080
cmpq 0x130(%rbx), %r12
jae 0x8d196
movq %r12, 0x128(%rbx)
jmp 0x8d146
movb $0x1, 0x33d(%rbx)
jmp 0x8d146
| rtree_find_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
test byte ptr [rdi+1D0h], 8
jnz loc_8D112
mov rax, [rbx]
mov r13d, esi
imul r14, r13, 70h ; 'p'
add r14, [rax+218h]
cmp byte ptr [rbx+33Dh], 0
jnz short loc_8D0E6
mov r15, [rbx+128h]
cmp r15, [rbx+130h]
jnb short loc_8D0E6
loc_8D0A8:
mov rdi, [r14+28h]
mov rsi, [rbx+118h]
mov ecx, [rbx+1DCh]
mov rdx, r15
mov r8d, 400h
call rtree_key_cmp
movzx r12d, word ptr [r14+12h]
add r12, r15
test eax, eax
jz loc_8D158
mov r15, r12
cmp r12, [rbx+130h]
jb short loc_8D0A8
mov rax, [rbx]
loc_8D0E6:
mov rax, [rax+98h]
mov rdx, [rax+r13*8]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_8D135
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rtree_find_req
loc_8D112:
mov rdx, [rbx+108h]
mov ecx, [rbx+1D8h]
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rtree_find_first
loc_8D135:
call _my_thread_var
mov dword ptr [rax], 89h
mov r14d, 0FFFFFFFFh
loc_8D146:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8D158:
xor r14d, r14d
mov rdi, rbx
xor esi, esi
mov rdx, r12
call _mi_dpos
mov [rbx+170h], rax
mov rdi, [rbx+108h]
mov edx, [rbx+1D8h]
mov rsi, r15
call _memcpy
cmp r12, [rbx+130h]
jnb short loc_8D196
mov [rbx+128h], r12
jmp short loc_8D146
loc_8D196:
mov byte ptr [rbx+33Dh], 1
jmp short loc_8D146
| long long rtree_find_next(long long a1, unsigned int a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // r14
unsigned long long v5; // r15
int v6; // eax
unsigned long long v7; // r12
long long v8; // rdx
unsigned int v10; // r14d
v2 = a1;
if ( (*(_BYTE *)(a1 + 464) & 8) != 0 )
return rtree_find_first(a1, a2, *(_QWORD *)(a1 + 264), *(_DWORD *)(a1 + 472));
v3 = *(_QWORD *)a1;
v4 = *(_QWORD *)(*(_QWORD *)a1 + 536LL) + 112LL * a2;
if ( *(_BYTE *)(a1 + 829) || (v5 = *(_QWORD *)(a1 + 296), v5 >= *(_QWORD *)(a1 + 304)) )
{
LABEL_7:
v8 = *(_QWORD *)(*(_QWORD *)(v3 + 152) + 8LL * a2);
if ( v8 != -1 )
return rtree_find_req((long long *)v2, v4, v8, 0LL);
*(_DWORD *)my_thread_var(a1) = 137;
return (unsigned int)-1;
}
else
{
while ( 1 )
{
a1 = *(_QWORD *)(v4 + 40);
v6 = rtree_key_cmp(a1, *(_QWORD *)(v2 + 280), v5, *(unsigned int *)(v2 + 476), 1024LL);
v7 = v5 + *(unsigned __int16 *)(v4 + 18);
if ( !v6 )
break;
v5 += *(unsigned __int16 *)(v4 + 18);
if ( v7 >= *(_QWORD *)(v2 + 304) )
{
v3 = *(_QWORD *)v2;
goto LABEL_7;
}
}
v10 = 0;
*(_QWORD *)(v2 + 368) = mi_dpos((long long *)v2, 0, v7);
memcpy(*(_QWORD *)(v2 + 264), v5, *(unsigned int *)(v2 + 472));
if ( v7 >= *(_QWORD *)(v2 + 304) )
*(_BYTE *)(v2 + 829) = 1;
else
*(_QWORD *)(v2 + 296) = v7;
}
return v10;
}
| rtree_find_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
TEST byte ptr [RDI + 0x1d0],0x8
JNZ 0x0018d112
MOV RAX,qword ptr [RBX]
MOV R13D,ESI
IMUL R14,R13,0x70
ADD R14,qword ptr [RAX + 0x218]
CMP byte ptr [RBX + 0x33d],0x0
JNZ 0x0018d0e6
MOV R15,qword ptr [RBX + 0x128]
CMP R15,qword ptr [RBX + 0x130]
JNC 0x0018d0e6
LAB_0018d0a8:
MOV RDI,qword ptr [R14 + 0x28]
MOV RSI,qword ptr [RBX + 0x118]
MOV ECX,dword ptr [RBX + 0x1dc]
MOV RDX,R15
MOV R8D,0x400
CALL 0x0018e73c
MOVZX R12D,word ptr [R14 + 0x12]
ADD R12,R15
TEST EAX,EAX
JZ 0x0018d158
MOV R15,R12
CMP R12,qword ptr [RBX + 0x130]
JC 0x0018d0a8
MOV RAX,qword ptr [RBX]
LAB_0018d0e6:
MOV RAX,qword ptr [RAX + 0x98]
MOV RDX,qword ptr [RAX + R13*0x8]
CMP RDX,-0x1
JZ 0x0018d135
MOV RDI,RBX
MOV RSI,R14
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018cde7
LAB_0018d112:
MOV RDX,qword ptr [RBX + 0x108]
MOV ECX,dword ptr [RBX + 0x1d8]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018cd54
LAB_0018d135:
CALL 0x001a4ab2
MOV dword ptr [RAX],0x89
MOV R14D,0xffffffff
LAB_0018d146:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018d158:
XOR R14D,R14D
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R12
CALL 0x001879d9
MOV qword ptr [RBX + 0x170],RAX
MOV RDI,qword ptr [RBX + 0x108]
MOV EDX,dword ptr [RBX + 0x1d8]
MOV RSI,R15
CALL 0x00129080
CMP R12,qword ptr [RBX + 0x130]
JNC 0x0018d196
MOV qword ptr [RBX + 0x128],R12
JMP 0x0018d146
LAB_0018d196:
MOV byte ptr [RBX + 0x33d],0x1
JMP 0x0018d146
|
int8 rtree_find_next(long *param_1,ulong param_2)
{
int iVar1;
int8 uVar2;
int4 *puVar3;
long lVar4;
void *pvVar5;
long lVar6;
void *__src;
if ((*(byte *)(param_1 + 0x3a) & 8) != 0) {
uVar2 = rtree_find_first(param_1,param_2,param_1[0x21],(int)param_1[0x3b]);
return uVar2;
}
lVar4 = *param_1;
lVar6 = (param_2 & 0xffffffff) * 0x70 + *(long *)(lVar4 + 0x218);
if ((*(char *)((long)param_1 + 0x33d) == '\0') &&
(__src = (void *)param_1[0x25], (void *)param_1[0x25] < (void *)param_1[0x26])) {
do {
iVar1 = rtree_key_cmp(*(int8 *)(lVar6 + 0x28),param_1[0x23],__src,
*(int4 *)((long)param_1 + 0x1dc),0x400);
pvVar5 = (void *)((ulong)*(ushort *)(lVar6 + 0x12) + (long)__src);
if (iVar1 == 0) {
lVar4 = _mi_dpos(param_1,0,pvVar5);
param_1[0x2e] = lVar4;
memcpy((void *)param_1[0x21],__src,(ulong)*(uint *)(param_1 + 0x3b));
if (pvVar5 < (void *)param_1[0x26]) {
param_1[0x25] = (long)pvVar5;
return 0;
}
*(int1 *)((long)param_1 + 0x33d) = 1;
return 0;
}
__src = pvVar5;
} while (pvVar5 < (void *)param_1[0x26]);
lVar4 = *param_1;
}
lVar4 = *(long *)(*(long *)(lVar4 + 0x98) + (param_2 & 0xffffffff) * 8);
if (lVar4 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
return 0xffffffff;
}
uVar2 = rtree_find_req(param_1,lVar6,lVar4,0);
return uVar2;
}
|
|
1,634 | google::protobuf::Reflection::FieldSize(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_message_reflection.cc | int Reflection::FieldSize(const Message& message,
const FieldDescriptor* field) const {
USAGE_CHECK_MESSAGE_TYPE(FieldSize);
USAGE_CHECK_REPEATED(FieldSize);
CheckInvalidAccess(schema_, field);
if (field->is_extension()) {
return GetExtensionSet(message).ExtensionSize(field->number());
} else {
switch (field->cpp_type()) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
HANDLE_TYPE(INT32, int32_t);
HANDLE_TYPE(INT64, int64_t);
HANDLE_TYPE(UINT32, uint32_t);
HANDLE_TYPE(UINT64, uint64_t);
HANDLE_TYPE(DOUBLE, double);
HANDLE_TYPE(FLOAT, float);
HANDLE_TYPE(BOOL, bool);
HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
case FieldDescriptor::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
const internal::MapFieldBase& map =
GetRaw<MapFieldBase>(message, field);
if (map.IsRepeatedFieldValid()) {
return map.GetRepeatedField().size();
} else {
// No need to materialize the repeated field if it is out of sync:
// its size will be the same as the map's size.
return map.size();
}
} else {
return GetRaw<RepeatedPtrFieldBase>(message, field).size();
}
}
GOOGLE_LOG(FATAL) << "Can't get here.";
return 0;
}
} | O0 | cpp | google::protobuf::Reflection::FieldSize(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*) const:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rdi
callq 0x1be1f0
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
je 0x1aef9d
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x78(%rsp), %rsi
leaq 0x237d97(%rip), %rdx # 0x3e6d28
leaq 0x237cd7(%rip), %rcx # 0x3e6c6f
callq 0x1aec80
movq 0x78(%rsp), %rdi
callq 0x1be200
cmpl $0x3, %eax
je 0x1aefcc
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x78(%rsp), %rsi
leaq 0x237d68(%rip), %rdx # 0x3e6d28
leaq 0x237d6b(%rip), %rcx # 0x3e6d32
callq 0x1aec80
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x78(%rsp), %rsi
callq 0x1aedf0
movq 0x78(%rsp), %rdi
callq 0x1bab10
testb $0x1, %al
jne 0x1aefef
jmp 0x1af028
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x1ac100
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0x1bab30
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x214d70
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x78(%rsp), %rdi
callq 0x1badb0
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x9, %eax
ja 0x1af24a
movq 0x10(%rsp), %rax
leaq 0x237810(%rip), %rcx # 0x3e6860
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1badd0
movq %rax, %rdi
callq 0x182970
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1baf50
movq %rax, %rdi
callq 0x188030
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb0d0
movq %rax, %rdi
callq 0x1854d0
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb250
movq %rax, %rdi
callq 0x18ab60
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb3d0
movq %rax, %rdi
callq 0x190260
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb550
movq %rax, %rdi
callq 0x18d6d0
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb6d0
movq %rax, %rdi
callq 0x17fd50
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1badd0
movq %rax, %rdi
callq 0x182970
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x78(%rsp), %rdi
callq 0x1ac760
testb $0x1, %al
jne 0x1af1c1
jmp 0x1af222
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bb9e0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1ca830
testb $0x1, %al
jne 0x1af1ed
jmp 0x1af20b
movq 0x70(%rsp), %rdi
callq 0x1c9b60
movq %rax, %rdi
callq 0x1591f0
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x70(%rsp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
movq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1bbb60
movq %rax, %rdi
callq 0x1591f0
movl %eax, 0x94(%rsp)
jmp 0x1af2c2
leaq 0x23779f(%rip), %rdx # 0x3e69f0
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x4c2, %ecx # imm = 0x4C2
callq 0x19a670
movq (%rsp), %rdi
leaq 0x237af7(%rip), %rsi # 0x3e6d6b
callq 0x199f30
movq %rax, 0x8(%rsp)
jmp 0x1af280
movq 0x8(%rsp), %rsi
leaq 0x2b(%rsp), %rdi
callq 0x19a0e0
jmp 0x1af291
leaq 0x38(%rsp), %rdi
callq 0x19a6b0
movl $0x0, 0x94(%rsp)
jmp 0x1af2c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19a6b0
jmp 0x1af2d1
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x90db0
nopl (%rax,%rax)
| _ZNK6google8protobuf10Reflection9FieldSizeERKNS0_7MessageEPKNS0_15FieldDescriptorE:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov [rsp+98h+var_18], rsi
mov [rsp+98h+var_20], rdx
mov rax, [rsp+98h+var_10]
mov [rsp+98h+var_78], rax
mov rdi, [rsp+98h+var_20]; this
call _ZNK6google8protobuf15FieldDescriptor15containing_typeEv; google::protobuf::FieldDescriptor::containing_type(void)
mov rcx, [rsp+98h+var_78]
cmp rax, [rcx]
jz short loc_1AEF9D
mov rax, [rsp+98h+var_78]
mov rdi, [rax]; this
mov rsi, [rsp+98h+var_20]; google::protobuf::Descriptor *
lea rdx, aFieldsize; "FieldSize"
lea rcx, aFieldDoesNotMa; "Field does not match message type."
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
loc_1AEF9D:
mov rdi, [rsp+98h+var_20]; this
call _ZNK6google8protobuf15FieldDescriptor5labelEv; google::protobuf::FieldDescriptor::label(void)
cmp eax, 3
jz short loc_1AEFCC
mov rax, [rsp+98h+var_78]
mov rdi, [rax]; this
mov rsi, [rsp+98h+var_20]; google::protobuf::Descriptor *
lea rdx, aFieldsize; "FieldSize"
lea rcx, aFieldIsSingula; "Field is singular; the method requires "...
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
loc_1AEFCC:
mov rdi, [rsp+98h+var_78]
add rdi, 8; this
mov rsi, [rsp+98h+var_20]; google::protobuf::FieldDescriptor *
call _ZN6google8protobuf12_GLOBAL__N_118CheckInvalidAccessERKNS0_8internal16ReflectionSchemaEPKNS0_15FieldDescriptorE; google::protobuf::`anonymous namespace'::CheckInvalidAccess(google::protobuf::internal::ReflectionSchema const&,google::protobuf::FieldDescriptor const*)
mov rdi, [rsp+98h+var_20]; this
call _ZNK6google8protobuf15FieldDescriptor12is_extensionEv; google::protobuf::FieldDescriptor::is_extension(void)
test al, 1
jnz short loc_1AEFEF
jmp short loc_1AF028
loc_1AEFEF:
mov rdi, [rsp+98h+var_78]; this
mov rsi, [rsp+98h+var_18]; google::protobuf::Message *
call _ZNK6google8protobuf10Reflection15GetExtensionSetERKNS0_7MessageE; google::protobuf::Reflection::GetExtensionSet(google::protobuf::Message const&)
mov [rsp+98h+var_80], rax
mov rdi, [rsp+98h+var_20]; this
call _ZNK6google8protobuf15FieldDescriptor6numberEv; google::protobuf::FieldDescriptor::number(void)
mov rdi, [rsp+98h+var_80]; this
mov esi, eax; int
call _ZNK6google8protobuf8internal12ExtensionSet13ExtensionSizeEi; google::protobuf::internal::ExtensionSet::ExtensionSize(int)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF028:
mov rdi, [rsp+98h+var_20]; this
call _ZNK6google8protobuf15FieldDescriptor8cpp_typeEv; google::protobuf::FieldDescriptor::cpp_type(void)
dec eax; switch 10 cases
mov ecx, eax
mov [rsp+98h+var_88], rcx
sub eax, 9
ja def_1AF057; jumptable 00000000001AF057 default case
mov rax, [rsp+98h+var_88]
lea rcx, jpt_1AF057
movsxd rax, ds:(jpt_1AF057 - 3E6860h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1AF059:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 1
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIiEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<int>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIiE4sizeEv; google::protobuf::RepeatedField<int>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF084:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 2
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIlEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<long>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIlE4sizeEv; google::protobuf::RepeatedField<long>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF0AF:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 3
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIjEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<uint>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIjE4sizeEv; google::protobuf::RepeatedField<uint>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF0DA:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 4
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldImEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<ulong>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldImE4sizeEv; google::protobuf::RepeatedField<ulong>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF105:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 5
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIdEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<double>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIdE4sizeEv; google::protobuf::RepeatedField<double>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF130:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 6
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIfEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<float>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIfE4sizeEv; google::protobuf::RepeatedField<float>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF15B:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 7
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIbEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<bool>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIbE4sizeEv; google::protobuf::RepeatedField<bool>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF186:
mov rdi, [rsp+98h+var_78]; jumptable 00000000001AF057 case 8
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_13RepeatedFieldIiEEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<int>>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax
call _ZNK6google8protobuf13RepeatedFieldIiE4sizeEv; google::protobuf::RepeatedField<int>::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF1B1:
mov rdi, [rsp+98h+var_20]; jumptable 00000000001AF057 cases 9,10
call _ZN6google8protobuf12_GLOBAL__N_115IsMapFieldInApiEPKNS0_15FieldDescriptorE; google::protobuf::`anonymous namespace'::IsMapFieldInApi(google::protobuf::FieldDescriptor const*)
test al, 1
jnz short loc_1AF1C1
jmp short loc_1AF222
loc_1AF1C1:
mov rdi, [rsp+98h+var_78]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_8internal12MapFieldBaseEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::internal::MapFieldBase>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov [rsp+98h+var_28], rax
mov rdi, [rsp+98h+var_28]; this
call _ZNK6google8protobuf8internal12MapFieldBase20IsRepeatedFieldValidEv; google::protobuf::internal::MapFieldBase::IsRepeatedFieldValid(void)
test al, 1
jnz short loc_1AF1ED
jmp short loc_1AF20B
loc_1AF1ED:
mov rdi, [rsp+98h+var_28]; this
call _ZNK6google8protobuf8internal12MapFieldBase16GetRepeatedFieldEv; google::protobuf::internal::MapFieldBase::GetRepeatedField(void)
mov rdi, rax; this
call _ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv; google::protobuf::internal::RepeatedPtrFieldBase::size(void)
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF20B:
mov rdi, [rsp+98h+var_28]
mov rax, [rdi]
call qword ptr [rax+50h]
mov [rsp+98h+var_4], eax
jmp loc_1AF2C2
loc_1AF222:
mov rdi, [rsp+98h+var_78]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_20]
call _ZNK6google8protobuf10Reflection6GetRawINS0_8internal20RepeatedPtrFieldBaseEEERKT_RKNS0_7MessageEPKNS0_15FieldDescriptorE; google::protobuf::Reflection::GetRaw<google::protobuf::internal::RepeatedPtrFieldBase>(google::protobuf::Message const&,google::protobuf::FieldDescriptor const*)
mov rdi, rax; this
call _ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv; google::protobuf::internal::RepeatedPtrFieldBase::size(void)
mov [rsp+98h+var_4], eax
jmp short loc_1AF2C2
def_1AF057:
lea rdx, aWorkspaceLlm4b_29; jumptable 00000000001AF057 default case
lea rdi, [rsp+98h+var_60]
mov [rsp+98h+var_98], rdi
mov esi, 3
mov ecx, 4C2h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+98h+var_98]
lea rsi, aCanTGetHere; "Can't get here."
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_90], rax
jmp short $+2
loc_1AF280:
mov rsi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_1AF291:
lea rdi, [rsp+98h+var_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov [rsp+98h+var_4], 0
jmp short loc_1AF2C2
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_30]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_1AF2D1
loc_1AF2C2:
mov eax, [rsp+98h+var_4]
add rsp, 98h
retn
loc_1AF2D1:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long google::protobuf::Reflection::FieldSize(
google::protobuf::_anonymous_namespace_ **this,
const google::protobuf::Message *a2,
const google::protobuf::FieldDescriptor *a3)
{
const char *v3; // r8
const google::protobuf::FieldDescriptor *v4; // rdx
const char *v5; // r8
int v6; // eax
int v7; // eax
int v8; // r8d
int v9; // r9d
int v10; // ecx
unsigned int *v11; // rax
unsigned int *v12; // rax
unsigned int *v13; // rax
unsigned int *v14; // rax
unsigned int *v15; // rax
unsigned int *v16; // rax
unsigned int *v17; // rax
int v18; // ecx
int v19; // r8d
int v20; // r9d
google::protobuf::internal::RepeatedPtrFieldBase *RepeatedField; // rax
google::protobuf::internal::RepeatedPtrFieldBase *v22; // rax
google::protobuf::internal::LogMessage *v24; // [rsp+8h] [rbp-90h]
google::protobuf::internal::ExtensionSet *ExtensionSet; // [rsp+18h] [rbp-80h]
_BYTE v26[13]; // [rsp+2Bh] [rbp-6Dh] BYREF
_BYTE v27[56]; // [rsp+38h] [rbp-60h] BYREF
google::protobuf::internal::MapFieldBase *v28; // [rsp+70h] [rbp-28h]
google::protobuf::FieldDescriptor *v29; // [rsp+78h] [rbp-20h]
google::protobuf::Message *v30; // [rsp+80h] [rbp-18h]
google::protobuf::_anonymous_namespace_ **v31; // [rsp+88h] [rbp-10h]
unsigned int v32; // [rsp+94h] [rbp-4h]
v31 = this;
v30 = a2;
v29 = a3;
if ( (google::protobuf::_anonymous_namespace_ *)google::protobuf::FieldDescriptor::containing_type(a3) != *this )
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
*this,
v29,
(const google::protobuf::FieldDescriptor *)"FieldSize",
"Field does not match message type.",
v3);
if ( (unsigned int)google::protobuf::FieldDescriptor::label(v29) != 3 )
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
*this,
v29,
(const google::protobuf::FieldDescriptor *)"FieldSize",
"Field is singular; the method requires a repeated field.",
v5);
google::protobuf::`anonymous namespace'::CheckInvalidAccess(
(google::protobuf::_anonymous_namespace_ *)(this + 1),
v29,
v4);
if ( (google::protobuf::FieldDescriptor::is_extension(v29) & 1) != 0 )
{
ExtensionSet = (google::protobuf::internal::ExtensionSet *)google::protobuf::Reflection::GetExtensionSet(
(google::protobuf::Reflection *)this,
v30);
v6 = google::protobuf::FieldDescriptor::number(v29);
return (unsigned int)google::protobuf::internal::ExtensionSet::ExtensionSize(ExtensionSet, v6);
}
else
{
v7 = google::protobuf::FieldDescriptor::cpp_type(v29);
v10 = v7 - 1;
switch ( v7 )
{
case 1:
case 8:
v11 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<int>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<int>::size(v11);
break;
case 2:
v12 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<long>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<long>::size(v12);
break;
case 3:
v13 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<unsigned int>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<unsigned int>::size(v13);
break;
case 4:
v14 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<unsigned long>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<unsigned long>::size(v14);
break;
case 5:
v15 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<double>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<double>::size(v15);
break;
case 6:
v16 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<float>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<float>::size(v16);
break;
case 7:
v17 = (unsigned int *)google::protobuf::Reflection::GetRaw<google::protobuf::RepeatedField<bool>>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v10,
v8,
v9);
v32 = google::protobuf::RepeatedField<bool>::size(v17);
break;
case 9:
case 10:
if ( (google::protobuf::`anonymous namespace'::IsMapFieldInApi(v29, v29) & 1) != 0 )
{
v28 = (google::protobuf::internal::MapFieldBase *)google::protobuf::Reflection::GetRaw<google::protobuf::internal::MapFieldBase>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v18,
v19,
v20);
if ( (google::protobuf::internal::MapFieldBase::IsRepeatedFieldValid(v28) & 1) != 0 )
{
RepeatedField = (google::protobuf::internal::RepeatedPtrFieldBase *)google::protobuf::internal::MapFieldBase::GetRepeatedField(v28);
v32 = google::protobuf::internal::RepeatedPtrFieldBase::size(RepeatedField);
}
else
{
v32 = (*(long long ( **)(google::protobuf::internal::MapFieldBase *))(*(_QWORD *)v28 + 80LL))(v28);
}
}
else
{
v22 = (google::protobuf::internal::RepeatedPtrFieldBase *)google::protobuf::Reflection::GetRaw<google::protobuf::internal::RepeatedPtrFieldBase>(
(_DWORD)this,
(_DWORD)v30,
(_DWORD)v29,
v18,
v19,
v20);
v32 = google::protobuf::internal::RepeatedPtrFieldBase::size(v22);
}
break;
default:
google::protobuf::internal::LogMessage::LogMessage(
(long long)v27,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_me"
"ssage_reflection.cc",
1218);
v24 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v27,
(long long)"Can't get here.");
google::protobuf::internal::LogFinisher::operator=((long long)v26, v24);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v27);
v32 = 0;
break;
}
}
return v32;
}
| isnan:
MOVSD qword ptr [RSP + -0x8],XMM0
MOVSD XMM0,qword ptr [RSP + -0x8]
UCOMISD XMM0,XMM0
SETP AL
AND AL,0x1
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* std::isnan(double) */
bool std::isnan(double param_1)
{
return NAN(param_1);
}
|
|
1,635 | google::protobuf::Reflection::FieldSize(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*) const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_message_reflection.cc | int Reflection::FieldSize(const Message& message,
const FieldDescriptor* field) const {
USAGE_CHECK_MESSAGE_TYPE(FieldSize);
USAGE_CHECK_REPEATED(FieldSize);
CheckInvalidAccess(schema_, field);
if (field->is_extension()) {
return GetExtensionSet(message).ExtensionSize(field->number());
} else {
switch (field->cpp_type()) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case FieldDescriptor::CPPTYPE_##UPPERCASE: \
return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
HANDLE_TYPE(INT32, int32_t);
HANDLE_TYPE(INT64, int64_t);
HANDLE_TYPE(UINT32, uint32_t);
HANDLE_TYPE(UINT64, uint64_t);
HANDLE_TYPE(DOUBLE, double);
HANDLE_TYPE(FLOAT, float);
HANDLE_TYPE(BOOL, bool);
HANDLE_TYPE(ENUM, int);
#undef HANDLE_TYPE
case FieldDescriptor::CPPTYPE_STRING:
case FieldDescriptor::CPPTYPE_MESSAGE:
if (IsMapFieldInApi(field)) {
const internal::MapFieldBase& map =
GetRaw<MapFieldBase>(message, field);
if (map.IsRepeatedFieldValid()) {
return map.GetRepeatedField().size();
} else {
// No need to materialize the repeated field if it is out of sync:
// its size will be the same as the map's size.
return map.size();
}
} else {
return GetRaw<RepeatedPtrFieldBase>(message, field).size();
}
}
GOOGLE_LOG(FATAL) << "Can't get here.";
return 0;
}
} | O3 | cpp | google::protobuf::Reflection::FieldSize(google::protobuf::Message const&, google::protobuf::FieldDescriptor const*) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
cmpq %rdi, 0x20(%rdx)
je 0x8efbe
leaq 0xd96a3(%rip), %rdx # 0x168652
leaq 0xd95e3(%rip), %rcx # 0x168599
movq %r14, %rsi
callq 0x8ee9e
movb 0x1(%r14), %al
movl %eax, %ecx
notb %cl
testb $0x60, %cl
je 0x8efe8
movq (%r15), %rdi
leaq 0xd967d(%rip), %rdx # 0x168652
leaq 0xd9680(%rip), %rcx # 0x16865c
movq %r14, %rsi
callq 0x8ee9e
movb 0x1(%r14), %al
testb $0x8, %al
jne 0x8f05a
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x8f011
leaq 0x4e158(%rip), %rax # 0xdd154
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
callq 0x97dfb
movzbl 0x2(%r14), %eax
leaq 0xdcce3(%rip), %rcx # 0x16bd00
movl (%rcx,%rax,4), %eax
decl %eax
cmpl $0x9, %eax
ja 0x8f0b8
leaq 0xd91de(%rip), %rcx # 0x168210
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x97f78
movl %eax, %eax
movl (%rbx,%rax), %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x28(%r15), %eax
addq %rax, %rbx
movl 0x4(%r14), %esi
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb32a2
movq %r14, %rdi
callq 0x8d966
movl %eax, %ebp
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x97f78
movl %eax, %eax
addq %rax, %rbx
testb %bpl, %bpl
je 0x8f0b3
movq %rbx, %rdi
callq 0x99f28
testb %al, %al
je 0x8f103
movq %rbx, %rdi
callq 0x99bd4
movl 0x8(%rax), %eax
jmp 0x8f04f
movl 0x8(%rbx), %eax
jmp 0x8f04f
leaq 0xd92f9(%rip), %rdx # 0x1683b8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4c2, %ecx # imm = 0x4C2
callq 0x857c2
leaq 0xd95b8(%rip), %rsi # 0x168695
movq %rbx, %rdi
callq 0x852c0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x10(%rsp), %rdi
callq 0x857e0
xorl %eax, %eax
jmp 0x8f04f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
jmp 0x8f04f
jmp 0x8f113
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x857e0
movq %rbx, %rdi
callq 0x2e220
| _ZNK6google8protobuf10Reflection9FieldSizeERKNS0_7MessageEPKNS0_15FieldDescriptorE:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rdi, [rdi]; this
cmp [rdx+20h], rdi
jz short loc_8EFBE
lea rdx, aFieldsize; "FieldSize"
lea rcx, aFieldDoesNotMa; "Field does not match message type."
mov rsi, r14; google::protobuf::Descriptor *
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
loc_8EFBE:
mov al, [r14+1]
mov ecx, eax
not cl
test cl, 60h
jz short loc_8EFE8
mov rdi, [r15]; this
lea rdx, aFieldsize; "FieldSize"
lea rcx, aFieldIsSingula; "Field is singular; the method requires "...
mov rsi, r14; google::protobuf::Descriptor *
call _ZN6google8protobuf12_GLOBAL__N_126ReportReflectionUsageErrorEPKNS0_10DescriptorEPKNS0_15FieldDescriptorEPKcS9_; google::protobuf::`anonymous namespace'::ReportReflectionUsageError(google::protobuf::Descriptor const*,google::protobuf::FieldDescriptor const*,char const*,char const*)
mov al, [r14+1]
loc_8EFE8:
test al, 8
jnz short loc_8F05A
mov rdi, [r14+18h]
test rdi, rdi
jz short loc_8F011
lea rax, _ZN6google8protobuf15FieldDescriptor12TypeOnceInitEPKS1_; google::protobuf::FieldDescriptor::TypeOnceInit(google::protobuf::FieldDescriptor const*)
lea rsi, [rsp+68h+var_58]; google::protobuf::FieldDescriptor *
mov [rsi], rax
lea rdx, [rsp+68h+var_60]
mov [rdx], r14
call _ZSt9call_onceIPFvPKN6google8protobuf15FieldDescriptorEEJS4_EEvRSt9once_flagOT_DpOT0_; std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(std::once_flag &,void (*)(google::protobuf::FieldDescriptor const*) &&,google::protobuf::FieldDescriptor const* &&)
loc_8F011:
movzx eax, byte ptr [r14+2]
lea rcx, _ZN6google8protobuf15FieldDescriptor17kTypeToCppTypeMapE; google::protobuf::FieldDescriptor::kTypeToCppTypeMap
mov eax, [rcx+rax*4]
dec eax; switch 10 cases
cmp eax, 9
ja def_8F039; jumptable 000000000008F039 default case
lea rcx, jpt_8F039
movsxd rax, ds:(jpt_8F039 - 168210h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8F03B:
add r15, 8; jumptable 000000000008F039 cases 1-8
mov rdi, r15; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*)
mov eax, eax
mov eax, [rbx+rax]
loc_8F04F:
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8F05A:
mov eax, [r15+28h]
add rbx, rax
mov esi, [r14+4]; int
mov rdi, rbx; this
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZNK6google8protobuf8internal12ExtensionSet13ExtensionSizeEi; google::protobuf::internal::ExtensionSet::ExtensionSize(int)
loc_8F077:
mov rdi, r14; jumptable 000000000008F039 cases 9,10
call _ZN6google8protobuf12_GLOBAL__N_115IsMapFieldInApiEPKNS0_15FieldDescriptorE; google::protobuf::`anonymous namespace'::IsMapFieldInApi(google::protobuf::FieldDescriptor const*)
mov ebp, eax
add r15, 8
mov rdi, r15; this
mov rsi, r14; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf8internal16ReflectionSchema14GetFieldOffsetEPKNS0_15FieldDescriptorE; google::protobuf::internal::ReflectionSchema::GetFieldOffset(google::protobuf::FieldDescriptor const*)
mov eax, eax
add rbx, rax
test bpl, bpl
jz short loc_8F0B3
mov rdi, rbx; this
call _ZNK6google8protobuf8internal12MapFieldBase20IsRepeatedFieldValidEv; google::protobuf::internal::MapFieldBase::IsRepeatedFieldValid(void)
test al, al
jz short loc_8F103
mov rdi, rbx; this
call _ZNK6google8protobuf8internal12MapFieldBase16GetRepeatedFieldEv; google::protobuf::internal::MapFieldBase::GetRepeatedField(void)
mov eax, [rax+8]
jmp short loc_8F04F
loc_8F0B3:
mov eax, [rbx+8]
jmp short loc_8F04F
def_8F039:
lea rdx, aWorkspaceLlm4b_21; jumptable 000000000008F039 default case
lea rbx, [rsp+68h+var_58]
mov rdi, rbx
mov esi, 3
mov ecx, 4C2h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCanTGetHere; "Can't get here."
mov rdi, rbx
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+68h+var_60]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+68h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
xor eax, eax
jmp loc_8F04F
loc_8F103:
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+50h]
jmp loc_8F04F
jmp short $+2
loc_8F113:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::Reflection::FieldSize(
google::protobuf::_anonymous_namespace_ **this,
const google::protobuf::Message *a2,
const google::protobuf::FieldDescriptor *a3,
long long a4,
const char *a5)
{
const google::protobuf::Message *v6; // rbx
google::protobuf::_anonymous_namespace_ *v8; // rdi
char v9; // al
long long v10; // rdi
long long result; // rax
char IsMapFieldInApi; // bp
unsigned int *v13; // rbx
google::protobuf::internal::LogMessage *v14; // rax
const google::protobuf::FieldDescriptor *v15; // [rsp+8h] [rbp-60h] BYREF
_QWORD v16[11]; // [rsp+10h] [rbp-58h] BYREF
v6 = a2;
v8 = *this;
if ( *((google::protobuf::_anonymous_namespace_ **)a3 + 4) != v8 )
{
a2 = a3;
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
v8,
a3,
(const google::protobuf::FieldDescriptor *)"FieldSize",
"Field does not match message type.",
a5);
}
v9 = *((_BYTE *)a3 + 1);
if ( (~v9 & 0x60) != 0 )
{
a2 = a3;
google::protobuf::`anonymous namespace'::ReportReflectionUsageError(
*this,
a3,
(const google::protobuf::FieldDescriptor *)"FieldSize",
"Field is singular; the method requires a repeated field.",
a5);
v9 = *((_BYTE *)a3 + 1);
}
if ( (v9 & 8) != 0 )
return google::protobuf::internal::ExtensionSet::ExtensionSize(
(const google::protobuf::Message *)((char *)v6 + *((unsigned int *)this + 10)),
*((_DWORD *)a3 + 1));
v10 = *((_QWORD *)a3 + 3);
if ( v10 )
{
a2 = (const google::protobuf::Message *)v16;
v16[0] = google::protobuf::FieldDescriptor::TypeOnceInit;
v15 = a3;
std::call_once<void (*)(google::protobuf::FieldDescriptor const*),google::protobuf::FieldDescriptor const*>(
v10,
v16);
}
switch ( *((_BYTE *)a3 + 2) )
{
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 0xD:
case 0xE:
case 0xF:
case 0x10:
case 0x11:
case 0x12:
result = *(unsigned int *)((char *)v6
+ (unsigned int)google::protobuf::internal::ReflectionSchema::GetFieldOffset(
(google::protobuf::internal::ReflectionSchema *)(this + 1),
a3));
break;
case 9:
case 0xA:
case 0xB:
case 0xC:
IsMapFieldInApi = google::protobuf::`anonymous namespace'::IsMapFieldInApi(a3, a2);
v13 = (unsigned int *)((char *)v6
+ (unsigned int)google::protobuf::internal::ReflectionSchema::GetFieldOffset(
(google::protobuf::internal::ReflectionSchema *)(this + 1),
a3));
if ( IsMapFieldInApi )
{
if ( (unsigned __int8)google::protobuf::internal::MapFieldBase::IsRepeatedFieldValid((google::protobuf::internal::MapFieldBase *)v13) )
result = *(unsigned int *)(google::protobuf::internal::MapFieldBase::GetRepeatedField((google::protobuf::internal::MapFieldBase *)v13)
+ 8);
else
result = (*(long long ( **)(unsigned int *))(*(_QWORD *)v13 + 80LL))(v13);
}
else
{
result = v13[2];
}
break;
default:
google::protobuf::internal::LogMessage::LogMessage(
(long long)v16,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_mess"
"age_reflection.cc",
1218);
v14 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v16,
(long long)"Can't get here.");
google::protobuf::internal::LogFinisher::operator=((long long)&v15, v14);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v16);
result = 0LL;
break;
}
return result;
}
| FieldSize:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDX + 0x20],RDI
JZ 0x0018efbe
LEA RDX,[0x268652]
LEA RCX,[0x268599]
MOV RSI,R14
CALL 0x0018ee9e
LAB_0018efbe:
MOV AL,byte ptr [R14 + 0x1]
MOV ECX,EAX
NOT CL
TEST CL,0x60
JZ 0x0018efe8
MOV RDI,qword ptr [R15]
LEA RDX,[0x268652]
LEA RCX,[0x26865c]
MOV RSI,R14
CALL 0x0018ee9e
MOV AL,byte ptr [R14 + 0x1]
LAB_0018efe8:
TEST AL,0x8
JNZ 0x0018f05a
MOV RDI,qword ptr [R14 + 0x18]
TEST RDI,RDI
JZ 0x0018f011
LEA RAX,[0x1dd154]
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],R14
CALL 0x00197dfb
LAB_0018f011:
MOVZX EAX,byte ptr [R14 + 0x2]
LEA RCX,[0x26bd00]
MOV EAX,dword ptr [RCX + RAX*0x4]
DEC EAX
CMP EAX,0x9
JA 0x0018f0b8
LEA RCX,[0x268210]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
ADD R15,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x00197f78
MOV EAX,EAX
MOV EAX,dword ptr [RBX + RAX*0x1]
LAB_0018f04f:
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018f05a:
MOV EAX,dword ptr [R15 + 0x28]
ADD RBX,RAX
MOV ESI,dword ptr [R14 + 0x4]
MOV RDI,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001b32a2
caseD_9:
MOV RDI,R14
CALL 0x0018d966
MOV EBP,EAX
ADD R15,0x8
MOV RDI,R15
MOV RSI,R14
CALL 0x00197f78
MOV EAX,EAX
ADD RBX,RAX
TEST BPL,BPL
JZ 0x0018f0b3
MOV RDI,RBX
CALL 0x00199f28
TEST AL,AL
JZ 0x0018f103
MOV RDI,RBX
CALL 0x00199bd4
MOV EAX,dword ptr [RAX + 0x8]
JMP 0x0018f04f
LAB_0018f0b3:
MOV EAX,dword ptr [RBX + 0x8]
JMP 0x0018f04f
default:
LEA RDX,[0x2683b8]
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x3
MOV ECX,0x4c2
CALL 0x001857c2
LAB_0018f0d6:
LEA RSI,[0x268695]
MOV RDI,RBX
CALL 0x001852c0
LAB_0018f0e5:
LEA RDI,[RSP + 0x8]
MOV RSI,RAX
CALL 0x0018539a
LAB_0018f0f2:
LEA RDI,[RSP + 0x10]
CALL 0x001857e0
XOR EAX,EAX
JMP 0x0018f04f
LAB_0018f103:
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x50]
JMP 0x0018f04f
|
/* google::protobuf::Reflection::FieldSize(google::protobuf::Message const&,
google::protobuf::FieldDescriptor const*) const */
ulong __thiscall
google::protobuf::Reflection::FieldSize(Reflection *this,Message *param_1,FieldDescriptor *param_2)
{
FieldDescriptor FVar1;
char cVar2;
uint uVar3;
ulong uVar4;
long lVar5;
LogMessage *pLVar6;
MapFieldBase *this_00;
FieldDescriptor *local_60;
code *local_58 [7];
if (*(Descriptor **)(param_2 + 0x20) != *(Descriptor **)this) {
(anonymous_namespace)::ReportReflectionUsageError
(*(Descriptor **)this,param_2,"FieldSize","Field does not match message type.");
}
FVar1 = param_2[1];
if ((~(byte)FVar1 & 0x60) != 0) {
(anonymous_namespace)::ReportReflectionUsageError
(*(Descriptor **)this,param_2,"FieldSize",
"Field is singular; the method requires a repeated field.");
FVar1 = param_2[1];
}
if (((byte)FVar1 & 8) != 0) {
uVar4 = internal::ExtensionSet::ExtensionSize
((ExtensionSet *)(param_1 + *(uint *)(this + 0x28)),*(int *)(param_2 + 4));
return uVar4;
}
if (*(once_flag **)(param_2 + 0x18) != (once_flag *)0x0) {
local_58[0] = FieldDescriptor::TypeOnceInit;
local_60 = param_2;
std::
call_once<void(*)(google::protobuf::FieldDescriptor_const*),google::protobuf::FieldDescriptor_const*>
(*(once_flag **)(param_2 + 0x18),(_func_void_FieldDescriptor_ptr *)local_58,&local_60)
;
}
switch(*(int4 *)(FieldDescriptor::kTypeToCppTypeMap + (ulong)(byte)param_2[2] * 4)) {
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
uVar3 = internal::ReflectionSchema::GetFieldOffset((ReflectionSchema *)(this + 8),param_2);
uVar4 = (ulong)*(uint *)(param_1 + uVar3);
break;
case 9:
case 10:
cVar2 = (anonymous_namespace)::IsMapFieldInApi(param_2);
uVar3 = internal::ReflectionSchema::GetFieldOffset((ReflectionSchema *)(this + 8),param_2);
this_00 = (MapFieldBase *)(param_1 + uVar3);
if (cVar2 == '\0') {
uVar4 = (ulong)*(uint *)(this_00 + 8);
}
else {
cVar2 = internal::MapFieldBase::IsRepeatedFieldValid(this_00);
if (cVar2 == '\0') {
uVar4 = (**(code **)(*(long *)this_00 + 0x50))(this_00);
}
else {
lVar5 = internal::MapFieldBase::GetRepeatedField(this_00);
uVar4 = (ulong)*(uint *)(lVar5 + 8);
}
}
break;
default:
internal::LogMessage::LogMessage
((LogMessage *)local_58,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/generated_message_reflection.cc"
,0x4c2);
/* try { // try from 0018f0d6 to 0018f0e4 has its CatchHandler @ 0018f113 */
pLVar6 = (LogMessage *)
internal::LogMessage::operator<<((LogMessage *)local_58,"Can\'t get here.");
/* try { // try from 0018f0e5 to 0018f0f1 has its CatchHandler @ 0018f111 */
internal::LogFinisher::operator=((LogFinisher *)&local_60,pLVar6);
internal::LogMessage::~LogMessage((LogMessage *)local_58);
uVar4 = 0;
}
return uVar4;
}
|
|
1,636 | my_mb_wc_sjis | eloqsql/strings/ctype-sjis.c | static int
my_mb_wc_sjis(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) /* ASCII: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= sjis_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208 [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= sjis_to_unicode[(hi << 8) + s[1]]))
return (issjishead(hi) && issjistail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O3 | c | my_mb_wc_sjis:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb6577
movzbl (%rdx), %edi
testb %dil, %dil
js 0xb655d
movq %rdi, (%rsi)
jmp 0xb6572
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0xb6579
leaq 0x16fb25(%rip), %rax # 0x226090
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xb6577
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x16faf6(%rip), %rcx # 0x226090
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xb6577
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0xb6577
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0xb6577
movl $0x0, %eax
testb %cl, %cl
jns 0xb6577
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0xb6577
| my_mb_wc_sjis:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_B6577
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_B655D
mov [rsi], rdi
jmp short loc_B6572
loc_B655D:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_B6579
lea rax, sjis_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_B6572:
mov eax, 1
loc_B6577:
pop rbp
retn
loc_B6579:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_B6577
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, sjis_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_B6577
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_B6577
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_B6577
mov eax, 0
test cl, cl
jns short loc_B6577
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_B6577
| long long my_mb_wc_sjis(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = sjis_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = sjis_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
| my_mb_wc_sjis:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b6577
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001b655d
MOV qword ptr [RSI],RDI
JMP 0x001b6572
LAB_001b655d:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x001b6579
LEA RAX,[0x326090]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_001b6572:
MOV EAX,0x1
LAB_001b6577:
POP RBP
RET
LAB_001b6579:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001b6577
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x326090]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001b6577
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x001b6577
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x001b6577
MOV EAX,0x0
TEST CL,CL
JNS 0x001b6577
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x001b6577
|
int my_mb_wc_sjis(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(sjis_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(sjis_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
|
|
1,637 | psi_cond_timedwait | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_cond_timedwait(mysql_cond_t *that, mysql_mutex_t *mutex,
const struct timespec *abstime,
const char *file, uint line)
{
PSI_cond_locker_state state;
PSI_cond_locker *locker= PSI_COND_CALL(start_cond_wait)
(&state, that->m_psi, mutex->m_psi, PSI_COND_TIMEDWAIT, file, line);
int result= my_cond_timedwait(&that->m_cond, &mutex->m_mutex, abstime);
if (psi_likely(locker))
PSI_COND_CALL(end_cond_wait)(locker, result);
return result;
} | O3 | c | psi_cond_timedwait:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r9d
movq %rcx, %r8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x2cac6e(%rip), %r13 # 0x2ef820
movq (%r13), %rax
movq 0x30(%rdi), %rsi
movq 0x40(%r15), %rdx
leaq -0x60(%rbp), %rdi
pushq $0x1
popq %rcx
callq *0x1c0(%rax)
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24610
movl %eax, %r14d
testq %rbx, %rbx
jne 0x24bf6
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1c8(%rax)
jmp 0x24be4
| psi_cond_timedwait:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r9d, r8d
mov r8, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
lea r13, PSI_server
mov rax, [r13+0]
mov rsi, [rdi+30h]
mov rdx, [r15+40h]
lea rdi, [rbp+var_60]
push 1
pop rcx
call qword ptr [rax+1C0h]
mov rbx, rax
mov rdi, r12
mov rsi, r15
mov rdx, r14
call _pthread_cond_timedwait
mov r14d, eax
test rbx, rbx
jnz short loc_24BF6
loc_24BE4:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_24BF6:
mov rax, [r13+0]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1C8h]
jmp short loc_24BE4
| long long psi_cond_timedwait(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long v6; // rbx
unsigned int v7; // r14d
_BYTE v9[96]; // [rsp+0h] [rbp-60h] BYREF
v6 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, long long, long long, _QWORD))PSI_server[0] + 56))(
v9,
*(_QWORD *)(a1 + 48),
*(_QWORD *)(a2 + 64),
1LL,
a4,
a5);
v7 = pthread_cond_timedwait(a1, a2, a3);
if ( v6 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 57))(v6, v7);
return v7;
}
| psi_cond_timedwait:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R9D,R8D
MOV R8,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LEA R13,[0x3ef820]
MOV RAX,qword ptr [R13]
MOV RSI,qword ptr [RDI + 0x30]
MOV RDX,qword ptr [R15 + 0x40]
LEA RDI,[RBP + -0x60]
PUSH 0x1
POP RCX
CALL qword ptr [RAX + 0x1c0]
MOV RBX,RAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
CALL 0x00124610
MOV R14D,EAX
TEST RBX,RBX
JNZ 0x00124bf6
LAB_00124be4:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00124bf6:
MOV RAX,qword ptr [R13]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1c8]
JMP 0x00124be4
|
int psi_cond_timedwait(pthread_cond_t *param_1,pthread_mutex_t *param_2,timespec *param_3,
int8 param_4,int4 param_5)
{
int iVar1;
long lVar2;
int1 local_68 [56];
lVar2 = (**(code **)(PSI_server + 0x1c0))
(local_68,param_1[1].__align,*(int8 *)((long)param_2 + 0x40),1,param_4,
param_5);
iVar1 = pthread_cond_timedwait(param_1,param_2,param_3);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1c8))(lVar2,iVar1);
}
return iVar1;
}
|
|
1,638 | testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*) | giladroyz[P]FindPeaks/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-printers.h | static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(::std::wstring(str), os);
}
} | O0 | c | testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5b5a9
movq -0x10(%rbp), %rdi
leaq 0x21701(%rip), %rsi # 0x7cca3
callq 0xa600
jmp 0x5b622
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa2c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xa240
jmp 0x5b5d1
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5b640
jmp 0x5b5e0
leaq -0x30(%rbp), %rdi
callq 0xab80
leaq -0x31(%rbp), %rdi
callq 0xac30
jmp 0x5b622
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5b617
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xab80
leaq -0x31(%rbp), %rdi
callq 0xac30
jmp 0x5b628
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xac00
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN7testing8internal21UniversalTersePrinterIPKwE5PrintES3_PSo:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
cmp [rbp+var_8], 0
jnz short loc_5B5A9
mov rdi, [rbp+var_10]
lea rsi, aNull_0; "NULL"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short loc_5B622
loc_5B5A9:
mov rax, [rbp+var_8]
mov [rbp+var_58], rax
lea rdi, [rbp+var_31]
mov [rbp+var_50], rdi
call __ZNSaIwEC1Ev; std::allocator<wchar_t>::allocator(void)
mov rsi, [rbp+var_58]
mov rdx, [rbp+var_50]
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEC1EPKwRKS3_; std::wstring::basic_string(wchar_t const*,std::allocator<wchar_t> const&)
jmp short $+2
loc_5B5D1:
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_30]
call _ZN7testing8internal14UniversalPrintINSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEEEEvRKT_PSo; testing::internal::UniversalPrint<std::wstring>(std::wstring const&,std::ostream *)
jmp short $+2
loc_5B5E0:
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEED1Ev; std::wstring::~wstring()
lea rdi, [rbp+var_31]
call __ZNSaIwED1Ev; std::allocator<wchar_t>::~allocator()
jmp short loc_5B622
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
jmp short loc_5B617
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_30]
call __ZNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEED1Ev; std::wstring::~wstring()
loc_5B617:
lea rdi, [rbp+var_31]
call __ZNSaIwED1Ev; std::allocator<wchar_t>::~allocator()
jmp short loc_5B628
loc_5B622:
add rsp, 60h
pop rbp
retn
loc_5B628:
mov rdi, [rbp+var_40]
call __Unwind_Resume
| long long testing::internal::UniversalTersePrinter<wchar_t const*>::Print(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-58h]
char v4; // [rsp+2Fh] [rbp-31h] BYREF
_BYTE v5[32]; // [rsp+30h] [rbp-30h] BYREF
long long v6; // [rsp+50h] [rbp-10h]
long long v7; // [rsp+58h] [rbp-8h]
v7 = a1;
v6 = a2;
if ( !a1 )
return std::operator<<<std::char_traits<char>>(v6, "NULL");
v3 = v7;
std::allocator<wchar_t>::allocator();
std::wstring::basic_string(v5, v3, &v4);
testing::internal::UniversalPrint<std::wstring>(v5, v6);
std::wstring::~wstring(v5);
return std::allocator<wchar_t>::~allocator(&v4);
}
| Print:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0015b5a9
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x17cca3]
CALL 0x0010a600
JMP 0x0015b622
LAB_0015b5a9:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x58],RAX
LEA RDI,[RBP + -0x31]
MOV qword ptr [RBP + -0x50],RDI
CALL 0x0010a2c0
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x50]
LAB_0015b5c6:
LEA RDI,[RBP + -0x30]
CALL 0x0010a240
JMP 0x0015b5d1
LAB_0015b5d1:
MOV RSI,qword ptr [RBP + -0x10]
LAB_0015b5d5:
LEA RDI,[RBP + -0x30]
CALL 0x0015b640
LAB_0015b5de:
JMP 0x0015b5e0
LAB_0015b5e0:
LEA RDI,[RBP + -0x30]
CALL 0x0010ab80
LEA RDI,[RBP + -0x31]
CALL 0x0010ac30
JMP 0x0015b622
LAB_0015b622:
ADD RSP,0x60
POP RBP
RET
|
/* testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*) */
void testing::internal::UniversalTersePrinter<wchar_t_const*>::Print
(wchar_t *param_1,ostream *param_2)
{
allocator local_39;
wstring local_38 [32];
ostream *local_18;
wchar_t *local_10;
local_18 = param_2;
local_10 = param_1;
if (param_1 == (wchar_t *)0x0) {
std::operator<<(param_2,"NULL");
}
else {
std::allocator<wchar_t>::allocator();
/* try { // try from 0015b5c6 to 0015b5ce has its CatchHandler @ 0015b5f4 */
std::__cxx11::wstring::wstring(local_38,param_1,&local_39);
/* try { // try from 0015b5d5 to 0015b5dd has its CatchHandler @ 0015b602 */
UniversalPrint<std::__cxx11::wstring>(local_38,local_18);
std::__cxx11::wstring::~wstring(local_38);
std::allocator<wchar_t>::~allocator((allocator<wchar_t> *)&local_39);
}
return;
}
|
|
1,639 | SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _generate_union_rule(const std::string & name, const std::vector<json> & alt_schemas) {
std::vector<std::string> rules;
for (size_t i = 0; i < alt_schemas.size(); i++) {
rules.push_back(visit(alt_schemas[i], name + (name.empty() ? "alternative-" : "-") + std::to_string(i)));
}
return string_join(rules, " | ");
} | O1 | cpp | SchemaConverter::_generate_union_rule(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdi, 0x98(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movq (%rcx), %r12
movq %rcx, 0xa0(%rsp)
cmpq %r12, 0x8(%rcx)
je 0xc5a52
leaq 0x50(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x60(%rsp), %r14
movq %rbp, %rbx
movq 0xb0(%rsp), %rcx
movq 0x8(%rcx), %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rcx), %rsi
leaq (%rsi,%rbp), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x232a0
testq %rbp, %rbp
leaq 0x3222d(%rip), %rsi # 0xf7a87
leaq 0x322cf(%rip), %rax # 0xf7b30
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x1c0e0
movl $0x1, %esi
cmpq $0xa, %r13
movq %rbx, %rbp
jb 0xc58ca
movl $0x4, %esi
movq %r13, %rcx
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
cmpq $0x63, %rcx
jbe 0xc58c3
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0xc58c8
cmpq $0x2710, %rcx # imm = 0x2710
jb 0xc58ca
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx # imm = 0x1869F
movq %rdx, %rcx
ja 0xc588d
addl $-0x3, %esi
jmp 0xc58ca
addl $-0x2, %esi
jmp 0xc58ca
decl %esi
movl %esi, %esi
movq %rbp, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0x1ba30
movq 0x40(%rsp), %rdi
movl 0x48(%rsp), %esi
movq %r13, %rdx
callq 0x5e67d
movq (%rsp), %rcx
movl $0xf, %esi
leaq 0x10(%rsp), %rax
cmpq %rax, %rcx
je 0xc5906
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %r8
movq 0x48(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0xc592f
movl $0xf, %esi
cmpq %rbp, 0x40(%rsp)
je 0xc592a
movq 0x50(%rsp), %rsi
cmpq %rsi, %rax
jbe 0xc593e
movq 0x40(%rsp), %rsi
movq %rsp, %rdi
callq 0x1b270
jmp 0xc594c
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1b9e0
leaq 0x30(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0xc5971
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0xc5977
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq %r13, %rax
shlq $0x4, %rax
addq %rax, %r12
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %r14, %rdi
movq 0xa8(%rsp), %rsi
movq %r12, %rdx
leaq 0x20(%rsp), %rcx
callq 0xc2a24
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
leaq 0x30(%rsp), %r12
callq 0x23512
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0xc59e7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc59fe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0xc5a15
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc5a30
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8e0
incq %r13
movq 0xa0(%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
sarq $0x4, %rax
cmpq %rax, %r13
jb 0xc5826
leaq 0x70(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x32285(%rip), %rsi # 0xf7ce7
leaq 0x32281(%rip), %rdx # 0xf7cea
leaq 0x60(%rsp), %rdi
callq 0x233d6
leaq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdx
movq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x73224
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc5aa7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x80(%rsp), %rdi
callq 0x22380
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc5b66
movq 0x70(%rsp), %rsi
jmp 0xc5b5e
jmp 0xc5ae3
movq %rax, %r14
jmp 0xc5b66
jmp 0xc5aea
movq %rax, %r14
jmp 0xc5b4b
movq %rax, %r14
jmp 0xc5b34
movq %rax, %r14
jmp 0xc5b18
movq %rax, %r14
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0xc5b18
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xc5b34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x40(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc5b4b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc5b66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x80(%rsp), %rdi
callq 0x22380
movq %r14, %rdi
callq 0x1bf90
nop
| _ZN15SchemaConverter20_generate_union_ruleERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapES8_S5_blmdSaNSA_14adl_serializerES8_IhSaIhEEvEESaISG_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov [rsp+0E8h+var_38], rdx
mov [rsp+0E8h+var_40], rsi
mov [rsp+0E8h+var_50], rdi
xorps xmm0, xmm0
movaps [rsp+0E8h+var_68], xmm0
mov [rsp+0E8h+var_58], 0
mov r12, [rcx]
mov [rsp+0E8h+var_48], rcx
cmp [rcx+8], r12
jz loc_C5A52
lea rbp, [rsp+0E8h+var_98]
xor r13d, r13d
lea r14, [rsp+0E8h+var_88]
loc_C5826:
mov rbx, rbp
mov rcx, [rsp+0E8h+var_38]
mov rbp, [rcx+8]
lea rax, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_E8], rax
mov rsi, [rcx]
lea rdx, [rsi+rbp]
mov r15, rsp
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
test rbp, rbp
lea rsi, aTuple+5; "-"
lea rax, aAlternative; "alternative-"
cmovz rsi, rax
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov esi, 1
cmp r13, 0Ah
mov rbp, rbx
jb short loc_C58CA
mov esi, 4
mov rcx, r13
mov rdi, 346DC5D63886594Bh
loc_C588D:
cmp rcx, 63h ; 'c'
jbe short loc_C58C3
cmp rcx, 3E7h
jbe short loc_C58C8
cmp rcx, 2710h
jb short loc_C58CA
mov rax, rcx
mul rdi
shr rdx, 0Bh
add esi, 4
cmp rcx, 1869Fh
mov rcx, rdx
ja short loc_C588D
add esi, 0FFFFFFFDh
jmp short loc_C58CA
loc_C58C3:
add esi, 0FFFFFFFEh
jmp short loc_C58CA
loc_C58C8:
dec esi
loc_C58CA:
mov esi, esi
mov [rsp+0E8h+var_A8], rbp
lea rdi, [rsp+0E8h+var_A8]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, [rsp+0E8h+var_A8]
mov esi, dword ptr [rsp+0E8h+var_A0]
mov rdx, r13
call _ZNSt8__detail18__to_chars_10_implImEEvPcjT_; std::__detail::__to_chars_10_impl<ulong>(char *,uint,ulong)
mov rcx, [rsp+0E8h+var_E8]
mov esi, 0Fh
lea rax, [rsp+0E8h+var_D8]
cmp rcx, rax
jz short loc_C5906
mov rsi, [rsp+0E8h+var_D8]
loc_C5906:
mov r8, [rsp+0E8h+var_E0]
mov rdx, [rsp+0E8h+var_A0]
lea rax, [rdx+r8]
cmp rax, rsi
jbe short loc_C592F
mov esi, 0Fh
cmp [rsp+0E8h+var_A8], rbp
jz short loc_C592A
mov rsi, [rsp+0E8h+var_98]
loc_C592A:
cmp rax, rsi
jbe short loc_C593E
loc_C592F:
mov rsi, [rsp+0E8h+var_A8]
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
jmp short loc_C594C
loc_C593E:
lea rdi, [rsp+0E8h+var_A8]
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
loc_C594C:
lea rsi, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_C8], rsi
mov rdx, [rax]
lea rcx, [rax+10h]
cmp rdx, rcx
jz short loc_C5971
mov [rsp+0E8h+var_C8], rdx
mov rdx, [rcx]
mov [rsp+0E8h+var_B8], rdx
jmp short loc_C5977
loc_C5971:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_C5977:
mov rdx, rax
add rdx, 8
mov rsi, [rax+8]
mov [rsp+0E8h+var_C0], rsi
mov [rax], rcx
mov rax, r13
shl rax, 4
add r12, rax
mov qword ptr [rdx], 0
mov byte ptr [rcx], 0
mov rdi, r14
mov rsi, [rsp+0E8h+var_40]
mov rdx, r12
lea rcx, [rsp+0E8h+var_C8]
call _ZN15SchemaConverter5visitERKN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEERKSA_; SchemaConverter::visit(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::string const&)
lea rdi, [rsp+0E8h+var_68]
mov rsi, r14
lea r12, [rsp+0E8h+var_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+0E8h+var_88]; void *
lea rax, [rsp+0E8h+var_78]
cmp rdi, rax
jz short loc_C59E7
mov rsi, [rsp+0E8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C59E7:
mov rdi, [rsp+0E8h+var_C8]; void *
cmp rdi, r12
jz short loc_C59FE
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C59FE:
mov rdi, [rsp+0E8h+var_A8]; void *
cmp rdi, rbp
jz short loc_C5A15
mov rsi, [rsp+0E8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5A15:
mov rdi, [rsp+0E8h+var_E8]; void *
lea rax, [rsp+0E8h+var_D8]
cmp rdi, rax
jz short loc_C5A30
mov rsi, [rsp+0E8h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5A30:
inc r13
mov rax, [rsp+0E8h+var_48]
mov r12, [rax]
mov rax, [rax+8]
sub rax, r12
sar rax, 4
cmp r13, rax
jb loc_C5826
loc_C5A52:
lea rbx, [rsp+0E8h+var_78]
mov [rbx-10h], rbx
lea rsi, asc_F7CE6+1; " | "
lea rdx, asc_F7CE6+4; ""
lea rdi, [rsp+0E8h+var_88]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, [rsp+0E8h+var_68]
lea rdx, [rsp+0E8h+var_88]
mov r14, [rsp+0E8h+var_50]
mov rdi, r14
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
mov rdi, [rsp+0E8h+var_88]; void *
cmp rdi, rbx
jz short loc_C5AA7
mov rsi, [rsp+0E8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5AA7:
lea rdi, [rsp+0E8h+var_68]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, r14
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [rsp+arg_58]
cmp rdi, rbx
jz loc_C5B66
mov rsi, [rsp+arg_68]
jmp short loc_C5B5E
jmp short $+2
loc_C5AE3:
mov r14, rax
jmp short loc_C5B66
jmp short $+2
loc_C5AEA:
mov r14, rax
jmp short loc_C5B4B
mov r14, rax
jmp short loc_C5B34
mov r14, rax
jmp short loc_C5B18
mov r14, rax
mov rdi, [rsp+arg_58]; void *
lea rax, [rsp+arg_68]
cmp rdi, rax
jz short loc_C5B18
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5B18:
mov rdi, [rsp+arg_18]; void *
lea rax, [rsp+arg_28]
cmp rdi, rax
jz short loc_C5B34
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5B34:
mov rdi, [rsp+arg_38]; void *
cmp rdi, rbx
jz short loc_C5B4B
mov rsi, [rsp+arg_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5B4B:
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_C5B66
mov rsi, [rsp+arg_8]
loc_C5B5E:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5B66:
lea rdi, [rsp+arg_78]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long SchemaConverter::_generate_union_rule(long long a1, long long a2, long long a3, long long *a4)
{
__m128d v4; // xmm0
long long v5; // r12
unsigned long long *v6; // rbp
unsigned long long v7; // r13
unsigned long long *v8; // rbx
long long v9; // rbp
char *v10; // rsi
unsigned int v11; // esi
unsigned long long v12; // rcx
bool v13; // cc
unsigned long long v14; // rsi
unsigned long long v15; // rsi
void **v16; // rax
__m128d *v17; // rcx
long long v18; // r14
void *v20; // [rsp+0h] [rbp-E8h] BYREF
long long v21; // [rsp+8h] [rbp-E0h]
_QWORD v22[2]; // [rsp+10h] [rbp-D8h] BYREF
void *v23[2]; // [rsp+20h] [rbp-C8h] BYREF
__m128d v24; // [rsp+30h] [rbp-B8h] BYREF
void *v25; // [rsp+40h] [rbp-A8h] BYREF
long long v26; // [rsp+48h] [rbp-A0h]
unsigned long long v27; // [rsp+50h] [rbp-98h] BYREF
void *v28[2]; // [rsp+60h] [rbp-88h] BYREF
_QWORD v29[2]; // [rsp+70h] [rbp-78h] BYREF
__int128 v30; // [rsp+80h] [rbp-68h] BYREF
long long v31; // [rsp+90h] [rbp-58h]
long long v32; // [rsp+98h] [rbp-50h]
long long *v33; // [rsp+A0h] [rbp-48h]
long long v34; // [rsp+A8h] [rbp-40h]
long long v35; // [rsp+B0h] [rbp-38h]
v35 = a3;
v34 = a2;
v32 = a1;
v4 = 0LL;
v30 = 0LL;
v31 = 0LL;
v5 = *a4;
v33 = a4;
if ( a4[1] != v5 )
{
v6 = &v27;
v7 = 0LL;
do
{
v8 = v6;
v9 = *(_QWORD *)(v35 + 8);
v20 = v22;
std::string::_M_construct<char *>(&v20, *(_BYTE **)v35, *(_QWORD *)v35 + v9);
v10 = "-";
if ( !v9 )
v10 = "alternative-";
std::string::append(&v20, v10);
v11 = 1;
v6 = v8;
if ( v7 >= 0xA )
{
v11 = 4;
v12 = v7;
while ( 1 )
{
if ( v12 <= 0x63 )
{
v11 -= 2;
goto LABEL_14;
}
if ( v12 <= 0x3E7 )
break;
if ( v12 < 0x2710 )
goto LABEL_14;
v11 += 4;
v13 = v12 <= 0x1869F;
v12 /= 0x2710uLL;
if ( v13 )
{
v11 -= 3;
goto LABEL_14;
}
}
--v11;
}
LABEL_14:
v25 = v8;
std::string::_M_construct(&v25, v11, 0LL);
std::__detail::__to_chars_10_impl<unsigned long>((char *)v25, v26, v7);
v14 = 15LL;
if ( v20 != v22 )
v14 = v22[0];
if ( v26 + v21 <= v14 )
goto LABEL_20;
v15 = 15LL;
if ( v25 != v8 )
v15 = v27;
if ( v26 + v21 <= v15 )
v16 = (void **)std::string::replace(&v25, 0LL, 0LL, v20, v21);
else
LABEL_20:
v16 = (void **)std::string::_M_append(&v20, v25, v26);
v23[0] = &v24;
v17 = (__m128d *)(v16 + 2);
if ( *v16 == v16 + 2 )
{
v4 = *v17;
v24 = *v17;
}
else
{
v23[0] = *v16;
v24.m128d_f64[0] = v17->m128d_f64[0];
}
v23[1] = v16[1];
*v16 = v17;
v16[1] = 0LL;
LOBYTE(v17->m128d_f64[0]) = 0;
SchemaConverter::visit(v28, v34, (unsigned __int8 *)(16 * v7 + v5), v23, v4);
std::vector<std::string>::emplace_back<std::string>((long long)&v30, (long long)v28);
if ( v28[0] != v29 )
operator delete(v28[0], v29[0] + 1LL);
if ( v23[0] != &v24 )
operator delete(v23[0], *(_QWORD *)&v24.m128d_f64[0] + 1LL);
if ( v25 != v8 )
operator delete(v25, v27 + 1);
if ( v20 != v22 )
operator delete(v20, v22[0] + 1LL);
++v7;
v5 = *v33;
}
while ( v7 < (v33[1] - *v33) >> 4 );
}
v28[0] = v29;
std::string::_M_construct<char const*>(v28, " | ", (long long)"");
v18 = v32;
string_join(v32, &v30, v28);
if ( v28[0] != v29 )
operator delete(v28[0], v29[0] + 1LL);
std::vector<std::string>::~vector(&v30);
return v18;
}
| _generate_union_rule:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0x98],RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x90],0x0
MOV R12,qword ptr [RCX]
MOV qword ptr [RSP + 0xa0],RCX
CMP qword ptr [RCX + 0x8],R12
JZ 0x001c5a52
LEA RBP,[RSP + 0x50]
XOR R13D,R13D
LEA R14,[RSP + 0x60]
LAB_001c5826:
MOV RBX,RBP
MOV RCX,qword ptr [RSP + 0xb0]
MOV RBP,qword ptr [RCX + 0x8]
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RCX]
LEA RDX,[RSI + RBP*0x1]
LAB_001c5845:
MOV R15,RSP
MOV RDI,R15
CALL 0x001232a0
TEST RBP,RBP
LEA RSI,[0x1f7a87]
LEA RAX,[0x1f7b30]
CMOVZ RSI,RAX
LAB_001c5865:
MOV RDI,R15
CALL 0x0011c0e0
MOV ESI,0x1
CMP R13,0xa
MOV RBP,RBX
JC 0x001c58ca
MOV ESI,0x4
MOV RCX,R13
MOV RDI,0x346dc5d63886594b
LAB_001c588d:
CMP RCX,0x63
JBE 0x001c58c3
CMP RCX,0x3e7
JBE 0x001c58c8
CMP RCX,0x2710
JC 0x001c58ca
MOV RAX,RCX
MUL RDI
SHR RDX,0xb
ADD ESI,0x4
CMP RCX,0x1869f
MOV RCX,RDX
JA 0x001c588d
ADD ESI,-0x3
JMP 0x001c58ca
LAB_001c58c3:
ADD ESI,-0x2
JMP 0x001c58ca
LAB_001c58c8:
DEC ESI
LAB_001c58ca:
MOV ESI,ESI
MOV qword ptr [RSP + 0x40],RBP
LAB_001c58d1:
LEA RDI,[RSP + 0x40]
XOR EDX,EDX
CALL 0x0011ba30
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x48]
MOV RDX,R13
CALL 0x0015e67d
MOV RCX,qword ptr [RSP]
MOV ESI,0xf
LEA RAX,[RSP + 0x10]
CMP RCX,RAX
JZ 0x001c5906
MOV RSI,qword ptr [RSP + 0x10]
LAB_001c5906:
MOV R8,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x48]
LEA RAX,[RDX + R8*0x1]
CMP RAX,RSI
JBE 0x001c592f
MOV ESI,0xf
CMP qword ptr [RSP + 0x40],RBP
JZ 0x001c592a
MOV RSI,qword ptr [RSP + 0x50]
LAB_001c592a:
CMP RAX,RSI
JBE 0x001c593e
LAB_001c592f:
MOV RSI,qword ptr [RSP + 0x40]
LAB_001c5934:
MOV RDI,RSP
CALL 0x0011b270
JMP 0x001c594c
LAB_001c593e:
LEA RDI,[RSP + 0x40]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011b9e0
LAB_001c594c:
LEA RSI,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RSI
MOV RDX,qword ptr [RAX]
LEA RCX,[RAX + 0x10]
CMP RDX,RCX
JZ 0x001c5971
MOV qword ptr [RSP + 0x20],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x30],RDX
JMP 0x001c5977
LAB_001c5971:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_001c5977:
MOV RDX,RAX
ADD RDX,0x8
MOV RSI,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RAX],RCX
MOV RAX,R13
SHL RAX,0x4
ADD R12,RAX
MOV qword ptr [RDX],0x0
MOV byte ptr [RCX],0x0
LAB_001c599e:
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,R12
LEA RCX,[RSP + 0x20]
CALL 0x001c2a24
LAB_001c59b6:
LEA RDI,[RSP + 0x80]
MOV RSI,R14
LEA R12,[RSP + 0x30]
CALL 0x00123512
MOV RDI,qword ptr [RSP + 0x60]
LEA RAX,[RSP + 0x70]
CMP RDI,RAX
JZ 0x001c59e7
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011b8e0
LAB_001c59e7:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R12
JZ 0x001c59fe
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011b8e0
LAB_001c59fe:
MOV RDI,qword ptr [RSP + 0x40]
CMP RDI,RBP
JZ 0x001c5a15
MOV RSI,qword ptr [RSP + 0x50]
INC RSI
CALL 0x0011b8e0
LAB_001c5a15:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001c5a30
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b8e0
LAB_001c5a30:
INC R13
MOV RAX,qword ptr [RSP + 0xa0]
MOV R12,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,R12
SAR RAX,0x4
CMP R13,RAX
JC 0x001c5826
LAB_001c5a52:
LEA RBX,[RSP + 0x70]
MOV qword ptr [RBX + -0x10],RBX
LAB_001c5a5b:
LEA RSI,[0x1f7ce7]
LEA RDX,[0x1f7cea]
LEA RDI,[RSP + 0x60]
CALL 0x001233d6
LAB_001c5a73:
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x60]
MOV R14,qword ptr [RSP + 0x98]
MOV RDI,R14
CALL 0x00173224
LAB_001c5a90:
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,RBX
JZ 0x001c5aa7
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x0011b8e0
LAB_001c5aa7:
LEA RDI,[RSP + 0x80]
CALL 0x00122380
MOV RAX,R14
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* SchemaConverter::_generate_union_rule(std::__cxx11::string const&,
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > const&) */
vector * SchemaConverter::_generate_union_rule(string *param_1,vector *param_2)
{
long *plVar1;
ulong uVar2;
bool bVar3;
string *psVar4;
char cVar5;
int8 *puVar6;
long *in_RCX;
ulong uVar7;
long *in_RDX;
char cVar8;
ulong uVar9;
ulong *local_e8;
long local_e0;
ulong local_d8 [2];
long *local_c8;
int8 local_c0;
long local_b8;
int8 uStack_b0;
ulong *local_a8;
uint local_a0;
int4 uStack_9c;
ulong local_98 [2];
long *local_88 [2];
long local_78 [2];
int8 local_68;
int8 uStack_60;
int8 local_58;
string *local_50;
long *local_48;
vector *local_40;
long *local_38;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
local_50 = param_1;
local_40 = param_2;
if (in_RCX[1] != *in_RCX) {
uVar9 = 0;
local_48 = in_RCX;
local_38 = in_RDX;
do {
local_e8 = local_d8;
/* try { // try from 001c5845 to 001c584f has its CatchHandler @ 001c5ae3 */
std::__cxx11::string::_M_construct<char*>(&local_e8,*local_38,*local_38 + local_38[1]);
/* try { // try from 001c5865 to 001c586c has its CatchHandler @ 001c5ae8 */
std::__cxx11::string::append((char *)&local_e8);
cVar8 = '\x01';
if (9 < uVar9) {
uVar7 = uVar9;
cVar5 = '\x04';
do {
cVar8 = cVar5;
if (uVar7 < 100) {
cVar8 = cVar8 + -2;
goto LAB_001c58ca;
}
if (uVar7 < 1000) {
cVar8 = cVar8 + -1;
goto LAB_001c58ca;
}
if (uVar7 < 10000) goto LAB_001c58ca;
bVar3 = 99999 < uVar7;
uVar7 = uVar7 / 10000;
cVar5 = cVar8 + '\x04';
} while (bVar3);
cVar8 = cVar8 + '\x01';
}
LAB_001c58ca:
/* try { // try from 001c58d1 to 001c58dc has its CatchHandler @ 001c5aea */
local_a8 = local_98;
std::__cxx11::string::_M_construct((ulong)&local_a8,cVar8);
std::__detail::__to_chars_10_impl<unsigned_long>((char *)local_a8,local_a0,uVar9);
uVar7 = 0xf;
if (local_e8 != local_d8) {
uVar7 = local_d8[0];
}
uVar2 = CONCAT44(uStack_9c,local_a0) + local_e0;
if (uVar7 < uVar2) {
uVar7 = 0xf;
if (local_a8 != local_98) {
uVar7 = local_98[0];
}
if (uVar7 < uVar2) goto LAB_001c592f;
puVar6 = (int8 *)
std::__cxx11::string::replace((ulong)&local_a8,0,(char *)0x0,(ulong)local_e8);
}
else {
LAB_001c592f:
/* try { // try from 001c5934 to 001c594b has its CatchHandler @ 001c5aef */
puVar6 = (int8 *)std::__cxx11::string::_M_append((char *)&local_e8,(ulong)local_a8);
}
local_c8 = &local_b8;
plVar1 = puVar6 + 2;
if ((long *)*puVar6 == plVar1) {
local_b8 = *plVar1;
uStack_b0 = puVar6[3];
}
else {
local_b8 = *plVar1;
local_c8 = (long *)*puVar6;
}
local_c0 = puVar6[1];
*puVar6 = plVar1;
puVar6[1] = 0;
*(int1 *)plVar1 = 0;
/* try { // try from 001c599e to 001c59b5 has its CatchHandler @ 001c5af4 */
visit((basic_json *)local_88,(string *)local_40);
/* try { // try from 001c59b6 to 001c59ca has its CatchHandler @ 001c5af9 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68,
(string *)local_88);
if (local_88[0] != local_78) {
operator_delete(local_88[0],local_78[0] + 1);
}
if (local_c8 != &local_b8) {
operator_delete(local_c8,local_b8 + 1);
}
if (local_a8 != local_98) {
operator_delete(local_a8,local_98[0] + 1);
}
if (local_e8 != local_d8) {
operator_delete(local_e8,local_d8[0] + 1);
}
uVar9 = uVar9 + 1;
} while (uVar9 < (ulong)(local_48[1] - *local_48 >> 4));
}
/* try { // try from 001c5a5b to 001c5a72 has its CatchHandler @ 001c5ae1 */
local_88[0] = local_78;
std::__cxx11::string::_M_construct<char_const*>(local_88,&DAT_001f7ce7,&DAT_001f7cea);
psVar4 = local_50;
/* try { // try from 001c5a73 to 001c5a8f has its CatchHandler @ 001c5ac9 */
string_join((vector *)local_50,(string *)&local_68);
if (local_88[0] != local_78) {
operator_delete(local_88[0],local_78[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
return (vector *)psVar4;
}
|
|
1,640 | ma_block_start_trans_no_versioning | eloqsql/storage/maria/ma_state.c | my_bool _ma_block_start_trans_no_versioning(void* param)
{
MARIA_HA *info=(MARIA_HA*) param;
DBUG_ENTER("_ma_block_start_trans_no_versioning");
DBUG_ASSERT(info->s->base.born_transactional && !info->s->lock_key_trees);
info->state->changed= 0; /* from _ma_reset_update_flag() */
info->state= info->state_start;
*info->state= info->s->state.state;
if (!info->trn)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
*/
DBUG_RETURN(maria_create_trn_hook(info));
}
DBUG_RETURN(0);
} | O0 | c | ma_block_start_trans_no_versioning:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x37186
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movb 0x34(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x34(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
movl $0x38, %edx
callq 0x2a090
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x371e9
jmp 0x371d4
leaq 0x4409fd(%rip), %rax # 0x477bd8
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movb %al, -0x1(%rbp)
jmp 0x371ef
jmp 0x371eb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_block_start_trans_no_versioning:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
jmp short $+2
loc_37186:
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov cl, [rax+34h]
and cl, 0FEh
or cl, 0
mov [rax+34h], cl
mov rax, [rbp+var_18]
mov rcx, [rax+60h]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
mov rax, [rbp+var_18]
mov rsi, [rax]
add rsi, 18h
mov edx, 38h ; '8'
call _memcpy
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jnz short loc_371E9
jmp short $+2
loc_371D4:
lea rax, maria_create_trn_hook
mov rax, [rax]
mov rdi, [rbp+var_18]
call rax
mov [rbp+var_1], al
jmp short loc_371EF
loc_371E9:
jmp short $+2
loc_371EB:
mov [rbp+var_1], 0
loc_371EF:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_block_start_trans_no_versioning(_QWORD *a1)
{
*(_BYTE *)(a1[4] + 52LL) &= ~1u;
a1[4] = a1[12];
memcpy(a1[4], *a1 + 24LL, 56LL);
if ( a1[1] )
return 0;
else
return maria_create_trn_hook(a1);
}
| _ma_block_start_trans_no_versioning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00137186
LAB_00137186:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV CL,byte ptr [RAX + 0x34]
AND CL,0xfe
OR CL,0x0
MOV byte ptr [RAX + 0x34],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
ADD RSI,0x18
MOV EDX,0x38
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x001371e9
JMP 0x001371d4
LAB_001371d4:
LEA RAX,[0x577bd8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
MOV byte ptr [RBP + -0x1],AL
JMP 0x001371ef
LAB_001371e9:
JMP 0x001371eb
LAB_001371eb:
MOV byte ptr [RBP + -0x1],0x0
LAB_001371ef:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_block_start_trans_no_versioning(long *param_1)
{
int1 local_9;
*(byte *)(param_1[4] + 0x34) = *(byte *)(param_1[4] + 0x34) & 0xfe;
param_1[4] = param_1[0xc];
memcpy((void *)param_1[4],(void *)(*param_1 + 0x18),0x38);
if (param_1[1] == 0) {
local_9 = (*maria_create_trn_hook)(param_1);
}
else {
local_9 = 0;
}
return local_9;
}
|
|
1,641 | YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test() | yoga-mod/tests/YGComputedPaddingTest.cpp | TEST(YogaTest, padding_side_overrides_horizontal_and_vertical) {
const std::array<YGEdge, 6> edges = {
{YGEdgeTop,
YGEdgeBottom,
YGEdgeStart,
YGEdgeEnd,
YGEdgeLeft,
YGEdgeRight}};
for (float edgeValue = 0; edgeValue < 2; ++edgeValue) {
for (const auto& edge : edges) {
YGEdge horizontalOrVertical = edge == YGEdgeTop || edge == YGEdgeBottom
? YGEdgeVertical
: YGEdgeHorizontal;
YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetPadding(root, horizontalOrVertical, 10);
YGNodeStyleSetPadding(root, edge, edgeValue);
YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
ASSERT_FLOAT_EQ(edgeValue, YGNodeLayoutGetPadding(root, edge));
YGNodeFreeRecursive(root);
}
}
} | O0 | cpp | YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x704850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN60YogaTest_padding_side_overrides_horizontal_and_vertical_TestD2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
call _ZN7testing4TestD2Ev; testing::Test::~Test()
add rsp, 10h
pop rbp
retn
| void YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test(
YogaTest_padding_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test(this);
}
| ~YogaTest_padding_side_overrides_horizontal_and_vertical_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00804850
ADD RSP,0x10
POP RBP
RET
|
/* YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test()
*/
void __thiscall
YogaTest_padding_side_overrides_horizontal_and_vertical_Test::
~YogaTest_padding_side_overrides_horizontal_and_vertical_Test
(YogaTest_padding_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test((Test *)this);
return;
}
|
|
1,642 | YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test() | yoga-mod/tests/YGComputedPaddingTest.cpp | TEST(YogaTest, padding_side_overrides_horizontal_and_vertical) {
const std::array<YGEdge, 6> edges = {
{YGEdgeTop,
YGEdgeBottom,
YGEdgeStart,
YGEdgeEnd,
YGEdgeLeft,
YGEdgeRight}};
for (float edgeValue = 0; edgeValue < 2; ++edgeValue) {
for (const auto& edge : edges) {
YGEdge horizontalOrVertical = edge == YGEdgeTop || edge == YGEdgeBottom
? YGEdgeVertical
: YGEdgeHorizontal;
YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetPadding(root, horizontalOrVertical, 10);
YGNodeStyleSetPadding(root, edge, edgeValue);
YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
ASSERT_FLOAT_EQ(edgeValue, YGNodeLayoutGetPadding(root, edge));
YGNodeFreeRecursive(root);
}
}
} | O3 | cpp | YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test():
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x381548
movl $0x10, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32440
nop
| _ZN60YogaTest_padding_side_overrides_horizontal_and_vertical_TestD0Ev:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _ZN7testing4TestD2Ev; testing::Test::~Test()
mov esi, 10h; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop rbp
jmp __ZdlPvm; operator delete(void *,ulong)
| void YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test(
YogaTest_padding_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test(this);
operator delete(this, 0x10uLL);
}
| ~YogaTest_padding_side_overrides_horizontal_and_vertical_Test:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00481548
MOV ESI,0x10
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00132440
|
/* YogaTest_padding_side_overrides_horizontal_and_vertical_Test::~YogaTest_padding_side_overrides_horizontal_and_vertical_Test()
*/
void __thiscall
YogaTest_padding_side_overrides_horizontal_and_vertical_Test::
~YogaTest_padding_side_overrides_horizontal_and_vertical_Test
(YogaTest_padding_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test((Test *)this);
operator_delete(this,0x10);
return;
}
|
|
1,643 | ma_check_if_right_bitmap_type | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_check_if_right_bitmap_type(MARIA_HA *info,
enum en_page_type page_type,
pgcache_page_no_t page,
uint *bitmap_pattern)
{
if ((*bitmap_pattern= _ma_bitmap_get_page_bits(info, &info->s->bitmap,
page)) > 7)
return 1; /* Couldn't read page */
switch (page_type) {
case HEAD_PAGE:
return *bitmap_pattern < 1 || *bitmap_pattern > 4;
case TAIL_PAGE:
return *bitmap_pattern < 5;
case BLOB_PAGE:
return *bitmap_pattern != 7;
default:
break;
}
DBUG_ASSERT(0);
return 1;
} | O3 | c | ma_check_if_right_bitmap_type:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %esi, %ebx
movl $0xa10, %esi # imm = 0xA10
addq (%rdi), %rsi
callq 0x53e99
movl %eax, %ecx
movl %eax, (%r14)
movb $0x1, %al
cmpl $0x7, %ecx
ja 0x5493c
cmpl $0x3, %ebx
je 0x54936
cmpl $0x2, %ebx
je 0x5492e
cmpl $0x1, %ebx
jne 0x5493c
addl $-0x5, %ecx
cmpl $-0x4, %ecx
jmp 0x54931
cmpl $0x5, %ecx
setb %al
jmp 0x5493c
cmpl $0x7, %ecx
setne %al
popq %rbx
popq %r14
popq %rbp
retq
| _ma_check_if_right_bitmap_type:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rcx
mov ebx, esi
mov esi, 0A10h
add rsi, [rdi]
call _ma_bitmap_get_page_bits
mov ecx, eax
mov [r14], eax
mov al, 1
cmp ecx, 7
ja short loc_5493C
cmp ebx, 3
jz short loc_54936
cmp ebx, 2
jz short loc_5492E
cmp ebx, 1
jnz short loc_5493C
add ecx, 0FFFFFFFBh
cmp ecx, 0FFFFFFFCh
jmp short loc_54931
loc_5492E:
cmp ecx, 5
loc_54931:
setb al
jmp short loc_5493C
loc_54936:
cmp ecx, 7
setnz al
loc_5493C:
pop rbx
pop r14
pop rbp
retn
| char ma_check_if_right_bitmap_type(long long *a1, int a2, unsigned long long a3, unsigned int *a4)
{
unsigned int page_bits; // ecx
char result; // al
page_bits = ma_bitmap_get_page_bits(a1, (_QWORD *)(*a1 + 2576), a3);
*a4 = page_bits;
result = 1;
if ( page_bits <= 7 )
{
switch ( a2 )
{
case 3:
return page_bits != 7;
case 2:
return page_bits < 5;
case 1:
return page_bits - 5 < 0xFFFFFFFC;
default:
return result;
}
}
return result;
}
| _ma_check_if_right_bitmap_type:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RCX
MOV EBX,ESI
MOV ESI,0xa10
ADD RSI,qword ptr [RDI]
CALL 0x00153e99
MOV ECX,EAX
MOV dword ptr [R14],EAX
MOV AL,0x1
CMP ECX,0x7
JA 0x0015493c
CMP EBX,0x3
JZ 0x00154936
CMP EBX,0x2
JZ 0x0015492e
CMP EBX,0x1
JNZ 0x0015493c
ADD ECX,-0x5
CMP ECX,-0x4
JMP 0x00154931
LAB_0015492e:
CMP ECX,0x5
LAB_00154931:
SETC AL
JMP 0x0015493c
LAB_00154936:
CMP ECX,0x7
SETNZ AL
LAB_0015493c:
POP RBX
POP R14
POP RBP
RET
|
bool _ma_check_if_right_bitmap_type(long *param_1,int param_2,int8 param_3,uint *param_4)
{
uint uVar1;
bool bVar2;
uVar1 = _ma_bitmap_get_page_bits(param_1,*param_1 + 0xa10);
*param_4 = uVar1;
bVar2 = true;
if (uVar1 < 8) {
if (param_2 == 3) {
bVar2 = uVar1 != 7;
}
else if (param_2 == 2) {
bVar2 = uVar1 < 5;
}
else {
if (param_2 != 1) {
return true;
}
bVar2 = uVar1 - 5 < 0xfffffffc;
}
}
return bVar2;
}
|
|
1,644 | my_wc_mb_eucjpms | eloqsql/strings/ctype-eucjpms.c | static int
my_wc_mb_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjpms[wc])) /* JIS-X-0208 MS */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjpms[wc])) /* JIS-X-0212 MS */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
} | O0 | c | my_wc_mb_eucjpms:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x7377d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x73765
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x738a5
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x738a5
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x73793
movl $0x0, -0x4(%rbp)
jmp 0x738a5
movq -0x18(%rbp), %rcx
leaq 0x1fd912(%rip), %rax # 0x2710b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x737ef
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x737c4
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x738a5
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x738a5
movq -0x18(%rbp), %rcx
leaq 0x21d8b6(%rip), %rax # 0x2910b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x73850
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x73820
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x738a5
movq -0x20(%rbp), %rax
movb $-0x71, (%rax)
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x738a5
cmpq $0xff61, -0x18(%rbp) # imm = 0xFF61
jb 0x7389e
cmpq $0xff9f, -0x18(%rbp) # imm = 0xFF9F
ja 0x7389e
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x7387b
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x738a5
movq -0x20(%rbp), %rax
movb $-0x72, (%rax)
movq -0x18(%rbp), %rax
subq $0xfec0, %rax # imm = 0xFEC0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x738a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_wc_mb_eucjpms:
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_18]
cmp eax, 80h
jge short loc_7377D
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_73765
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_738A5
loc_73765:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_738A5
loc_7377D:
cmp [rbp+var_18], 0FFFFh
jbe short loc_73793
mov [rbp+var_4], 0
jmp loc_738A5
loc_73793:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0208_eucjpms
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_737EF
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_737C4
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_738A5
loc_737C4:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
jmp loc_738A5
loc_737EF:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0212_eucjpms
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_73850
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_73820
mov [rbp+var_4], 0FFFFFF99h
jmp loc_738A5
loc_73820:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Fh
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov [rbp+var_4], 3
jmp short loc_738A5
loc_73850:
cmp [rbp+var_18], 0FF61h
jb short loc_7389E
cmp [rbp+var_18], 0FF9Fh
ja short loc_7389E
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_7387B
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_738A5
loc_7387B:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Eh
mov rax, [rbp+var_18]
sub rax, 0FEC0h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
jmp short loc_738A5
loc_7389E:
mov [rbp+var_4], 0
loc_738A5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_eucjpms(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
__int16 v5; // [rsp+0h] [rbp-2Ch]
__int16 v6; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjpms[a2];
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
v6 = unicode_to_jisx0212_eucjpms[a2];
if ( v6 )
{
if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = -113;
a3[1] = HIBYTE(v6);
a3[2] = v6;
return 3;
}
else
{
return (unsigned int)-103;
}
}
else if ( a2 < 0xFF61 || a2 > 0xFF9F )
{
return 0;
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = -114;
a3[1] = a2 + 64;
return 2;
}
else
{
return (unsigned int)-102;
}
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_eucjpms:
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 + -0x18]
CMP EAX,0x80
JGE 0x0017377d
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x00173765
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001738a5
LAB_00173765:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001738a5
LAB_0017377d:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x00173793
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001738a5
LAB_00173793:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x3710b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x001737ef
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001737c4
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001738a5
LAB_001737c4:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001738a5
LAB_001737ef:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x3910b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x00173850
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00173820
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x001738a5
LAB_00173820:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8f
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001738a5
LAB_00173850:
CMP qword ptr [RBP + -0x18],0xff61
JC 0x0017389e
CMP qword ptr [RBP + -0x18],0xff9f
JA 0x0017389e
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0017387b
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001738a5
LAB_0017387b:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8e
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0xfec0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001738a5
LAB_0017389e:
MOV dword ptr [RBP + -0x4],0x0
LAB_001738a5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_eucjpms(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
short sVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_2 < 0x10000) {
sVar1 = *(short *)(unicode_to_jisx0208_eucjpms + param_2 * 2);
if (sVar1 == 0) {
sVar1 = *(short *)(unicode_to_jisx0212_eucjpms + param_2 * 2);
if (sVar1 == 0) {
if ((param_2 < 0xff61) || (0xff9f < param_2)) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = -0x72;
param_3[1] = (char)param_2 + '@';
local_c = 2;
}
}
else if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = -0x71;
param_3[1] = (char)((ushort)sVar1 >> 8);
param_3[2] = (char)sVar1;
local_c = 3;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((ushort)sVar1 >> 8);
param_3[1] = (char)sVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
1,645 | blst_p1_mult | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/e1.c | void blst_p1_mult(POINTonE1 *out, const POINTonE1 *a,
const byte *scalar, size_t nbits)
{
if (nbits < 176) {
if (nbits)
POINTonE1_mult_w4(out, a, scalar, nbits);
else
vec_zero(out, sizeof(*out));
} else if (nbits <= 256) {
union { vec256 l; pow256 s; } val;
size_t i, j, top, mask = (size_t)0 - 1;
/* this is not about constant-time-ness, but branch optimization */
for (top = (nbits + 7)/8, i=0, j=0; i<sizeof(val.s);) {
val.s[i++] = scalar[j] & mask;
mask = 0 - ((i - top) >> (8*sizeof(top)-1));
j += 1 & mask;
}
if (check_mod_256(val.s, BLS12_381_r)) /* z^4 is the formal limit */
POINTonE1_mult_glv(out, a, val.s);
else /* should never be the case, added for formal completeness */
POINTonE1_mult_w5(out, a, scalar, nbits);
vec_zero(val.l, sizeof(val));
} else { /* should never be the case, added for formal completeness */
POINTonE1_mult_w5(out, a, scalar, nbits);
}
} | O0 | c | blst_p1_mult:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0xb0, -0x20(%rbp)
jae 0xa9593
cmpq $0x0, -0x20(%rbp)
je 0xa9580
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xa9690
jmp 0xa958e
movq -0x8(%rbp), %rdi
movl $0x90, %esi
callq 0xa7170
jmp 0xa9681
cmpq $0x100, -0x20(%rbp) # imm = 0x100
ja 0xa966a
movq $-0x1, -0x60(%rbp)
movq -0x20(%rbp), %rax
addq $0x7, %rax
shrq $0x3, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x20, -0x48(%rbp)
jae 0xa961c
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andq -0x60(%rbp), %rax
movb %al, %cl
movq -0x48(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x48(%rbp)
movb %cl, -0x40(%rbp,%rax)
movq -0x48(%rbp), %rcx
subq -0x58(%rbp), %rcx
shrq $0x3f, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
andq $0x1, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xa95c9
leaq -0x40(%rbp), %rdi
leaq 0x3c7d9(%rip), %rsi # 0xe5e00
callq 0xcbac0
cmpq $0x0, %rax
je 0xa9645
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xa9950
jmp 0xa965a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xa9b30
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0xa7170
jmp 0xa967f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xa9b30
jmp 0xa9681
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| blst_p1_mult:
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
cmp [rbp+var_20], 0B0h
jnb short loc_A9593
cmp [rbp+var_20], 0
jz short loc_A9580
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call POINTonE1_mult_w4
jmp short loc_A958E
loc_A9580:
mov rdi, [rbp+var_8]
mov esi, 90h
call vec_zero
loc_A958E:
jmp loc_A9681
loc_A9593:
cmp [rbp+var_20], 100h
ja loc_A966A
mov [rbp+var_60], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_20]
add rax, 7
shr rax, 3
mov [rbp+var_58], rax
mov [rbp+var_48], 0
mov [rbp+var_50], 0
loc_A95C9:
cmp [rbp+var_48], 20h ; ' '
jnb short loc_A961C
mov rax, [rbp+var_18]
mov rcx, [rbp+var_50]
movzx eax, byte ptr [rax+rcx]
and rax, [rbp+var_60]
mov cl, al
mov rax, [rbp+var_48]
mov rdx, rax
add rdx, 1
mov [rbp+var_48], rdx
mov [rbp+rax+var_40], cl
mov rcx, [rbp+var_48]
sub rcx, [rbp+var_58]
shr rcx, 3Fh
xor eax, eax
sub rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
and rax, 1
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp short loc_A95C9
loc_A961C:
lea rdi, [rbp+var_40]
lea rsi, BLS12_381_r
call check_mod_256
cmp rax, 0
jz short loc_A9645
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_40]
call POINTonE1_mult_glv
jmp short loc_A965A
loc_A9645:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call POINTonE1_mult_w5
loc_A965A:
lea rdi, [rbp+var_40]
mov esi, 20h ; ' '
call vec_zero
jmp short loc_A967F
loc_A966A:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call POINTonE1_mult_w5
loc_A967F:
jmp short $+2
loc_A9681:
add rsp, 60h
pop rbp
retn
| long long blst_p1_mult(long long a1, long long a2, long long a3, unsigned long long a4)
{
unsigned long long v5; // rax
long long v6; // [rsp+0h] [rbp-60h]
unsigned long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
_BYTE v10[32]; // [rsp+20h] [rbp-40h] BYREF
unsigned long long v11; // [rsp+40h] [rbp-20h]
long long v12; // [rsp+48h] [rbp-18h]
long long v13; // [rsp+50h] [rbp-10h]
long long v14; // [rsp+58h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
if ( a4 >= 0xB0 )
{
if ( v11 > 0x100 )
{
return POINTonE1_mult_w5(v14, v13, v12, v11);
}
else
{
LOBYTE(v6) = -1;
v7 = (v11 + 7) >> 3;
v9 = 0LL;
v8 = 0LL;
while ( v9 < 0x20 )
{
v5 = v9++;
v10[v5] = v6 & *(_BYTE *)(v12 + v8);
v6 = -(long long)((v9 - v7) >> 63);
v8 += (long long)(v9 - v7) < 0;
}
if ( check_mod_256(v10, &BLS12_381_r) )
POINTonE1_mult_glv(v14, v13, v10);
else
POINTonE1_mult_w5(v14, v13, v12, v11);
return vec_zero((long long)v10, 0x20uLL);
}
}
else if ( v11 )
{
return POINTonE1_mult_w4(v14, v13, v12, v11);
}
else
{
return vec_zero(v14, 0x90uLL);
}
}
| blst_p1_mult:
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
CMP qword ptr [RBP + -0x20],0xb0
JNC 0x001a9593
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001a9580
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001a9690
JMP 0x001a958e
LAB_001a9580:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x90
CALL 0x001a7170
LAB_001a958e:
JMP 0x001a9681
LAB_001a9593:
CMP qword ptr [RBP + -0x20],0x100
JA 0x001a966a
MOV qword ptr [RBP + -0x60],-0x1
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x7
SHR RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x50],0x0
LAB_001a95c9:
CMP qword ptr [RBP + -0x48],0x20
JNC 0x001a961c
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x50]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
AND RAX,qword ptr [RBP + -0x60]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x48],RDX
MOV byte ptr [RBP + RAX*0x1 + -0x40],CL
MOV RCX,qword ptr [RBP + -0x48]
SUB RCX,qword ptr [RBP + -0x58]
SHR RCX,0x3f
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
AND RAX,0x1
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001a95c9
LAB_001a961c:
LEA RDI,[RBP + -0x40]
LEA RSI,[0x1e5e00]
CALL 0x001cbac0
CMP RAX,0x0
JZ 0x001a9645
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x40]
CALL 0x001a9950
JMP 0x001a965a
LAB_001a9645:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001a9b30
LAB_001a965a:
LEA RDI,[RBP + -0x40]
MOV ESI,0x20
CALL 0x001a7170
JMP 0x001a967f
LAB_001a966a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001a9b30
LAB_001a967f:
JMP 0x001a9681
LAB_001a9681:
ADD RSP,0x60
POP RBP
RET
|
void blst_p1_mult(int8 param_1,int8 param_2,long param_3,ulong param_4)
{
long lVar1;
ulong local_68;
long local_58;
ulong local_50;
byte local_48 [32];
ulong local_28;
long local_20;
int8 local_18;
int8 local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_4 < 0xb0) {
if (param_4 == 0) {
vec_zero(param_1,0x90);
}
else {
POINTonE1_mult_w4(param_1,param_2,param_3,param_4);
}
}
else if (param_4 < 0x101) {
local_68 = 0xffffffffffffffff;
local_50 = 0;
local_58 = 0;
while (local_50 < 0x20) {
local_48[local_50] = *(byte *)(param_3 + local_58) & (byte)local_68;
local_68 = (long)((local_50 + 1) - (param_4 + 7 >> 3)) >> 0x3f;
local_58 = (local_68 & 1) + local_58;
local_50 = local_50 + 1;
}
lVar1 = check_mod_256(local_48,BLS12_381_r);
if (lVar1 == 0) {
POINTonE1_mult_w5(local_10,local_18,local_20,local_28);
}
else {
POINTonE1_mult_glv(local_10,local_18,local_48);
}
vec_zero(local_48,0x20);
}
else {
POINTonE1_mult_w5(param_1,param_2,param_3,param_4);
}
return;
}
|
|
1,646 | my_wc_mb_8bit | eloqsql/strings/ctype-simple.c | int my_wc_mb_8bit(CHARSET_INFO *cs,my_wc_t wc,
uchar *str,
uchar *end)
{
MY_UNI_IDX *idx;
if (str >= end)
return MY_CS_TOOSMALL;
for (idx=cs->tab_from_uni; idx->tab ; idx++)
{
if (idx->from <= wc && idx->to >= wc)
{
str[0]= idx->tab[wc - idx->from];
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
}
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_8bit:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x3be01
pushq %rbp
movq %rsp, %rbp
movq 0x70(%rdi), %rcx
movq 0x8(%rcx), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x3be00
addq $0x2, %rcx
movzwl -0x2(%rcx), %r9d
movq %rsi, %r8
subq %r9, %r8
jb 0x3bddb
movzwl (%rcx), %r9d
cmpq %rsi, %r9
jae 0x3bdea
movq 0x16(%rcx), %rdi
addq $0x10, %rcx
testq %rdi, %rdi
jne 0x3bdc5
jmp 0x3be00
movb (%rdi,%r8), %al
movb %al, (%rdx)
testb %al, %al
setne %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movzbl %cl, %eax
popq %rbp
retq
| my_wc_mb_8bit:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_3BE01
push rbp
mov rbp, rsp
mov rcx, [rdi+70h]
mov rdi, [rcx+8]
xor eax, eax
test rdi, rdi
jz short loc_3BE00
add rcx, 2
loc_3BDC5:
movzx r9d, word ptr [rcx-2]
mov r8, rsi
sub r8, r9
jb short loc_3BDDB
movzx r9d, word ptr [rcx]
cmp r9, rsi
jnb short loc_3BDEA
loc_3BDDB:
mov rdi, [rcx+16h]
add rcx, 10h
test rdi, rdi
jnz short loc_3BDC5
jmp short loc_3BE00
loc_3BDEA:
mov al, [rdi+r8]
mov [rdx], al
test al, al
setnz al
test rsi, rsi
setz cl
or cl, al
movzx eax, cl
loc_3BE00:
pop rbp
locret_3BE01:
retn
| long long my_wc_mb_8bit(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rcx
long long v6; // rdi
unsigned __int16 *i; // rcx
unsigned long long v8; // r9
char v9; // al
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *(_QWORD *)(a1 + 112);
v6 = *(_QWORD *)(v5 + 8);
result = 0LL;
if ( v6 )
{
for ( i = (unsigned __int16 *)(v5 + 2); ; i += 8 )
{
v8 = *(i - 1);
if ( a2 >= v8 && *i >= a2 )
break;
v6 = *(_QWORD *)(i + 11);
if ( !v6 )
return result;
}
v9 = *(_BYTE *)(v6 + a2 - v8);
*a3 = v9;
return (v9 != 0) | (unsigned __int8)(a2 == 0);
}
}
return result;
}
| my_wc_mb_8bit:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0013be01
PUSH RBP
MOV RBP,RSP
MOV RCX,qword ptr [RDI + 0x70]
MOV RDI,qword ptr [RCX + 0x8]
XOR EAX,EAX
TEST RDI,RDI
JZ 0x0013be00
ADD RCX,0x2
LAB_0013bdc5:
MOVZX R9D,word ptr [RCX + -0x2]
MOV R8,RSI
SUB R8,R9
JC 0x0013bddb
MOVZX R9D,word ptr [RCX]
CMP R9,RSI
JNC 0x0013bdea
LAB_0013bddb:
MOV RDI,qword ptr [RCX + 0x16]
ADD RCX,0x10
TEST RDI,RDI
JNZ 0x0013bdc5
JMP 0x0013be00
LAB_0013bdea:
MOV AL,byte ptr [RDI + R8*0x1]
MOV byte ptr [RDX],AL
TEST AL,AL
SETNZ AL
TEST RSI,RSI
SETZ CL
OR CL,AL
MOVZX EAX,CL
LAB_0013be00:
POP RBP
LAB_0013be01:
RET
|
ulong my_wc_mb_8bit(long param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
ulong uVar2;
ushort *puVar3;
long lVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
lVar4 = *(long *)(*(long *)(param_1 + 0x70) + 8);
uVar2 = 0;
if (lVar4 != 0) {
puVar3 = (ushort *)(*(long *)(param_1 + 0x70) + 2);
do {
if ((puVar3[-1] <= param_2) && (param_2 <= *puVar3)) {
cVar1 = *(char *)(lVar4 + (param_2 - puVar3[-1]));
*param_3 = cVar1;
return (ulong)(param_2 == 0 || cVar1 != '\0');
}
lVar4 = *(long *)(puVar3 + 0xb);
puVar3 = puVar3 + 8;
} while (lVar4 != 0);
}
}
return uVar2;
}
|
|
1,647 | js_parse_from_clause | bluesky950520[P]quickjs/quickjs.c | static __exception JSAtom js_parse_from_clause(JSParseState *s)
{
JSAtom module_name;
if (!token_is_pseudo_keyword(s, JS_ATOM_from)) {
js_parse_error(s, "from clause expected");
return JS_ATOM_NULL;
}
if (next_token(s))
return JS_ATOM_NULL;
if (s->token.val != TOK_STRING) {
js_parse_error(s, "string expected");
return JS_ATOM_NULL;
}
module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (module_name == JS_ATOM_NULL)
return JS_ATOM_NULL;
if (next_token(s)) {
JS_FreeAtom(s->ctx, module_name);
return JS_ATOM_NULL;
}
return module_name;
} | O1 | c | js_parse_from_clause:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $-0x7d, 0x20(%rdi)
jne 0x6c84b
cmpl $0x7b, 0x38(%r14)
jne 0x6c84b
cmpl $0x0, 0x3c(%r14)
je 0x6c865
leaq 0x34a8c(%rip), %rsi # 0xa12de
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2fce9
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x5d1cf
xorl %ebx, %ebx
testl %eax, %eax
jne 0x6c85e
cmpl $-0x7f, 0x20(%r14)
jne 0x6c8a8
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x24093
testl %eax, %eax
je 0x6c85e
movl %eax, %ebp
movq %r14, %rdi
callq 0x5d1cf
testl %eax, %eax
je 0x6c8b1
movq (%r14), %rdi
movl %ebp, %esi
callq 0x207d8
jmp 0x6c85e
leaq 0x32bb7(%rip), %rsi # 0x9f466
jmp 0x6c852
movl %ebp, %ebx
jmp 0x6c85e
| js_parse_from_clause:
push rbp
push r14
push rbx
mov r14, rdi
cmp dword ptr [rdi+20h], 0FFFFFF83h
jnz short loc_6C84B
cmp dword ptr [r14+38h], 7Bh ; '{'
jnz short loc_6C84B
cmp dword ptr [r14+3Ch], 0
jz short loc_6C865
loc_6C84B:
lea rsi, aFromClauseExpe; "from clause expected"
loc_6C852:
xor ebx, ebx
mov rdi, r14
xor eax, eax
call js_parse_error
loc_6C85E:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_6C865:
mov rdi, r14
call next_token
xor ebx, ebx
test eax, eax
jnz short loc_6C85E
cmp dword ptr [r14+20h], 0FFFFFF81h
jnz short loc_6C8A8
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz short loc_6C85E
mov ebp, eax
mov rdi, r14
call next_token
test eax, eax
jz short loc_6C8B1
mov rdi, [r14]
mov esi, ebp
call JS_FreeAtom
jmp short loc_6C85E
loc_6C8A8:
lea rsi, aStringExpected; "string expected"
jmp short loc_6C852
loc_6C8B1:
mov ebx, ebp
jmp short loc_6C85E
| long long js_parse_from_clause(
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)
{
const char *v14; // rsi
unsigned int v15; // ebx
long long v17; // rsi
unsigned int v18; // eax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
unsigned int v25; // ebp
char v26; // [rsp+0h] [rbp-18h]
if ( *(_DWORD *)(a1 + 32) != -125 || *(_DWORD *)(a1 + 56) != 123 || *(_DWORD *)(a1 + 60) )
{
v14 = "from clause expected";
LABEL_5:
v15 = 0;
js_parse_error((long long *)a1, (long long)v14, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
return v15;
}
v15 = 0;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
return v15;
if ( *(_DWORD *)(a1 + 32) != -127 )
{
v14 = "string expected";
goto LABEL_5;
}
v17 = *(_QWORD *)(a1 + 56);
v18 = JS_ValueToAtom(*(_QWORD *)a1, v17, *(_QWORD *)(a1 + 64));
if ( v18 )
{
v25 = v18;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, v23, v24, a13, a14, v17, v19, v20, v21, v22) )
JS_FreeAtom(*(_QWORD *)a1, v25);
else
return v25;
}
return v15;
}
| js_parse_from_clause:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDI
CMP dword ptr [RDI + 0x20],-0x7d
JNZ 0x0016c84b
CMP dword ptr [R14 + 0x38],0x7b
JNZ 0x0016c84b
CMP dword ptr [R14 + 0x3c],0x0
JZ 0x0016c865
LAB_0016c84b:
LEA RSI,[0x1a12de]
LAB_0016c852:
XOR EBX,EBX
MOV RDI,R14
XOR EAX,EAX
CALL 0x0012fce9
LAB_0016c85e:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_0016c865:
MOV RDI,R14
CALL 0x0015d1cf
XOR EBX,EBX
TEST EAX,EAX
JNZ 0x0016c85e
CMP dword ptr [R14 + 0x20],-0x7f
JNZ 0x0016c8a8
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x00124093
TEST EAX,EAX
JZ 0x0016c85e
MOV EBP,EAX
MOV RDI,R14
CALL 0x0015d1cf
TEST EAX,EAX
JZ 0x0016c8b1
MOV RDI,qword ptr [R14]
MOV ESI,EBP
CALL 0x001207d8
JMP 0x0016c85e
LAB_0016c8a8:
LEA RSI,[0x19f466]
JMP 0x0016c852
LAB_0016c8b1:
MOV EBX,EBP
JMP 0x0016c85e
|
int js_parse_from_clause(int8 *param_1)
{
int iVar1;
int iVar2;
char *pcVar3;
if (((*(int *)(param_1 + 4) == -0x7d) && (*(int *)(param_1 + 7) == 0x7b)) &&
(*(int *)((long)param_1 + 0x3c) == 0)) {
iVar1 = next_token(param_1);
if (iVar1 != 0) {
return 0;
}
if (*(int *)(param_1 + 4) == -0x7f) {
iVar1 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
if (iVar1 == 0) {
return 0;
}
iVar2 = next_token(param_1);
if (iVar2 == 0) {
return iVar1;
}
JS_FreeAtom(*param_1,iVar1);
return 0;
}
pcVar3 = "string expected";
}
else {
pcVar3 = "from clause expected";
}
js_parse_error(param_1,pcVar3);
return 0;
}
|
|
1,648 | js_parse_from_clause | bluesky950520[P]quickjs/quickjs.c | static __exception JSAtom js_parse_from_clause(JSParseState *s)
{
JSAtom module_name;
if (!token_is_pseudo_keyword(s, JS_ATOM_from)) {
js_parse_error(s, "from clause expected");
return JS_ATOM_NULL;
}
if (next_token(s))
return JS_ATOM_NULL;
if (s->token.val != TOK_STRING) {
js_parse_error(s, "string expected");
return JS_ATOM_NULL;
}
module_name = JS_ValueToAtom(s->ctx, s->token.u.str.str);
if (module_name == JS_ATOM_NULL)
return JS_ATOM_NULL;
if (next_token(s)) {
JS_FreeAtom(s->ctx, module_name);
return JS_ATOM_NULL;
}
return module_name;
} | O3 | c | js_parse_from_clause:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $-0x7d, 0x20(%rdi)
jne 0x6ea0e
cmpl $0x7b, 0x38(%r14)
jne 0x6ea0e
cmpl $0x0, 0x3c(%r14)
je 0x6ea28
leaq 0x35873(%rip), %rsi # 0xa4288
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x30b0d
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x600a6
xorl %ebx, %ebx
testl %eax, %eax
jne 0x6ea21
cmpl $-0x7f, 0x20(%r14)
jne 0x6ea6b
movq (%r14), %rdi
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
callq 0x2470d
testl %eax, %eax
je 0x6ea21
movl %eax, %ebp
movq %r14, %rdi
callq 0x600a6
testl %eax, %eax
je 0x6ea74
movq (%r14), %rdi
movl %ebp, %esi
callq 0x20f31
jmp 0x6ea21
leaq 0x339b4(%rip), %rsi # 0xa2426
jmp 0x6ea15
movl %ebp, %ebx
jmp 0x6ea21
| js_parse_from_clause:
push rbp
push r14
push rbx
mov r14, rdi
cmp dword ptr [rdi+20h], 0FFFFFF83h
jnz short loc_6EA0E
cmp dword ptr [r14+38h], 7Bh ; '{'
jnz short loc_6EA0E
cmp dword ptr [r14+3Ch], 0
jz short loc_6EA28
loc_6EA0E:
lea rsi, aFromClauseExpe; "from clause expected"
loc_6EA15:
xor ebx, ebx
mov rdi, r14
xor eax, eax
call js_parse_error
loc_6EA21:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
loc_6EA28:
mov rdi, r14
call next_token
xor ebx, ebx
test eax, eax
jnz short loc_6EA21
cmp dword ptr [r14+20h], 0FFFFFF81h
jnz short loc_6EA6B
mov rdi, [r14]
mov rsi, [r14+38h]
mov rdx, [r14+40h]
call JS_ValueToAtom
test eax, eax
jz short loc_6EA21
mov ebp, eax
mov rdi, r14
call next_token
test eax, eax
jz short loc_6EA74
mov rdi, [r14]
mov esi, ebp
call JS_FreeAtom
jmp short loc_6EA21
loc_6EA6B:
lea rsi, aStringExpected; "string expected"
jmp short loc_6EA15
loc_6EA74:
mov ebx, ebp
jmp short loc_6EA21
| long long js_parse_from_clause(
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)
{
const char *v14; // rsi
unsigned int v15; // ebx
long long v17; // rsi
unsigned int v18; // eax
long long v19; // rdx
long long v20; // rcx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
unsigned int v25; // ebp
char v26; // [rsp+0h] [rbp-18h]
if ( *(_DWORD *)(a1 + 32) != -125 || *(_DWORD *)(a1 + 56) != 123 || *(_DWORD *)(a1 + 60) )
{
v14 = "from clause expected";
LABEL_5:
v15 = 0;
js_parse_error((long long *)a1, (long long)v14, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v26);
return v15;
}
v15 = 0;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6) )
return v15;
if ( *(_DWORD *)(a1 + 32) != -127 )
{
v14 = "string expected";
goto LABEL_5;
}
v17 = *(_QWORD *)(a1 + 56);
v18 = JS_ValueToAtom(*(_QWORD *)a1, v17, *(_QWORD *)(a1 + 64));
if ( v18 )
{
v25 = v18;
if ( (unsigned int)next_token(a1, a7, a8, a9, a10, v23, v24, a13, a14, v17, v19, v20, v21, v22) )
JS_FreeAtom(*(_QWORD *)a1, v25);
else
return v25;
}
return v15;
}
| js_parse_from_clause:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDI
CMP dword ptr [RDI + 0x20],-0x7d
JNZ 0x0016ea0e
CMP dword ptr [R14 + 0x38],0x7b
JNZ 0x0016ea0e
CMP dword ptr [R14 + 0x3c],0x0
JZ 0x0016ea28
LAB_0016ea0e:
LEA RSI,[0x1a4288]
LAB_0016ea15:
XOR EBX,EBX
MOV RDI,R14
XOR EAX,EAX
CALL 0x00130b0d
LAB_0016ea21:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
LAB_0016ea28:
MOV RDI,R14
CALL 0x001600a6
XOR EBX,EBX
TEST EAX,EAX
JNZ 0x0016ea21
CMP dword ptr [R14 + 0x20],-0x7f
JNZ 0x0016ea6b
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x38]
MOV RDX,qword ptr [R14 + 0x40]
CALL 0x0012470d
TEST EAX,EAX
JZ 0x0016ea21
MOV EBP,EAX
MOV RDI,R14
CALL 0x001600a6
TEST EAX,EAX
JZ 0x0016ea74
MOV RDI,qword ptr [R14]
MOV ESI,EBP
CALL 0x00120f31
JMP 0x0016ea21
LAB_0016ea6b:
LEA RSI,[0x1a2426]
JMP 0x0016ea15
LAB_0016ea74:
MOV EBX,EBP
JMP 0x0016ea21
|
int js_parse_from_clause(int8 *param_1)
{
int iVar1;
int iVar2;
char *pcVar3;
if (((*(int *)(param_1 + 4) == -0x7d) && (*(int *)(param_1 + 7) == 0x7b)) &&
(*(int *)((long)param_1 + 0x3c) == 0)) {
iVar1 = next_token(param_1);
if (iVar1 != 0) {
return 0;
}
if (*(int *)(param_1 + 4) == -0x7f) {
iVar1 = JS_ValueToAtom(*param_1,param_1[7],param_1[8]);
if (iVar1 == 0) {
return 0;
}
iVar2 = next_token(param_1);
if (iVar2 == 0) {
return iVar1;
}
JS_FreeAtom(*param_1,iVar1);
return 0;
}
pcVar3 = "string expected";
}
else {
pcVar3 = "from clause expected";
}
js_parse_error(param_1,pcVar3);
return 0;
}
|
|
1,649 | js_number_isInteger | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_isInteger(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int ret;
ret = JS_NumberIsInteger(ctx, argv[0]);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O0 | c | js_number_isInteger:
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x35530
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0xd1090
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0xd10a3
movl 0xc(%rsp), %edi
callq 0x55f90
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| js_number_isInteger:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_2C], ecx
mov [rsp+48h+var_38], r8
mov rdi, [rsp+48h+var_28]
mov rax, [rsp+48h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_NumberIsInteger
mov [rsp+48h+var_3C], eax
cmp [rsp+48h+var_3C], 0
jge short loc_D1090
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp short loc_D10A3
loc_D1090:
mov edi, [rsp+48h+var_3C]
call js_bool
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
loc_D10A3:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_number_isInteger(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
int IsInteger; // [rsp+Ch] [rbp-3Ch]
long long v7; // [rsp+38h] [rbp-10h]
IsInteger = JS_NumberIsInteger(a1, *a5, a5[1]);
if ( IsInteger >= 0 )
return js_bool(IsInteger);
LODWORD(v7) = 0;
return v7;
}
| js_number_isInteger:
SUB RSP,0x48
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00135530
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x0
JGE 0x001d1090
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x001d10a3
LAB_001d1090:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00155f90
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
LAB_001d10a3:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16] js_number_isInteger(int8 param_1)
{
int iVar1;
int8 *in_R8;
int1 auVar2 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar1 = JS_NumberIsInteger(param_1,*in_R8,in_R8[1]);
if (iVar1 < 0) {
local_10 = 0;
local_8 = 6;
}
else {
auVar2 = js_bool(iVar1);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
|
|
1,650 | js_number_isInteger | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_isInteger(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int ret;
ret = JS_NumberIsInteger(ctx, argv[0]);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O1 | c | js_number_isInteger:
pushq %rax
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0xf9d9
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
shrl $0x1f, %eax
leaq (%rax,%rax,4), %rdx
incq %rdx
movq %rcx, %rax
popq %rcx
retq
| js_number_isInteger:
push rax
mov rsi, [r8]
mov rdx, [r8+8]
call JS_NumberIsInteger
xor ecx, ecx
test eax, eax
setnle cl
shr eax, 1Fh
lea rdx, [rax+rax*4]
inc rdx
mov rax, rcx
pop rcx
retn
| _BOOL8 js_number_isInteger(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
return (int)JS_NumberIsInteger(a1, *a5, a5[1]) > 0;
}
| js_number_isInteger:
PUSH RAX
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x0010f9d9
XOR ECX,ECX
TEST EAX,EAX
SETG CL
SHR EAX,0x1f
LEA RDX,[RAX + RAX*0x4]
INC RDX
MOV RAX,RCX
POP RCX
RET
|
bool js_number_isInteger(int8 param_1)
{
int iVar1;
int8 *in_R8;
iVar1 = JS_NumberIsInteger(param_1,*in_R8,in_R8[1]);
return 0 < iVar1;
}
|
|
1,651 | js_number_isInteger | bluesky950520[P]quickjs/quickjs.c | static JSValue js_number_isInteger(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int ret;
ret = JS_NumberIsInteger(ctx, argv[0]);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O3 | c | js_number_isInteger:
pushq %rax
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0xfb86
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
shrl $0x1f, %eax
leaq (%rax,%rax,4), %rdx
incq %rdx
movq %rcx, %rax
popq %rcx
retq
| js_number_isInteger:
push rax
mov rsi, [r8]
mov rdx, [r8+8]
call JS_NumberIsInteger
xor ecx, ecx
test eax, eax
setnle cl
shr eax, 1Fh
lea rdx, [rax+rax*4]
inc rdx
mov rax, rcx
pop rcx
retn
| _BOOL8 js_number_isInteger(long long a1, __m128d a2, long long a3, long long a4, long long a5, unsigned long long *a6)
{
return (int)JS_NumberIsInteger(a2, a1, *a6, a6[1]) > 0;
}
| js_number_isInteger:
PUSH RAX
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x0010fb86
XOR ECX,ECX
TEST EAX,EAX
SETG CL
SHR EAX,0x1f
LEA RDX,[RAX + RAX*0x4]
INC RDX
MOV RAX,RCX
POP RCX
RET
|
bool js_number_isInteger(int8 param_1)
{
int iVar1;
int8 *in_R8;
iVar1 = JS_NumberIsInteger(param_1,*in_R8,in_R8[1]);
return 0 < iVar1;
}
|
|
1,652 | check_mb_utf8_sequence | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_utf8_sequence(const char *start, const char *end)
{
uchar c;
if (start >= end) {
return 0;
}
c = (uchar) start[0];
if (c < 0x80) {
return 1; /* single byte character */
}
if (c < 0xC2) {
return 0; /* invalid mb character */
}
if (c < 0xE0) {
if (start + 2 > end) {
return 0; /* too small */
}
if (!(((uchar)start[1] ^ 0x80) < 0x40)) {
return 0;
}
return 2;
}
if (c < 0xF0) {
if (start + 3 > end) {
return 0; /* too small */
}
if (!(((uchar)start[1] ^ 0x80) < 0x40 && ((uchar)start[2] ^ 0x80) < 0x40 &&
(c >= 0xE1 || (uchar)start[1] >= 0xA0))) {
return 0; /* invalid utf8 character */
}
return 3;
}
if (c < 0xF5) {
if (start + 4 > end) { /* We need 4 characters */
return 0; /* too small */
}
/*
UTF-8 quick four-byte mask:
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
Encoding allows to encode U+00010000..U+001FFFFF
The maximum character defined in the Unicode standard is U+0010FFFF.
Higher characters U+00110000..U+001FFFFF are not used.
11110000.10010000.10xxxxxx.10xxxxxx == F0.90.80.80 == U+00010000 (min)
11110100.10001111.10111111.10111111 == F4.8F.BF.BF == U+0010FFFF (max)
Valid codes:
[F0][90..BF][80..BF][80..BF]
[F1][80..BF][80..BF][80..BF]
[F2][80..BF][80..BF][80..BF]
[F3][80..BF][80..BF][80..BF]
[F4][80..8F][80..BF][80..BF]
*/
if (!(((uchar)start[1] ^ 0x80) < 0x40 &&
((uchar)start[2] ^ 0x80) < 0x40 &&
((uchar)start[3] ^ 0x80) < 0x40 &&
(c >= 0xf1 || (uchar)start[1] >= 0x90) &&
(c <= 0xf3 || (uchar)start[1] <= 0x8F)))
{
return 0; /* invalid utf8 character */
}
return 4;
}
return 0;
} | O0 | c | check_mb_utf8_sequence:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x444a2
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x80, %eax
jge 0x444c2
movl $0x1, -0x4(%rbp)
jmp 0x4464f
movzbl -0x19(%rbp), %eax
cmpl $0xc2, %eax
jge 0x444d9
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movzbl -0x19(%rbp), %eax
cmpl $0xe0, %eax
jge 0x44528
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x18(%rbp), %rax
jbe 0x444fe
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x4451c
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movl $0x2, -0x4(%rbp)
jmp 0x4464f
movzbl -0x19(%rbp), %eax
cmpl $0xf0, %eax
jge 0x445a3
movq -0x10(%rbp), %rax
addq $0x3, %rax
cmpq -0x18(%rbp), %rax
jbe 0x4454d
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x4458b
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x4458b
movzbl -0x19(%rbp), %eax
cmpl $0xe1, %eax
jge 0x44597
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x44597
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movl $0x3, -0x4(%rbp)
jmp 0x4464f
movzbl -0x19(%rbp), %eax
cmpl $0xf5, %eax
jge 0x44648
movq -0x10(%rbp), %rax
addq $0x4, %rax
cmpq -0x18(%rbp), %rax
jbe 0x445cc
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x44636
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x44636
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x44636
movzbl -0x19(%rbp), %eax
cmpl $0xf1, %eax
jge 0x4461c
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x90, %eax
jl 0x44636
movzbl -0x19(%rbp), %eax
cmpl $0xf3, %eax
jle 0x4463f
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8f, %eax
jle 0x4463f
movl $0x0, -0x4(%rbp)
jmp 0x4464f
movl $0x4, -0x4(%rbp)
jmp 0x4464f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_mb_utf8_sequence:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jb short loc_444A2
mov [rbp+var_4], 0
jmp loc_4464F
loc_444A2:
mov rax, [rbp+var_10]
mov al, [rax]
mov [rbp+var_19], al
movzx eax, [rbp+var_19]
cmp eax, 80h
jge short loc_444C2
mov [rbp+var_4], 1
jmp loc_4464F
loc_444C2:
movzx eax, [rbp+var_19]
cmp eax, 0C2h
jge short loc_444D9
mov [rbp+var_4], 0
jmp loc_4464F
loc_444D9:
movzx eax, [rbp+var_19]
cmp eax, 0E0h
jge short loc_44528
mov rax, [rbp+var_10]
add rax, 2
cmp rax, [rbp+var_18]
jbe short loc_444FE
mov [rbp+var_4], 0
jmp loc_4464F
loc_444FE:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_4451C
mov [rbp+var_4], 0
jmp loc_4464F
loc_4451C:
mov [rbp+var_4], 2
jmp loc_4464F
loc_44528:
movzx eax, [rbp+var_19]
cmp eax, 0F0h
jge short loc_445A3
mov rax, [rbp+var_10]
add rax, 3
cmp rax, [rbp+var_18]
jbe short loc_4454D
mov [rbp+var_4], 0
jmp loc_4464F
loc_4454D:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_4458B
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_4458B
movzx eax, [rbp+var_19]
cmp eax, 0E1h
jge short loc_44597
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_44597
loc_4458B:
mov [rbp+var_4], 0
jmp loc_4464F
loc_44597:
mov [rbp+var_4], 3
jmp loc_4464F
loc_445A3:
movzx eax, [rbp+var_19]
cmp eax, 0F5h
jge loc_44648
mov rax, [rbp+var_10]
add rax, 4
cmp rax, [rbp+var_18]
jbe short loc_445CC
mov [rbp+var_4], 0
jmp loc_4464F
loc_445CC:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_44636
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_44636
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_44636
movzx eax, [rbp+var_19]
cmp eax, 0F1h
jge short loc_4461C
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 90h
jl short loc_44636
loc_4461C:
movzx eax, [rbp+var_19]
cmp eax, 0F3h
jle short loc_4463F
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
cmp eax, 8Fh
jle short loc_4463F
loc_44636:
mov [rbp+var_4], 0
jmp short loc_4464F
loc_4463F:
mov [rbp+var_4], 4
jmp short loc_4464F
loc_44648:
mov [rbp+var_4], 0
loc_4464F:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_utf8_sequence(unsigned __int8 *a1, unsigned long long a2)
{
unsigned __int8 v3; // [rsp+1h] [rbp-19h]
if ( (unsigned long long)a1 < a2 )
{
v3 = *a1;
if ( *a1 >= 0x80u )
{
if ( v3 >= 0xC2u )
{
if ( v3 >= 0xE0u )
{
if ( v3 >= 0xF0u )
{
if ( v3 >= 0xF5u )
{
return 0;
}
else if ( (unsigned long long)(a1 + 4) <= a2 )
{
if ( (a1[1] ^ 0x80) < 64
&& (a1[2] ^ 0x80) < 64
&& (a1[3] ^ 0x80) < 64
&& (v3 >= 0xF1u || a1[1] >= 0x90u)
&& (v3 <= 0xF3u || a1[1] <= 0x8Fu) )
{
return 4;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)(a1 + 3) <= a2 )
{
if ( (a1[1] ^ 0x80) < 64 && (a1[2] ^ 0x80) < 64 && (v3 >= 0xE1u || a1[1] >= 0xA0u) )
return 3;
else
return 0;
}
else
{
return 0;
}
}
else if ( (unsigned long long)(a1 + 2) <= a2 )
{
if ( (a1[1] ^ 0x80) < 64 )
return 2;
else
return 0;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
else
{
return 1;
}
}
else
{
return 0;
}
}
| check_mb_utf8_sequence:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x001444a2
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_001444a2:
MOV RAX,qword ptr [RBP + -0x10]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x19],AL
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0x80
JGE 0x001444c2
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014464f
LAB_001444c2:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xc2
JGE 0x001444d9
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_001444d9:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xe0
JGE 0x00144528
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001444fe
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_001444fe:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0014451c
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_0014451c:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0014464f
LAB_00144528:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xf0
JGE 0x001445a3
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x0014454d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_0014454d:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0014458b
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0014458b
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xe1
JGE 0x00144597
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x00144597
LAB_0014458b:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_00144597:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0014464f
LAB_001445a3:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xf5
JGE 0x00144648
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001445cc
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_001445cc:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00144636
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00144636
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x00144636
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xf1
JGE 0x0014461c
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x90
JL 0x00144636
LAB_0014461c:
MOVZX EAX,byte ptr [RBP + -0x19]
CMP EAX,0xf3
JLE 0x0014463f
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x8f
JLE 0x0014463f
LAB_00144636:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014464f
LAB_0014463f:
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0014464f
LAB_00144648:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014464f:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_utf8_sequence(byte *param_1,byte *param_2)
{
byte bVar1;
int4 local_c;
if (param_1 < param_2) {
bVar1 = *param_1;
if (bVar1 < 0x80) {
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_2 < param_1 + 2) {
local_c = 0;
}
else if ((param_1[1] ^ 0x80) < 0x40) {
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_2 < param_1 + 3) {
local_c = 0;
}
else if ((((param_1[1] ^ 0x80) < 0x40) && ((param_1[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_1[1])))) {
local_c = 3;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf5) {
if (param_2 < param_1 + 4) {
local_c = 0;
}
else if ((((((param_1[1] ^ 0x80) < 0x40) && ((param_1[2] ^ 0x80) < 0x40)) &&
((param_1[3] ^ 0x80) < 0x40)) && ((0xf0 < bVar1 || (0x8f < param_1[1])))) &&
((bVar1 < 0xf4 || (param_1[1] < 0x90)))) {
local_c = 4;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
1,653 | my_hash_init2 | eloqsql/mysys/hash.c | my_bool
my_hash_init2(PSI_memory_key psi_key, HASH *hash, uint growth_size,
CHARSET_INFO *charset, ulong size, size_t key_offset,
size_t key_length, my_hash_get_key get_key,
my_hash_function hash_function,
void (*free_element)(void*), uint flags)
{
my_bool res;
DBUG_ENTER("my_hash_init2");
DBUG_PRINT("enter",("hash:%p size: %u", hash, (uint) size));
hash->records=0;
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->get_key=get_key;
hash->hash_function= hash_function ? hash_function : my_hash_sort;
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
res= init_dynamic_array2(psi_key, &hash->array, sizeof(HASH_LINK), NULL, size,
growth_size, MYF((flags & HASH_THREAD_SPECIFIC ?
MY_THREAD_SPECIFIC : 0)));
DBUG_RETURN(res);
} | O3 | c | my_hash_init2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %eax
movl 0x30(%rbp), %edx
movq 0x28(%rbp), %r10
movq 0x20(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x10(%rbp), %r14
movq $0x0, 0x18(%rsi)
movq %r9, (%rsi)
movq %r14, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
movq %rbx, 0x50(%rsi)
testq %r11, %r11
jne 0x3bd88
leaq -0x7c(%rip), %r11 # 0x3bd0c
movq %r11, 0x58(%rsi)
movq %r10, 0x60(%rsi)
movl %edx, 0x20(%rsi)
movq %rcx, 0x68(%rsi)
addq $0x28, %rsi
andl $0x2, %edx
shll $0xf, %edx
movq %rdx, (%rsp)
movl $0x10, %edx
xorl %ecx, %ecx
movl %eax, %r9d
callq 0x3f28c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| my_hash_init2:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov eax, edx
mov edx, [rbp+arg_20]
mov r10, [rbp+arg_18]
mov r11, [rbp+arg_10]
mov rbx, [rbp+arg_8]
mov r14, [rbp+arg_0]
mov qword ptr [rsi+18h], 0
mov [rsi], r9
mov [rsi+8], r14
mov qword ptr [rsi+10h], 1
mov [rsi+50h], rbx
test r11, r11
jnz short loc_3BD88
lea r11, my_hash_sort
loc_3BD88:
mov [rsi+58h], r11
mov [rsi+60h], r10
mov [rsi+20h], edx
mov [rsi+68h], rcx
add rsi, 28h ; '('
and edx, 2
shl edx, 0Fh
mov [rsp+20h+var_20], rdx
mov edx, 10h
xor ecx, ecx
mov r9d, eax
call init_dynamic_array2
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long my_hash_init2(
int a1,
long long a2,
int a3,
long long a4,
int a5,
long long a6,
long long a7,
long long a8,
long long ( *a9)(long long a1, long long a2, long long a3),
long long a10,
int a11)
{
long long ( *v11)(long long, long long, long long); // r11
v11 = a9;
*(_QWORD *)(a2 + 24) = 0LL;
*(_QWORD *)a2 = a6;
*(_QWORD *)(a2 + 8) = a7;
*(_QWORD *)(a2 + 16) = 1LL;
*(_QWORD *)(a2 + 80) = a8;
if ( !a9 )
v11 = my_hash_sort;
*(_QWORD *)(a2 + 88) = v11;
*(_QWORD *)(a2 + 96) = a10;
*(_DWORD *)(a2 + 32) = a11;
*(_QWORD *)(a2 + 104) = a4;
return init_dynamic_array2(a1, (int)a2 + 40, 16, 0, a5, a3, (unsigned __int8)(a11 & 2) << 15);
}
| my_hash_init2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EAX,EDX
MOV EDX,dword ptr [RBP + 0x30]
MOV R10,qword ptr [RBP + 0x28]
MOV R11,qword ptr [RBP + 0x20]
MOV RBX,qword ptr [RBP + 0x18]
MOV R14,qword ptr [RBP + 0x10]
MOV qword ptr [RSI + 0x18],0x0
MOV qword ptr [RSI],R9
MOV qword ptr [RSI + 0x8],R14
MOV qword ptr [RSI + 0x10],0x1
MOV qword ptr [RSI + 0x50],RBX
TEST R11,R11
JNZ 0x0013bd88
LEA R11,[0x13bd0c]
LAB_0013bd88:
MOV qword ptr [RSI + 0x58],R11
MOV qword ptr [RSI + 0x60],R10
MOV dword ptr [RSI + 0x20],EDX
MOV qword ptr [RSI + 0x68],RCX
ADD RSI,0x28
AND EDX,0x2
SHL EDX,0xf
MOV qword ptr [RSP],RDX
MOV EDX,0x10
XOR ECX,ECX
MOV R9D,EAX
CALL 0x0013f28c
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
void my_hash_init2(int8 param_1,int8 *param_2,int4 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
code *param_9,int8 param_10,uint param_11)
{
param_2[3] = 0;
*param_2 = param_6;
param_2[1] = param_7;
param_2[2] = 1;
param_2[10] = param_8;
if (param_9 == (code *)0x0) {
param_9 = my_hash_sort;
}
param_2[0xb] = param_9;
param_2[0xc] = param_10;
*(uint *)(param_2 + 4) = param_11;
param_2[0xd] = param_4;
init_dynamic_array2(param_1,param_2 + 5,0x10,0,param_5,param_3,(param_11 & 2) << 0xf);
return;
}
|
|
1,654 | my_caseup_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_str_8bit(CHARSET_INFO * cs,char *str)
{
register const uchar *map= cs->to_upper;
char *str_orig= str;
while ((*str= (char) map[(uchar) *str]) != 0)
str++;
return (size_t) (str - str_orig);
} | O0 | c | my_caseup_str_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xd897a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd8950
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| my_caseup_str_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+50h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_D8950:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov al, [rax+rcx]
mov rcx, [rbp+var_10]
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_D897A
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_D8950
loc_D897A:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
| _BYTE * my_caseup_str_8bit(long long a1, _BYTE *a2)
{
char v2; // al
long long v4; // [rsp+8h] [rbp-18h]
_BYTE *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
v4 = *(_QWORD *)(a1 + 80);
while ( 1 )
{
v2 = *(_BYTE *)(v4 + (unsigned __int8)*v5);
*v5 = v2;
if ( !v2 )
break;
++v5;
}
return (_BYTE *)(v5 - a2);
}
| my_caseup_str_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_001d8950:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001d897a
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001d8950
LAB_001d897a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
POP RBP
RET
|
long my_caseup_str_8bit(long param_1,byte *param_2)
{
byte bVar1;
long lVar2;
byte *local_18;
lVar2 = *(long *)(param_1 + 0x50);
local_18 = param_2;
while (bVar1 = *(byte *)(lVar2 + (ulong)*local_18), *local_18 = bVar1, bVar1 != 0) {
local_18 = local_18 + 1;
}
return (long)local_18 - (long)param_2;
}
|
|
1,655 | my_uncompress | eloqsql/mysys/my_compress.c | my_bool my_uncompress(uchar *packet, size_t len, size_t *complen)
{
uLongf tmp_complen;
DBUG_ENTER("my_uncompress");
if (*complen) /* If compressed */
{
uchar *compbuf= (uchar *) my_malloc(key_memory_my_compress_alloc,
*complen,MYF(MY_WME));
int error;
if (!compbuf)
DBUG_RETURN(1); /* Not enough memory */
tmp_complen= (uLongf) *complen;
error= uncompress((Bytef*) compbuf, &tmp_complen, (Bytef*) packet,
(uLong) len);
*complen= tmp_complen;
if (error != Z_OK)
{ /* Probably wrong packet */
DBUG_PRINT("error",("Can't uncompress packet, error: %d",error));
my_free(compbuf);
DBUG_RETURN(1);
}
memcpy(packet, compbuf, *complen);
my_free(compbuf);
}
else
*complen= len;
DBUG_RETURN(0);
} | O0 | c | my_uncompress:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb6235
leaq 0xb95e73(%rip), %rax # 0xc4c01c
movl (%rax), %edi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x10, %edx
callq 0xbe600
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xb61cf
jmp 0xb61c9
movb $0x1, -0x1(%rbp)
jmp 0xb6246
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rsi
callq 0x279a0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x34(%rbp)
je 0xb6216
jmp 0xb6205
jmp 0xb6207
movq -0x30(%rbp), %rdi
callq 0xbe980
movb $0x1, -0x1(%rbp)
jmp 0xb6246
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x270d0
movq -0x30(%rbp), %rdi
callq 0xbe980
jmp 0xb6240
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xb6242
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nop
| my_uncompress:
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_20]
cmp qword ptr [rax], 0
jz loc_B6235
lea rax, key_memory_my_compress_alloc
mov edi, [rax]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov edx, 10h
call my_malloc
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_B61CF
jmp short $+2
loc_B61C9:
mov [rbp+var_1], 1
jmp short loc_B6246
loc_B61CF:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_18]
lea rsi, [rbp+var_28]
call _uncompress
mov [rbp+var_34], eax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rax], rcx
cmp [rbp+var_34], 0
jz short loc_B6216
jmp short $+2
loc_B6205:
jmp short $+2
loc_B6207:
mov rdi, [rbp+var_30]
call my_free
mov [rbp+var_1], 1
jmp short loc_B6246
loc_B6216:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rax, [rbp+var_20]
mov rdx, [rax]
call _memcpy
mov rdi, [rbp+var_30]
call my_free
jmp short loc_B6240
loc_B6235:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax], rcx
loc_B6240:
jmp short $+2
loc_B6242:
mov [rbp+var_1], 0
loc_B6246:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char my_uncompress(long long a1, long long a2, _QWORD *a3)
{
int v3; // eax
long long v5; // [rsp+10h] [rbp-30h]
long long v6; // [rsp+18h] [rbp-28h] BYREF
_QWORD *v7; // [rsp+20h] [rbp-20h]
long long v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( !*a3 )
{
*v7 = v8;
return 0;
}
v5 = my_malloc(key_memory_my_compress_alloc, *v7, 16LL);
if ( v5 )
{
v6 = *v7;
v3 = uncompress(v5, &v6, v9, v8);
*v7 = v6;
if ( v3 )
{
my_free(v5);
return 1;
}
memcpy(v9, v5, *v7);
my_free(v5);
return 0;
}
return 1;
}
| my_uncompress:
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 + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x001b6235
LEA RAX,[0xd4c01c]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV EDX,0x10
CALL 0x001be600
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001b61cf
JMP 0x001b61c9
LAB_001b61c9:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001b6246
LAB_001b61cf:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x28]
CALL 0x001279a0
MOV dword ptr [RBP + -0x34],EAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
CMP dword ptr [RBP + -0x34],0x0
JZ 0x001b6216
JMP 0x001b6205
LAB_001b6205:
JMP 0x001b6207
LAB_001b6207:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001be980
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001b6246
LAB_001b6216:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RAX]
CALL 0x001270d0
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001be980
JMP 0x001b6240
LAB_001b6235:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
LAB_001b6240:
JMP 0x001b6242
LAB_001b6242:
MOV byte ptr [RBP + -0x1],0x0
LAB_001b6246:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 my_uncompress(void *param_1,size_t param_2,size_t *param_3)
{
int iVar1;
void *__src;
size_t local_30;
size_t *local_28;
size_t local_20;
void *local_18;
if (*param_3 == 0) {
*param_3 = param_2;
}
else {
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
__src = (void *)my_malloc(key_memory_my_compress_alloc,*param_3,0x10);
if (__src == (void *)0x0) {
return 1;
}
local_30 = *local_28;
iVar1 = uncompress(__src,&local_30,local_18,local_20);
*local_28 = local_30;
if (iVar1 != 0) {
my_free(__src);
return 1;
}
memcpy(local_18,__src,*local_28);
my_free(__src);
}
return 0;
}
|
|
1,656 | ma_close | eloqsql/libmariadb/libmariadb/ma_io.c | int ma_close(MA_FILE *file)
{
int rc;
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
rc= fclose((FILE *)file->ptr);
free(file);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
rc= rio_plugin->methods->mclose(file);
break;
#endif
default:
return -1;
}
return rc;
} | O0 | c | ma_close:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5b91c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b97d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x5b936
jmp 0x5b92c
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x5b951
jmp 0x5b96e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x36430
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x361a0
jmp 0x5b977
leaq 0x3e1658(%rip), %rax # 0x43cfb0
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
jmp 0x5b977
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5b97d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_close:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_5B91C
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_5B97D
loc_5B91C:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_18], eax
sub eax, 1
jz short loc_5B936
jmp short $+2
loc_5B92C:
mov eax, [rbp+var_18]
sub eax, 2
jz short loc_5B951
jmp short loc_5B96E
loc_5B936:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _fclose
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
call _free
jmp short loc_5B977
loc_5B951:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+8]
mov rdi, [rbp+var_10]
call rax
mov [rbp+var_14], eax
jmp short loc_5B977
loc_5B96E:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_5B97D
loc_5B977:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_5B97D:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long ma_close(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
if ( a1 )
{
if ( *(_DWORD *)a1 == 1 )
{
v2 = fclose(*(_QWORD *)(a1 + 8));
free(a1);
}
else
{
if ( *(_DWORD *)a1 != 2 )
return (unsigned int)-1;
return (unsigned int)(*(long long ( **)(long long))(*(_QWORD *)(rio_plugin + 88LL) + 8LL))(a1);
}
return v2;
}
return (unsigned int)-1;
}
| ma_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0015b91c
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0015b97d
LAB_0015b91c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
SUB EAX,0x1
JZ 0x0015b936
JMP 0x0015b92c
LAB_0015b92c:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x2
JZ 0x0015b951
JMP 0x0015b96e
LAB_0015b936:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00136430
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001361a0
JMP 0x0015b977
LAB_0015b951:
LEA RAX,[0x53cfb0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0015b977
LAB_0015b96e:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0015b97d
LAB_0015b977:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_0015b97d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int ma_close(int *param_1)
{
int local_1c;
int local_c;
if (param_1 == (int *)0x0) {
local_c = -1;
}
else {
if (*param_1 == 1) {
local_1c = fclose(*(FILE **)(param_1 + 2));
free(param_1);
}
else {
if (*param_1 != 2) {
return -1;
}
local_1c = (**(code **)(*(long *)(rio_plugin + 0x58) + 8))(param_1);
}
local_c = local_1c;
}
return local_c;
}
|
|
1,657 | ft_make_key | eloqsql/storage/myisam/ft_update.c | uint _ft_make_key(MI_INFO *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
} | O0 | c | ft_make_key:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x128(%rbp)
movl %esi, -0x12c(%rbp)
movq %rdx, -0x138(%rbp)
movq %rcx, -0x140(%rbp)
movq %r8, -0x148(%rbp)
cmpq $-0x1, -0x148(%rbp)
jne 0xa3301
xorps %xmm0, %xmm0
movsd %xmm0, -0x160(%rbp)
jmp 0xa3315
movq -0x140(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x160(%rbp)
movsd -0x160(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14c(%rbp)
movb -0x149(%rbp), %al
movb %al, -0x120(%rbp)
movb -0x14a(%rbp), %al
movb %al, -0x11f(%rbp)
movb -0x14b(%rbp), %al
movb %al, -0x11e(%rbp)
movb -0x14c(%rbp), %al
movb %al, -0x11d(%rbp)
leaq -0x120(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x158(%rbp)
movq -0x140(%rbp), %rax
movq 0x10(%rax), %rax
movw %ax, %cx
movq -0x158(%rbp), %rax
movw %cx, (%rax)
leaq -0x120(%rbp), %rdi
addq $0x4, %rdi
addq $0x2, %rdi
movq -0x140(%rbp), %rax
movq (%rax), %rsi
movq -0x140(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x2a090
movq -0x128(%rbp), %rdi
movl -0x12c(%rbp), %esi
movq -0x138(%rbp), %rdx
leaq -0x120(%rbp), %rcx
movq -0x148(%rbp), %r8
callq 0xae5c0
movl %eax, -0x164(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xa33fa
movl -0x164(%rbp), %eax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
callq 0x2a270
nop
| _ft_make_key:
push rbp
mov rbp, rsp
sub rsp, 170h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_128], rdi
mov [rbp+var_12C], esi
mov [rbp+var_138], rdx
mov [rbp+var_140], rcx
mov [rbp+var_148], r8
cmp [rbp+var_148], 0FFFFFFFFFFFFFFFFh
jnz short loc_A3301
xorps xmm0, xmm0
movsd [rbp+var_160], xmm0
jmp short loc_A3315
loc_A3301:
mov rax, [rbp+var_140]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_160], xmm0
loc_A3315:
movsd xmm0, [rbp+var_160]
cvtsd2ss xmm0, xmm0
movss [rbp+var_14C], xmm0
mov al, byte ptr [rbp+var_14C+3]
mov [rbp+var_120], al
mov al, byte ptr [rbp+var_14C+2]
mov [rbp+var_11F], al
mov al, byte ptr [rbp+var_14C+1]
mov [rbp+var_11E], al
mov al, byte ptr [rbp+var_14C]
mov [rbp+var_11D], al
lea rax, [rbp+var_120]
add rax, 4
mov [rbp+var_158], rax
mov rax, [rbp+var_140]
mov rax, [rax+10h]
mov cx, ax
mov rax, [rbp+var_158]
mov [rax], cx
lea rdi, [rbp+var_120]
add rdi, 4
add rdi, 2
mov rax, [rbp+var_140]
mov rsi, [rax]
mov rax, [rbp+var_140]
mov rdx, [rax+10h]
call _memcpy
mov rdi, [rbp+var_128]
mov esi, [rbp+var_12C]
mov rdx, [rbp+var_138]
lea rcx, [rbp+var_120]
mov r8, [rbp+var_148]
call _mi_make_key
mov [rbp+var_164], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_A33FA
mov eax, [rbp+var_164]
add rsp, 170h
pop rbp
retn
loc_A33FA:
call ___stack_chk_fail
| long long ft_make_key(long long a1, unsigned int a2, long long a3, long long a4, long long a5)
{
float v5; // xmm0_4
double v7; // [rsp+10h] [rbp-160h]
_BYTE v10[4]; // [rsp+50h] [rbp-120h] BYREF
__int16 v11; // [rsp+54h] [rbp-11Ch]
_BYTE v12[282]; // [rsp+56h] [rbp-11Ah] BYREF
*(_QWORD *)&v12[274] = __readfsqword(0x28u);
if ( a5 == -1 )
v7 = 0.0;
else
v7 = *(double *)(a4 + 8);
v5 = v7;
v10[0] = HIBYTE(v5);
v10[1] = BYTE2(v5);
v10[2] = BYTE1(v5);
v10[3] = LOBYTE(v5);
v11 = *(_QWORD *)(a4 + 16);
memcpy(v12, *(_QWORD *)a4, *(_QWORD *)(a4 + 16));
return (unsigned int)mi_make_key(a1, a2, a3, v10, a5);
}
| _ft_make_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x128],RDI
MOV dword ptr [RBP + -0x12c],ESI
MOV qword ptr [RBP + -0x138],RDX
MOV qword ptr [RBP + -0x140],RCX
MOV qword ptr [RBP + -0x148],R8
CMP qword ptr [RBP + -0x148],-0x1
JNZ 0x001a3301
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x160],XMM0
JMP 0x001a3315
LAB_001a3301:
MOV RAX,qword ptr [RBP + -0x140]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x160],XMM0
LAB_001a3315:
MOVSD XMM0,qword ptr [RBP + -0x160]
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RBP + -0x14c],XMM0
MOV AL,byte ptr [RBP + -0x149]
MOV byte ptr [RBP + -0x120],AL
MOV AL,byte ptr [RBP + -0x14a]
MOV byte ptr [RBP + -0x11f],AL
MOV AL,byte ptr [RBP + -0x14b]
MOV byte ptr [RBP + -0x11e],AL
MOV AL,byte ptr [RBP + -0x14c]
MOV byte ptr [RBP + -0x11d],AL
LEA RAX,[RBP + -0x120]
ADD RAX,0x4
MOV qword ptr [RBP + -0x158],RAX
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX + 0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x158]
MOV word ptr [RAX],CX
LEA RDI,[RBP + -0x120]
ADD RDI,0x4
ADD RDI,0x2
MOV RAX,qword ptr [RBP + -0x140]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x140]
MOV RDX,qword ptr [RAX + 0x10]
CALL 0x0012a090
MOV RDI,qword ptr [RBP + -0x128]
MOV ESI,dword ptr [RBP + -0x12c]
MOV RDX,qword ptr [RBP + -0x138]
LEA RCX,[RBP + -0x120]
MOV R8,qword ptr [RBP + -0x148]
CALL 0x001ae5c0
MOV dword ptr [RBP + -0x164],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001a33fa
MOV EAX,dword ptr [RBP + -0x164]
ADD RSP,0x170
POP RBP
RET
LAB_001a33fa:
CALL 0x0012a270
|
int4
_ft_make_key(int8 param_1,int4 param_2,int8 param_3,int8 *param_4,
long param_5)
{
int4 uVar1;
long in_FS_OFFSET;
float fVar2;
double local_168;
int1 local_154;
int1 uStack_153;
int1 uStack_152;
int1 uStack_151;
int1 local_128;
int1 local_127;
int1 local_126;
int1 local_125;
int2 local_124;
int1 auStack_122 [274];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (param_5 == -1) {
local_168 = 0.0;
}
else {
local_168 = (double)param_4[1];
}
fVar2 = (float)local_168;
uStack_151 = (int1)((uint)fVar2 >> 0x18);
local_128 = uStack_151;
uStack_152 = (int1)((uint)fVar2 >> 0x10);
local_127 = uStack_152;
uStack_153 = (int1)((uint)fVar2 >> 8);
local_126 = uStack_153;
local_154 = SUB41(fVar2,0);
local_125 = local_154;
local_124 = (int2)param_4[2];
memcpy(auStack_122,(void *)*param_4,param_4[2]);
uVar1 = _mi_make_key(param_1,param_2,param_3,&local_128,param_5);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,658 | uf_space_endspace | eloqsql/storage/maria/ma_packrec.c | static void uf_space_endspace(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
bfill(to, (end-to), ' ');
else
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill(end - spaces, spaces, ' ');
}
} | O0 | c | uf_space_endspace:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x4d2c7
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x4d2eb
jmp 0x4d309
movq -0x10(%rbp), %rdi
callq 0x4c900
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0x4d309
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
movl $0x20, %esi
callq 0x2a2a0
jmp 0x4d3d4
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jb 0x4d34c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, %edx
leaq 0x270dbc(%rip), %rcx # 0x2be100
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0x4d35f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x4c0b0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0x4d381
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x4d3d4
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0x4d3b4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %r8d
xorl %eax, %eax
subq %r8, %rax
addq %rax, %rcx
callq 0x4cc40
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| uf_space_endspace:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_4D2C7
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_4D2EB
jmp short loc_4D309
loc_4D2C7:
mov rdi, [rbp+var_10]
call fill_buffer
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_4D309
loc_4D2EB:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
mov esi, 20h ; ' '
call _memset
jmp loc_4D3D4
loc_4D309:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+24h]
jb short loc_4D34C
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+24h]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+24h]
mov edx, ecx
lea rcx, mask
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_4D35F
loc_4D34C:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+24h]
call fill_and_get_bits
mov [rbp+var_28], eax
loc_4D35F:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_4D381
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_4D3D4
loc_4D381:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_4D3B4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov r8d, eax
xor eax, eax
sub rax, r8
add rcx, rax
call decode_bytes
loc_4D3B4:
mov rdi, [rbp+var_20]
mov eax, [rbp+var_24]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
loc_4D3D4:
add rsp, 30h
pop rbp
retn
| long long uf_space_endspace(long long a1, int *a2, _BYTE *a3, _BYTE *a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int v7; // eax
int v8; // ecx
unsigned int bits; // [rsp+8h] [rbp-28h]
if ( a2[1] )
{
v4 = *a2;
v5 = a2[1] - 1;
a2[1] = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 32LL, a4 - a3);
}
fill_buffer((long long)a2);
a2[1] = 31;
if ( *a2 < 0 )
return memset(a3, 32LL, a4 - a3);
LABEL_6:
if ( (unsigned int)a2[1] < *(_DWORD *)(a1 + 36) )
{
bits = fill_and_get_bits(a2, *(_DWORD *)(a1 + 36));
}
else
{
v7 = *a2;
v8 = a2[1] - *(_DWORD *)(a1 + 36);
a2[1] = v8;
bits = mask[*(unsigned int *)(a1 + 36)] & (v7 >> v8);
}
if ( &a3[bits] <= a4 )
{
if ( &a3[bits] != a4 )
decode_bytes(a1, (long long)a2, a3, &a4[-bits]);
return memset(&a4[-bits], 32LL, bits);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
| uf_space_endspace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0014d2c7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x0014d2eb
JMP 0x0014d309
LAB_0014d2c7:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014c900
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x0014d309
LAB_0014d2eb:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
MOV ESI,0x20
CALL 0x0012a2a0
JMP 0x0014d3d4
LAB_0014d309:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x24]
JC 0x0014d34c
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x24]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x24]
MOV EDX,ECX
LEA RCX,[0x3be100]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0014d35f
LAB_0014d34c:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x24]
CALL 0x0014c0b0
MOV dword ptr [RBP + -0x28],EAX
LAB_0014d35f:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0014d381
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x0014d3d4
LAB_0014d381:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x0014d3b4
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV R8D,EAX
XOR EAX,EAX
SUB RAX,R8
ADD RCX,RAX
CALL 0x0014cc40
LAB_0014d3b4:
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2a0
LAB_0014d3d4:
ADD RSP,0x30
POP RBP
RET
|
void uf_space_endspace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x24)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x24));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x24);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x24) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 - local_30);
}
memset((void *)(param_4 - local_30),0x20,(ulong)local_30);
}
}
else {
memset(param_3,0x20,param_4 - (long)param_3);
}
return;
}
|
|
1,659 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O3 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x240(%rbp), %r15
movl $0x201, %edx # imm = 0x201
movq %r15, %rdi
movq %rbx, %rsi
callq 0x624e4
cmpb $0x0, (%rax)
je 0x3447f
callq 0x24050
movl $0x24, (%rax)
jmp 0x34556
cmpb $0x2f, -0x240(%rbp)
jne 0x3452b
movq %rax, %r12
movq %r14, -0x248(%rbp)
movb -0x23f(%rbp), %al
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpb $0x2f, %al
je 0x3453b
leaq -0x23f(%rbp), %rcx
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movq %r15, %rsi
incq %rcx
movq %rcx, %r15
testb %al, %al
je 0x344d4
movzbl %al, %eax
cmpl $0x2f, %eax
je 0x344d4
movb (%r15), %al
incq %r15
jmp 0x344c0
movb $0x0, -0x1(%r15)
cmpw $0x2e, (%rsi)
je 0x34538
movzwl (%rsi), %eax
xorl $0x2e2e, %eax # imm = 0x2E2E
movzbl 0x2(%rsi), %ecx
orw %ax, %cx
je 0x34538
cmpq %r12, %r15
jae 0x3457c
movl %r14d, %edi
movl $0x2a0000, %edx # imm = 0x2A0000
xorl %eax, %eax
callq 0x242a0
testl %eax, %eax
js 0x34549
movl %eax, %r13d
testl %r14d, %r14d
js 0x3451c
movl %r14d, %edi
callq 0x245b0
movb (%r15), %al
movl %r13d, %r14d
movq %r15, %rcx
cmpb $0x2f, %al
jne 0x344b7
jmp 0x3453b
callq 0x24050
movl $0x2, (%rax)
jmp 0x34556
movl %r14d, %r13d
callq 0x24050
movl $0x2, (%rax)
movl %r13d, %r14d
testl %r14d, %r14d
js 0x34556
movl %r14d, %edi
callq 0x245b0
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x34595
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x248(%rbp), %rax
movl %r14d, (%rax)
leaq -0x240(%rbp), %rax
subq %rax, %rsi
addq %rsi, %rbx
jmp 0x34558
callq 0x24300
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 228h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_240]
mov edx, 201h
mov rdi, r15
mov rsi, rbx
call strnmov
cmp byte ptr [rax], 0
jz short loc_3447F
call ___errno_location
mov dword ptr [rax], 24h ; '$'
jmp loc_34556
loc_3447F:
cmp [rbp+var_240], 2Fh ; '/'
jnz loc_3452B
mov r12, rax
mov [rbp+var_248], r14
mov al, [rbp+var_23F]
mov r13d, 0FFFFFFFFh
cmp al, 2Fh ; '/'
jz loc_3453B
lea rcx, [rbp+var_23F]
mov r14d, 0FFFFFFFFh
loc_344B7:
mov rsi, r15
inc rcx
mov r15, rcx
loc_344C0:
test al, al
jz short loc_344D4
movzx eax, al
cmp eax, 2Fh ; '/'
jz short loc_344D4
mov al, [r15]
inc r15
jmp short loc_344C0
loc_344D4:
mov byte ptr [r15-1], 0
cmp word ptr [rsi], 2Eh ; '.'
jz short loc_34538
movzx eax, word ptr [rsi]
xor eax, 2E2Eh
movzx ecx, byte ptr [rsi+2]
or cx, ax
jz short loc_34538
cmp r15, r12
jnb loc_3457C
mov edi, r14d
mov edx, offset unk_2A0000
xor eax, eax
call _openat64
test eax, eax
js short loc_34549
mov r13d, eax
test r14d, r14d
js short loc_3451C
mov edi, r14d
call _close
loc_3451C:
mov al, [r15]
mov r14d, r13d
mov rcx, r15
cmp al, 2Fh ; '/'
jnz short loc_344B7
jmp short loc_3453B
loc_3452B:
call ___errno_location
mov dword ptr [rax], 2
jmp short loc_34556
loc_34538:
mov r13d, r14d
loc_3453B:
call ___errno_location
mov dword ptr [rax], 2
mov r14d, r13d
loc_34549:
test r14d, r14d
js short loc_34556
mov edi, r14d
call _close
loc_34556:
xor ebx, ebx
loc_34558:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_34595
mov rax, rbx
add rsp, 228h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3457C:
mov rax, [rbp+var_248]
mov [rax], r14d
lea rax, [rbp+var_240]
sub rsi, rax
add rbx, rsi
jmp short loc_34558
loc_34595:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, unsigned int *a2)
{
char *v3; // r15
char *v4; // rdi
char *v5; // rax
char *v6; // r12
char v7; // al
int v8; // r13d
char *v9; // rcx
unsigned int v10; // r14d
char *v11; // rsi
long long v12; // rcx
int v13; // eax
unsigned int *v16; // [rsp+8h] [rbp-248h]
char v17; // [rsp+10h] [rbp-240h] BYREF
char v18; // [rsp+11h] [rbp-23Fh] BYREF
unsigned long long v19; // [rsp+220h] [rbp-30h]
v19 = __readfsqword(0x28u);
v3 = &v17;
v4 = &v17;
v5 = (char *)strnmov(&v17, a1, 513LL);
if ( *v5 )
{
*(_DWORD *)__errno_location(&v17) = 36;
return 0LL;
}
if ( v17 != 47 )
{
*(_DWORD *)__errno_location(&v17) = 2;
return 0LL;
}
v6 = v5;
v16 = a2;
v7 = v18;
v8 = -1;
if ( v18 == 47 )
{
LABEL_20:
*(_DWORD *)__errno_location(v4) = 2;
v10 = v8;
LABEL_21:
if ( (v10 & 0x80000000) == 0 )
close(v10);
return 0LL;
}
v9 = &v18;
v10 = -1;
while ( 1 )
{
v11 = v3;
v3 = v9 + 1;
while ( v7 && v7 != 47 )
v7 = *v3++;
*(v3 - 1) = 0;
if ( *(_WORD *)v11 == 46 || (v12 = (unsigned __int8)v11[2], LOWORD(v12) = *(_WORD *)v11 ^ 0x2E2E | v12, !(_WORD)v12) )
{
v8 = v10;
goto LABEL_20;
}
if ( v3 >= v6 )
break;
v4 = (char *)v10;
v13 = openat64(v10, v11, &unk_2A0000, v12);
if ( v13 < 0 )
goto LABEL_21;
v8 = v13;
if ( (v10 & 0x80000000) == 0 )
{
v4 = (char *)v10;
close(v10);
}
v7 = *v3;
v10 = v8;
v9 = v3;
if ( *v3 == 47 )
goto LABEL_20;
}
*v16 = v10;
return v11 - &v17 + a1;
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x240]
MOV EDX,0x201
MOV RDI,R15
MOV RSI,RBX
CALL 0x001624e4
CMP byte ptr [RAX],0x0
JZ 0x0013447f
CALL 0x00124050
MOV dword ptr [RAX],0x24
JMP 0x00134556
LAB_0013447f:
CMP byte ptr [RBP + -0x240],0x2f
JNZ 0x0013452b
MOV R12,RAX
MOV qword ptr [RBP + -0x248],R14
MOV AL,byte ptr [RBP + -0x23f]
MOV R13D,0xffffffff
CMP AL,0x2f
JZ 0x0013453b
LEA RCX,[RBP + -0x23f]
MOV R14D,0xffffffff
LAB_001344b7:
MOV RSI,R15
INC RCX
MOV R15,RCX
LAB_001344c0:
TEST AL,AL
JZ 0x001344d4
MOVZX EAX,AL
CMP EAX,0x2f
JZ 0x001344d4
MOV AL,byte ptr [R15]
INC R15
JMP 0x001344c0
LAB_001344d4:
MOV byte ptr [R15 + -0x1],0x0
CMP word ptr [RSI],0x2e
JZ 0x00134538
MOVZX EAX,word ptr [RSI]
XOR EAX,0x2e2e
MOVZX ECX,byte ptr [RSI + 0x2]
OR CX,AX
JZ 0x00134538
CMP R15,R12
JNC 0x0013457c
MOV EDI,R14D
MOV EDX,0x2a0000
XOR EAX,EAX
CALL 0x001242a0
TEST EAX,EAX
JS 0x00134549
MOV R13D,EAX
TEST R14D,R14D
JS 0x0013451c
MOV EDI,R14D
CALL 0x001245b0
LAB_0013451c:
MOV AL,byte ptr [R15]
MOV R14D,R13D
MOV RCX,R15
CMP AL,0x2f
JNZ 0x001344b7
JMP 0x0013453b
LAB_0013452b:
CALL 0x00124050
MOV dword ptr [RAX],0x2
JMP 0x00134556
LAB_00134538:
MOV R13D,R14D
LAB_0013453b:
CALL 0x00124050
MOV dword ptr [RAX],0x2
MOV R14D,R13D
LAB_00134549:
TEST R14D,R14D
JS 0x00134556
MOV EDI,R14D
CALL 0x001245b0
LAB_00134556:
XOR EBX,EBX
LAB_00134558:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00134595
MOV RAX,RBX
ADD RSP,0x228
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013457c:
MOV RAX,qword ptr [RBP + -0x248]
MOV dword ptr [RAX],R14D
LEA RAX,[RBP + -0x240]
SUB RSI,RAX
ADD RBX,RSI
JMP 0x00134558
LAB_00134595:
CALL 0x00124300
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
short *psVar1;
int iVar2;
short *psVar3;
int *piVar4;
long lVar5;
int __fd;
short *psVar6;
short *__file;
long in_FS_OFFSET;
int1 local_248 [2];
int1 local_246 [526];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
psVar3 = (short *)strnmov(local_248,param_1,0x201);
if ((char)*psVar3 == '\0') {
if (local_248[0] == '/') {
__fd = -1;
if (local_248[1] != '/') {
psVar1 = (short *)(local_248 + 1);
__file = (short *)local_248;
__fd = -1;
do {
while ((psVar6 = (short *)((long)psVar1 + 1), local_248[1] != '\0' &&
(local_248[1] != '/'))) {
psVar1 = psVar6;
local_248[1] = *(char *)psVar6;
}
*(char *)psVar1 = '\0';
if ((*__file == 0x2e) || ((char)__file[1] == '\0' && *__file == 0x2e2e)) break;
if (psVar3 <= psVar6) {
*param_2 = __fd;
lVar5 = (long)__file + (param_1 - (long)local_248);
goto LAB_00134558;
}
iVar2 = openat64(__fd,(char *)__file,0x2a0000);
if (iVar2 < 0) goto LAB_00134549;
if (-1 < __fd) {
close(__fd);
}
local_248[1] = *(char *)psVar6;
__fd = iVar2;
psVar1 = psVar6;
__file = psVar6;
} while (local_248[1] != '/');
}
piVar4 = __errno_location();
*piVar4 = 2;
LAB_00134549:
if (-1 < __fd) {
close(__fd);
}
}
else {
piVar4 = __errno_location();
*piVar4 = 2;
}
}
else {
piVar4 = __errno_location();
*piVar4 = 0x24;
}
lVar5 = 0;
LAB_00134558:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return lVar5;
}
|
|
1,660 | rb_delete_fixup | eloqsql/mysys/tree.c | static void rb_delete_fixup(TREE *tree, TREE_ELEMENT ***parent)
{
TREE_ELEMENT *x,*w,*par;
x= **parent;
while (x != tree->root && x->colour == BLACK)
{
if (x == (par=parent[-1][0])->left)
{
w=par->right;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
left_rotate(parent[-1],par);
parent[0]= &w->left;
*++parent= &par->left;
w=par->right;
}
if (w->left->colour == BLACK && w->right->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->right->colour == BLACK)
{
w->left->colour=BLACK;
w->colour=RED;
right_rotate(&par->right,w);
w=par->right;
}
w->colour=par->colour;
par->colour=BLACK;
w->right->colour=BLACK;
left_rotate(parent[-1],par);
x=tree->root;
break;
}
}
else
{
w=par->left;
if (w->colour == RED)
{
w->colour=BLACK;
par->colour=RED;
right_rotate(parent[-1],par);
parent[0]= &w->right;
*++parent= &par->right;
w=par->left;
}
if (w->right->colour == BLACK && w->left->colour == BLACK)
{
w->colour=RED;
x=par;
parent--;
}
else
{
if (w->left->colour == BLACK)
{
w->right->colour=BLACK;
w->colour=RED;
left_rotate(&par->left,w);
w=par->left;
}
w->colour=par->colour;
par->colour=BLACK;
w->left->colour=BLACK;
right_rotate(parent[-1],par);
x=tree->root;
break;
}
}
}
x->colour=BLACK;
} | O0 | c | rb_delete_fixup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x29(%rbp)
je 0xfb113
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xfb11f
jmp 0xfb48a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
cmpq (%rcx), %rax
jne 0xfb2e3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xfb1be
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc0c0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb20f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb20f
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xfb2de
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb26b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0xfc100
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc0c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfb48a
jmp 0xfb485
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0xfb36c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc100
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb3bd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb3bd
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xfb483
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x1, %eax
jne 0xfb414
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x0, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xfc0c0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %edx
shrl $0x1f, %edx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfb48a
jmp 0xfb485
jmp 0xfb0ee
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
orl $0x80000000, %ecx # imm = 0x80000000
movl %ecx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| rb_delete_fixup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax]
mov [rbp+var_18], rax
loc_FB0EE:
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_8]
xor eax, eax
cmp rcx, [rdx]
mov [rbp+var_29], al
jz short loc_FB113
mov rax, [rbp+var_18]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
setz al
mov [rbp+var_29], al
loc_FB113:
mov al, [rbp+var_29]
test al, 1
jnz short loc_FB11F
jmp loc_FB48A
loc_FB11F:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx-8]
mov rcx, [rcx]
mov [rbp+var_28], rcx
cmp rax, [rcx]
jnz loc_FB2E3
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FB1BE
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_FB1BE:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB20F
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB20F
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_FB2DE
loc_FB20F:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB26B
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_20]
call right_rotate
mov rax, [rbp+var_28]
mov rax, [rax+8]
mov [rbp+var_20], rax
loc_FB26B:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call left_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_FB48A
loc_FB2DE:
jmp loc_FB485
loc_FB2E3:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 0
jnz short loc_FB36C
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rcx, [rbp+var_20]
add rcx, 8
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_28]
add rcx, 8
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_FB36C:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB3BD
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB3BD
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
jmp loc_FB483
loc_FB3BD:
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
shr eax, 1Fh
cmp eax, 1
jnz short loc_FB414
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 0
mov [rax+10h], ecx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call left_rotate
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
loc_FB414:
mov rax, [rbp+var_28]
mov edx, [rax+10h]
shr edx, 1Fh
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
and edx, 1
shl edx, 1Fh
and ecx, 7FFFFFFFh
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_28]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax-8]
mov rsi, [rbp+var_28]
call right_rotate
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_FB48A
loc_FB483:
jmp short $+2
loc_FB485:
jmp loc_FB0EE
loc_FB48A:
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
and ecx, 7FFFFFFFh
or ecx, 80000000h
mov [rax+10h], ecx
add rsp, 30h
pop rbp
retn
| long long * rb_delete_fixup(long long **a1, _QWORD **a2)
{
_QWORD *v2; // rax
_QWORD *v3; // rax
long long *result; // rax
bool v5; // [rsp+7h] [rbp-29h]
long long *v6; // [rsp+8h] [rbp-28h]
long long v7; // [rsp+10h] [rbp-20h]
long long v8; // [rsp+10h] [rbp-20h]
long long *v9; // [rsp+18h] [rbp-18h]
_QWORD *v10; // [rsp+20h] [rbp-10h]
v10 = a2;
v9 = (long long *)**a2;
while ( 1 )
{
v5 = 0;
if ( v9 != *a1 )
v5 = *((_DWORD *)v9 + 4) >> 31 == 1;
if ( !v5 )
break;
v6 = *(long long **)*(v10 - 1);
if ( v9 == (long long *)*v6 )
{
v7 = v6[1];
if ( *(int *)(v7 + 16) >= 0 )
{
*(_DWORD *)(v7 + 16) = *(_DWORD *)(v7 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
left_rotate(*(v10 - 1), v6);
*v10 = v7;
v2 = v10++;
v2[1] = v6;
v7 = v6[1];
}
if ( *(_DWORD *)(*(_QWORD *)v7 + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)v7 + 16LL) = *(_DWORD *)(*(_QWORD *)v7 + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v7 + 16) &= ~0x80000000;
right_rotate(v6 + 1, v7);
v7 = v6[1];
}
*(_DWORD *)(v7 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v7 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v7 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
left_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v7 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
else
{
v8 = *v6;
if ( *(int *)(*v6 + 16) >= 0 )
{
*(_DWORD *)(v8 + 16) = *(_DWORD *)(v8 + 16) & 0x7FFFFFFF | 0x80000000;
*((_DWORD *)v6 + 4) &= ~0x80000000;
right_rotate(*(v10 - 1), v6);
*v10 = v8 + 8;
v3 = v10++;
v3[1] = v6 + 1;
v8 = *v6;
}
if ( *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) >> 31 != 1 || *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 != 1 )
{
if ( *(_DWORD *)(*(_QWORD *)v8 + 16LL) >> 31 == 1 )
{
*(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) = *(_DWORD *)(*(_QWORD *)(v8 + 8) + 16LL) & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(v8 + 16) &= ~0x80000000;
left_rotate(v6, v8);
v8 = *v6;
}
*(_DWORD *)(v8 + 16) = (*((_DWORD *)v6 + 4) >> 31 << 31) | *(_DWORD *)(v8 + 16) & 0x7FFFFFFF;
*((_DWORD *)v6 + 4) = v6[2] & 0x7FFFFFFF | 0x80000000;
*(_DWORD *)(*(_QWORD *)v8 + 16LL) = *(_DWORD *)(*(_QWORD *)v8 + 16LL) & 0x7FFFFFFF | 0x80000000;
right_rotate(*(v10 - 1), v6);
v9 = *a1;
break;
}
*(_DWORD *)(v8 + 16) &= ~0x80000000;
v9 = v6;
--v10;
}
}
result = v9;
*((_DWORD *)v9 + 4) = v9[2] & 0x7FFFFFFF | 0x80000000;
return result;
}
| rb_delete_fixup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001fb0ee:
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x8]
XOR EAX,EAX
CMP RCX,qword ptr [RDX]
MOV byte ptr [RBP + -0x29],AL
JZ 0x001fb113
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_001fb113:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x001fb11f
JMP 0x001fb48a
LAB_001fb11f:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + -0x8]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RBP + -0x28],RCX
CMP RAX,qword ptr [RCX]
JNZ 0x001fb2e3
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001fb1be
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc0c0
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fb1be:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb20f
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb20f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001fb2de
LAB_001fb20f:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb26b
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001fc100
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fb26b:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc0c0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fb48a
LAB_001fb2de:
JMP 0x001fb485
LAB_001fb2e3:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x0
JNZ 0x001fb36c
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc100
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fb36c:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb3bd
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb3bd
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001fb483
LAB_001fb3bd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
SHR EAX,0x1f
CMP EAX,0x1
JNZ 0x001fb414
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x0
MOV dword ptr [RAX + 0x10],ECX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001fc0c0
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001fb414:
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x10]
SHR EDX,0x1f
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x1
SHL EDX,0x1f
AND ECX,0x7fffffff
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001fc100
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fb48a
LAB_001fb483:
JMP 0x001fb485
LAB_001fb485:
JMP 0x001fb0ee
LAB_001fb48a:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x7fffffff
OR ECX,0x80000000
MOV dword ptr [RAX + 0x10],ECX
ADD RSP,0x30
POP RBP
RET
|
void rb_delete_fixup(long *param_1,long *param_2)
{
long *plVar1;
bool bVar2;
long *local_28;
long *local_20;
long *local_18;
local_20 = *(long **)*param_2;
local_18 = param_2;
do {
bVar2 = false;
if (local_20 != (long *)*param_1) {
bVar2 = (int)local_20[2] < 0;
}
if (!bVar2) goto LAB_001fb48a;
plVar1 = *(long **)local_18[-1];
if (local_20 == (long *)*plVar1) {
local_28 = (long *)plVar1[1];
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
left_rotate(local_18[-1],plVar1);
*local_18 = (long)local_28;
local_18[1] = (long)plVar1;
local_28 = (long *)plVar1[1];
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(*local_28 + 0x10)) || (-1 < *(int *)(local_28[1] + 0x10))) {
if (*(int *)(local_28[1] + 0x10) < 0) {
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
right_rotate(plVar1 + 1,local_28);
local_28 = (long *)plVar1[1];
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
left_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
LAB_001fb48a:
*(uint *)(local_20 + 2) = *(uint *)(local_20 + 2) & 0x7fffffff | 0x80000000;
return;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
else {
local_28 = (long *)*plVar1;
if (-1 < (int)local_28[2]) {
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff;
right_rotate(local_18[-1],plVar1);
*local_18 = (long)(local_28 + 1);
local_18[1] = (long)(plVar1 + 1);
local_28 = (long *)*plVar1;
local_18 = local_18 + 1;
}
if ((-1 < *(int *)(local_28[1] + 0x10)) || (-1 < *(int *)(*local_28 + 0x10))) {
if (*(int *)(*local_28 + 0x10) < 0) {
*(uint *)(local_28[1] + 0x10) = *(uint *)(local_28[1] + 0x10) & 0x7fffffff | 0x80000000;
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
left_rotate(plVar1,local_28);
local_28 = (long *)*plVar1;
}
*(uint *)(local_28 + 2) =
*(uint *)(local_28 + 2) & 0x7fffffff | *(uint *)(plVar1 + 2) & 0x80000000;
*(uint *)(plVar1 + 2) = *(uint *)(plVar1 + 2) & 0x7fffffff | 0x80000000;
*(uint *)(*local_28 + 0x10) = *(uint *)(*local_28 + 0x10) & 0x7fffffff | 0x80000000;
right_rotate(local_18[-1],plVar1);
local_20 = (long *)*param_1;
goto LAB_001fb48a;
}
*(uint *)(local_28 + 2) = *(uint *)(local_28 + 2) & 0x7fffffff;
}
local_18 = local_18 + -1;
local_20 = plVar1;
} while( true );
}
|
|
1,661 | diag | eloqsql/libmariadb/unittest/mytap/tap.c | void
diag(char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(tapout, "# ");
vfprintf(tapout, fmt, ap);
emit_endl();
va_end(ap);
} | O0 | c | diag:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1bb65
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x4a414(%rip), %rax # 0x65fc8
movq %rax, -0xd8(%rbp)
movq (%rax), %rdi
leaq 0x37287(%rip), %rsi # 0x52e4c
xorl %eax, %eax
callq 0x13660
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x135e0
callq 0x1c250
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| diag:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_1BB65
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_1BB65:
mov [rbp+var_A8], r9
mov [rbp+var_B0], r8
mov [rbp+var_B8], rcx
mov [rbp+var_C0], rdx
mov [rbp+var_C8], rsi
mov [rbp+var_8], rdi
lea rax, [rbp+var_D0]
mov [rbp+var_10], rax
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
mov [rbp+var_1C], 30h ; '0'
mov [rbp+var_20], 8
mov rax, cs:stdout_ptr
mov [rbp+var_D8], rax
mov rdi, [rax]
lea rsi, asc_52E4C; "# "
xor eax, eax
call _fprintf
mov rax, [rbp+var_D8]
mov rdi, [rax]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_20]
call _vfprintf
call emit_endl
add rsp, 0E0h
pop rbp
retn
| long long diag(
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,
char a15)
{
char v16; // [rsp+10h] [rbp-D0h] BYREF
long long v17; // [rsp+18h] [rbp-C8h]
long long v18; // [rsp+20h] [rbp-C0h]
long long v19; // [rsp+28h] [rbp-B8h]
long long v20; // [rsp+30h] [rbp-B0h]
long long v21; // [rsp+38h] [rbp-A8h]
__m128 v22; // [rsp+40h] [rbp-A0h]
__m128 v23; // [rsp+50h] [rbp-90h]
__m128 v24; // [rsp+60h] [rbp-80h]
__m128 v25; // [rsp+70h] [rbp-70h]
__m128 v26; // [rsp+80h] [rbp-60h]
__m128 v27; // [rsp+90h] [rbp-50h]
__m128 v28; // [rsp+A0h] [rbp-40h]
__m128 v29; // [rsp+B0h] [rbp-30h]
_DWORD v30[2]; // [rsp+C0h] [rbp-20h] BYREF
char *v31; // [rsp+C8h] [rbp-18h]
char *v32; // [rsp+D0h] [rbp-10h]
long long v33; // [rsp+D8h] [rbp-8h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v21 = a6;
v20 = a5;
v19 = a4;
v18 = a3;
v17 = a2;
v33 = a1;
v32 = &v16;
v31 = &a15;
v30[1] = 48;
v30[0] = 8;
fprintf(stdout, "# ");
vfprintf(stdout, v33, v30);
return emit_endl();
}
| diag:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x0011bb65
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0011bb65:
MOV qword ptr [RBP + -0xa8],R9
MOV qword ptr [RBP + -0xb0],R8
MOV qword ptr [RBP + -0xb8],RCX
MOV qword ptr [RBP + -0xc0],RDX
MOV qword ptr [RBP + -0xc8],RSI
MOV qword ptr [RBP + -0x8],RDI
LEA RAX,[RBP + -0xd0]
MOV qword ptr [RBP + -0x10],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x30
MOV dword ptr [RBP + -0x20],0x8
MOV RAX,qword ptr [0x00165fc8]
MOV qword ptr [RBP + -0xd8],RAX
MOV RDI,qword ptr [RAX]
LEA RSI,[0x152e4c]
XOR EAX,EAX
CALL 0x00113660
MOV RAX,qword ptr [RBP + -0xd8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x20]
CALL 0x001135e0
CALL 0x0011c250
ADD RSP,0xe0
POP RBP
RET
|
void diag(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,char *param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
int *puVar1;
char in_AL;
int1 local_d8 [8];
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int4 local_28;
int4 local_24;
int1 *local_20;
int1 *local_18;
char *local_10;
puVar1 = PTR_stdout_00165fc8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_18 = local_d8;
local_20 = &stack0x00000008;
local_24 = 0x30;
local_28 = 8;
local_d0 = param_10;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
local_10 = param_9;
fprintf(*(FILE **)PTR_stdout_00165fc8,"# ");
vfprintf(*(FILE **)puVar1,local_10,&local_28);
emit_endl();
return;
}
|
|
1,662 | ma_set_share_data_file_length | eloqsql/storage/maria/ma_state.c | void _ma_set_share_data_file_length(MARIA_SHARE *share, ulonglong new_length)
{
if (!share->internal_table)
mysql_mutex_lock(&share->intern_lock);
if (share->state.state.data_file_length < new_length)
{
share->state.state.data_file_length= new_length;
if (new_length >= share->base.max_data_file_length)
{
/* Give an error on next insert */
share->state.changed|= STATE_DATA_FILE_FULL;
}
}
if (!share->internal_table)
mysql_mutex_unlock(&share->intern_lock);
} | O3 | c | ma_set_share_data_file_length:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x7e2(%rdi)
jne 0x3891c
leaq 0x8f0(%rbx), %rdi
cmpq $0x0, 0x930(%rbx)
jne 0x38963
callq 0x29220
cmpq %r14, 0x40(%rbx)
jae 0x38936
movq %r14, 0x40(%rbx)
cmpq %r14, 0x368(%rbx)
ja 0x38936
orb $0x10, 0x171(%rbx)
cmpb $0x0, 0x7e2(%rbx)
je 0x38944
popq %rbx
popq %r14
popq %rbp
retq
movq 0x930(%rbx), %rdi
addq $0x8f0, %rbx # imm = 0x8F0
testq %rdi, %rdi
jne 0x38976
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x291e0
leaq 0xa0a7d(%rip), %rsi # 0xd93e7
movl $0x313, %edx # imm = 0x313
callq 0x2eb8f
jmp 0x3891c
leaq 0x34d693(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x38957
| _ma_set_share_data_file_length:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
cmp byte ptr [rdi+7E2h], 0
jnz short loc_3891C
lea rdi, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz short loc_38963
call _pthread_mutex_lock
loc_3891C:
cmp [rbx+40h], r14
jnb short loc_38936
mov [rbx+40h], r14
cmp [rbx+368h], r14
ja short loc_38936
or byte ptr [rbx+171h], 10h
loc_38936:
cmp byte ptr [rbx+7E2h], 0
jz short loc_38944
pop rbx
pop r14
pop rbp
retn
loc_38944:
mov rdi, [rbx+930h]
add rbx, 8F0h
test rdi, rdi
jnz short loc_38976
loc_38957:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_38963:
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 313h
call psi_mutex_lock
jmp short loc_3891C
loc_38976:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_38957
| long long ma_set_share_data_file_length(long long a1, unsigned long long a2)
{
long long v3; // rdi
long long result; // rax
long long v5; // rdi
long long v6; // rbx
if ( !*(_BYTE *)(a1 + 2018) )
{
v3 = a1 + 2288;
if ( *(_QWORD *)(a1 + 2352) )
result = psi_mutex_lock(v3, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0x313u);
else
result = pthread_mutex_lock(v3);
}
if ( *(_QWORD *)(a1 + 64) < a2 )
{
*(_QWORD *)(a1 + 64) = a2;
if ( *(_QWORD *)(a1 + 872) <= a2 )
*(_BYTE *)(a1 + 369) |= 0x10u;
}
if ( !*(_BYTE *)(a1 + 2018) )
{
v5 = *(_QWORD *)(a1 + 2352);
v6 = a1 + 2288;
if ( v5 )
PSI_server[44]();
return pthread_mutex_unlock(v6);
}
return result;
}
| _ma_set_share_data_file_length:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CMP byte ptr [RDI + 0x7e2],0x0
JNZ 0x0013891c
LEA RDI,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x00138963
CALL 0x00129220
LAB_0013891c:
CMP qword ptr [RBX + 0x40],R14
JNC 0x00138936
MOV qword ptr [RBX + 0x40],R14
CMP qword ptr [RBX + 0x368],R14
JA 0x00138936
OR byte ptr [RBX + 0x171],0x10
LAB_00138936:
CMP byte ptr [RBX + 0x7e2],0x0
JZ 0x00138944
POP RBX
POP R14
POP RBP
RET
LAB_00138944:
MOV RDI,qword ptr [RBX + 0x930]
ADD RBX,0x8f0
TEST RDI,RDI
JNZ 0x00138976
LAB_00138957:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001291e0
LAB_00138963:
LEA RSI,[0x1d93e7]
MOV EDX,0x313
CALL 0x0012eb8f
JMP 0x0013891c
LAB_00138976:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00138957
|
void _ma_set_share_data_file_length(long param_1,ulong param_2)
{
if (*(char *)(param_1 + 0x7e2) == '\0') {
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x8f0));
}
else {
psi_mutex_lock((pthread_mutex_t *)(param_1 + 0x8f0),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0x313);
}
}
if ((*(ulong *)(param_1 + 0x40) < param_2) &&
(*(ulong *)(param_1 + 0x40) = param_2, *(ulong *)(param_1 + 0x368) <= param_2)) {
*(byte *)(param_1 + 0x171) = *(byte *)(param_1 + 0x171) | 0x10;
}
if (*(char *)(param_1 + 0x7e2) != '\0') {
return;
}
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x8f0));
return;
}
|
|
1,663 | MNN::CreateEltwiseInt8(flatbuffers::FlatBufferBuilder&, MNN::EltwiseType, flatbuffers::Offset<MNN::QuantizedFloatParam>, flatbuffers::Offset<MNN::QuantizedFloatParam>, flatbuffers::Offset<MNN::QuantizedFloatParam>) | mnn-tts/MNN/schema/current/CaffeOp_generated.h | inline flatbuffers::Offset<EltwiseInt8> CreateEltwiseInt8(
flatbuffers::FlatBufferBuilder &_fbb,
EltwiseType type = EltwiseType_PROD,
flatbuffers::Offset<QuantizedFloatParam> inputQuan0 = 0,
flatbuffers::Offset<QuantizedFloatParam> inputQuan1 = 0,
flatbuffers::Offset<QuantizedFloatParam> outputQuan = 0) {
EltwiseInt8Builder builder_(_fbb);
builder_.add_outputQuan(outputQuan);
builder_.add_inputQuan1(inputQuan1);
builder_.add_inputQuan0(inputQuan0);
builder_.add_type(type);
return builder_.Finish();
} | O0 | c | MNN::CreateEltwiseInt8(flatbuffers::FlatBufferBuilder&, MNN::EltwiseType, flatbuffers::Offset<MNN::QuantizedFloatParam>, flatbuffers::Offset<MNN::QuantizedFloatParam>, flatbuffers::Offset<MNN::QuantizedFloatParam>):
subq $0x48, %rsp
movl %edx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl %r8d, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x550e0
movl 0x38(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x55120
movl 0x3c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x55150
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x55180
movl 0x2c(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x551b0
leaq 0x18(%rsp), %rdi
callq 0x551e0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
| _ZN3MNN17CreateEltwiseInt8ERN11flatbuffers17FlatBufferBuilderENS_11EltwiseTypeENS0_6OffsetINS_19QuantizedFloatParamEEES6_S6_:
sub rsp, 48h
mov [rsp+48h+var_8], edx
mov [rsp+48h+var_C], ecx
mov [rsp+48h+var_10], r8d
mov [rsp+48h+var_18], rdi
mov [rsp+48h+var_1C], esi
mov rsi, [rsp+48h+var_18]; flatbuffers::FlatBufferBuilder *
lea rdi, [rsp+48h+var_30]; this
call _ZN3MNN18EltwiseInt8BuilderC2ERN11flatbuffers17FlatBufferBuilderE; MNN::EltwiseInt8Builder::EltwiseInt8Builder(flatbuffers::FlatBufferBuilder &)
mov eax, [rsp+48h+var_10]
mov [rsp+48h+var_34], eax
mov esi, [rsp+48h+var_34]
lea rdi, [rsp+48h+var_30]
call _ZN3MNN18EltwiseInt8Builder14add_outputQuanEN11flatbuffers6OffsetINS_19QuantizedFloatParamEEE; MNN::EltwiseInt8Builder::add_outputQuan(flatbuffers::Offset<MNN::QuantizedFloatParam>)
mov eax, [rsp+48h+var_C]
mov [rsp+48h+var_38], eax
mov esi, [rsp+48h+var_38]
lea rdi, [rsp+48h+var_30]
call _ZN3MNN18EltwiseInt8Builder14add_inputQuan1EN11flatbuffers6OffsetINS_19QuantizedFloatParamEEE; MNN::EltwiseInt8Builder::add_inputQuan1(flatbuffers::Offset<MNN::QuantizedFloatParam>)
mov eax, [rsp+48h+var_8]
mov [rsp+48h+var_3C], eax
mov esi, [rsp+48h+var_3C]
lea rdi, [rsp+48h+var_30]
call _ZN3MNN18EltwiseInt8Builder14add_inputQuan0EN11flatbuffers6OffsetINS_19QuantizedFloatParamEEE; MNN::EltwiseInt8Builder::add_inputQuan0(flatbuffers::Offset<MNN::QuantizedFloatParam>)
mov esi, [rsp+48h+var_1C]
lea rdi, [rsp+48h+var_30]
call _ZN3MNN18EltwiseInt8Builder8add_typeENS_11EltwiseTypeE; MNN::EltwiseInt8Builder::add_type(MNN::EltwiseType)
lea rdi, [rsp+48h+var_30]; this
call _ZN3MNN18EltwiseInt8Builder6FinishEv; MNN::EltwiseInt8Builder::Finish(void)
mov [rsp+48h+var_4], eax
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long MNN::CreateEltwiseInt8(
flatbuffers::FlatBufferBuilder *a1,
unsigned int a2,
unsigned int a3,
unsigned int a4,
unsigned int a5)
{
_BYTE v6[20]; // [rsp+18h] [rbp-30h] BYREF
unsigned int v7; // [rsp+2Ch] [rbp-1Ch]
flatbuffers::FlatBufferBuilder *v8; // [rsp+30h] [rbp-18h]
unsigned int v9; // [rsp+38h] [rbp-10h]
unsigned int v10; // [rsp+3Ch] [rbp-Ch]
unsigned int v11; // [rsp+40h] [rbp-8h]
v11 = a3;
v10 = a4;
v9 = a5;
v8 = a1;
v7 = a2;
MNN::EltwiseInt8Builder::EltwiseInt8Builder((MNN::EltwiseInt8Builder *)v6, a1);
MNN::EltwiseInt8Builder::add_outputQuan(v6, v9);
MNN::EltwiseInt8Builder::add_inputQuan1(v6, v10);
MNN::EltwiseInt8Builder::add_inputQuan0(v6, v11);
MNN::EltwiseInt8Builder::add_type(v6, v7);
return (unsigned int)MNN::EltwiseInt8Builder::Finish((MNN::EltwiseInt8Builder *)v6);
}
| CreateEltwiseInt8:
SUB RSP,0x48
MOV dword ptr [RSP + 0x40],EDX
MOV dword ptr [RSP + 0x3c],ECX
MOV dword ptr [RSP + 0x38],R8D
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ESI
MOV RSI,qword ptr [RSP + 0x30]
LEA RDI,[RSP + 0x18]
CALL 0x001550e0
MOV EAX,dword ptr [RSP + 0x38]
MOV dword ptr [RSP + 0x14],EAX
MOV ESI,dword ptr [RSP + 0x14]
LEA RDI,[RSP + 0x18]
CALL 0x00155120
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x10],EAX
MOV ESI,dword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x18]
CALL 0x00155150
MOV EAX,dword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0xc],EAX
MOV ESI,dword ptr [RSP + 0xc]
LEA RDI,[RSP + 0x18]
CALL 0x00155180
MOV ESI,dword ptr [RSP + 0x2c]
LEA RDI,[RSP + 0x18]
CALL 0x001551b0
LEA RDI,[RSP + 0x18]
CALL 0x001551e0
MOV dword ptr [RSP + 0x44],EAX
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
/* MNN::CreateEltwiseInt8(flatbuffers::FlatBufferBuilder&, MNN::EltwiseType,
flatbuffers::Offset<MNN::QuantizedFloatParam>, flatbuffers::Offset<MNN::QuantizedFloatParam>,
flatbuffers::Offset<MNN::QuantizedFloatParam>) */
int4
MNN::CreateEltwiseInt8
(FlatBufferBuilder *param_1,int4 param_2,int4 param_3,int4 param_4,
int4 param_5)
{
int4 uVar1;
EltwiseInt8Builder local_30 [20];
int4 local_1c;
FlatBufferBuilder *local_18;
int4 local_10;
int4 local_c;
int4 local_8;
local_1c = param_2;
local_18 = param_1;
local_10 = param_5;
local_c = param_4;
local_8 = param_3;
EltwiseInt8Builder::EltwiseInt8Builder(local_30,param_1);
EltwiseInt8Builder::add_outputQuan(local_30,local_10);
EltwiseInt8Builder::add_inputQuan1(local_30,local_c);
EltwiseInt8Builder::add_inputQuan0(local_30,local_8);
EltwiseInt8Builder::add_type(local_30,local_1c);
uVar1 = EltwiseInt8Builder::Finish(local_30);
return uVar1;
}
|
|
1,664 | resolve_charset | eloqsql/mysys/charset.c | my_bool resolve_charset(const char *cs_name,
CHARSET_INFO *default_cs,
CHARSET_INFO **cs,
myf flags)
{
*cs= get_charset_by_csname(cs_name, MY_CS_PRIMARY, flags);
if (*cs == NULL)
{
*cs= default_cs;
return TRUE;
}
return FALSE;
} | O3 | c | resolve_charset:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0xc8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x12f0(%rip), %rax # 0x91ace
movq %rax, 0x80(%rdi)
leaq -0x12ef(%rip), %rax # 0x91add
movq %rax, 0x88(%rdi)
leaq -0x12e2(%rip), %rax # 0x91af8
movq %rax, 0x90(%rdi)
leaq 0xcd46(%rip), %rax # 0x9fb2e
movq %rax, 0x98(%rdi)
leaq 0x2f28fa(%rip), %rax # 0x3856f0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x12f1(%rip), %rax # 0x91b16
movq %rax, 0xa8(%rdi)
movl $0x20, %edx
callq 0x92c10
movq %rax, %rcx
testq %rax, %rax
sete %al
cmovneq %rcx, %r14
movq %r14, (%rbx)
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x92e43
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29270
| resolve_charset:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov rbx, rdx
mov r14, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, [rbp+var_C8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
mov edx, 20h ; ' '
call my_charset_get_by_name
mov rcx, rax
test rax, rax
setz al
cmovnz r14, rcx
mov [rbx], r14
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_92E43
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
loc_92E43:
call ___stack_chk_fail
| bool resolve_charset(long long a1, long long a2, long long *a3, long long a4)
{
long long v6; // rcx
bool result; // al
char v8[128]; // [rsp+8h] [rbp-C8h] BYREF
long long ( *v9)(long long); // [rsp+88h] [rbp-48h]
long long ( *v10)(long long); // [rsp+90h] [rbp-40h]
long long ( *v11)(long long, long long, long long, long long, long long, long long); // [rsp+98h] [rbp-38h]
long long ( *v12)(_QWORD); // [rsp+A0h] [rbp-30h]
long long ( *v13)(); // [rsp+A8h] [rbp-28h]
long long ( *v14)(unsigned int *); // [rsp+B0h] [rbp-20h]
unsigned long long v15; // [rsp+B8h] [rbp-18h]
v15 = __readfsqword(0x28u);
v8[0] = 0;
v9 = my_once_alloc_c;
v10 = my_malloc_c;
v11 = my_realloc_c;
v12 = my_free;
v13 = my_charset_error_reporter;
v14 = add_collation;
v6 = my_charset_get_by_name((long long)v8, a1, 0x20u, a4);
result = v6 == 0;
if ( v6 )
a2 = v6;
*a3 = a2;
return result;
}
| resolve_charset:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV RBX,RDX
MOV R14,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0xc8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x191ace]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x191add]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x191af8]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x19fb2e]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x4856f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x191b16]
MOV qword ptr [RDI + 0xa8],RAX
MOV EDX,0x20
CALL 0x00192c10
MOV RCX,RAX
TEST RAX,RAX
SETZ AL
CMOVNZ R14,RCX
MOV qword ptr [RBX],R14
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x00192e43
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
LAB_00192e43:
CALL 0x00129270
|
bool resolve_charset(int8 param_1,long param_2,long *param_3)
{
long lVar1;
long in_FS_OFFSET;
int1 local_d0 [128];
code *local_50;
code *local_48;
code *local_40;
code *local_38;
int *local_30;
code *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_d0[0] = 0;
local_50 = my_once_alloc_c;
local_48 = my_malloc_c;
local_40 = my_realloc_c;
local_38 = my_free;
local_30 = my_charset_error_reporter;
local_28 = add_collation;
lVar1 = my_charset_get_by_name(local_d0,param_1,0x20);
if (lVar1 != 0) {
param_2 = lVar1;
}
*param_3 = param_2;
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return lVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,665 | common_params_sampling::print[abi:cxx11]() const | monkey531[P]llama/common/sampling.cpp | std::string common_params_sampling::print() const {
char result[1024];
snprintf(result, sizeof(result),
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
penalty_last_n, penalty_repeat, penalty_freq, penalty_present,
dry_multiplier, dry_base, dry_allowed_length, dry_penalty_last_n,
top_k, top_p, min_p, xtc_probability, xtc_threshold, typ_p, temp,
mirostat, mirostat_eta, mirostat_tau);
return std::string(result);
} | O3 | cpp | common_params_sampling::print[abi:cxx11]() const:
pushq %r14
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cvtss2sd 0x38(%rsi), %xmm0
cvtss2sd 0x3c(%rsi), %xmm1
cvtss2sd 0x40(%rsi), %xmm2
cvtss2sd 0x44(%rsi), %xmm3
cvtss2sd 0x48(%rsi), %xmm4
movl 0x34(%rsi), %ecx
movl 0x4c(%rsi), %r8d
cvtss2sd 0x14(%rsi), %xmm5
cvtss2sd 0x18(%rsi), %xmm6
cvtss2sd 0x1c(%rsi), %xmm7
cvtss2sd 0x20(%rsi), %xmm8
cvtss2sd 0x24(%rsi), %xmm9
movl 0x50(%rsi), %r9d
cvtss2sd 0x28(%rsi), %xmm10
movl 0x54(%rsi), %edx
cvtss2sd 0x5c(%rsi), %xmm11
cvtss2sd 0x58(%rsi), %xmm12
movsd %xmm12, 0x30(%rsp)
movsd %xmm11, 0x28(%rsp)
movl %edx, 0x20(%rsp)
movsd %xmm10, 0x18(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
movl %eax, (%rsp)
leaq 0x28197(%rip), %rdx # 0xf52b0
leaq 0x40(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movb $0x8, %al
callq 0x1ae10
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1a3f0
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x222de
movq %rbx, %rax
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r14
retq
| _ZNK22common_params_sampling5printB5cxx11Ev:
push r14
push rbx
sub rsp, 448h
mov rbx, rdi
mov eax, [rsi+10h]
cvtss2sd xmm0, dword ptr [rsi+38h]
cvtss2sd xmm1, dword ptr [rsi+3Ch]
cvtss2sd xmm2, dword ptr [rsi+40h]
cvtss2sd xmm3, dword ptr [rsi+44h]
cvtss2sd xmm4, dword ptr [rsi+48h]
mov ecx, [rsi+34h]
mov r8d, [rsi+4Ch]
cvtss2sd xmm5, dword ptr [rsi+14h]
cvtss2sd xmm6, dword ptr [rsi+18h]
cvtss2sd xmm7, dword ptr [rsi+1Ch]
cvtss2sd xmm8, dword ptr [rsi+20h]
cvtss2sd xmm9, dword ptr [rsi+24h]
mov r9d, [rsi+50h]
cvtss2sd xmm10, dword ptr [rsi+28h]
mov edx, [rsi+54h]
cvtss2sd xmm11, dword ptr [rsi+5Ch]
cvtss2sd xmm12, dword ptr [rsi+58h]
movsd [rsp+458h+var_428], xmm12
movsd [rsp+458h+var_430], xmm11
mov [rsp+458h+var_438], edx
movsd [rsp+458h+var_440], xmm10
movsd [rsp+458h+var_448], xmm9
movsd [rsp+458h+var_450], xmm8
mov [rsp+458h+var_458], eax
lea rdx, aRepeatLastNDRe; "\trepeat_last_n = %d, repeat_penalty = "...
lea r14, [rsp+458h+var_418]
mov esi, 400h
mov rdi, r14
mov al, 8
call _snprintf
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, r14
call _strlen
lea rdx, [rsp+rax+458h+var_458]
add rdx, 40h ; '@'
mov rdi, rbx
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
add rsp, 448h
pop rbx
pop r14
retn
| _QWORD * common_params_sampling::print[abi:cxx11](_QWORD *a1, long long a2)
{
long long v2; // rax
_BYTE v4[1048]; // [rsp+40h] [rbp-418h] BYREF
snprintf(
v4,
1024LL,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3"
"f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
*(_DWORD *)(a2 + 52),
*(float *)(a2 + 56),
*(float *)(a2 + 60),
*(float *)(a2 + 64),
*(float *)(a2 + 68),
*(float *)(a2 + 72),
*(_DWORD *)(a2 + 76),
*(_DWORD *)(a2 + 80),
*(_DWORD *)(a2 + 16),
*(float *)(a2 + 20),
*(float *)(a2 + 24),
*(float *)(a2 + 28),
*(float *)(a2 + 32),
*(float *)(a2 + 36),
*(float *)(a2 + 40),
*(_DWORD *)(a2 + 84),
*(float *)(a2 + 92),
*(float *)(a2 + 88));
*a1 = a1 + 2;
v2 = strlen(v4);
std::string::_M_construct<char const*>((long long)a1, v4, (long long)&v4[v2]);
return a1;
}
| print[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x448
MOV RBX,RDI
MOV EAX,dword ptr [RSI + 0x10]
CVTSS2SD XMM0,dword ptr [RSI + 0x38]
CVTSS2SD XMM1,dword ptr [RSI + 0x3c]
CVTSS2SD XMM2,dword ptr [RSI + 0x40]
CVTSS2SD XMM3,dword ptr [RSI + 0x44]
CVTSS2SD XMM4,dword ptr [RSI + 0x48]
MOV ECX,dword ptr [RSI + 0x34]
MOV R8D,dword ptr [RSI + 0x4c]
CVTSS2SD XMM5,dword ptr [RSI + 0x14]
CVTSS2SD XMM6,dword ptr [RSI + 0x18]
CVTSS2SD XMM7,dword ptr [RSI + 0x1c]
CVTSS2SD XMM8,dword ptr [RSI + 0x20]
CVTSS2SD XMM9,dword ptr [RSI + 0x24]
MOV R9D,dword ptr [RSI + 0x50]
CVTSS2SD XMM10,dword ptr [RSI + 0x28]
MOV EDX,dword ptr [RSI + 0x54]
CVTSS2SD XMM11,dword ptr [RSI + 0x5c]
CVTSS2SD XMM12,dword ptr [RSI + 0x58]
MOVSD qword ptr [RSP + 0x30],XMM12
MOVSD qword ptr [RSP + 0x28],XMM11
MOV dword ptr [RSP + 0x20],EDX
MOVSD qword ptr [RSP + 0x18],XMM10
MOVSD qword ptr [RSP + 0x10],XMM9
MOVSD qword ptr [RSP + 0x8],XMM8
MOV dword ptr [RSP],EAX
LEA RDX,[0x1f52b0]
LEA R14,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,R14
MOV AL,0x8
CALL 0x0011ae10
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV RDI,R14
CALL 0x0011a3f0
LEA RDX,[RSP + RAX*0x1]
ADD RDX,0x40
MOV RDI,RBX
MOV RSI,R14
CALL 0x001222de
MOV RAX,RBX
ADD RSP,0x448
POP RBX
POP R14
RET
|
/* common_params_sampling::print[abi:cxx11]() const */
void common_params_sampling::print_abi_cxx11_(void)
{
long in_RSI;
long *in_RDI;
char local_418 [1032];
snprintf(local_418,0x400,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f"
,(double)*(float *)(in_RSI + 0x38),(double)*(float *)(in_RSI + 0x3c),
(double)*(float *)(in_RSI + 0x40),(double)*(float *)(in_RSI + 0x44),
(double)*(float *)(in_RSI + 0x48),(double)*(float *)(in_RSI + 0x14),
(double)*(float *)(in_RSI + 0x18),(double)*(float *)(in_RSI + 0x1c),
(ulong)*(uint *)(in_RSI + 0x34),(ulong)*(uint *)(in_RSI + 0x4c),
(ulong)*(uint *)(in_RSI + 0x50),*(int4 *)(in_RSI + 0x10),
(double)*(float *)(in_RSI + 0x20),(double)*(float *)(in_RSI + 0x24),
(double)*(float *)(in_RSI + 0x28),*(int4 *)(in_RSI + 0x54),
(double)*(float *)(in_RSI + 0x5c),(double)*(float *)(in_RSI + 0x58));
*in_RDI = (long)(in_RDI + 2);
strlen(local_418);
std::__cxx11::string::_M_construct<char_const*>();
return;
}
|
|
1,666 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) | llama.cpp/common/json.hpp | serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
, decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
movups (%rsi), %xmm0
movq %r15, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %r15, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
callq 0x21100
movq %rax, 0x50(%r14)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x83306
movb (%rcx), %r15b
movb %r15b, 0x58(%r14)
movq (%rax), %rax
testq %rax, %rax
je 0x83316
movb (%rax), %al
jmp 0x83318
xorl %eax, %eax
leaq 0x8(%r14), %r15
movb %al, 0x59(%r14)
leaq 0x5a(%r14), %rdi
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x21510
movb %bpl, 0x25a(%r14)
leaq 0x260(%r14), %rdi
leaq 0x270(%r14), %rax
movq %rax, 0x260(%r14)
movsbl %bpl, %edx
movl $0x200, %esi # imm = 0x200
callq 0x21a60
movl %ebx, 0x280(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7620e
movq %rbx, %rdi
callq 0x21b80
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt10shared_ptrINS1_23output_adapter_protocolIcEEEcNS1_15error_handler_tE:
push rbp
push r15
push r14
push rbx
push rax
mov ebx, ecx
mov ebp, edx
mov r14, rdi
xor r15d, r15d
mov [rdi+8], r15
movups xmm0, xmmword ptr [rsi]
mov [rsi+8], r15
movups xmmword ptr [rdi], xmm0
mov [rsi], r15
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
call _localeconv
mov [r14+50h], rax
mov rcx, [rax+8]
test rcx, rcx
jz short loc_83306
mov r15b, [rcx]
loc_83306:
mov [r14+58h], r15b
mov rax, [rax]
test rax, rax
jz short loc_83316
mov al, [rax]
jmp short loc_83318
loc_83316:
xor eax, eax
loc_83318:
lea r15, [r14+8]
mov [r14+59h], al
lea rdi, [r14+5Ah]
mov edx, 200h
xor esi, esi
call _memset
mov [r14+25Ah], bpl
lea rdi, [r14+260h]
lea rax, [r14+270h]
mov [r14+260h], rax
movsx edx, bpl
mov esi, 200h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov [r14+280h], ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::serializer(
long long a1,
__int128 *a2,
char a3,
int a4)
{
char v6; // r15
__int128 v7; // xmm0
long long v8; // rax
char *v9; // rcx
char *v10; // rax
char v11; // al
long long result; // rax
v6 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
v7 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)a1 = v7;
*(_QWORD *)a2 = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
v8 = localeconv(a1);
*(_QWORD *)(a1 + 80) = v8;
v9 = *(char **)(v8 + 8);
if ( v9 )
v6 = *v9;
*(_BYTE *)(a1 + 88) = v6;
v10 = *(char **)v8;
if ( v10 )
v11 = *v10;
else
v11 = 0;
*(_BYTE *)(a1 + 89) = v11;
memset(a1 + 90, 0LL, 512LL);
*(_BYTE *)(a1 + 602) = a3;
*(_QWORD *)(a1 + 608) = a1 + 624;
result = std::string::_M_construct(a1 + 608, 512LL, (unsigned int)a3);
*(_DWORD *)(a1 + 640) = a4;
return result;
}
| serializer:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV EBP,EDX
MOV R14,RDI
XOR R15D,R15D
MOV qword ptr [RDI + 0x8],R15
MOVUPS XMM0,xmmword ptr [RSI]
MOV qword ptr [RSI + 0x8],R15
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSI],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x00121100
MOV qword ptr [R14 + 0x50],RAX
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x00183306
MOV R15B,byte ptr [RCX]
LAB_00183306:
MOV byte ptr [R14 + 0x58],R15B
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00183316
MOV AL,byte ptr [RAX]
JMP 0x00183318
LAB_00183316:
XOR EAX,EAX
LAB_00183318:
LEA R15,[R14 + 0x8]
MOV byte ptr [R14 + 0x59],AL
LEA RDI,[R14 + 0x5a]
MOV EDX,0x200
XOR ESI,ESI
CALL 0x00121510
MOV byte ptr [R14 + 0x25a],BPL
LEA RDI,[R14 + 0x260]
LEA RAX,[R14 + 0x270]
MOV qword ptr [R14 + 0x260],RAX
LAB_0018334c:
MOVSX EDX,BPL
MOV ESI,0x200
CALL 0x00121a60
LAB_0018335a:
MOV dword ptr [R14 + 0x280],EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>
>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::serializer(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,int8 *param_2,
serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
param_3,int4 param_4)
{
int8 uVar1;
serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
sVar2;
lconv *plVar3;
sVar2 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
*(int8 *)(this + 8) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)this = *param_2;
*(int8 *)(this + 8) = uVar1;
*param_2 = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
plVar3 = localeconv();
*(lconv **)(this + 0x50) = plVar3;
if ((serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->thousands_sep !=
(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar2 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->thousands_sep;
}
this[0x58] = sVar2;
if ((serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->decimal_point ==
(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)0x0) {
sVar2 = (serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
)0x0;
}
else {
sVar2 = *(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)plVar3->decimal_point;
}
this[0x59] = sVar2;
memset(this + 0x5a,0,0x200);
this[0x25a] = param_3;
*(serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
**)(this + 0x260) = this + 0x270;
/* try { // try from 0018334c to 00183359 has its CatchHandler @ 0018336c */
std::__cxx11::string::_M_construct((ulong)(this + 0x260),'\0');
*(int4 *)(this + 0x280) = param_4;
return;
}
|
|
1,667 | ExampleGuardedVector<main::Payload32B>::size() const | BadAccessGuards/benchmarks/../examples/GuardedVectorExample.h | typename super::size_type size() const
{
BA_GUARD_READ(BAShadow);
return super::size();
} | O0 | c | ExampleGuardedVector<main::Payload32B>::size() const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rax
leaq -0x31(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xd07a
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10370
movq -0x40(%rbp), %rdi
callq 0xc060
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| _ZNK20ExampleGuardedVectorIZ4mainE13PayloadStringE4sizeEv:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_30], rdi
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
add rax, 18h
lea rcx, [rbp+var_31]
mov [rbp+var_10], rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
and rax, 3
cmp rax, 0
jz short loc_D07A
mov rdi, [rbp+var_20]
xor eax, eax
mov esi, eax
call _Z22BAGuardHandleBadAccessm19BadAccessGuardState; BAGuardHandleBadAccess(ulong,BadAccessGuardState)
loc_D07A:
mov rdi, [rbp+var_40]
call _ZNKSt6vectorIZ4mainE13PayloadStringSaIS0_EE4sizeEv; std::vector<main::PayloadString>::size(void)
add rsp, 40h
pop rbp
retn
| long long ExampleGuardedVector<main::PayloadString>::size(_QWORD *a1)
{
char v2; // [rsp+Fh] [rbp-31h] BYREF
_QWORD *v3; // [rsp+10h] [rbp-30h]
long long v4; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
_QWORD *v6; // [rsp+28h] [rbp-18h]
char *v7; // [rsp+30h] [rbp-10h]
long long v8; // [rsp+38h] [rbp-8h]
v3 = a1;
v7 = &v2;
v6 = a1 + 3;
v4 = a1[3];
v5 = v4;
v8 = v4;
if ( (v4 & 3) != 0 )
BAGuardHandleBadAccess(v5, 0LL);
return std::vector<main::PayloadString>::size(a1);
}
| size:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x30],RDI
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
ADD RAX,0x18
LEA RCX,[RBP + -0x31]
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
AND RAX,0x3
CMP RAX,0x0
JZ 0x0010d07a
MOV RDI,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00110370
LAB_0010d07a:
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x0010c060
ADD RSP,0x40
POP RBP
RET
|
/* ExampleGuardedVector<main::PayloadString>::size() const */
void __thiscall
ExampleGuardedVector<main::PayloadString>::size(ExampleGuardedVector<main::PayloadString> *this)
{
int1 local_39;
ExampleGuardedVector<main::PayloadString> *local_38;
ulong local_30;
ulong local_28;
ExampleGuardedVector<main::PayloadString> *local_20;
int1 *local_18;
ulong local_10;
local_20 = this + 0x18;
local_18 = &local_39;
local_30 = *(ulong *)local_20;
local_38 = this;
local_28 = local_30;
local_10 = local_30;
if ((local_30 & 3) != 0) {
BAGuardHandleBadAccess(local_30,0);
}
std::vector<main::PayloadString,std::allocator<main::PayloadString>>::size
((vector<main::PayloadString,std::allocator<main::PayloadString>> *)this);
return;
}
|
|
1,668 | maria_rtree_get_req | eloqsql/storage/maria/ma_rt_index.c | static int maria_rtree_get_req(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
uint key_length, my_off_t page_pos, int level)
{
MARIA_SHARE *share= info->s;
uchar *page_buf, *last, *k;
uint nod_flag, key_data_length;
int res;
uint *saved_key= (uint*) (info->maria_rtree_recursion_state) + level;
my_bool buff_alloced;
MARIA_PAGE page;
alloc_on_stack(*info->stack_end_ptr, page_buf, buff_alloced,
keyinfo->block_length);
if (!page_buf)
{
my_errno= HA_ERR_OUT_OF_MEM;
return(-1);
}
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, page_buf, 0))
goto err;
nod_flag= page.node;
key_data_length= keyinfo->keylength - share->base.rec_reflength;
if (info->maria_rtree_recursion_depth >= level)
{
k= page.buff + *saved_key;
if (!nod_flag)
{
/* Only leaf pages contain data references. */
/* Need to check next key with data reference. */
k= rt_PAGE_NEXT_KEY(share, k, key_data_length, nod_flag);
}
}
else
{
k= rt_PAGE_FIRST_KEY(share, page.buff, nod_flag);
}
last= rt_PAGE_END(&page);
for (; k < last; k= rt_PAGE_NEXT_KEY(share, k, key_data_length, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
switch ((res= maria_rtree_get_req(info, keyinfo, key_length,
_ma_kpos(nod_flag, k), level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key= (uint) (k - page.buff);
goto ok;
case 1: /* not found - continue searching */
info->maria_rtree_recursion_depth= level;
break;
default:
case -1: /* error */
goto err;
}
}
else
{
/* this is a leaf */
uchar *after_key= rt_PAGE_NEXT_KEY(share, k, key_data_length, 0);
MARIA_KEY tmp_key;
/*
We don't need to set all MARIA_KEY elements here as
_ma_row_pos_from_key() only uses a few of them.
*/
tmp_key.keyinfo= keyinfo;
tmp_key.data= k;
tmp_key.data_length= key_data_length;
info->cur_row.lastpos= _ma_row_pos_from_key(&tmp_key);
info->last_key.data_length= key_data_length;
info->last_key.ref_length= share->base.rec_reflength;
memcpy(info->last_key.data, k,
info->last_key.data_length + info->last_key.ref_length);
info->maria_rtree_recursion_depth= level;
*saved_key= (uint) (k - page.buff);
if (after_key < last)
{
uchar *keyread_buff= info->keyread_buff;
info->last_rtree_keypos= saved_key;
memcpy(keyread_buff, page.buff, page.size);
info->int_maxpos= keyread_buff + page.size;
info->keyread_buff_used= 0;
}
else
{
info->keyread_buff_used= 1;
}
res= 0;
goto ok;
}
}
info->cur_row.lastpos= HA_OFFSET_ERROR;
my_errno= HA_ERR_KEY_NOT_FOUND;
res= 1;
ok:
stack_alloc_free(page_buf, buff_alloced);
return res;
err:
stack_alloc_free(page_buf, buff_alloced);
info->cur_row.lastpos= HA_OFFSET_ERROR;
return -1;
} | O3 | c | maria_rtree_get_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r13
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x40(%rbp)
movslq %ecx, %r15
shlq $0x2, %r15
addq 0x6e0(%rdi), %r15
movq (%rdi), %r12
movq %rsi, -0x68(%rbp)
movzwl 0xa6(%rsi), %esi
leaq -0xb8(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x6b2db
cmpq $0x10000, %rax # imm = 0x10000
ja 0x6b2c1
cmpl $0x1000, %esi # imm = 0x1000
jb 0x6b2db
cmpq $0x8001, %rax # imm = 0x8001
jb 0x6b2db
movq %r12, -0x58(%rbp)
movq %rsp, %r14
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %r14
movq %r14, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x6b2fe
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fc95
testq %rax, %rax
je 0x6b38f
movq %rax, %r14
movq %r12, -0x58(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rbx, %rsi
movq -0x68(%rbp), %r12
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %r14
callq 0x58de2
addq $0x10, %rsp
testb %al, %al
je 0x6b347
cmpb $0x0, -0x34(%rbp)
jne 0x6b33a
movq %r14, %rdi
callq 0x9fec2
movq $-0x1, 0x98(%rbx)
jmp 0x6b39a
movq %r15, -0x48(%rbp)
movl -0x90(%rbp), %r13d
movzwl 0xaa(%r12), %ecx
movq -0x58(%rbp), %rdx
movl 0x3e0(%rdx), %eax
movl %ecx, %esi
subl %eax, %ecx
movl %ecx, -0x38(%rbp)
movq -0xa8(%rbp), %r15
movq -0x40(%rbp), %rcx
cmpl %ecx, 0x6f0(%rbx)
movq %r14, -0x50(%rbp)
jge 0x6b3c3
movl 0x744(%rdx), %edx
leaq (%r15,%r13), %rcx
jmp 0x6b3d7
callq 0xa1a06
movl $0x80, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6b578
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x48(%rbp), %rcx
movl (%rcx), %edx
addq %r15, %rdx
testq %r13, %r13
jne 0x6b3da
movl -0x38(%rbp), %ecx
addq %rax, %rcx
addq %rcx, %rdx
movl -0x98(%rbp), %ecx
addq %rcx, %r15
movq %rdx, -0x78(%rbp)
cmpq %r15, %rdx
jae 0x6b450
movq -0x40(%rbp), %rcx
incl %ecx
movl %ecx, -0x60(%rbp)
movl -0x38(%rbp), %ecx
movq %rcx, -0x80(%rbp)
addl %r13d, %esi
subl %eax, %esi
movl %esi, -0x6c(%rbp)
movq -0x78(%rbp), %r14
movl %r14d, %r12d
testq %r13, %r13
je 0x6b4a7
movl %r13d, %edi
movq %r14, %rsi
callq 0x56df3
movq %rbx, %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
movl -0x60(%rbp), %ecx
callq 0x6b249
cmpl $0x1, %eax
jne 0x6b489
movq -0x40(%rbp), %rax
movl %eax, 0x6f0(%rbx)
addq -0x80(%rbp), %r14
addq %r13, %r14
addl -0x6c(%rbp), %r12d
cmpq %r15, %r14
jb 0x6b40b
movq $-0x1, 0x98(%rbx)
callq 0xa1a06
movl $0x78, (%rax)
movl $0x1, %ebx
movq -0x50(%rbp), %r14
movl -0x34(%rbp), %r12d
testb %r12b, %r12b
jne 0x6b39f
movq %r14, %rdi
callq 0x9fec2
jmp 0x6b39f
testl %eax, %eax
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %rax
jne 0x6b32c
subl -0xa8(%rbp), %r12d
movl %r12d, (%rax)
xorl %ebx, %ebx
jmp 0x6b46f
movq -0x78(%rbp), %r13
movq -0x80(%rbp), %rax
addq %r13, %rax
movq -0x58(%rbp), %r12
movl 0x3e0(%r12), %ecx
addq %rax, %rcx
movq %rcx, -0x60(%rbp)
leaq -0xd8(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, 0x8(%rdi)
movq %r13, (%rdi)
movl -0x38(%rbp), %r14d
movl %r14d, 0x10(%rdi)
callq 0x56f58
movq %rax, 0x98(%rbx)
movl %r14d, 0x210(%rbx)
movl 0x3e0(%r12), %edx
movl %edx, 0x214(%rbx)
movq 0x200(%rbx), %rdi
addl %r14d, %edx
movq %r13, %rsi
callq 0x29080
movq -0x40(%rbp), %rax
movl %eax, 0x6f0(%rbx)
movq -0xa8(%rbp), %rsi
subl %esi, %r13d
movq -0x48(%rbp), %rcx
movl %r13d, (%rcx)
movb $0x1, %al
cmpq %r15, -0x60(%rbp)
movl -0x34(%rbp), %r12d
jae 0x6b567
movq 0x380(%rbx), %r14
movq %rcx, 0x638(%rbx)
movl -0x98(%rbp), %edx
movq %r14, %rdi
callq 0x29080
movl -0x98(%rbp), %eax
addq %r14, %rax
movq %rax, 0x3b8(%rbx)
xorl %eax, %eax
movb %al, 0x685(%rbx)
xorl %ebx, %ebx
movq -0x50(%rbp), %r14
jmp 0x6b473
callq 0x29270
| maria_rtree_get_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r13, rdx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_40], rcx
movsxd r15, ecx
shl r15, 2
add r15, [rdi+6E0h]
mov r12, [rdi]
mov [rbp+var_68], rsi
movzx esi, word ptr [rsi+0A6h]
lea rcx, [rbp+var_B8]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_6B2DB
cmp rax, offset stru_10000
ja short loc_6B2C1
cmp esi, 1000h
jb short loc_6B2DB
cmp rax, 8001h
jb short loc_6B2DB
loc_6B2C1:
mov [rbp+var_58], r12
mov r14, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub r14, rsi
mov rsp, r14
mov al, 1
mov [rbp+var_34], eax
jmp short loc_6B2FE
loc_6B2DB:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_6B38F
mov r14, rax
mov [rbp+var_58], r12
mov [rbp+var_34], 0
loc_6B2FE:
lea rdi, [rbp+var_B8]
mov rsi, rbx
mov r12, [rbp+var_68]
mov rdx, r12
mov rcx, r13
xor r8d, r8d
mov r9d, 3
push 0
push r14
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_6B347
loc_6B32C:
cmp byte ptr [rbp+var_34], 0
jnz short loc_6B33A
mov rdi, r14
call my_free
loc_6B33A:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
jmp short loc_6B39A
loc_6B347:
mov [rbp+var_48], r15
mov r13d, [rbp+var_90]
movzx ecx, word ptr [r12+0AAh]
mov rdx, [rbp+var_58]
mov eax, [rdx+3E0h]
mov esi, ecx
sub ecx, eax
mov [rbp+var_38], ecx
mov r15, [rbp+var_A8]
mov rcx, [rbp+var_40]
cmp [rbx+6F0h], ecx
mov [rbp+var_50], r14
jge short loc_6B3C3
mov edx, [rdx+744h]
lea rcx, [r15+r13]
jmp short loc_6B3D7
loc_6B38F:
call _my_thread_var
mov dword ptr [rax], 80h
loc_6B39A:
mov ebx, 0FFFFFFFFh
loc_6B39F:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6B578
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6B3C3:
mov rcx, [rbp+var_48]
mov edx, [rcx]
add rdx, r15
test r13, r13
jnz short loc_6B3DA
mov ecx, [rbp+var_38]
add rcx, rax
loc_6B3D7:
add rdx, rcx
loc_6B3DA:
mov ecx, [rbp+var_98]
add r15, rcx
mov [rbp+var_78], rdx
cmp rdx, r15
jnb short loc_6B450
mov rcx, [rbp+var_40]
inc ecx
mov dword ptr [rbp+var_60], ecx
mov ecx, [rbp+var_38]
mov [rbp+var_80], rcx
add esi, r13d
sub esi, eax
mov [rbp+var_6C], esi
mov r14, [rbp+var_78]
mov r12d, r14d
loc_6B40B:
test r13, r13
jz loc_6B4A7
mov edi, r13d
mov rsi, r14
call _ma_kpos
mov rdi, rbx
mov rsi, [rbp+var_68]
mov rdx, rax
mov ecx, dword ptr [rbp+var_60]
call maria_rtree_get_req
cmp eax, 1
jnz short loc_6B489
mov rax, [rbp+var_40]
mov [rbx+6F0h], eax
add r14, [rbp+var_80]
add r14, r13
add r12d, [rbp+var_6C]
cmp r14, r15
jb short loc_6B40B
loc_6B450:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov ebx, 1
mov r14, [rbp+var_50]
loc_6B46F:
mov r12d, [rbp+var_34]
loc_6B473:
test r12b, r12b
jnz loc_6B39F
mov rdi, r14
call my_free
jmp loc_6B39F
loc_6B489:
test eax, eax
mov r14, [rbp+var_50]
mov rax, [rbp+var_48]
jnz loc_6B32C
sub r12d, dword ptr [rbp+var_A8]
mov [rax], r12d
xor ebx, ebx
jmp short loc_6B46F
loc_6B4A7:
mov r13, [rbp+var_78]
mov rax, [rbp+var_80]
add rax, r13
mov r12, [rbp+var_58]
mov ecx, [r12+3E0h]
add rcx, rax
mov [rbp+var_60], rcx
lea rdi, [rbp+var_D8]
mov rax, [rbp+var_68]
mov [rdi+8], rax
mov [rdi], r13
mov r14d, [rbp+var_38]
mov [rdi+10h], r14d
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov [rbx+210h], r14d
mov edx, [r12+3E0h]
mov [rbx+214h], edx
mov rdi, [rbx+200h]
add edx, r14d
mov rsi, r13
call _memcpy
mov rax, [rbp+var_40]
mov [rbx+6F0h], eax
mov rsi, [rbp+var_A8]
sub r13d, esi
mov rcx, [rbp+var_48]
mov [rcx], r13d
mov al, 1
cmp [rbp+var_60], r15
mov r12d, [rbp+var_34]
jnb short loc_6B567
mov r14, [rbx+380h]
mov [rbx+638h], rcx
mov edx, [rbp+var_98]
mov rdi, r14
call _memcpy
mov eax, [rbp+var_98]
add rax, r14
mov [rbx+3B8h], rax
xor eax, eax
loc_6B567:
mov [rbx+685h], al
xor ebx, ebx
mov r14, [rbp+var_50]
jmp loc_6B473
loc_6B578:
call ___stack_chk_fail
| long long maria_rtree_get_req(long long a1, long long a2, unsigned long long a3, long long a4)
{
long long v6; // r15
long long v7; // r12
const char *v8; // rsi
unsigned long long v9; // rax
bool v10; // cc
unsigned long long v11; // rax
char *v12; // r14
long long v13; // rax
_QWORD *v14; // rdi
long long v15; // r12
long long v16; // r13
long long v17; // rax
const char *v18; // rsi
unsigned long long v19; // rdx
long long v20; // rcx
unsigned int v21; // ebx
unsigned long long v23; // r15
unsigned long long v24; // r14
int v25; // r12d
long long v26; // rax
int req; // eax
char v28; // r12
long long v29; // r13
long long v30; // r12
unsigned int v31; // r14d
int v32; // edx
long long v33; // rsi
_DWORD *v34; // rcx
char v35; // al
long long v36; // r14
long long v38[2]; // [rsp+8h] [rbp-D8h] BYREF
unsigned int v39; // [rsp+18h] [rbp-C8h]
_QWORD v40[2]; // [rsp+28h] [rbp-B8h] BYREF
long long v41; // [rsp+38h] [rbp-A8h]
unsigned int v42; // [rsp+48h] [rbp-98h]
unsigned int v43; // [rsp+50h] [rbp-90h]
long long v44; // [rsp+60h] [rbp-80h]
long long v45; // [rsp+68h] [rbp-78h]
int v46; // [rsp+74h] [rbp-6Ch]
const char *v47; // [rsp+78h] [rbp-68h]
unsigned long long v48; // [rsp+80h] [rbp-60h]
long long v49; // [rsp+88h] [rbp-58h]
char *v50; // [rsp+90h] [rbp-50h]
_DWORD *v51; // [rsp+98h] [rbp-48h]
long long v52; // [rsp+A0h] [rbp-40h]
unsigned int v53; // [rsp+A8h] [rbp-38h]
int v54; // [rsp+ACh] [rbp-34h]
unsigned long long v55; // [rsp+B0h] [rbp-30h]
v55 = __readfsqword(0x28u);
v52 = a4;
v6 = *(_QWORD *)(a1 + 1760) + 4LL * (int)a4;
v7 = *(_QWORD *)a1;
v47 = (const char *)a2;
v8 = (const char *)*(unsigned __int16 *)(a2 + 166);
v40[0] = v8;
v9 = **(_QWORD **)(a1 + 120) - (_QWORD)v40;
v10 = v9 <= (unsigned long long)v8;
v11 = v9 - (_QWORD)v8;
if ( v10 || v11 <= (unsigned long long)&stru_10000 && ((unsigned int)v8 < 0x1000 || v11 < 0x8001) )
{
v13 = my_malloc(0LL, v8, 65552LL);
if ( !v13 )
{
*(_DWORD *)my_thread_var(0LL, v8) = 128;
return (unsigned int)-1;
}
v12 = (char *)v13;
v49 = v7;
v54 = 0;
}
else
{
v49 = v7;
v12 = (char *)&v38[-1] - (((_DWORD)v8 + 15) & 0xFFFFFFF0);
LOBYTE(v11) = 1;
v54 = v11;
}
v14 = v40;
v15 = (long long)v47;
if ( ma_fetch_keypage((long long)v40, a1, (long long)v47, a3, 0, 3, (long long)v12) )
{
LABEL_9:
if ( !(_BYTE)v54 )
my_free(v12);
*(_QWORD *)(a1 + 152) = -1LL;
return (unsigned int)-1;
}
v51 = (_DWORD *)v6;
v16 = v43;
v17 = *(unsigned int *)(v49 + 992);
v18 = (const char *)*(unsigned __int16 *)(v15 + 170);
v53 = (_DWORD)v18 - v17;
v10 = *(_DWORD *)(a1 + 1776) < (int)v52;
v50 = v12;
if ( v10 )
{
v19 = *(unsigned int *)(v49 + 1860);
v20 = v41 + v43;
LABEL_19:
v19 += v20;
goto LABEL_20;
}
v19 = v41 + (unsigned int)*v51;
if ( !v43 )
{
v20 = v17 + v53;
goto LABEL_19;
}
LABEL_20:
v23 = v42 + v41;
v45 = v19;
if ( v19 >= v23 )
{
LABEL_25:
*(_QWORD *)(a1 + 152) = -1LL;
*(_DWORD *)my_thread_var(v14, v18) = 120;
v21 = 1;
v12 = v50;
}
else
{
LODWORD(v48) = v52 + 1;
v44 = v53;
v46 = v43 + (_DWORD)v18 - v17;
v24 = v45;
v25 = v45;
while ( 1 )
{
if ( !v16 )
{
v29 = v45;
v30 = v49;
v48 = v45 + v44 + *(unsigned int *)(v49 + 992);
v38[1] = (long long)v47;
v38[0] = v45;
v31 = v53;
v39 = v53;
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key(v38);
*(_DWORD *)(a1 + 528) = v31;
v32 = *(_DWORD *)(v30 + 992);
*(_DWORD *)(a1 + 532) = v32;
memcpy(*(_QWORD *)(a1 + 512), v29, v31 + v32);
*(_DWORD *)(a1 + 1776) = v52;
v33 = v41;
v34 = v51;
*v51 = v29 - v41;
v35 = 1;
v28 = v54;
if ( v48 < v23 )
{
v36 = *(_QWORD *)(a1 + 896);
*(_QWORD *)(a1 + 1592) = v34;
memcpy(v36, v33, v42);
*(_QWORD *)(a1 + 952) = v36 + v42;
v35 = 0;
}
*(_BYTE *)(a1 + 1669) = v35;
v21 = 0;
v12 = v50;
goto LABEL_27;
}
v26 = ma_kpos(v16, v24);
v14 = (_QWORD *)a1;
v18 = v47;
req = maria_rtree_get_req(a1, v47, v26, (unsigned int)v48);
if ( req != 1 )
break;
*(_DWORD *)(a1 + 1776) = v52;
v24 += v16 + v44;
v25 += v46;
if ( v24 >= v23 )
goto LABEL_25;
}
v12 = v50;
if ( req )
goto LABEL_9;
*v51 = v25 - v41;
v21 = 0;
}
v28 = v54;
LABEL_27:
if ( !v28 )
my_free(v12);
return v21;
}
| maria_rtree_get_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R13,RDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x40],RCX
MOVSXD R15,ECX
SHL R15,0x2
ADD R15,qword ptr [RDI + 0x6e0]
MOV R12,qword ptr [RDI]
MOV qword ptr [RBP + -0x68],RSI
MOVZX ESI,word ptr [RSI + 0xa6]
LEA RCX,[RBP + -0xb8]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x0016b2db
CMP RAX,0x10000
JA 0x0016b2c1
CMP ESI,0x1000
JC 0x0016b2db
CMP RAX,0x8001
JC 0x0016b2db
LAB_0016b2c1:
MOV qword ptr [RBP + -0x58],R12
MOV R14,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB R14,RSI
MOV RSP,R14
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0016b2fe
LAB_0016b2db:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fc95
TEST RAX,RAX
JZ 0x0016b38f
MOV R14,RAX
MOV qword ptr [RBP + -0x58],R12
MOV dword ptr [RBP + -0x34],0x0
LAB_0016b2fe:
LEA RDI,[RBP + -0xb8]
MOV RSI,RBX
MOV R12,qword ptr [RBP + -0x68]
MOV RDX,R12
MOV RCX,R13
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH R14
CALL 0x00158de2
ADD RSP,0x10
TEST AL,AL
JZ 0x0016b347
LAB_0016b32c:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x0016b33a
MOV RDI,R14
CALL 0x0019fec2
LAB_0016b33a:
MOV qword ptr [RBX + 0x98],-0x1
JMP 0x0016b39a
LAB_0016b347:
MOV qword ptr [RBP + -0x48],R15
MOV R13D,dword ptr [RBP + -0x90]
MOVZX ECX,word ptr [R12 + 0xaa]
MOV RDX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RDX + 0x3e0]
MOV ESI,ECX
SUB ECX,EAX
MOV dword ptr [RBP + -0x38],ECX
MOV R15,qword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RBP + -0x40]
CMP dword ptr [RBX + 0x6f0],ECX
MOV qword ptr [RBP + -0x50],R14
JGE 0x0016b3c3
MOV EDX,dword ptr [RDX + 0x744]
LEA RCX,[R15 + R13*0x1]
JMP 0x0016b3d7
LAB_0016b38f:
CALL 0x001a1a06
MOV dword ptr [RAX],0x80
LAB_0016b39a:
MOV EBX,0xffffffff
LAB_0016b39f:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016b578
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016b3c3:
MOV RCX,qword ptr [RBP + -0x48]
MOV EDX,dword ptr [RCX]
ADD RDX,R15
TEST R13,R13
JNZ 0x0016b3da
MOV ECX,dword ptr [RBP + -0x38]
ADD RCX,RAX
LAB_0016b3d7:
ADD RDX,RCX
LAB_0016b3da:
MOV ECX,dword ptr [RBP + -0x98]
ADD R15,RCX
MOV qword ptr [RBP + -0x78],RDX
CMP RDX,R15
JNC 0x0016b450
MOV RCX,qword ptr [RBP + -0x40]
INC ECX
MOV dword ptr [RBP + -0x60],ECX
MOV ECX,dword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x80],RCX
ADD ESI,R13D
SUB ESI,EAX
MOV dword ptr [RBP + -0x6c],ESI
MOV R14,qword ptr [RBP + -0x78]
MOV R12D,R14D
LAB_0016b40b:
TEST R13,R13
JZ 0x0016b4a7
MOV EDI,R13D
MOV RSI,R14
CALL 0x00156df3
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,RAX
MOV ECX,dword ptr [RBP + -0x60]
CALL 0x0016b249
CMP EAX,0x1
JNZ 0x0016b489
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBX + 0x6f0],EAX
ADD R14,qword ptr [RBP + -0x80]
ADD R14,R13
ADD R12D,dword ptr [RBP + -0x6c]
CMP R14,R15
JC 0x0016b40b
LAB_0016b450:
MOV qword ptr [RBX + 0x98],-0x1
CALL 0x001a1a06
MOV dword ptr [RAX],0x78
MOV EBX,0x1
MOV R14,qword ptr [RBP + -0x50]
LAB_0016b46f:
MOV R12D,dword ptr [RBP + -0x34]
LAB_0016b473:
TEST R12B,R12B
JNZ 0x0016b39f
MOV RDI,R14
CALL 0x0019fec2
JMP 0x0016b39f
LAB_0016b489:
TEST EAX,EAX
MOV R14,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x48]
JNZ 0x0016b32c
SUB R12D,dword ptr [RBP + -0xa8]
MOV dword ptr [RAX],R12D
XOR EBX,EBX
JMP 0x0016b46f
LAB_0016b4a7:
MOV R13,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,R13
MOV R12,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [R12 + 0x3e0]
ADD RCX,RAX
MOV qword ptr [RBP + -0x60],RCX
LEA RDI,[RBP + -0xd8]
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RDI + 0x8],RAX
MOV qword ptr [RDI],R13
MOV R14D,dword ptr [RBP + -0x38]
MOV dword ptr [RDI + 0x10],R14D
CALL 0x00156f58
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0x210],R14D
MOV EDX,dword ptr [R12 + 0x3e0]
MOV dword ptr [RBX + 0x214],EDX
MOV RDI,qword ptr [RBX + 0x200]
ADD EDX,R14D
MOV RSI,R13
CALL 0x00129080
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBX + 0x6f0],EAX
MOV RSI,qword ptr [RBP + -0xa8]
SUB R13D,ESI
MOV RCX,qword ptr [RBP + -0x48]
MOV dword ptr [RCX],R13D
MOV AL,0x1
CMP qword ptr [RBP + -0x60],R15
MOV R12D,dword ptr [RBP + -0x34]
JNC 0x0016b567
MOV R14,qword ptr [RBX + 0x380]
MOV qword ptr [RBX + 0x638],RCX
MOV EDX,dword ptr [RBP + -0x98]
MOV RDI,R14
CALL 0x00129080
MOV EAX,dword ptr [RBP + -0x98]
ADD RAX,R14
MOV qword ptr [RBX + 0x3b8],RAX
XOR EAX,EAX
LAB_0016b567:
MOV byte ptr [RBX + 0x685],AL
XOR EBX,EBX
MOV R14,qword ptr [RBP + -0x50]
JMP 0x0016b473
LAB_0016b578:
CALL 0x00129270
|
int8 maria_rtree_get_req(long *param_1,long param_2,int8 param_3,int8 param_4)
{
ushort uVar1;
uint uVar2;
long lVar3;
void *__src;
char cVar4;
int iVar5;
ulong uVar6;
int1 *puVar7;
int4 *puVar8;
long lVar9;
uint uVar10;
ulong uVar11;
void *pvVar12;
int8 uVar13;
int1 *puVar14;
ulong uVar15;
uint *puVar16;
void *pvVar17;
long in_FS_OFFSET;
bool bVar18;
int1 auStack_e8 [8];
void *local_e0;
long local_d8;
uint local_d0;
ulong local_c0 [2];
int local_b0;
int4 uStack_ac;
uint local_a0;
uint local_98;
ulong local_88;
void *local_80;
int local_74;
long local_70;
void *local_68;
long local_60;
int1 *local_58;
uint *local_50;
int8 local_48;
uint local_40;
int4 local_3c;
long local_38;
puVar14 = auStack_e8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
puVar16 = (uint *)((long)(int)param_4 * 4 + param_1[0xdc]);
lVar3 = *param_1;
uVar1 = *(ushort *)(param_2 + 0xa6);
local_c0[0] = (ulong)uVar1;
uVar6 = (*(long *)param_1[0xf] - (long)local_c0) - local_c0[0];
local_70 = param_2;
local_48 = param_4;
if (((ulong)(*(long *)param_1[0xf] - (long)local_c0) < local_c0[0] || uVar6 == 0) ||
((uVar6 < 0x10001 && ((uVar1 < 0x1000 || (uVar6 < 0x8001)))))) {
puVar7 = (int1 *)my_malloc(0,local_c0[0],0x10010);
if (puVar7 != (int1 *)0x0) {
local_3c = 0;
puVar14 = auStack_e8;
goto LAB_0016b2fe;
}
puVar8 = (int4 *)_my_thread_var();
*puVar8 = 0x80;
}
else {
puVar7 = auStack_e8 + -(ulong)(uVar1 + 0xf & 0xfffffff0);
local_3c = (int4)CONCAT71((int7)(uVar6 >> 8),1);
puVar14 = puVar7;
LAB_0016b2fe:
lVar9 = local_70;
local_60 = lVar3;
*(int8 *)(puVar14 + -8) = 0;
*(int1 **)(puVar14 + -0x10) = puVar7;
*(int8 *)(puVar14 + -0x18) = 0x16b324;
cVar4 = _ma_fetch_keypage(local_c0,param_1,lVar9,param_3,0,3);
if (cVar4 == '\0') {
uVar6 = (ulong)local_98;
uVar2 = *(uint *)(local_60 + 0x3e0);
uVar10 = (uint)*(ushort *)(lVar9 + 0xaa);
local_40 = uVar10 - uVar2;
lVar3 = CONCAT44(uStack_ac,local_b0);
if ((int)param_1[0xde] < (int)local_48) {
pvVar12 = (void *)(ulong)*(uint *)(local_60 + 0x744);
lVar9 = lVar3 + uVar6;
LAB_0016b3d7:
pvVar12 = (void *)((long)pvVar12 + lVar9);
}
else {
pvVar12 = (void *)((ulong)*puVar16 + lVar3);
if (uVar6 == 0) {
lVar9 = (ulong)local_40 + (ulong)uVar2;
goto LAB_0016b3d7;
}
}
pvVar17 = (void *)(lVar3 + (ulong)local_a0);
local_80 = pvVar12;
local_58 = puVar7;
local_50 = puVar16;
if (pvVar12 < pvVar17) {
local_68 = (void *)CONCAT44(local_68._4_4_,(int)local_48 + 1);
local_88 = (ulong)local_40;
local_74 = (uVar10 + local_98) - uVar2;
uVar15 = (ulong)pvVar12 & 0xffffffff;
do {
uVar2 = local_40;
lVar3 = local_60;
__src = local_80;
if (uVar6 == 0) {
local_68 = (void *)((long)local_80 + *(uint *)(local_60 + 0x3e0) + local_88);
local_d8 = local_70;
local_e0 = local_80;
local_d0 = local_40;
*(int8 *)(puVar14 + -8) = 0x16b4e4;
lVar9 = _ma_row_pos_from_key();
param_1[0x13] = lVar9;
*(uint *)(param_1 + 0x42) = uVar2;
iVar5 = *(int *)(lVar3 + 0x3e0);
*(int *)((long)param_1 + 0x214) = iVar5;
pvVar12 = (void *)param_1[0x40];
*(int8 *)(puVar14 + -8) = 0x16b512;
memcpy(pvVar12,__src,(ulong)(iVar5 + uVar2));
*(int *)(param_1 + 0xde) = (int)local_48;
*local_50 = (int)__src - local_b0;
bVar18 = pvVar17 <= local_68;
cVar4 = (char)local_3c;
if (!bVar18) {
pvVar12 = (void *)param_1[0x70];
param_1[199] = (long)local_50;
uVar6 = (ulong)local_a0;
*(int8 *)(puVar14 + -8) = 0x16b555;
memcpy(pvVar12,(void *)CONCAT44(uStack_ac,local_b0),uVar6);
param_1[0x77] = (ulong)local_a0 + (long)pvVar12;
}
*(bool *)((long)param_1 + 0x685) = bVar18;
uVar13 = 0;
goto LAB_0016b473;
}
*(int8 *)(puVar14 + -8) = 0x16b41f;
uVar13 = _ma_kpos(local_98,pvVar12);
lVar3 = local_70;
uVar11 = (ulong)local_68 & 0xffffffff;
*(int8 *)(puVar14 + -8) = 0x16b431;
iVar5 = maria_rtree_get_req(param_1,lVar3,uVar13,uVar11);
if (iVar5 != 1) {
puVar7 = local_58;
if (iVar5 != 0) goto LAB_0016b32c;
*local_50 = (int)uVar15 - local_b0;
uVar13 = 0;
goto LAB_0016b46f;
}
*(int *)(param_1 + 0xde) = (int)local_48;
pvVar12 = (void *)((long)pvVar12 + uVar6 + local_88);
uVar15 = (ulong)(uint)((int)uVar15 + local_74);
} while (pvVar12 < pvVar17);
}
param_1[0x13] = -1;
*(int8 *)(puVar14 + -8) = 0x16b460;
puVar8 = (int4 *)_my_thread_var();
*puVar8 = 0x78;
uVar13 = 1;
LAB_0016b46f:
cVar4 = (char)local_3c;
LAB_0016b473:
puVar7 = local_58;
if (cVar4 == '\0') {
*(int8 *)(puVar14 + -8) = 0x16b484;
my_free(puVar7);
}
goto LAB_0016b39f;
}
LAB_0016b32c:
if ((char)local_3c == '\0') {
*(int8 *)(puVar14 + -8) = 0x16b33a;
my_free(puVar7);
}
param_1[0x13] = -1;
}
uVar13 = 0xffffffff;
LAB_0016b39f:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar13;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar14 + -8) = maria_rtree_get_next;
__stack_chk_fail();
}
|
|
1,669 | aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActNameByJointName[abi:cxx11](mjModel_ const*, std::basic_string_view<char, std::char_traits<char>>) | aimrt_mujoco_sim/src/module/mujoco_sim_module/common/xmodel_reader.cc | std::optional<std::string> GetJointActNameByJointName(const mjModel* m, std::string_view joint_name) {
if (auto actuator_id = GetJointActIdByJointName(m, joint_name.data())) {
return mj_id2name(m, mjOBJ_ACTUATOR, actuator_id.value_or(-1));
}
return std::nullopt;
} | O3 | cpp | aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActNameByJointName[abi:cxx11](mjModel_ const*, std::basic_string_view<char, std::char_traits<char>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x2c700
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x600da
btq $0x20, %rax
jb 0x60283
xorl %eax, %eax
jmp 0x602a4
movq %r14, %rdi
movl $0x13, %esi
movl %eax, %edx
callq 0x2dbc0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x505e2
movb $0x1, %al
movb %al, 0x20(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZN16aimrt_mujoco_sim17mujoco_sim_module6common26GetJointActNameByJointNameB5cxx11EPK8mjModel_St17basic_string_viewIcSt11char_traitsIcEE:
push r15
push r14
push rbx
sub rsp, 10h
mov r15, rcx
mov r14, rsi
mov rbx, rdi
mov rdi, rcx
call _strlen
mov rdi, r14
mov rsi, rax
mov rdx, r15
call _ZN16aimrt_mujoco_sim17mujoco_sim_module6common24GetJointActIdByJointNameEPK8mjModel_St17basic_string_viewIcSt11char_traitsIcEE; aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActIdByJointName(mjModel_ const*,std::string_view)
bt rax, 20h ; ' '
jb short loc_60283
xor eax, eax
jmp short loc_602A4
loc_60283:
mov rdi, r14
mov esi, 13h
mov edx, eax
call _mj_id2name
lea rdx, [rsp+28h+var_19]
mov rdi, rbx
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov al, 1
loc_602A4:
mov [rbx+20h], al
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActNameByJointName[abi:cxx11](
long long a1,
long long a2,
long long a3,
long long a4)
{
long long v5; // rax
long long JointActIdByJointName; // rax
char v7; // al
long long v8; // rax
v5 = strlen(a4);
JointActIdByJointName = aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActIdByJointName(a2, v5, a4);
if ( (JointActIdByJointName & 0x100000000LL) != 0 )
{
v8 = mj_id2name(a2, 19LL, (unsigned int)JointActIdByJointName);
std::string::basic_string<std::allocator<char>>((_QWORD *)a1, v8);
v7 = 1;
}
else
{
v7 = 0;
}
*(_BYTE *)(a1 + 32) = v7;
return a1;
}
| GetJointActNameByJointName[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R15,RCX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RCX
CALL 0x0012c700
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R15
CALL 0x001600da
BT RAX,0x20
JC 0x00160283
XOR EAX,EAX
JMP 0x001602a4
LAB_00160283:
MOV RDI,R14
MOV ESI,0x13
MOV EDX,EAX
CALL 0x0012dbc0
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001505e2
MOV AL,0x1
LAB_001602a4:
MOV byte ptr [RBX + 0x20],AL
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActNameByJointName[abi:cxx11](mjModel_
const*, std::basic_string_view<char, std::char_traits<char> >) */
string * aimrt_mujoco_sim::mujoco_sim_module::common::GetJointActNameByJointName_abi_cxx11_
(string *param_1,common *param_2,int8 param_3,char *param_4)
{
size_t sVar1;
ulong uVar2;
char *pcVar3;
string sVar4;
allocator local_19;
sVar1 = strlen(param_4);
uVar2 = GetJointActIdByJointName(param_2,sVar1,param_4);
sVar4 = (string)((uVar2 >> 0x20 & 1) != 0);
if ((bool)sVar4) {
pcVar3 = (char *)mj_id2name(param_2,0x13,uVar2 & 0xffffffff);
std::__cxx11::string::string<std::allocator<char>>(param_1,pcVar3,&local_19);
}
param_1[0x20] = sVar4;
return param_1;
}
|
|
1,670 | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) | 7CodeWizard[P]stablediffusion/ggml_extend.hpp | bool alloc_params_buffer(ggml_backend_t backend_, ggml_type wtype_ = GGML_TYPE_F32) {
backend = backend_;
wtype = wtype_;
params_buffer_size = 10 * 1024 * 1024; // 10 MB, for padding
params_buffer_size += calculate_mem_size();
size_t num_tensors = get_num_tensors();
LOG_DEBUG("%s params backend buffer size = % 6.2f MB (%i tensors)",
name.c_str(), params_buffer_size / (1024.0 * 1024.0), num_tensors);
struct ggml_init_params params;
params.mem_size = static_cast<size_t>(num_tensors * ggml_tensor_overhead()) + 1 * 1024 * 1024;
params.mem_buffer = NULL;
params.no_alloc = true;
// LOG_DEBUG("mem_size %u ", params.mem_size);
params_ctx = ggml_init(params);
if (!params_ctx) {
LOG_ERROR("ggml_init() failed");
return false;
}
params_buffer = ggml_backend_alloc_buffer(backend, params_buffer_size);
return true;
} | O0 | cpp | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type):
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rdi)
movl 0x6c(%rsp), %eax
movl %eax, 0x58(%rdi)
movq $0xa00000, 0x30(%rdi) # imm = 0xA00000
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x30(%rdi), %rax
addq %rcx, %rax
movq %rax, 0x30(%rdi)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq 0x28(%rsp), %rdi
movq %rax, 0x60(%rsp)
addq $0x8, %rdi
callq 0xb280
movq %rax, %r8
movq 0x28(%rsp), %rax
movq 0x30(%rax), %xmm0
movaps 0x12c55e(%rip), %xmm1 # 0x17f220
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x12c562(%rip), %xmm1 # 0x17f230
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x12c59b(%rip), %xmm1 # 0x17f280
divsd %xmm1, %xmm0
movq 0x60(%rsp), %r9
xorl %edi, %edi
leaq 0x12d065(%rip), %rsi # 0x17fd5c
movl $0x228, %edx # imm = 0x228
leaq 0x12d0af(%rip), %rcx # 0x17fdb2
movb $0x1, %al
callq 0xeb5e0
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x11b480
movq %rax, %rcx
movq 0x20(%rsp), %rax
imulq %rcx, %rax
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movb $0x1, 0x58(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x11b680
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x52dbb
movl $0x3, %edi
leaq 0x12cfbe(%rip), %rsi # 0x17fd5c
movl $0x232, %edx # imm = 0x232
leaq 0x12c92c(%rip), %rcx # 0x17f6d6
movb $0x0, %al
callq 0xeb5e0
movb $0x0, 0x87(%rsp)
jmp 0x52de1
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x30(%rax), %rsi
callq 0x166ba0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x40(%rax)
movb $0x1, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN10GGMLModule19alloc_params_bufferEP12ggml_backend9ggml_type:
sub rsp, 88h
mov [rsp+88h+var_10], rdi
mov [rsp+88h+var_18], rsi
mov [rsp+88h+var_1C], edx
mov rdi, [rsp+88h+var_10]
mov [rsp+88h+var_60], rdi
mov rax, [rsp+88h+var_18]
mov [rdi+60h], rax
mov eax, [rsp+88h+var_1C]
mov [rdi+58h], eax
mov qword ptr [rdi+30h], 0A00000h
mov rax, [rdi]
mov rax, [rax]
call rax
mov rdi, [rsp+88h+var_60]
mov rcx, rax
mov rax, [rdi+30h]
add rax, rcx
mov [rdi+30h], rax
mov rax, [rdi]
mov rax, [rax+8]
call rax
mov rdi, [rsp+88h+var_60]
mov [rsp+88h+var_28], rax
add rdi, 8
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov r8, rax
mov rax, [rsp+88h+var_60]
movq xmm0, qword ptr [rax+30h]
movaps xmm1, cs:xmmword_17F220
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_17F230
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
movsd xmm1, cs:qword_17F280
divsd xmm0, xmm1
mov r9, [rsp+88h+var_28]
xor edi, edi
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 228h
lea rcx, aSParamsBackend; "%s params backend buffer size = % 6.2f "...
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
mov rax, [rsp+88h+var_28]
mov [rsp+88h+var_68], rax
call ggml_tensor_overhead
mov rcx, rax
mov rax, [rsp+88h+var_68]
imul rax, rcx
add rax, 100000h
mov [rsp+88h+var_40], rax
mov [rsp+88h+var_38], 0
mov byte ptr [rsp+88h+var_30], 1
mov rax, [rsp+88h+var_40]
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_50], rax
mov rax, [rsp+88h+var_30]
mov [rsp+88h+var_48], rax
lea rax, [rsp+88h+var_58]
mov rcx, [rax]
mov [rsp+88h+var_88], rcx
mov rcx, [rax+8]
mov [rsp+88h+var_80], rcx
mov rax, [rax+10h]
mov [rsp+88h+var_78], rax
call ggml_init
mov rcx, rax
mov rax, [rsp+88h+var_60]
mov [rax+28h], rcx
cmp qword ptr [rax+28h], 0
jnz short loc_52DBB
mov edi, 3
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 232h
lea rcx, aGgmlInitFailed; "ggml_init() failed"
mov al, 0
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
mov [rsp+88h+var_1], 0
jmp short loc_52DE1
loc_52DBB:
mov rax, [rsp+88h+var_60]
mov rdi, [rax+60h]
mov rsi, [rax+30h]
call ggml_backend_alloc_buffer
mov rcx, rax
mov rax, [rsp+88h+var_60]
mov [rax+40h], rcx
mov [rsp+88h+var_1], 1
loc_52DE1:
mov al, [rsp+88h+var_1]
and al, 1
add rsp, 88h
retn
| char GGMLModule::alloc_params_buffer(const __m128i *a1, long long a2, __int32 a3)
{
int v3; // eax
__m128d v4; // xmm0
int v5; // edx
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
long long v11; // [rsp+30h] [rbp-58h]
char v12; // [rsp+58h] [rbp-30h]
long long v13; // [rsp+60h] [rbp-28h]
a1[6].m128i_i64[0] = a2;
a1[5].m128i_i32[2] = a3;
a1[3].m128i_i64[0] = 10485760LL;
a1[3].m128i_i64[0] += (*(long long ( **)(const __m128i *))a1->m128i_i64[0])(a1);
v13 = (*(long long ( **)(const __m128i *))(a1->m128i_i64[0] + 8))(a1);
v3 = std::string::c_str(&a1->m128i_u64[1]);
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64(a1 + 3), (__m128i)xmmword_17F220),
(__m128d)xmmword_17F230);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
552,
(unsigned int)"%s params backend buffer size = % 6.2f MB (%i tensors)",
v3,
v13);
v12 = 1;
v11 = ggml_tensor_overhead((_mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0]) / 1048576.0) * v13 + 0x100000;
a1[2].m128i_i64[1] = ggml_init(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
v5,
0,
v6,
v7,
v11,
0LL,
v12);
if ( a1[2].m128i_i64[1] )
{
a1[4].m128i_i64[0] = ggml_backend_alloc_buffer(a1[6].m128i_i64[0], a1[3].m128i_i64[0]);
return 1;
}
else
{
log_printf(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
562,
(unsigned int)"ggml_init() failed",
v8,
v9);
return 0;
}
}
| alloc_params_buffer:
SUB RSP,0x88
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RSI
MOV dword ptr [RSP + 0x6c],EDX
MOV RDI,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RDI + 0x60],RAX
MOV EAX,dword ptr [RSP + 0x6c]
MOV dword ptr [RDI + 0x58],EAX
MOV qword ptr [RDI + 0x30],0xa00000
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
CALL RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV RCX,RAX
MOV RAX,qword ptr [RDI + 0x30]
ADD RAX,RCX
MOV qword ptr [RDI + 0x30],RAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
CALL RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x60],RAX
ADD RDI,0x8
CALL 0x0010b280
MOV R8,RAX
MOV RAX,qword ptr [RSP + 0x28]
MOVQ XMM0,qword ptr [RAX + 0x30]
MOVAPS XMM1,xmmword ptr [0x0027f220]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x0027f230]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x0027f280]
DIVSD XMM0,XMM1
MOV R9,qword ptr [RSP + 0x60]
XOR EDI,EDI
LEA RSI,[0x27fd5c]
MOV EDX,0x228
LEA RCX,[0x27fdb2]
MOV AL,0x1
CALL 0x001eb5e0
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x20],RAX
CALL 0x0021b480
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
IMUL RAX,RCX
ADD RAX,0x100000
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],0x0
MOV byte ptr [RSP + 0x58],0x1
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[RSP + 0x30]
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 0x0021b680
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x28],RCX
CMP qword ptr [RAX + 0x28],0x0
JNZ 0x00152dbb
MOV EDI,0x3
LEA RSI,[0x27fd5c]
MOV EDX,0x232
LEA RCX,[0x27f6d6]
MOV AL,0x0
CALL 0x001eb5e0
MOV byte ptr [RSP + 0x87],0x0
JMP 0x00152de1
LAB_00152dbb:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x60]
MOV RSI,qword ptr [RAX + 0x30]
CALL 0x00266ba0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x40],RCX
MOV byte ptr [RSP + 0x87],0x1
LAB_00152de1:
MOV AL,byte ptr [RSP + 0x87]
AND AL,0x1
ADD RSP,0x88
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) */
bool __thiscall
GGMLModule::alloc_params_buffer(GGMLModule *this,int8 param_1,int4 param_3)
{
long lVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
*(int8 *)(this + 0x60) = param_1;
*(int4 *)(this + 0x58) = param_3;
*(int8 *)(this + 0x30) = 0xa00000;
lVar1 = (*(code *)**(int8 **)this)();
*(long *)(this + 0x30) = *(long *)(this + 0x30) + lVar1;
uVar2 = (**(code **)(*(long *)this + 8))();
uVar3 = std::__cxx11::string::c_str();
uVar4 = *(int8 *)(this + 0x30);
auVar5._8_4_ = (int)((ulong)uVar4 >> 0x20);
auVar5._0_8_ = uVar4;
auVar5._12_4_ = _UNK_0027f224;
log_printf(((auVar5._8_8_ - _UNK_0027f238) +
((double)CONCAT44(_DAT_0027f220,(int)uVar4) - _DAT_0027f230)) / DAT_0027f280,0,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,0x228,"%s params backend buffer size = % 6.2f MB (%i tensors)",uVar3,uVar2);
ggml_tensor_overhead();
uVar4 = ggml_init();
*(int8 *)(this + 0x28) = uVar4;
lVar1 = *(long *)(this + 0x28);
if (lVar1 != 0) {
uVar4 = ggml_backend_alloc_buffer(*(int8 *)(this + 0x60),*(int8 *)(this + 0x30));
*(int8 *)(this + 0x40) = uVar4;
}
else {
log_printf(3,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,0x232,"ggml_init() failed");
}
return lVar1 != 0;
}
|
|
1,671 | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) | 7CodeWizard[P]stablediffusion/ggml_extend.hpp | bool alloc_params_buffer(ggml_backend_t backend_, ggml_type wtype_ = GGML_TYPE_F32) {
backend = backend_;
wtype = wtype_;
params_buffer_size = 10 * 1024 * 1024; // 10 MB, for padding
params_buffer_size += calculate_mem_size();
size_t num_tensors = get_num_tensors();
LOG_DEBUG("%s params backend buffer size = % 6.2f MB (%i tensors)",
name.c_str(), params_buffer_size / (1024.0 * 1024.0), num_tensors);
struct ggml_init_params params;
params.mem_size = static_cast<size_t>(num_tensors * ggml_tensor_overhead()) + 1 * 1024 * 1024;
params.mem_buffer = NULL;
params.no_alloc = true;
// LOG_DEBUG("mem_size %u ", params.mem_size);
params_ctx = ggml_init(params);
if (!params_ctx) {
LOG_ERROR("ggml_init() failed");
return false;
}
params_buffer = ggml_backend_alloc_buffer(backend, params_buffer_size);
return true;
} | O1 | cpp | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x60(%rdi)
movl %edx, 0x58(%rdi)
movq $0xa00000, 0x30(%rdi) # imm = 0xA00000
movq (%rdi), %rax
callq *(%rax)
addq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
movsd 0x30(%rbx), %xmm1
unpcklps 0x8037c(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq 0x8(%rbx), %r8
subpd 0x80380(%rip), %xmm1 # 0xbd930
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x804f4(%rip), %xmm0 # 0xbdab8
leaq 0x80e65(%rip), %rsi # 0xbe430
leaq 0x80eb4(%rip), %rcx # 0xbe486
xorl %edi, %edi
movl $0x228, %edx # imm = 0x228
movq %rax, %r9
movb $0x1, %al
callq 0x7a4d6
callq 0x8e322
imulq %r14, %rax
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8e3d1
movq %rax, %r14
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x3d63c
movq 0x30(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0xb3ed3
movq %rax, 0x40(%rbx)
jmp 0x3d65b
leaq 0x80ded(%rip), %rsi # 0xbe430
leaq 0x80760(%rip), %rcx # 0xbddaa
movl $0x3, %edi
movl $0x232, %edx # imm = 0x232
xorl %eax, %eax
callq 0x7a4d6
testq %r14, %r14
setne %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN10GGMLModule19alloc_params_bufferEP12ggml_backend9ggml_type:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rdi+60h], rsi
mov [rdi+58h], edx
mov qword ptr [rdi+30h], 0A00000h
mov rax, [rdi]
call qword ptr [rax]
add [rbx+30h], rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
mov r14, rax
movsd xmm1, qword ptr [rbx+30h]
unpcklps xmm1, cs:xmmword_BD920
mov r8, [rbx+8]
subpd xmm1, cs:xmmword_BD930
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
mulsd xmm0, cs:qword_BDAB8
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSParamsBackend; "%s params backend buffer size = % 6.2f "...
xor edi, edi
mov edx, 228h
mov r9, rax
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
call ggml_tensor_overhead
imul rax, r14
add rax, 100000h
mov qword ptr [rsp+48h+var_28], rax
mov qword ptr [rsp+48h+var_28+8], 0
mov byte ptr [rsp+48h+var_18], 1
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_38], rax
movups xmm0, [rsp+48h+var_28]
movups [rsp+48h+var_48], xmm0
call ggml_init
mov r14, rax
mov [rbx+28h], rax
test rax, rax
jz short loc_3D63C
mov rsi, [rbx+30h]
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+40h], rax
jmp short loc_3D65B
loc_3D63C:
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aGgmlInitFailed; "ggml_init() failed"
mov edi, 3
mov edx, 232h
xor eax, eax
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
loc_3D65B:
test r14, r14
setnz al
add rsp, 38h
pop rbx
pop r14
retn
| bool GGMLModule::alloc_params_buffer(long long a1, long long a2, int a3)
{
long long v3; // r14
__m128d v4; // xmm1
long long v5; // rax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // r8d
int v11; // r9d
long long v12; // r14
*(_QWORD *)(a1 + 96) = a2;
*(_DWORD *)(a1 + 88) = a3;
*(_QWORD *)(a1 + 48) = 10485760LL;
*(_QWORD *)(a1 + 48) += (**(long long ( ***)(long long))a1)(a1);
v3 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 8LL))(a1);
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_ps((__m128)*(unsigned long long *)(a1 + 48), (__m128)xmmword_BD920),
(__m128d)xmmword_BD930);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
552,
(unsigned int)"%s params backend buffer size = % 6.2f MB (%i tensors)",
*(_QWORD *)(a1 + 8),
v3);
v5 = ggml_tensor_overhead((_mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0]) * 0.00000095367431640625);
v12 = ggml_init(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
v6,
v7,
v8,
v9,
v3 * v5 + 0x100000,
0LL,
1);
*(_QWORD *)(a1 + 40) = v12;
if ( v12 )
*(_QWORD *)(a1 + 64) = ggml_backend_alloc_buffer(*(_QWORD *)(a1 + 96), *(_QWORD *)(a1 + 48));
else
log_printf(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
562,
(unsigned int)"ggml_init() failed",
v10,
v11);
return v12 != 0;
}
| |||
1,672 | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) | 7CodeWizard[P]stablediffusion/ggml_extend.hpp | bool alloc_params_buffer(ggml_backend_t backend_, ggml_type wtype_ = GGML_TYPE_F32) {
backend = backend_;
wtype = wtype_;
params_buffer_size = 10 * 1024 * 1024; // 10 MB, for padding
params_buffer_size += calculate_mem_size();
size_t num_tensors = get_num_tensors();
LOG_DEBUG("%s params backend buffer size = % 6.2f MB (%i tensors)",
name.c_str(), params_buffer_size / (1024.0 * 1024.0), num_tensors);
struct ggml_init_params params;
params.mem_size = static_cast<size_t>(num_tensors * ggml_tensor_overhead()) + 1 * 1024 * 1024;
params.mem_buffer = NULL;
params.no_alloc = true;
// LOG_DEBUG("mem_size %u ", params.mem_size);
params_ctx = ggml_init(params);
if (!params_ctx) {
LOG_ERROR("ggml_init() failed");
return false;
}
params_buffer = ggml_backend_alloc_buffer(backend, params_buffer_size);
return true;
} | O2 | cpp | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x60(%rdi)
movl %edx, 0x58(%rdi)
movq $0xa00000, 0x30(%rdi) # imm = 0xA00000
movq (%rdi), %rax
callq *(%rax)
addq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
movsd 0x30(%rbx), %xmm1
unpcklps 0x73280(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq 0x8(%rbx), %r8
subpd 0x73284(%rip), %xmm1 # 0x99870
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x733e0(%rip), %xmm0 # 0x999e0
leaq 0x73d59(%rip), %rsi # 0x9a360
leaq 0x73da8(%rip), %rcx # 0x9a3b6
xorl %edi, %edi
movl $0x228, %edx # imm = 0x228
movq %rax, %r9
movb $0x1, %al
callq 0x55f59
callq 0x67da7
imulq %r14, %rax
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x67e56
movq %rax, %r14
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x26675
movq 0x30(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0x8fd01
movq %rax, 0x40(%rbx)
jmp 0x26692
leaq 0x73ce4(%rip), %rsi # 0x9a360
leaq 0x73657(%rip), %rcx # 0x99cda
pushq $0x3
popq %rdi
movl $0x232, %edx # imm = 0x232
xorl %eax, %eax
callq 0x55f59
testq %r14, %r14
setne %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| _ZN10GGMLModule19alloc_params_bufferEP12ggml_backend9ggml_type:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rdi+60h], rsi
mov [rdi+58h], edx
mov qword ptr [rdi+30h], 0A00000h
mov rax, [rdi]
call qword ptr [rax]
add [rbx+30h], rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
mov r14, rax
movsd xmm1, qword ptr [rbx+30h]
unpcklps xmm1, cs:xmmword_99860
mov r8, [rbx+8]
subpd xmm1, cs:xmmword_99870
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
mulsd xmm0, cs:qword_999E0
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSParamsBackend; "%s params backend buffer size = % 6.2f "...
xor edi, edi
mov edx, 228h
mov r9, rax
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
call ggml_tensor_overhead
imul rax, r14
add rax, 100000h
mov qword ptr [rsp+48h+var_28], rax
and qword ptr [rsp+48h+var_28+8], 0
mov byte ptr [rsp+48h+var_18], 1
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_38], rax
movups xmm0, [rsp+48h+var_28]
movups [rsp+48h+var_48], xmm0
call ggml_init
mov r14, rax
mov [rbx+28h], rax
test rax, rax
jz short loc_26675
mov rsi, [rbx+30h]
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+40h], rax
jmp short loc_26692
loc_26675:
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aGgmlInitFailed; "ggml_init() failed"
push 3
pop rdi
mov edx, 232h
xor eax, eax
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
loc_26692:
test r14, r14
setnz al
add rsp, 38h
pop rbx
pop r14
retn
| bool GGMLModule::alloc_params_buffer(long long a1, long long a2, int a3)
{
long long v3; // r14
__m128d v4; // xmm1
long long v5; // rax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // r8d
int v11; // r9d
long long v12; // r14
*(_QWORD *)(a1 + 96) = a2;
*(_DWORD *)(a1 + 88) = a3;
*(_QWORD *)(a1 + 48) = 10485760LL;
*(_QWORD *)(a1 + 48) += (**(long long ( ***)(long long))a1)(a1);
v3 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 8LL))(a1);
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_ps((__m128)*(unsigned long long *)(a1 + 48), (__m128)xmmword_99860),
(__m128d)xmmword_99870);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
552,
(unsigned int)"%s params backend buffer size = % 6.2f MB (%i tensors)",
*(_QWORD *)(a1 + 8),
v3);
v5 = ggml_tensor_overhead((_mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0]) * 0.00000095367431640625);
v12 = ggml_init(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
v6,
v7,
v8,
v9,
v3 * v5 + 0x100000,
0LL,
1);
*(_QWORD *)(a1 + 40) = v12;
if ( v12 )
*(_QWORD *)(a1 + 64) = ggml_backend_alloc_buffer(*(_QWORD *)(a1 + 96), *(_QWORD *)(a1 + 48));
else
log_printf(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
562,
(unsigned int)"ggml_init() failed",
v10,
v11);
return v12 != 0;
}
| alloc_params_buffer:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV qword ptr [RDI + 0x60],RSI
MOV dword ptr [RDI + 0x58],EDX
MOV qword ptr [RDI + 0x30],0xa00000
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX]
ADD qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x8]
MOV R14,RAX
MOVSD XMM1,qword ptr [RBX + 0x30]
UNPCKLPS XMM1,xmmword ptr [0x00199860]
MOV R8,qword ptr [RBX + 0x8]
SUBPD XMM1,xmmword ptr [0x00199870]
MOVAPD XMM0,XMM1
UNPCKHPD XMM0,XMM1
ADDSD XMM0,XMM1
MULSD XMM0,qword ptr [0x001999e0]
LEA RSI,[0x19a360]
LEA RCX,[0x19a3b6]
XOR EDI,EDI
MOV EDX,0x228
MOV R9,RAX
MOV AL,0x1
CALL 0x00155f59
CALL 0x00167da7
IMUL RAX,R14
ADD RAX,0x100000
MOV qword ptr [RSP + 0x20],RAX
AND qword ptr [RSP + 0x28],0x0
MOV byte ptr [RSP + 0x30],0x1
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00167e56
MOV R14,RAX
MOV qword ptr [RBX + 0x28],RAX
TEST RAX,RAX
JZ 0x00126675
MOV RSI,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x60]
CALL 0x0018fd01
MOV qword ptr [RBX + 0x40],RAX
JMP 0x00126692
LAB_00126675:
LEA RSI,[0x19a360]
LEA RCX,[0x199cda]
PUSH 0x3
POP RDI
MOV EDX,0x232
XOR EAX,EAX
CALL 0x00155f59
LAB_00126692:
TEST R14,R14
SETNZ AL
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) */
bool __thiscall
GGMLModule::alloc_params_buffer(GGMLModule *this,int8 param_1,int4 param_3)
{
long lVar1;
int8 uVar2;
*(int8 *)(this + 0x60) = param_1;
*(int4 *)(this + 0x58) = param_3;
*(int8 *)(this + 0x30) = 0xa00000;
lVar1 = (*(code *)**(int8 **)this)();
*(long *)(this + 0x30) = *(long *)(this + 0x30) + lVar1;
uVar2 = (**(code **)(*(long *)this + 8))(this);
log_printf(SUB84((((double)CONCAT44(DAT_00199860._4_4_,
(int)((ulong)*(int8 *)(this + 0x30) >> 0x20)) -
_UNK_00199878) +
((double)CONCAT44((int4)DAT_00199860,(int)*(int8 *)(this + 0x30)) -
_DAT_00199870)) * DAT_001999e0,0),0,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,0x228,"%s params backend buffer size = % 6.2f MB (%i tensors)",
*(int8 *)(this + 8),uVar2);
ggml_tensor_overhead();
lVar1 = ggml_init();
*(long *)(this + 0x28) = lVar1;
if (lVar1 == 0) {
log_printf(3,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,0x232,"ggml_init() failed");
}
else {
uVar2 = ggml_backend_alloc_buffer(*(int8 *)(this + 0x60),*(int8 *)(this + 0x30));
*(int8 *)(this + 0x40) = uVar2;
}
return lVar1 != 0;
}
|
|
1,673 | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type) | 7CodeWizard[P]stablediffusion/ggml_extend.hpp | bool alloc_params_buffer(ggml_backend_t backend_, ggml_type wtype_ = GGML_TYPE_F32) {
backend = backend_;
wtype = wtype_;
params_buffer_size = 10 * 1024 * 1024; // 10 MB, for padding
params_buffer_size += calculate_mem_size();
size_t num_tensors = get_num_tensors();
LOG_DEBUG("%s params backend buffer size = % 6.2f MB (%i tensors)",
name.c_str(), params_buffer_size / (1024.0 * 1024.0), num_tensors);
struct ggml_init_params params;
params.mem_size = static_cast<size_t>(num_tensors * ggml_tensor_overhead()) + 1 * 1024 * 1024;
params.mem_buffer = NULL;
params.no_alloc = true;
// LOG_DEBUG("mem_size %u ", params.mem_size);
params_ctx = ggml_init(params);
if (!params_ctx) {
LOG_ERROR("ggml_init() failed");
return false;
}
params_buffer = ggml_backend_alloc_buffer(backend, params_buffer_size);
return true;
} | O3 | cpp | GGMLModule::alloc_params_buffer(ggml_backend*, ggml_type):
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x60(%rdi)
movl %edx, 0x58(%rdi)
movq $0xa00000, 0x30(%rdi) # imm = 0xA00000
movq (%rdi), %rax
callq *(%rax)
addq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %rax, %r14
movsd 0x30(%rbx), %xmm1
unpcklps 0x7feb4(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq 0x8(%rbx), %r8
subpd 0x7feb8(%rip), %xmm1 # 0xbc940
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x8002c(%rip), %xmm0 # 0xbcac8
leaq 0x8099d(%rip), %rsi # 0xbd440
leaq 0x809ec(%rip), %rcx # 0xbd496
xorl %edi, %edi
movl $0x228, %edx # imm = 0x228
movq %rax, %r9
movb $0x1, %al
callq 0x7947e
callq 0x8d091
imulq %r14, %rax
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movb $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x8d140
movq %rax, %r14
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x3cb14
movq 0x30(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0xb2abb
movq %rax, 0x40(%rbx)
jmp 0x3cb33
leaq 0x80925(%rip), %rsi # 0xbd440
leaq 0x80298(%rip), %rcx # 0xbcdba
movl $0x3, %edi
movl $0x232, %edx # imm = 0x232
xorl %eax, %eax
callq 0x7947e
testq %r14, %r14
setne %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN10GGMLModule19alloc_params_bufferEP12ggml_backend9ggml_type:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
mov [rdi+60h], rsi
mov [rdi+58h], edx
mov qword ptr [rdi+30h], 0A00000h
mov rax, [rdi]
call qword ptr [rax]
add [rbx+30h], rax
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
mov r14, rax
movsd xmm1, qword ptr [rbx+30h]
unpcklps xmm1, cs:xmmword_BC930
mov r8, [rbx+8]
subpd xmm1, cs:xmmword_BC940
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
mulsd xmm0, cs:qword_BCAC8
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSParamsBackend; "%s params backend buffer size = % 6.2f "...
xor edi, edi
mov edx, 228h
mov r9, rax
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
call ggml_tensor_overhead
imul rax, r14
add rax, 100000h
mov qword ptr [rsp+48h+var_28], rax
mov qword ptr [rsp+48h+var_28+8], 0
mov byte ptr [rsp+48h+var_18], 1
mov rax, [rsp+48h+var_18]
mov [rsp+48h+var_38], rax
movups xmm0, [rsp+48h+var_28]
movups [rsp+48h+var_48], xmm0
call ggml_init
mov r14, rax
mov [rbx+28h], rax
test rax, rax
jz short loc_3CB14
mov rsi, [rbx+30h]
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+40h], rax
jmp short loc_3CB33
loc_3CB14:
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aGgmlInitFailed; "ggml_init() failed"
mov edi, 3
mov edx, 232h
xor eax, eax
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
loc_3CB33:
test r14, r14
setnz al
add rsp, 38h
pop rbx
pop r14
retn
| bool GGMLModule::alloc_params_buffer(long long a1, long long a2, int a3)
{
long long v3; // r14
__m128d v4; // xmm1
long long v5; // rax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // r8d
int v11; // r9d
long long v12; // r14
*(_QWORD *)(a1 + 96) = a2;
*(_DWORD *)(a1 + 88) = a3;
*(_QWORD *)(a1 + 48) = 10485760LL;
*(_QWORD *)(a1 + 48) += (**(long long ( ***)(long long))a1)(a1);
v3 = (*(long long ( **)(long long))(*(_QWORD *)a1 + 8LL))(a1);
v4 = _mm_sub_pd(
(__m128d)_mm_unpacklo_ps((__m128)*(unsigned long long *)(a1 + 48), (__m128)xmmword_BC930),
(__m128d)xmmword_BC940);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
552,
(unsigned int)"%s params backend buffer size = % 6.2f MB (%i tensors)",
*(_QWORD *)(a1 + 8),
v3);
v5 = ggml_tensor_overhead((_mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0]) * 0.00000095367431640625);
v12 = ggml_init(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
v6,
v7,
v8,
v9,
v3 * v5 + 0x100000,
0LL,
1);
*(_QWORD *)(a1 + 40) = v12;
if ( v12 )
*(_QWORD *)(a1 + 64) = ggml_backend_alloc_buffer(*(_QWORD *)(a1 + 96), *(_QWORD *)(a1 + 48));
else
log_printf(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
562,
(unsigned int)"ggml_init() failed",
v10,
v11);
return v12 != 0;
}
| |||
1,674 | ma_randominit | eloqsql/libmariadb/libmariadb/ma_password.c | void ma_randominit(struct rand_struct *rand_st,ulong seed1, ulong seed2)
{ /* For mysql 3.21.# */
#ifdef HAVE_purify
memset((char*) rand_st, 0m sizeof(*rand_st)); /* Avoid UMC warnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O0 | c | ma_randominit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x3fffffff, 0x10(%rax) # imm = 0x3FFFFFFF
movq -0x8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0x7f04(%rip), %xmm1 # 0x596c0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x7f08(%rip), %xmm1 # 0x596d0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
| ma_randominit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 3FFFFFFFh
mov rax, [rbp+var_8]
movq xmm0, qword ptr [rax+10h]
movaps xmm1, cs:xmmword_596C0
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_596D0
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
mov rax, [rbp+var_8]
movsd qword ptr [rax+18h], xmm0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax], rdx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax+8], rdx
pop rbp
retn
| long long ma_randominit(long long a1, unsigned long long a2, unsigned long long a3)
{
__m128d v3; // xmm1
long long result; // rax
*(_QWORD *)(a1 + 16) = 0x3FFFFFFFLL;
v3 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)(a1 + 16)), (__m128i)xmmword_596C0),
(__m128d)xmmword_596D0);
*(double *)(a1 + 24) = _mm_unpackhi_pd(v3, v3).m128d_f64[0] + v3.m128d_f64[0];
*(_QWORD *)a1 = a2 % *(_QWORD *)(a1 + 16);
result = a1;
*(_QWORD *)(a1 + 8) = a3 % *(_QWORD *)(a1 + 16);
return result;
}
| ma_randominit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x3fffffff
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,qword ptr [RAX + 0x10]
MOVAPS XMM1,xmmword ptr [0x001596c0]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x001596d0]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x18],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RDX
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ma_randominit(ulong *param_1,ulong param_2,ulong param_3)
{
ulong uVar1;
int1 auVar2 [16];
param_1[2] = 0x3fffffff;
uVar1 = param_1[2];
auVar2._8_4_ = (int)(uVar1 >> 0x20);
auVar2._0_8_ = uVar1;
auVar2._12_4_ = _UNK_001596c4;
param_1[3] = (ulong)((auVar2._8_8_ - _UNK_001596d8) +
((double)CONCAT44(_DAT_001596c0,(int)uVar1) - _DAT_001596d0));
*param_1 = param_2 % param_1[2];
param_1[1] = param_3 % param_1[2];
return;
}
|
|
1,675 | minja::SetNode::SetNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | SetNode(const Location & location, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateNode(location), ns(ns), var_names(vns), value(std::move(v)) {} | O2 | cpp | minja::SetNode::SetNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %rbx
callq 0x738ec
leaq 0x86dcd(%rip), %rax # 0xfd348
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x23c40
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x3a41c
andq $0x0, 0x60(%rbx)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x58(%rbx)
andq $0x0, (%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x24208
jmp 0x765cd
movq %rax, %r14
movq %rbx, %rdi
callq 0x78566
movq %r14, %rdi
callq 0x23fc0
nop
| _ZN5minja7SetNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS9_SaIS9_EEOSt10shared_ptrINS_10ExpressionEE:
push r15
push r14
push r13
push r12
push rbx
mov r14, r8
mov r15, rcx
mov r13, rdx
mov rbx, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja7SetNodeE; `vtable for'minja::SetNode
add rax, 10h
mov [rbx], rax
lea r12, [rbx+20h]
mov rdi, r12
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
lea rdi, [rbx+40h]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
and qword ptr [rbx+60h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [rbx+58h], xmm0
and qword ptr [r14], 0
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_765CD
mov r14, rax
loc_765CD:
mov rdi, rbx; this
call _ZN5minja12TemplateNodeD2Ev; minja::TemplateNode::~TemplateNode()
mov rdi, r14
call __Unwind_Resume
| long long minja::SetNode::SetNode(long long a1, _QWORD *a2, long long a3, _QWORD *a4, __int128 *a5)
{
long long result; // rax
__int128 v8; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::SetNode + 2;
std::string::basic_string(a1 + 32);
result = std::vector<std::string>::vector((_QWORD *)(a1 + 64), a4);
*(_QWORD *)(a1 + 96) = 0LL;
v8 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 88) = v8;
*(_QWORD *)a5 = 0LL;
return result;
}
| SetNode:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,R8
MOV R15,RCX
MOV R13,RDX
MOV RBX,RDI
CALL 0x001738ec
LEA RAX,[0x1fd348]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA R12,[RBX + 0x20]
LAB_00176586:
MOV RDI,R12
MOV RSI,R13
CALL 0x00123c40
LEA RDI,[RBX + 0x40]
LAB_00176595:
MOV RSI,R15
CALL 0x0013a41c
LAB_0017659d:
AND qword ptr [RBX + 0x60],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [RBX + 0x58],XMM0
AND qword ptr [R14],0x0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::SetNode::SetNode(minja::Location const&, std::__cxx11::string const&,
std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::SetNode::SetNode
(SetNode *this,Location *param_1,string *param_2,vector *param_3,shared_ptr *param_4)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_001fd358;
/* try { // try from 00176586 to 00176590 has its CatchHandler @ 001765ca */
std::__cxx11::string::string((string *)(this + 0x20),param_2);
/* try { // try from 00176595 to 0017659c has its CatchHandler @ 001765bd */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x40),
param_3);
*(int8 *)(this + 0x60) = 0;
uVar1 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x58) = *(int8 *)param_4;
*(int8 *)(this + 0x60) = uVar1;
*(int8 *)param_4 = 0;
return;
}
|
|
1,676 | my_parse_charset_xml | eloqsql/strings/ctype.c | my_bool
my_parse_charset_xml(MY_CHARSET_LOADER *loader, const char *buf, size_t len)
{
MY_XML_PARSER p;
struct my_cs_file_info info;
my_bool rc;
my_charset_file_init(&info);
my_xml_parser_create(&p);
my_xml_set_enter_handler(&p,cs_enter);
my_xml_set_value_handler(&p,cs_value);
my_xml_set_leave_handler(&p,cs_leave);
info.loader= loader;
my_xml_set_user_data(&p, (void *) &info);
rc= (my_xml_parse(&p,buf,len) == MY_XML_OK) ? FALSE : TRUE;
my_xml_parser_free(&p);
my_charset_file_free(&info);
if (rc != MY_XML_OK)
{
const char *errstr= my_xml_error_string(&p);
if (sizeof(loader->error) > 32 + strlen(errstr))
{
/* We cannot use my_snprintf() here. See previous comment. */
sprintf(loader->error, "at line %d pos %d: %s",
my_xml_error_lineno(&p)+1,
(int) my_xml_error_pos(&p),
my_xml_error_string(&p));
}
}
return rc;
} | O0 | c | my_parse_charset_xml:
pushq %rbp
movq %rsp, %rbp
subq $0x960, %rsp # imm = 0x960
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x920(%rbp)
movq %rsi, -0x928(%rbp)
movq %rdx, -0x930(%rbp)
leaq -0x918(%rbp), %rdi
callq 0x6bde0
leaq -0x168(%rbp), %rdi
callq 0x78410
leaq -0x168(%rbp), %rdi
leaq 0x1bd(%rip), %rsi # 0x6be30
callq 0x784d0
leaq -0x168(%rbp), %rdi
leaq 0x29a(%rip), %rsi # 0x6bf20
callq 0x784b0
leaq -0x168(%rbp), %rdi
leaq 0x9f7(%rip), %rsi # 0x6c690
callq 0x784f0
movq -0x920(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
leaq -0x918(%rbp), %rsi
callq 0x78510
movq -0x928(%rbp), %rsi
movq -0x930(%rbp), %rdx
leaq -0x168(%rbp), %rdi
callq 0x772e0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0x931(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x78470
leaq -0x918(%rbp), %rdi
callq 0x6c9a0
movsbl -0x931(%rbp), %eax
cmpl $0x0, %eax
je 0x6bdad
leaq -0x168(%rbp), %rdi
callq 0x78530
movq %rax, -0x940(%rbp)
movq -0x940(%rbp), %rdi
callq 0x24130
movq %rax, %rcx
addq $0x20, %rcx
movl $0x80, %eax
cmpq %rcx, %rax
jbe 0x6bdab
movq -0x920(%rbp), %rax
movq %rax, -0x950(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x785c0
addl $0x1, %eax
movl %eax, -0x948(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x78550
movl %eax, -0x944(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x78530
movq -0x950(%rbp), %rdi
movl -0x948(%rbp), %edx
movl -0x944(%rbp), %ecx
movq %rax, %r8
leaq 0x10136(%rip), %rsi # 0x7beda
movb $0x0, %al
callq 0x240b0
jmp 0x6bdad
movb -0x931(%rbp), %al
movb %al, -0x951(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6bdda
movb -0x951(%rbp), %al
addq $0x960, %rsp # imm = 0x960
popq %rbp
retq
callq 0x242e0
nop
| my_parse_charset_xml:
push rbp
mov rbp, rsp
sub rsp, 960h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_920], rdi
mov [rbp+var_928], rsi
mov [rbp+var_930], rdx
lea rdi, [rbp+var_918]
call my_charset_file_init
lea rdi, [rbp+var_168]
call my_xml_parser_create
lea rdi, [rbp+var_168]
lea rsi, cs_enter
call my_xml_set_enter_handler
lea rdi, [rbp+var_168]
lea rsi, cs_value
call my_xml_set_value_handler
lea rdi, [rbp+var_168]
lea rsi, cs_leave
call my_xml_set_leave_handler
mov rax, [rbp+var_920]
mov [rbp+var_170], rax
lea rdi, [rbp+var_168]
lea rsi, [rbp+var_918]
call my_xml_set_user_data
mov rsi, [rbp+var_928]
mov rdx, [rbp+var_930]
lea rdi, [rbp+var_168]
call my_xml_parse
mov edx, eax
mov eax, 1
xor ecx, ecx
cmp edx, 0
cmovz eax, ecx
mov [rbp+var_931], al
lea rdi, [rbp+var_168]
call my_xml_parser_free
lea rdi, [rbp+var_918]
call my_charset_file_free
movsx eax, [rbp+var_931]
cmp eax, 0
jz loc_6BDAD
lea rdi, [rbp+var_168]
call my_xml_error_string
mov [rbp+var_940], rax
mov rdi, [rbp+var_940]
call _strlen
mov rcx, rax
add rcx, 20h ; ' '
mov eax, 80h
cmp rax, rcx
jbe short loc_6BDAB
mov rax, [rbp+var_920]
mov [rbp+var_950], rax
lea rdi, [rbp+var_168]
call my_xml_error_lineno
add eax, 1
mov [rbp+var_948], eax
lea rdi, [rbp+var_168]
call my_xml_error_pos
mov [rbp+var_944], eax
lea rdi, [rbp+var_168]
call my_xml_error_string
mov rdi, [rbp+var_950]
mov edx, [rbp+var_948]
mov ecx, [rbp+var_944]
mov r8, rax
lea rsi, aAtLineDPosDS; "at line %d pos %d: %s"
mov al, 0
call _sprintf
loc_6BDAB:
jmp short $+2
loc_6BDAD:
mov al, [rbp+var_931]
mov [rbp+var_951], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6BDDA
mov al, [rbp+var_951]
add rsp, 960h
pop rbp
retn
loc_6BDDA:
call ___stack_chk_fail
| bool my_parse_charset_xml(long long a1, long long a2, long long a3)
{
const char *v3; // rax
int v5; // [rsp+18h] [rbp-948h]
int v6; // [rsp+1Ch] [rbp-944h]
long long v7; // [rsp+20h] [rbp-940h]
bool v8; // [rsp+2Fh] [rbp-931h]
_BYTE v10[1960]; // [rsp+48h] [rbp-918h] BYREF
long long v11; // [rsp+7F0h] [rbp-170h]
_BYTE v12[352]; // [rsp+7F8h] [rbp-168h] BYREF
unsigned long long v13; // [rsp+958h] [rbp-8h]
v13 = __readfsqword(0x28u);
my_charset_file_init(v10);
my_xml_parser_create(v12);
my_xml_set_enter_handler(v12, cs_enter);
my_xml_set_value_handler(v12, cs_value);
my_xml_set_leave_handler(v12, cs_leave);
v11 = a1;
my_xml_set_user_data(v12, v10);
v8 = (unsigned int)my_xml_parse(v12, a2, a3) != 0;
my_xml_parser_free(v12);
my_charset_file_free(v10);
if ( v8 )
{
v7 = my_xml_error_string(v12);
if ( (unsigned long long)(strlen(v7) + 32) < 0x80 )
{
v5 = my_xml_error_lineno(v12) + 1;
v6 = my_xml_error_pos(v12);
v3 = (const char *)my_xml_error_string(v12);
sprintf(a1, "at line %d pos %d: %s", v5, v6, v3);
}
}
return v8;
}
| my_parse_charset_xml:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x960
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x920],RDI
MOV qword ptr [RBP + -0x928],RSI
MOV qword ptr [RBP + -0x930],RDX
LEA RDI,[RBP + -0x918]
CALL 0x0016bde0
LEA RDI,[RBP + -0x168]
CALL 0x00178410
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16be30]
CALL 0x001784d0
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16bf20]
CALL 0x001784b0
LEA RDI,[RBP + -0x168]
LEA RSI,[0x16c690]
CALL 0x001784f0
MOV RAX,qword ptr [RBP + -0x920]
MOV qword ptr [RBP + -0x170],RAX
LEA RDI,[RBP + -0x168]
LEA RSI,[RBP + -0x918]
CALL 0x00178510
MOV RSI,qword ptr [RBP + -0x928]
MOV RDX,qword ptr [RBP + -0x930]
LEA RDI,[RBP + -0x168]
CALL 0x001772e0
MOV EDX,EAX
MOV EAX,0x1
XOR ECX,ECX
CMP EDX,0x0
CMOVZ EAX,ECX
MOV byte ptr [RBP + -0x931],AL
LEA RDI,[RBP + -0x168]
CALL 0x00178470
LEA RDI,[RBP + -0x918]
CALL 0x0016c9a0
MOVSX EAX,byte ptr [RBP + -0x931]
CMP EAX,0x0
JZ 0x0016bdad
LEA RDI,[RBP + -0x168]
CALL 0x00178530
MOV qword ptr [RBP + -0x940],RAX
MOV RDI,qword ptr [RBP + -0x940]
CALL 0x00124130
MOV RCX,RAX
ADD RCX,0x20
MOV EAX,0x80
CMP RAX,RCX
JBE 0x0016bdab
MOV RAX,qword ptr [RBP + -0x920]
MOV qword ptr [RBP + -0x950],RAX
LEA RDI,[RBP + -0x168]
CALL 0x001785c0
ADD EAX,0x1
MOV dword ptr [RBP + -0x948],EAX
LEA RDI,[RBP + -0x168]
CALL 0x00178550
MOV dword ptr [RBP + -0x944],EAX
LEA RDI,[RBP + -0x168]
CALL 0x00178530
MOV RDI,qword ptr [RBP + -0x950]
MOV EDX,dword ptr [RBP + -0x948]
MOV ECX,dword ptr [RBP + -0x944]
MOV R8,RAX
LEA RSI,[0x17beda]
MOV AL,0x0
CALL 0x001240b0
LAB_0016bdab:
JMP 0x0016bdad
LAB_0016bdad:
MOV AL,byte ptr [RBP + -0x931]
MOV byte ptr [RBP + -0x951],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016bdda
MOV AL,byte ptr [RBP + -0x951]
ADD RSP,0x960
POP RBP
RET
LAB_0016bdda:
CALL 0x001242e0
|
int8 my_parse_charset_xml(char *param_1,int8 param_2,int8 param_3)
{
int iVar1;
int iVar2;
uint uVar3;
char *__s;
size_t sVar4;
int8 uVar5;
long in_FS_OFFSET;
int1 local_920 [1960];
char *local_178;
int1 local_170 [352];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_charset_file_init(local_920);
my_xml_parser_create(local_170);
my_xml_set_enter_handler(local_170,cs_enter);
my_xml_set_value_handler(local_170,cs_value);
my_xml_set_leave_handler(local_170,cs_leave);
local_178 = param_1;
my_xml_set_user_data(local_170,local_920);
iVar1 = my_xml_parse(local_170,param_2,param_3);
my_xml_parser_free(local_170);
my_charset_file_free(local_920);
if (iVar1 != 0) {
__s = (char *)my_xml_error_string(local_170);
sVar4 = strlen(__s);
if (sVar4 + 0x20 < 0x80) {
iVar2 = my_xml_error_lineno(local_170);
uVar3 = my_xml_error_pos(local_170);
uVar5 = my_xml_error_string(local_170);
sprintf(param_1,"at line %d pos %d: %s",(ulong)(iVar2 + 1),(ulong)uVar3,uVar5);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),iVar1 != 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,677 | mbedtls_ecp_curve_info_from_grp_id | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/ecp.c | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id(mbedtls_ecp_group_id grp_id)
{
const mbedtls_ecp_curve_info *curve_info;
for (curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++) {
if (curve_info->grp_id == grp_id) {
return curve_info;
}
}
return NULL;
} | O3 | c | mbedtls_ecp_curve_info_from_grp_id:
leaq 0x5dc79(%rip), %rax # 0xe1e70
movl $0x5, %ecx
cmpl %edi, %ecx
je 0x8420d
movl 0x10(%rax), %ecx
addq $0x10, %rax
testl %ecx, %ecx
jne 0x841fc
xorl %eax, %eax
retq
| mbedtls_ecp_curve_info_from_grp_id:
lea rax, ecp_supported_curves
mov ecx, 5
loc_841FC:
cmp ecx, edi
jz short locret_8420D
mov ecx, [rax+10h]
add rax, 10h
test ecx, ecx
jnz short loc_841FC
xor eax, eax
locret_8420D:
retn
| _DWORD * mbedtls_ecp_curve_info_from_grp_id(int a1)
{
_DWORD *result; // rax
int v2; // ecx
result = &ecp_supported_curves;
v2 = 5;
while ( v2 != a1 )
{
v2 = result[4];
result += 4;
if ( !v2 )
return 0LL;
}
return result;
}
| mbedtls_ecp_curve_info_from_grp_id:
LEA RAX,[0x1e1e70]
MOV ECX,0x5
LAB_001841fc:
CMP ECX,EDI
JZ 0x0018420d
MOV ECX,dword ptr [RAX + 0x10]
ADD RAX,0x10
TEST ECX,ECX
JNZ 0x001841fc
XOR EAX,EAX
LAB_0018420d:
RET
|
int4 * mbedtls_ecp_curve_info_from_grp_id(int param_1)
{
int4 *puVar1;
int iVar2;
puVar1 = &ecp_supported_curves;
iVar2 = 5;
do {
if (iVar2 == param_1) {
return puVar1;
}
iVar2 = puVar1[4];
puVar1 = puVar1 + 4;
} while (iVar2 != 0);
return (int4 *)0x0;
}
|
|
1,678 | my_print_default_files | eloqsql/mysys/my_default.c | void my_print_default_files(const char *conf_file)
{
const char *empty_list[]= { "", 0 };
my_bool have_ext= fn_ext(conf_file)[0] != 0;
const char **exts_to_use= have_ext ? empty_list : f_extensions;
char name[FN_REFLEN], **ext;
puts("\nDefault options are read from the following files in the given order:");
if (my_defaults_file)
{
puts(my_defaults_file);
return;
}
if (dirname_length(conf_file))
fputs(conf_file,stdout);
else
{
const char **dirs;
MEM_ROOT alloc;
init_alloc_root(key_memory_defaults, &alloc, 512, 0, MYF(0));
if ((dirs= init_default_directories(&alloc)) == NULL)
{
fputs("Internal error initializing default directories list", stdout);
}
else
{
for ( ; *dirs; dirs++)
{
for (ext= (char**) exts_to_use; *ext; ext++)
{
const char *pos;
char *end;
if (**dirs)
pos= *dirs;
else if (my_defaults_extra_file)
{
pos= my_defaults_extra_file;
fputs(pos, stdout);
fputs(" ", stdout);
continue;
}
else
continue;
end= convert_dirname(name, pos, NullS);
if (name[0] == FN_HOMELIB) /* Add . to filenames in home */
*end++= '.';
strxmov(end, conf_file, *ext, " ", NullS);
fputs(name, stdout);
}
}
}
free_root(&alloc, MYF(0));
}
puts("");
} | O3 | c | my_print_default_files:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
callq 0xb11fc
cmpb $0x0, (%rax)
leaq 0x2d4f46(%rip), %rax # 0x385b60
leaq 0x2d4f4f(%rip), %rbx # 0x385b70
cmoveq %rax, %rbx
leaq 0x3487f(%rip), %rdi # 0xe54ab
callq 0x2a7d0
leaq 0xb62660(%rip), %rax # 0xc13298
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0c69
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xb0de5
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a7d0
movq %r15, %rdi
callq 0x997dc
testq %rax, %rax
je 0xb0c8d
movq 0x2dd32b(%rip), %rax # 0x38dfa8
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2a2b0
jmp 0xb0dba
leaq 0xb61e94(%rip), %rax # 0xc12b28
movl (%rax), %edi
leaq -0x280(%rbp), %r14
movl $0x200, %edx # imm = 0x200
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa1a20
movq %r14, %rdi
callq 0xb0ad7
testq %rax, %rax
je 0xb0d96
movq %rax, %r14
cmpq $0x0, (%rax)
je 0xb0dac
movq (%rbx), %rax
movq %rax, -0x238(%rbp)
addq $0x8, %rbx
movq %rbx, -0x240(%rbp)
leaq -0x230(%rbp), %r12
cmpq $0x0, -0x238(%rbp)
je 0xb0d85
movq -0x240(%rbp), %rbx
movq -0x238(%rbp), %r13
movq (%r14), %rsi
cmpb $0x0, (%rsi)
je 0xb0d45
movq %r12, %rdi
xorl %edx, %edx
callq 0x99857
cmpb $0x7e, -0x230(%rbp)
jne 0xb0d26
movb $0x2e, (%rax)
incq %rax
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
leaq 0x33b87(%rip), %rcx # 0xe48bd
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xdfdc4
movq %r12, %rdi
jmp 0xb0d6a
leaq 0xb6255c(%rip), %rax # 0xc132a8
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0d79
movq 0x2dd24d(%rip), %rax # 0x38dfa8
movq (%rax), %rsi
callq 0x2a2b0
leaq 0x33b53(%rip), %rdi # 0xe48bd
movq 0x2dd237(%rip), %rax # 0x38dfa8
movq (%rax), %rsi
callq 0x2a2b0
movq (%rbx), %r13
addq $0x8, %rbx
testq %r13, %r13
jne 0xb0d05
cmpq $0x0, 0x8(%r14)
leaq 0x8(%r14), %r14
jne 0xb0ce9
jmp 0xb0dac
movq 0x2dd20b(%rip), %rax # 0x38dfa8
movq (%rax), %rsi
leaq 0x3474b(%rip), %rdi # 0xe54f2
callq 0x2a2b0
leaq -0x280(%rbp), %rdi
xorl %esi, %esi
callq 0xa1def
movl $0xa, %edi
callq 0x2a910
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xb0de5
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a240
| my_print_default_files:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 258h
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
call fn_ext
cmp byte ptr [rax], 0
lea rax, f_extensions
lea rbx, off_385B70; ""
cmovz rbx, rax
lea rdi, aDefaultOptions; "\nDefault options are read from the fol"...
call _puts
lea rax, my_defaults_file
mov rdi, [rax]
test rdi, rdi
jz short loc_B0C69
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_B0DE5
add rsp, 258h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
loc_B0C69:
mov rdi, r15
call dirname_length
test rax, rax
jz short loc_B0C8D
mov rax, cs:stdout_ptr
mov rsi, [rax]
mov rdi, r15
call _fputs
jmp loc_B0DBA
loc_B0C8D:
lea rax, key_memory_defaults
mov edi, [rax]
lea r14, [rbp+var_280]
mov edx, 200h
mov rsi, r14
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rdi, r14
call init_default_directories
test rax, rax
jz loc_B0D96
mov r14, rax
cmp qword ptr [rax], 0
jz loc_B0DAC
mov rax, [rbx]
mov [rbp+var_238], rax
add rbx, 8
mov [rbp+var_240], rbx
lea r12, [rbp+var_230]
loc_B0CE9:
cmp [rbp+var_238], 0
jz loc_B0D85
mov rbx, [rbp+var_240]
mov r13, [rbp+var_238]
loc_B0D05:
mov rsi, [r14]
cmp byte ptr [rsi], 0
jz short loc_B0D45
mov rdi, r12
xor edx, edx
call convert_dirname
cmp [rbp+var_230], 7Eh ; '~'
jnz short loc_B0D26
mov byte ptr [rax], 2Eh ; '.'
inc rax
loc_B0D26:
mov rdi, rax
mov rsi, r15
mov rdx, r13
lea rcx, asc_E48BC+1; " "
xor r8d, r8d
xor eax, eax
call strxmov
mov rdi, r12
jmp short loc_B0D6A
loc_B0D45:
lea rax, my_defaults_extra_file
mov rdi, [rax]
test rdi, rdi
jz short loc_B0D79
mov rax, cs:stdout_ptr
mov rsi, [rax]
call _fputs
lea rdi, asc_E48BC+1; " "
loc_B0D6A:
mov rax, cs:stdout_ptr
mov rsi, [rax]
call _fputs
loc_B0D79:
mov r13, [rbx]
add rbx, 8
test r13, r13
jnz short loc_B0D05
loc_B0D85:
cmp qword ptr [r14+8], 0
lea r14, [r14+8]
jnz loc_B0CE9
jmp short loc_B0DAC
loc_B0D96:
mov rax, cs:stdout_ptr
mov rsi, [rax]
lea rdi, aInternalErrorI; "Internal error initializing default dir"...
call _fputs
loc_B0DAC:
lea rdi, [rbp+var_280]
xor esi, esi
call free_root
loc_B0DBA:
mov edi, 0Ah
call _putchar
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_B0DE5
add rsp, 258h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B0DE5:
call ___stack_chk_fail
| long long my_print_default_files(_BYTE *a1)
{
int v1; // r15d
char **v2; // rbx
char *inited; // rax
long long *v5; // r14
char **v6; // rbx
long long v7; // r13
_WORD *v8; // rax
int v9; // r9d
char *v10; // rdi
bool v11; // zf
long long v12[8]; // [rsp+0h] [rbp-280h] BYREF
char **v13; // [rsp+40h] [rbp-240h]
char *v14; // [rsp+48h] [rbp-238h]
_WORD v15[256]; // [rsp+50h] [rbp-230h] BYREF
unsigned long long v16; // [rsp+250h] [rbp-30h]
v1 = (int)a1;
v16 = __readfsqword(0x28u);
v2 = (char **)&off_385B70;
if ( !*(_BYTE *)fn_ext() )
v2 = &f_extensions;
puts("\nDefault options are read from the following files in the given order:");
if ( my_defaults_file )
return puts(my_defaults_file);
if ( !dirname_length(a1) )
{
init_alloc_root(key_memory_defaults, v12, 512LL, 0LL, 0LL);
inited = init_default_directories((long long)v12);
if ( inited )
{
v5 = (long long *)inited;
if ( *(_QWORD *)inited )
{
v14 = *v2;
v13 = v2 + 1;
while ( !v14 )
{
LABEL_20:
v11 = v5[1] == 0;
++v5;
if ( v11 )
goto LABEL_23;
}
v6 = v13;
LODWORD(v7) = (_DWORD)v14;
while ( !*(_BYTE *)*v5 )
{
if ( my_defaults_extra_file )
{
fputs(my_defaults_extra_file, stdout);
v10 = " ";
LABEL_18:
fputs(v10, stdout);
}
v7 = (long long)*v6++;
if ( !v7 )
goto LABEL_20;
}
v8 = convert_dirname(v15, *v5, 0LL);
if ( LOBYTE(v15[0]) == 126 )
{
*(_BYTE *)v8 = 46;
LODWORD(v8) = (_DWORD)v8 + 1;
}
strxmov((_DWORD)v8, v1, v7, (unsigned int)" ", 0, v9);
v10 = (char *)v15;
goto LABEL_18;
}
}
else
{
fputs("Internal error initializing default directories list", stdout);
}
LABEL_23:
free_root(v12, 0);
goto LABEL_24;
}
fputs(a1, stdout);
LABEL_24:
putchar(10LL);
return __readfsqword(0x28u);
}
| my_print_default_files:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x258
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001b11fc
CMP byte ptr [RAX],0x0
LEA RAX,[0x485b60]
LEA RBX,[0x485b70]
CMOVZ RBX,RAX
LEA RDI,[0x1e54ab]
CALL 0x0012a7d0
LEA RAX,[0xd13298]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001b0c69
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001b0de5
ADD RSP,0x258
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012a7d0
LAB_001b0c69:
MOV RDI,R15
CALL 0x001997dc
TEST RAX,RAX
JZ 0x001b0c8d
MOV RAX,qword ptr [0x0048dfa8]
MOV RSI,qword ptr [RAX]
MOV RDI,R15
CALL 0x0012a2b0
JMP 0x001b0dba
LAB_001b0c8d:
LEA RAX,[0xd12b28]
MOV EDI,dword ptr [RAX]
LEA R14,[RBP + -0x280]
MOV EDX,0x200
MOV RSI,R14
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001a1a20
MOV RDI,R14
CALL 0x001b0ad7
TEST RAX,RAX
JZ 0x001b0d96
MOV R14,RAX
CMP qword ptr [RAX],0x0
JZ 0x001b0dac
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBP + -0x238],RAX
ADD RBX,0x8
MOV qword ptr [RBP + -0x240],RBX
LEA R12,[RBP + -0x230]
LAB_001b0ce9:
CMP qword ptr [RBP + -0x238],0x0
JZ 0x001b0d85
MOV RBX,qword ptr [RBP + -0x240]
MOV R13,qword ptr [RBP + -0x238]
LAB_001b0d05:
MOV RSI,qword ptr [R14]
CMP byte ptr [RSI],0x0
JZ 0x001b0d45
MOV RDI,R12
XOR EDX,EDX
CALL 0x00199857
CMP byte ptr [RBP + -0x230],0x7e
JNZ 0x001b0d26
MOV byte ptr [RAX],0x2e
INC RAX
LAB_001b0d26:
MOV RDI,RAX
MOV RSI,R15
MOV RDX,R13
LEA RCX,[0x1e48bd]
XOR R8D,R8D
XOR EAX,EAX
CALL 0x001dfdc4
MOV RDI,R12
JMP 0x001b0d6a
LAB_001b0d45:
LEA RAX,[0xd132a8]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001b0d79
MOV RAX,qword ptr [0x0048dfa8]
MOV RSI,qword ptr [RAX]
CALL 0x0012a2b0
LEA RDI,[0x1e48bd]
LAB_001b0d6a:
MOV RAX,qword ptr [0x0048dfa8]
MOV RSI,qword ptr [RAX]
CALL 0x0012a2b0
LAB_001b0d79:
MOV R13,qword ptr [RBX]
ADD RBX,0x8
TEST R13,R13
JNZ 0x001b0d05
LAB_001b0d85:
CMP qword ptr [R14 + 0x8],0x0
LEA R14,[R14 + 0x8]
JNZ 0x001b0ce9
JMP 0x001b0dac
LAB_001b0d96:
MOV RAX,qword ptr [0x0048dfa8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x1e54f2]
CALL 0x0012a2b0
LAB_001b0dac:
LEA RDI,[RBP + -0x280]
XOR ESI,ESI
CALL 0x001a1def
LAB_001b0dba:
MOV EDI,0xa
CALL 0x0012a910
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001b0de5
ADD RSP,0x258
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b0de5:
CALL 0x0012a240
|
void my_print_default_files(char *param_1)
{
long *plVar1;
int *puVar2;
char *pcVar3;
long lVar4;
long *plVar5;
int1 *puVar6;
int **ppuVar7;
long in_FS_OFFSET;
int1 local_288 [64];
int **local_248;
int *local_240;
char local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar3 = (char *)fn_ext();
ppuVar7 = &PTR_s__00485b70;
if (*pcVar3 == '\0') {
ppuVar7 = (int **)f_extensions;
}
puts("\nDefault options are read from the following files in the given order:");
if (my_defaults_file == (char *)0x0) {
lVar4 = dirname_length(param_1);
if (lVar4 == 0) {
init_alloc_root(key_memory_defaults,local_288,0x200,0,0);
plVar5 = (long *)init_default_directories(local_288);
if (plVar5 == (long *)0x0) {
fputs("Internal error initializing default directories list",*(FILE **)PTR_stdout_0048dfa8);
}
else if (*plVar5 != 0) {
local_240 = *ppuVar7;
local_248 = ppuVar7 + 1;
ppuVar7 = local_248;
puVar2 = local_240;
do {
while (puVar2 != (int *)0x0) {
if (*(char *)*plVar5 == '\0') {
if (my_defaults_extra_file != (char *)0x0) {
fputs(my_defaults_extra_file,*(FILE **)PTR_stdout_0048dfa8);
pcVar3 = " ";
goto LAB_001b0d6a;
}
}
else {
puVar6 = (int1 *)convert_dirname(local_238,(char *)*plVar5,0);
if (local_238[0] == '~') {
*puVar6 = 0x2e;
puVar6 = puVar6 + 1;
}
strxmov(puVar6,param_1,puVar2,&DAT_001e48bd,0);
pcVar3 = local_238;
LAB_001b0d6a:
fputs(pcVar3,*(FILE **)PTR_stdout_0048dfa8);
}
puVar2 = *ppuVar7;
ppuVar7 = ppuVar7 + 1;
}
plVar1 = plVar5 + 1;
plVar5 = plVar5 + 1;
ppuVar7 = local_248;
puVar2 = local_240;
} while (*plVar1 != 0);
}
free_root(local_288,0);
}
else {
fputs(param_1,*(FILE **)PTR_stdout_0048dfa8);
}
putchar(10);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
}
else if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
puts(my_defaults_file);
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,679 | 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>::insert(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>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::insert(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>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
cmpb $0x2, (%rsi)
jne 0x7df44
movq (%rdx), %rsi
cmpq %r14, %rsi
jne 0x7dfa2
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rsi, (%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %r14, %rsi
movq %rax, %rdx
callq 0x7e01e
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
movq %r14, %rdi
callq 0x434f0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38dd2(%rip), %rsi # 0xb6d38
leaq 0x10(%rsp), %rdi
callq 0x7e08f
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x135, %esi # imm = 0x135
movq %r14, %rcx
callq 0x433a4
xorl %ebp, %ebp
leaq 0x7ffa7(%rip), %rsi # 0xfdf38
leaq -0x3df18(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
jmp 0x7dff3
pushq $0x20
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x34d1e(%rip), %rsi # 0xb2cd2
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x27852
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x43210
xorl %ebp, %ebp
leaq 0x7ff14(%rip), %rsi # 0xfdef8
leaq -0x3df6b(%rip), %rdx # 0x40080
movq %rbx, %rdi
callq 0x24ee0
jmp 0x7dff7
jmp 0x7e00b
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x251b8
testb %bpl, %bpl
jne 0x7e00e
jmp 0x7e016
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
movq %r14, %rdi
callq 0x24f60
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 50h
mov r14, rsi
cmp byte ptr [rsi], 2
jnz short loc_7DF44
mov rsi, [rdx]
cmp rsi, r14
jnz loc_7DFA2
mov rbx, rdi
lea rax, [rsp+68h+var_38]
mov [rax], rsi
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
mov rdx, [rdx+18h]
mov [rax+18h], rdx
mov rsi, r14
mov rdx, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_7DF44:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_60]
mov [rdx], rax
lea rsi, aCannotUseInser; "cannot use insert() with "
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_58]
mov rdi, rbx; this
mov esi, 135h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_7DFF3
loc_7DFA2:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdi, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_60]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov bpl, 1
lea rdx, [rsp+68h+var_58]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
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_7DFF3:
jmp short loc_7DFF7
jmp short loc_7E00B
loc_7DFF7:
mov r14, rax
lea rdi, [rsp+68h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7E00E
jmp short loc_7E016
loc_7E00B:
mov r14, rax
loc_7E00E:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7E016:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert(
long long a1,
unsigned __int8 *a2,
long long a3)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::invalid_iterator *v5; // rbx
_QWORD v6[4]; // [rsp+10h] [rbp-58h] BYREF
unsigned __int8 *v7; // [rsp+30h] [rbp-38h] BYREF
__int128 v8; // [rsp+38h] [rbp-30h]
long long v9; // [rsp+48h] [rbp-20h]
if ( *a2 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
v6,
"cannot use insert() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
309,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( *(unsigned __int8 **)a3 != a2 )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::invalid_iterator *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(v6, (long long)"iterator does not fit current value");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
202,
(long long)v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v7 = *(unsigned __int8 **)a3;
v8 = *(_OWORD *)(a3 + 8);
v9 = *(_QWORD *)(a3 + 24);
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>::insert_iterator<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,
a2,
&v7);
return a1;
}
| insert:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
CMP byte ptr [RSI],0x2
JNZ 0x0017df44
MOV RSI,qword ptr [RDX]
CMP RSI,R14
JNZ 0x0017dfa2
MOV RBX,RDI
LEA RAX,[RSP + 0x30]
MOV qword ptr [RAX],RSI
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + 0x18],RDX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0017e01e
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0017df44:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
MOV RDI,R14
CALL 0x001434f0
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017df5f:
LEA RSI,[0x1b6d38]
LEA RDI,[RSP + 0x10]
CALL 0x0017e08f
MOV BPL,0x1
LAB_0017df73:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x135
MOV RCX,R14
CALL 0x001433a4
XOR EBP,EBP
LEA RSI,[0x1fdf38]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
LAB_0017dfa2:
PUSH 0x20
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_0017dfad:
LEA RSI,[0x1b2cd2]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
CALL 0x00127852
MOV BPL,0x1
LAB_0017dfc6:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00143210
XOR EBP,EBP
LEA RSI,[0x1fdef8]
LEA RDX,[0x140080]
MOV RDI,RBX
CALL 0x00124ee0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::insert(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2,long *param_3)
{
int8 uVar1;
char *local_60;
detail local_58 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_38;
int4 local_30;
int4 uStack_2c;
int4 uStack_28;
int4 uStack_24;
long local_20;
if (*param_2 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_60 = (char *)type_name(param_2);
/* try { // try from 0017df5f to 0017df6f has its CatchHandler @ 0017e00b */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
(local_58,"cannot use insert() with ",&local_60);
/* try { // try from 0017df73 to 0017df9f has its CatchHandler @ 0017dff7 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x135,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_38 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3;
if (local_38 == param_2) {
local_30 = (int4)param_3[1];
uStack_2c = *(int4 *)((long)param_3 + 0xc);
uStack_28 = (int4)param_3[2];
uStack_24 = *(int4 *)((long)param_3 + 0x14);
local_20 = param_3[3];
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(this,param_2,&local_38);
return this;
}
uVar1 = __cxa_allocate_exception(0x20);
/* try { // try from 0017dfad to 0017dfc2 has its CatchHandler @ 0017dff5 */
std::__cxx11::string::string<std::allocator<char>>
((string *)local_58,"iterator does not fit current value",(allocator *)&local_60);
/* try { // try from 0017dfc6 to 0017dff2 has its CatchHandler @ 0017dff3 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xca,local_58,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
|
|
1,680 | my_coll_rules_realloc | eloqsql/strings/ctype-uca.c | static int
my_coll_rules_realloc(MY_COLL_RULES *rules, size_t n)
{
if (rules->nrules < rules->mrules ||
(rules->rule= rules->loader->realloc(rules->rule,
sizeof(MY_COLL_RULE) *
(rules->mrules= n + 128))))
return 0;
return -1;
} | O0 | c | my_coll_rules_realloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x560c3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rcx
addq $0x80, %rcx
movq -0x10(%rbp), %rdx
movq %rcx, 0x18(%rdx)
imulq $0xa0, %rcx, %rsi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
je 0x560cc
movl $0x0, -0x4(%rbp)
jmp 0x560d3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_coll_rules_realloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jb short loc_560C3
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rax, [rax+90h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+20h]
mov rcx, [rbp+var_18]
add rcx, 80h
mov rdx, [rbp+var_10]
mov [rdx+18h], rcx
imul rsi, rcx, 0A0h
call rax
mov rcx, [rbp+var_10]
mov [rcx+20h], rax
cmp rax, 0
jz short loc_560CC
loc_560C3:
mov [rbp+var_4], 0
jmp short loc_560D3
loc_560CC:
mov [rbp+var_4], 0FFFFFFFFh
loc_560D3:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_coll_rules_realloc(_QWORD *a1, long long a2)
{
long long ( *v2)(long long, long long); // rax
long long v3; // rdi
long long v4; // rax
if ( a1[2] < a1[3] )
return 0;
v2 = *(long long ( **)(long long, long long))(a1[5] + 144LL);
v3 = a1[4];
a1[3] = a2 + 128;
v4 = v2(v3, 160 * (a2 + 128));
if ( (a1[4] = v4) != 0LL )
return 0;
else
return (unsigned int)-1;
}
| my_coll_rules_realloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JC 0x001560c3
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x20]
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x80
MOV RDX,qword ptr [RBP + -0x10]
MOV qword ptr [RDX + 0x18],RCX
IMUL RSI,RCX,0xa0
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JZ 0x001560cc
LAB_001560c3:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001560d3
LAB_001560cc:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001560d3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_rules_realloc(long param_1,long param_2)
{
code *pcVar1;
long lVar2;
if (*(ulong *)(param_1 + 0x18) <= *(ulong *)(param_1 + 0x10)) {
pcVar1 = *(code **)(*(long *)(param_1 + 0x28) + 0x90);
*(long *)(param_1 + 0x18) = param_2 + 0x80;
lVar2 = (*pcVar1)(*(int8 *)(param_1 + 0x20),(param_2 + 0x80) * 0xa0);
*(long *)(param_1 + 0x20) = lVar2;
if (lVar2 == 0) {
return 0xffffffff;
}
}
return 0;
}
|
|
1,681 | coro::context::context() | tinyCoroLab/src/context.cpp | context::context() noexcept
{
m_id = ginfo.context_id.fetch_add(1, std::memory_order_relaxed);
} | O0 | cpp | coro::context::context():
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6b8a0
movq (%rsp), %rdi
addq $0x20240, %rdi # imm = 0x20240
callq 0x6b9a0
leaq 0x364f2(%rip), %rax # 0xa15c0
movq %rax, 0x30(%rsp)
movl $0x1, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x24(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x6b11c
movq 0x10(%rsp), %rax
leaq 0x519d(%rip), %rcx # 0x702b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6b179
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6b179
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6b179
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
jmp 0x6b179
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x20(%rsp)
movq (%rsp), %rax
movl 0x20(%rsp), %ecx
movl %ecx, 0x20248(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
| _ZN4coro7contextC2Ev:
sub rsp, 38h
mov [rsp+38h+var_20], rdi
mov rdi, [rsp+38h+var_20]; this
mov [rsp+38h+var_38], rdi
call _ZN4coro6detail6engineC2Ev; coro::detail::engine::engine(void)
mov rdi, [rsp+38h+var_38]
add rdi, 20240h
call _ZNSt10unique_ptrISt7jthreadSt14default_deleteIS0_EEC2IS2_vEEv; std::unique_ptr<std::jthread>::unique_ptr<std::default_delete<std::jthread>,void>(void)
lea rax, _ZN4coro6detail5ginfoE; coro::detail::ginfo
mov [rsp+38h+var_8], rax
mov [rsp+38h+var_C], 1
mov [rsp+38h+var_10], 0
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_30], rax
mov eax, [rsp+38h+var_10]
mov ecx, [rsp+38h+var_C]
mov [rsp+38h+var_14], ecx
dec eax; switch 5 cases
mov ecx, eax
mov [rsp+38h+var_28], rcx
sub eax, 4
ja short def_6B11A; jumptable 000000000006B11A default case
mov rax, [rsp+38h+var_28]
lea rcx, jpt_6B11A
movsxd rax, ds:(jpt_6B11A - 702B0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_6B11A:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006B11A default case
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6B179
loc_6B12F:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006B11A cases 1,2
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6B179
loc_6B142:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006B11A case 3
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6B179
loc_6B155:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006B11A case 4
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
jmp short loc_6B179
loc_6B168:
mov rcx, [rsp+38h+var_30]; jumptable 000000000006B11A case 5
mov eax, [rsp+38h+var_14]
lock xadd [rcx], eax
mov [rsp+38h+var_18], eax
loc_6B179:
mov rax, [rsp+38h+var_38]
mov ecx, [rsp+38h+var_18]
mov [rax+20248h], ecx
add rsp, 38h
retn
| coro::context * coro::context::context(coro::context *this)
{
coro::context *result; // rax
coro::detail::engine::engine(this);
std::unique_ptr<std::jthread>::unique_ptr<std::default_delete<std::jthread>,void>((char *)this + 131648);
result = this;
*((_DWORD *)this + 32914) = _InterlockedExchangeAdd(&coro::detail::ginfo, 1u);
return result;
}
| context:
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RDI
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RDI
CALL 0x0016b8a0
MOV RDI,qword ptr [RSP]
ADD RDI,0x20240
CALL 0x0016b9a0
LEA RAX,[0x1a15c0]
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x2c],0x1
MOV dword ptr [RSP + 0x28],0x0
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x28]
MOV ECX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x24],ECX
DEC EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x10],RCX
SUB EAX,0x4
JA 0x0016b11c
MOV RAX,qword ptr [RSP + 0x10]
LEA RCX,[0x1702b0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
LAB_0016b11c:
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x24]
XADD.LOCK dword ptr [RCX],EAX
MOV dword ptr [RSP + 0x20],EAX
JMP 0x0016b179
LAB_0016b179:
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x20248],ECX
ADD RSP,0x38
RET
|
/* WARNING: Removing unreachable block (ram,0x0016b107) */
/* coro::context::context() */
void __thiscall coro::context::context(context *this)
{
int iVar1;
detail::engine::engine((engine *)this);
std::unique_ptr<std::jthread,std::default_delete<std::jthread>>::
unique_ptr<std::default_delete<std::jthread>,void>
((unique_ptr<std::jthread,std::default_delete<std::jthread>> *)(this + 0x20240));
LOCK();
UNLOCK();
iVar1 = detail::ginfo + 1;
*(int *)(this + 0x20248) = detail::ginfo;
detail::ginfo = iVar1;
return;
}
|
|
1,682 | pfs_set_socket_info_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_socket_info_v1(PSI_socket *socket,
const my_socket *fd,
const struct sockaddr *addr,
socklen_t addr_len)
{
PFS_socket *pfs= reinterpret_cast<PFS_socket*>(socket);
assert(pfs != NULL);
/** Set socket descriptor */
if (fd != NULL)
pfs->m_fd= (uint)*fd;
/** Set raw socket address and length */
if (likely(addr != NULL && addr_len > 0))
{
pfs->m_addr_len= addr_len;
/** Restrict address length to size of struct */
if (unlikely(pfs->m_addr_len > sizeof(sockaddr_storage)))
pfs->m_addr_len= sizeof(struct sockaddr_storage);
memcpy(&pfs->m_sock_addr, addr, pfs->m_addr_len);
}
} | O0 | cpp | pfs_set_socket_info_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x507a3
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x507b9
cmpl $0x0, -0x1c(%rbp)
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x5081b
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x28(%rbp), %rax
movl 0xa8(%rax), %eax
cmpq $0x80, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x507fe
movq -0x28(%rbp), %rax
movl $0x80, 0xa8(%rax)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, %edx
callq 0x26280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pfs_set_socket_info_v1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
cmp [rbp+var_10], 0
jz short loc_507A3
mov rax, [rbp+var_10]
mov ecx, [rax]
mov rax, [rbp+var_28]
mov [rax+20h], ecx
loc_507A3:
xor eax, eax
cmp [rbp+var_18], 0
mov [rbp+var_29], al
jz short loc_507B9
cmp [rbp+var_1C], 0
setnbe al
mov [rbp+var_29], al
loc_507B9:
mov al, [rbp+var_29]
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_5081B
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_28]
mov [rax+0A8h], ecx
mov rax, [rbp+var_28]
mov eax, [rax+0A8h]
cmp rax, 80h
setnbe al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_507FE
mov rax, [rbp+var_28]
mov dword ptr [rax+0A8h], 80h
loc_507FE:
mov rdi, [rbp+var_28]
add rdi, 28h ; '('
mov rsi, [rbp+var_18]
mov rax, [rbp+var_28]
mov eax, [rax+0A8h]
mov edx, eax
call _memcpy
loc_5081B:
add rsp, 30h
pop rbp
retn
| long long pfs_set_socket_info_v1(long long a1, _DWORD *a2, long long a3, int a4)
{
long long result; // rax
bool v5; // [rsp+7h] [rbp-29h]
if ( a2 )
*(_DWORD *)(a1 + 32) = *a2;
v5 = 0;
if ( a3 )
v5 = a4 != 0;
result = v5;
if ( v5 )
{
*(_DWORD *)(a1 + 168) = a4;
if ( *(unsigned int *)(a1 + 168) > 0x80uLL )
*(_DWORD *)(a1 + 168) = 128;
return memcpy(a1 + 40, a3, *(unsigned int *)(a1 + 168));
}
return result;
}
| pfs_set_socket_info_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001507a3
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x20],ECX
LAB_001507a3:
XOR EAX,EAX
CMP qword ptr [RBP + -0x18],0x0
MOV byte ptr [RBP + -0x29],AL
JZ 0x001507b9
CMP dword ptr [RBP + -0x1c],0x0
SETA AL
MOV byte ptr [RBP + -0x29],AL
LAB_001507b9:
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0015081b
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xa8],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0xa8]
CMP RAX,0x80
SETA AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001507fe
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xa8],0x80
LAB_001507fe:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0xa8]
MOV EDX,EAX
CALL 0x00126280
LAB_0015081b:
ADD RSP,0x30
POP RBP
RET
|
void pfs_set_socket_info_v1(long param_1,int4 *param_2,void *param_3,int param_4)
{
if (param_2 != (int4 *)0x0) {
*(int4 *)(param_1 + 0x20) = *param_2;
}
if (param_3 != (void *)0x0 && param_4 != 0) {
*(int *)(param_1 + 0xa8) = param_4;
if (0x80 < *(uint *)(param_1 + 0xa8)) {
*(int4 *)(param_1 + 0xa8) = 0x80;
}
memcpy((void *)(param_1 + 0x28),param_3,(ulong)*(uint *)(param_1 + 0xa8));
}
return;
}
|
|
1,683 | ggml_vec_dot_iq2_s_q8_K | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_iq2_s_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_iq2_s * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#if defined(__ARM_NEON)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
const ggml_uint8x16x2_t mask1 = ggml_vld1q_u8_x2(k_mask1);
const uint8x16_t mask2 = vld1q_u8(k_mask2);
const uint8x16_t m1 = vdupq_n_u8(1);
const int32x4_t vzero = vdupq_n_s32(0);
uint8x16x2_t vs;
ggml_int8x16x4_t q2s;
ggml_int8x16x4_t q8b;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
int sumi1 = 0, sumi2 = 0;
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
q8b = ggml_vld1q_s8_x4(q8); q8 += 64;
q2s.val[0] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[0] | ((qh[ib32+0] << 8) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[1] | ((qh[ib32+0] << 6) & 0x300)))));
q2s.val[1] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[2] | ((qh[ib32+0] << 4) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[3] | ((qh[ib32+0] << 2) & 0x300)))));
q2s.val[2] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[4] | ((qh[ib32+1] << 8) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[5] | ((qh[ib32+1] << 6) & 0x300)))));
q2s.val[3] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[6] | ((qh[ib32+1] << 4) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[7] | ((qh[ib32+1] << 2) & 0x300)))));
qs += 8;
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[0] | ((uint32_t) signs[1] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vceqq_u8(vs.val[0], mask2);
vs.val[1] = vceqq_u8(vs.val[1], mask2);
q2s.val[0] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[0], m1)), q2s.val[0]);
q2s.val[1] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[1], m1)), q2s.val[1]);
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[2] | ((uint32_t) signs[3] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vceqq_u8(vs.val[0], mask2);
vs.val[1] = vceqq_u8(vs.val[1], mask2);
signs += 4;
q2s.val[2] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[0], m1)), q2s.val[2]);
q2s.val[3] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[1], m1)), q2s.val[3]);
const int32x4_t p1 = ggml_vdotq_s32(vzero, q2s.val[0], q8b.val[0]);
const int32x4_t p2 = ggml_vdotq_s32(vzero, q2s.val[1], q8b.val[1]);
const int32x4_t p3 = ggml_vdotq_s32(vzero, q2s.val[2], q8b.val[2]);
const int32x4_t p4 = ggml_vdotq_s32(vzero, q2s.val[3], q8b.val[3]);
sumi1 += vaddvq_s32(p1) * (1 + 2*(x[i].scales[ib32+0] & 0xf));
sumi2 += vaddvq_s32(p2) * (1 + 2*(x[i].scales[ib32+0] >> 4));
sumi1 += vaddvq_s32(p3) * (1 + 2*(x[i].scales[ib32+1] & 0xf));
sumi2 += vaddvq_s32(p4) * (1 + 2*(x[i].scales[ib32+1] >> 4));
}
sumf += d*(sumi1 + sumi2);
}
*s = 0.125f * sumf;
#elif defined(__AVX2__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = _mm_set1_epi8(0xf);
const __m128i m1 = _mm_set1_epi8(1);
const __m256i mask1 = _mm256_loadu_si256((const __m256i*)k_mask1);
const __m256i mask2 = _mm256_loadu_si256((const __m256i*)k_mask2);
uint64_t aux64;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
memcpy(&aux64, x[i].scales, 8);
const __m128i scales8 = _mm_add_epi8(_mm_slli_epi16(_mm_and_si128(_mm_set_epi64x(aux64 >> 4, aux64), m4), 1), m1);
const __m256i scales16 = _mm256_cvtepi8_epi16(scales8); // 0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15
__m256i sumi1 = _mm256_setzero_si256();
__m256i sumi2 = _mm256_setzero_si256();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i q2_1 = _mm256_set_epi64x(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)],
iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m256i q2_2 = _mm256_set_epi64x(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)],
iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
qs += 8;
__m256i aux256 = _mm256_set1_epi32(signs[0] | ((uint32_t) signs[1] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_1 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_1 = _mm256_sub_epi8(_mm256_xor_si256(s2_1, q8_1), s2_1);
aux256 = _mm256_set1_epi32(signs[2] | ((uint32_t) signs[3] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_2 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_2 = _mm256_sub_epi8(_mm256_xor_si256(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = _mm256_maddubs_epi16(q2_1, q8s_1); // blocks 2*ib32+0, 2*ib32+1
const __m256i dot2 = _mm256_maddubs_epi16(q2_2, q8s_2); // blocks 2*ib32+2, 2*ib32+3
const __m256i p1 = _mm256_madd_epi16(dot1, _mm256_shuffle_epi8(scales16, get_scale_shuffle_k4(ib32+0)));
const __m256i p2 = _mm256_madd_epi16(dot2, _mm256_shuffle_epi8(scales16, get_scale_shuffle_k4(ib32+1)));
sumi1 = _mm256_add_epi32(sumi1, p1);
sumi2 = _mm256_add_epi32(sumi2, p2);
}
accumf = _mm256_fmadd_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(_mm256_add_epi32(sumi1, sumi2)), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#elif defined(__AVX__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = _mm_set1_epi8(0xf);
const __m128i m1 = _mm_set1_epi8(1);
const __m128i mask1_0 = _mm_loadu_si128((const __m128i*)k_mask1);
const __m128i mask1_1 = _mm_loadu_si128((const __m128i*)k_mask1 + 1);
const __m128i mask2_0 = _mm_loadu_si128((const __m128i*)k_mask2);
const __m128i mask2_1 = _mm_loadu_si128((const __m128i*)k_mask2 + 1);
uint64_t aux64;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
memcpy(&aux64, x[i].scales, 8);
const __m128i scales8 = _mm_add_epi8(_mm_slli_epi16(_mm_and_si128(_mm_set_epi64x(aux64 >> 4, aux64), m4), 1), m1);
const __m128i scales16_0 = _mm_cvtepi8_epi16(scales8);
const __m128i scales16_1 = _mm_cvtepi8_epi16(_mm_srli_si128(scales8, 8));
__m128i sumi1_0 = _mm_setzero_si128();
__m128i sumi1_1 = _mm_setzero_si128();
__m128i sumi2_0 = _mm_setzero_si128();
__m128i sumi2_1 = _mm_setzero_si128();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m128i q8_1_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_1_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q2_1_0 = _mm_set_epi64x(iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m128i q2_1_1 = _mm_set_epi64x(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)]);
const __m128i q2_2_0 = _mm_set_epi64x(iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
const __m128i q2_2_1 = _mm_set_epi64x(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)]);
qs += 8;
__m128i aux128_0 = _mm_set1_epi32(signs[0] | ((uint32_t) signs[1] << 16));
__m128i aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_1_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_1_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_1_0 = _mm_sub_epi8(_mm_xor_si128(s2_1_0, q8_1_0), s2_1_0);
const __m128i q8s_1_1 = _mm_sub_epi8(_mm_xor_si128(s2_1_1, q8_1_1), s2_1_1);
aux128_0 = _mm_set1_epi32(signs[2] | ((uint32_t) signs[3] << 16));
aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_2_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_2_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_2_0 = _mm_sub_epi8(_mm_xor_si128(s2_2_0, q8_2_0), s2_2_0);
const __m128i q8s_2_1 = _mm_sub_epi8(_mm_xor_si128(s2_2_1, q8_2_1), s2_2_1);
signs += 4;
const __m128i dot1_0 = _mm_maddubs_epi16(q2_1_0, q8s_1_0);
const __m128i dot1_1 = _mm_maddubs_epi16(q2_1_1, q8s_1_1);
const __m128i dot2_0 = _mm_maddubs_epi16(q2_2_0, q8s_2_0);
const __m128i dot2_1 = _mm_maddubs_epi16(q2_2_1, q8s_2_1);
const __m128i p1_0 = _mm_madd_epi16(dot1_0, _mm_shuffle_epi8(scales16_0, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+0), 0)));
const __m128i p1_1 = _mm_madd_epi16(dot1_1, _mm_shuffle_epi8(scales16_1, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+0), 1)));
const __m128i p2_0 = _mm_madd_epi16(dot2_0, _mm_shuffle_epi8(scales16_0, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+1), 0)));
const __m128i p2_1 = _mm_madd_epi16(dot2_1, _mm_shuffle_epi8(scales16_1, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+1), 1)));
sumi1_0 = _mm_add_epi32(sumi1_0, p1_0);
sumi1_1 = _mm_add_epi32(sumi1_1, p1_1);
sumi2_0 = _mm_add_epi32(sumi2_0, p2_0);
sumi2_1 = _mm_add_epi32(sumi2_1, p2_1);
}
accumf = _mm256_add_ps(_mm256_mul_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(MM256_SET_M128I(_mm_add_epi32(sumi1_1, sumi2_1), _mm_add_epi32(sumi1_0, sumi2_0)))), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#elif defined(__POWER9_VECTOR__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
const vector int v0 = vec_splats((int32_t)0);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
const vector unsigned char mask0 = vec_xl( 0, k_mask1);
const vector unsigned char mask1 = vec_xl(16, k_mask1);
const vector signed char mask2 = (vector signed char)vec_xl( 0, k_mask2);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
const uint8_t * restrict q2 = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const uint8_t * restrict sc = x[i].scales;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/32; j += 2) {
__builtin_prefetch(q2, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed long long aux64x2_0 = {*(const int64_t *)(iq2s_grid + (q2[0] | ((qh[0] << 8) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[1] | ((qh[0] << 6) & 0x300)))};
vector signed long long aux64x2_1 = {*(const int64_t *)(iq2s_grid + (q2[2] | ((qh[0] << 4) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[3] | ((qh[0] << 2) & 0x300)))};
vector signed long long aux64x2_2 = {*(const int64_t *)(iq2s_grid + (q2[4] | ((qh[1] << 8) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[5] | ((qh[1] << 6) & 0x300)))};
vector signed long long aux64x2_3 = {*(const int64_t *)(iq2s_grid + (q2[6] | ((qh[1] << 4) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[7] | ((qh[1] << 2) & 0x300)))};
q2 += 8;
qh += 2;
vector signed char vsigns01 = (vector signed char)vec_splats(*(const uint32_t *)&signs[0]);
vector signed char vsigns23 = (vector signed char)vec_splats(*(const uint32_t *)&signs[2]);
signs += 4;
vector signed char vsigns0 = vec_perm(vsigns01, vsigns01, mask0);
vector signed char vsigns1 = vec_perm(vsigns01, vsigns01, mask1);
vector signed char vsigns2 = vec_perm(vsigns23, vsigns23, mask0);
vector signed char vsigns3 = vec_perm(vsigns23, vsigns23, mask1);
vsigns0 = (vector signed char)vec_cmpeq(vec_and(vsigns0, mask2), mask2);
vsigns1 = (vector signed char)vec_cmpeq(vec_and(vsigns1, mask2), mask2);
vsigns2 = (vector signed char)vec_cmpeq(vec_and(vsigns2, mask2), mask2);
vsigns3 = (vector signed char)vec_cmpeq(vec_and(vsigns3, mask2), mask2);
vector signed char q2x0 = vec_sub(vec_xor(vsigns0, (vector signed char)aux64x2_0), vsigns0);
vector signed char q2x1 = vec_sub(vec_xor(vsigns1, (vector signed char)aux64x2_1), vsigns1);
vector signed char q2x2 = vec_sub(vec_xor(vsigns2, (vector signed char)aux64x2_2), vsigns2);
vector signed char q2x3 = vec_sub(vec_xor(vsigns3, (vector signed char)aux64x2_3), vsigns3);
vector signed char q8y0 = vec_xl( 0, q8);
vector signed char q8y1 = vec_xl(16, q8);
vector signed char q8y2 = vec_xl(32, q8);
vector signed char q8y3 = vec_xl(48, q8);
q8 += 64;
vector signed short qv0 = vec_add(vec_mule(q2x0, q8y0), vec_mulo(q2x0, q8y0));
vector signed short qv1 = vec_add(vec_mule(q2x1, q8y1), vec_mulo(q2x1, q8y1));
vector signed short qv2 = vec_add(vec_mule(q2x2, q8y2), vec_mulo(q2x2, q8y2));
vector signed short qv3 = vec_add(vec_mule(q2x3, q8y3), vec_mulo(q2x3, q8y3));
const uint16_t ls0 = (uint16_t)(sc[0] & 0xf);
const uint16_t ls1 = (uint16_t)(sc[0] >> 4);
const uint16_t ls2 = (uint16_t)(sc[1] & 0xf);
const uint16_t ls3 = (uint16_t)(sc[1] >> 4);
sc += 2;
vector signed short vscales0 = vec_splats((int16_t)(2*ls0+1));
vector signed short vscales1 = vec_splats((int16_t)(2*ls1+1));
vector signed short vscales2 = vec_splats((int16_t)(2*ls2+1));
vector signed short vscales3 = vec_splats((int16_t)(2*ls3+1));
vsumi0 = vec_msum(qv0, vscales0, vsumi0);
vsumi1 = vec_msum(qv1, vscales1, vsumi1);
vsumi2 = vec_msum(qv2, vscales2, vsumi2);
vsumi3 = vec_msum(qv3, vscales3, vsumi3);
}
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = 0.125f * vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = __lsx_vreplgr2vr_b(0xf);
const __m128i m1 = __lsx_vreplgr2vr_b(1);
const __m256i mask1 = __lasx_xvld((const __m256i*)k_mask1, 0);
const __m256i mask2 = __lasx_xvld((const __m256i*)k_mask2, 0);
uint64_t aux64;
__m256 accumf = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
__m128i tmp1;
memcpy(&aux64, x[i].scales, 8);
tmp1 = __lsx_vinsgr2vr_d(tmp1, aux64, 0);
tmp1 = __lsx_vinsgr2vr_d(tmp1, aux64 >> 4, 1);
const __m128i scales8 = __lsx_vadd_b(__lsx_vslli_h(__lsx_vand_v(tmp1, m4), 1), m1);
const __m256i scales16 = lasx_ext8_16(scales8); // 0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15
__m256i sumi1 = __lasx_xvldi(0);
__m256i sumi2 = __lasx_xvldi(0);
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i q2_1 = lasx_set_d(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)],
iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m256i q2_2 = lasx_set_d(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)],
iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
qs += 8;
__m256i aux256 = __lasx_xvreplgr2vr_w(signs[0] | ((uint32_t) signs[1] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_1 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_1 = __lasx_xvsub_b(__lasx_xvxor_v(s2_1, q8_1), s2_1);
aux256 = __lasx_xvreplgr2vr_w(signs[2] | ((uint32_t) signs[3] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_2 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_2 = __lasx_xvsub_b(__lasx_xvxor_v(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = lasx_maddubs_h(q2_1, q8s_1); // blocks 2*ib32+0, 2*ib32+1
const __m256i dot2 = lasx_maddubs_h(q2_2, q8s_2); // blocks 2*ib32+2, 2*ib32+3
const __m256i p1 = lasx_madd_h(dot1, lasx_shuffle_b(scales16, get_scale_shuffle_k4(ib32+0)));
const __m256i p2 = lasx_madd_h(dot2, lasx_shuffle_b(scales16, get_scale_shuffle_k4(ib32+1)));
sumi1 = __lasx_xvadd_w(sumi1, p1);
sumi2 = __lasx_xvadd_w(sumi2, p2);
}
accumf = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(__lasx_xvadd_w(sumi1, sumi2)), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#else
float sumf = 0;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const int8_t * q8 = y[i].qs;
const uint8_t * qs = x[i].qs;
const uint8_t * qh = x[i].qh;
const uint8_t * signs = qs + QK_K/8;
int bsum = 0;
for (int ib32 = 0; ib32 < QK_K/32; ++ib32) {
int ls1 = 1 + 2*(x[i].scales[ib32] & 0xf);
int ls2 = 1 + 2*(x[i].scales[ib32] >> 4);
int sumi1 = 0, sumi2 = 0;
for (int l = 0; l < 2; ++l) {
const uint8_t * grid = (const uint8_t *)(iq2s_grid + (qs[l] | (qh[ib32] << (8-2*l) & 0x300)));
for (int j = 0; j < 8; ++j) {
sumi1 += q8[j] * grid[j] * (signs[l] & kmask_iq2xs[j] ? -1 : 1);
}
q8 += 8;
}
for (int l = 2; l < 4; ++l) {
const uint8_t * grid = (const uint8_t *)(iq2s_grid + (qs[l] | (qh[ib32] << (8-2*l) & 0x300)));
for (int j = 0; j < 8; ++j) {
sumi2 += q8[j] * grid[j] * (signs[l] & kmask_iq2xs[j] ? -1 : 1);
}
q8 += 8;
}
bsum += ls1 * sumi1 + ls2 * sumi2;
qs += 4;
signs += 4;
}
sumf += d * bsum;
}
*s = 0.125f * sumf;
#endif
} | O1 | c | ggml_vec_dot_iq2_s_q8_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
testb %dil, %dil
jne 0x33c2a
cmpl $0x1, 0x58(%rsp)
jne 0x33c49
movq %rsi, 0x10(%rsp)
sarl $0x8, %edi
testl %edi, %edi
jle 0x33bec
movl %edi, %r9d
movq 0x8(%rsp), %rax
leaq 0x4(%rax), %rdx
vpxor %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vpbroadcastb 0x6a6d(%rip), %xmm1 # 0x3a418
vpbroadcastb 0x6a65(%rip), %xmm2 # 0x3a419
leaq 0x8675(%rip), %r10 # 0x3c030
vmovdqa 0x67dd(%rip), %ymm3 # 0x3a1a0
vpbroadcastq 0x6a0c(%rip), %ymm4 # 0x3a3d8
leaq 0xf25d(%rip), %r11 # 0x42c30
movq %rcx, %rbx
vxorps %xmm5, %xmm5, %xmm5
imulq $0x52, %rdi, %r14
movzwl (%rcx,%r14), %r15d
movq 0x1557e(%rip), %rax # 0x48f68
vmovss (%rax,%r15,4), %xmm6
imulq $0x124, %rdi, %r15 # imm = 0x124
movq 0x8(%rsp), %rax
vmovss (%rax,%r15), %xmm7
movq 0x4a(%rcx,%r14), %r14
vmovq %r14, %xmm8
shrq $0x4, %r14
vmovq %r14, %xmm9
vpunpcklqdq %xmm9, %xmm8, %xmm8 # xmm8 = xmm8[0],xmm9[0]
vpaddw %xmm8, %xmm8, %xmm8
vpternlogq $0xec, %xmm1, %xmm2, %xmm8
vpmovzxbw %xmm8, %ymm8 # ymm8 = xmm8[0],zero,xmm8[1],zero,xmm8[2],zero,xmm8[3],zero,xmm8[4],zero,xmm8[5],zero,xmm8[6],zero,xmm8[7],zero,xmm8[8],zero,xmm8[9],zero,xmm8[10],zero,xmm8[11],zero,xmm8[12],zero,xmm8[13],zero,xmm8[14],zero,xmm8[15],zero
movq $-0x2, %r14
xorl %r15d, %r15d
vpxor %xmm9, %xmm9, %xmm9
vpxor %xmm10, %xmm10, %xmm10
vmovdqu (%rdx,%r15,8), %ymm12
vmovdqu 0x20(%rdx,%r15,8), %ymm11
movzbl 0x44(%rbx,%r14), %esi
leal (,%rsi,4), %r13d
movb 0x5(%rbx,%r15), %r13b
movb 0x9(%rbx,%r15), %bpl
movzbl 0x4(%rbx,%r15), %r8d
movl %esi, %eax
andl $0x30, %eax
shll $0x4, %eax
orl %r8d, %eax
movzbl 0x3(%rbx,%r15), %r8d
movl %esi, %r12d
andl $0xc, %r12d
shll $0x6, %r12d
orl %r8d, %r12d
movzbl 0x2(%rbx,%r15), %r8d
andl $0x3, %esi
shll $0x8, %esi
vmovq (%r10,%r13,8), %xmm13
vmovq (%r10,%rax,8), %xmm14
orl %r8d, %esi
vpunpcklqdq %xmm13, %xmm14, %xmm13 # xmm13 = xmm14[0],xmm13[0]
vmovq (%r10,%r12,8), %xmm14
vmovq (%r10,%rsi,8), %xmm15
vpunpcklqdq %xmm14, %xmm15, %xmm14 # xmm14 = xmm15[0],xmm14[0]
vinserti128 $0x1, %xmm13, %ymm14, %ymm13
movzbl 0x45(%rbx,%r14), %r12d
leal (,%r12,4), %eax
movb %bpl, %al
movzbl 0x8(%rbx,%r15), %esi
movl %r12d, %r8d
andl $0x30, %r8d
shll $0x4, %r8d
orl %esi, %r8d
movzbl 0x7(%rbx,%r15), %esi
movl %r12d, %r13d
andl $0xc, %r13d
shll $0x6, %r13d
orl %esi, %r13d
movzbl 0x6(%rbx,%r15), %esi
andl $0x3, %r12d
shll $0x8, %r12d
orl %esi, %r12d
vmovq (%r10,%rax,8), %xmm14
vmovq (%r10,%r8,8), %xmm15
vmovq (%r10,%r13,8), %xmm16
vmovq (%r10,%r12,8), %xmm17
vpunpcklqdq %xmm14, %xmm15, %xmm14 # xmm14 = xmm15[0],xmm14[0]
vpunpcklqdq %xmm16, %xmm17, %xmm15 # xmm15 = xmm17[0],xmm16[0]
vinserti128 $0x1, %xmm14, %ymm15, %ymm14
vmovd 0x22(%rbx,%r15), %xmm15
vpermq $0x44, %ymm15, %ymm15 # ymm15 = ymm15[0,1,0,1]
vpshufb %ymm3, %ymm15, %ymm15
vptestnmb %ymm4, %ymm15, %k1
vpsubb %ymm12, %ymm0, %ymm15
vmovdqu8 %ymm12, %ymm15 {%k1}
vmovd 0x26(%rbx,%r15), %xmm12
vpmaddubsw %ymm15, %ymm13, %ymm13
vpermq $0x44, %ymm12, %ymm12 # ymm12 = ymm12[0,1,0,1]
vpshufb %ymm3, %ymm12, %ymm12
vptestnmb %ymm4, %ymm12, %k1
vpsubb %ymm11, %ymm0, %ymm12
vmovdqu8 %ymm11, %ymm12 {%k1}
vpmaddubsw %ymm12, %ymm14, %ymm11
vpshufb (%r11,%r15,8), %ymm8, %ymm12
vpmaddwd %ymm12, %ymm13, %ymm12
vpshufb 0x20(%r11,%r15,8), %ymm8, %ymm13
vpaddd %ymm9, %ymm12, %ymm9
vpmaddwd %ymm13, %ymm11, %ymm11
vpaddd %ymm10, %ymm11, %ymm10
addq $0x2, %r14
addq $0x8, %r15
cmpq $0x6, %r14
jb 0x33a3f
vmulss %xmm7, %xmm6, %xmm6
vbroadcastss %xmm6, %ymm7
vpaddd %ymm10, %ymm9, %ymm6
vcvtdq2ps %ymm6, %ymm6
vfmadd213ps %ymm5, %ymm7, %ymm6 # ymm6 = (ymm7 * ymm6) + ymm5
incq %rdi
addq $0x52, %rbx
addq $0x124, %rdx # imm = 0x124
vmovaps %ymm6, %ymm5
cmpq %r9, %rdi
jne 0x339da
jmp 0x33bf0
vxorps %xmm6, %xmm6, %xmm6
vextractf128 $0x1, %ymm6, %xmm0
vaddps %xmm6, %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmulss 0x6569(%rip), %xmm0, %xmm0 # 0x3a178
movq 0x10(%rsp), %rax
vmovss %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0xf80f(%rip), %rdi # 0x43440
leaq 0xf1b8(%rip), %rsi # 0x42df0
leaq 0xfaf6(%rip), %rcx # 0x43735
movl $0x208d, %edx # imm = 0x208D
callq 0x83b0
leaq 0x2e3e(%rip), %rdi # 0x36a8e
leaq 0xf199(%rip), %rsi # 0x42df0
leaq 0xfad7(%rip), %rcx # 0x43735
movl $0x208e, %edx # imm = 0x208E
callq 0x83b0
| ggml_vec_dot_iq2_s_q8_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], r9
test dil, dil
jnz loc_33C2A
cmp [rsp+48h+arg_8], 1
jnz loc_33C49
mov [rsp+48h+var_38], rsi
sar edi, 8
test edi, edi
jle loc_33BEC
mov r9d, edi
mov rax, [rsp+48h+var_40]
lea rdx, [rax+4]
vpxor xmm0, xmm0, xmm0
xor edi, edi
vpbroadcastb xmm1, cs:byte_3A418
vpbroadcastb xmm2, cs:byte_3A419
lea r10, iq2s_grid
vmovdqa ymm3, cs:ymmword_3A1A0
vpbroadcastq ymm4, cs:qword_3A3D8
lea r11, get_scale_shuffle_k4_k_shuffle
mov rbx, rcx
vxorps xmm5, xmm5, xmm5
loc_339DA:
imul r14, rdi, 52h ; 'R'
movzx r15d, word ptr [rcx+r14]
mov rax, cs:ggml_table_f32_f16_ptr
vmovss xmm6, dword ptr [rax+r15*4]
imul r15, rdi, 124h
mov rax, [rsp+48h+var_40]
vmovss xmm7, dword ptr [rax+r15]
mov r14, [rcx+r14+4Ah]
vmovq xmm8, r14
shr r14, 4
vmovq xmm9, r14
vpunpcklqdq xmm8, xmm8, xmm9
vpaddw xmm8, xmm8, xmm8
vpternlogq xmm8, xmm2, xmm1, 0ECh
vpmovzxbw ymm8, xmm8
mov r14, 0FFFFFFFFFFFFFFFEh
xor r15d, r15d
vpxor xmm9, xmm9, xmm9
vpxor xmm10, xmm10, xmm10
loc_33A3F:
vmovdqu ymm12, ymmword ptr [rdx+r15*8]
vmovdqu ymm11, ymmword ptr [rdx+r15*8+20h]
movzx esi, byte ptr [rbx+r14+44h]
lea r13d, ds:0[rsi*4]
mov r13b, [rbx+r15+5]
mov bpl, [rbx+r15+9]
movzx r8d, byte ptr [rbx+r15+4]
mov eax, esi
and eax, 30h
shl eax, 4
or eax, r8d
movzx r8d, byte ptr [rbx+r15+3]
mov r12d, esi
and r12d, 0Ch
shl r12d, 6
or r12d, r8d
movzx r8d, byte ptr [rbx+r15+2]
and esi, 3
shl esi, 8
vmovq xmm13, qword ptr [r10+r13*8]
vmovq xmm14, qword ptr [r10+rax*8]
or esi, r8d
vpunpcklqdq xmm13, xmm14, xmm13
vmovq xmm14, qword ptr [r10+r12*8]
vmovq xmm15, qword ptr [r10+rsi*8]
vpunpcklqdq xmm14, xmm15, xmm14
vinserti128 ymm13, ymm14, xmm13, 1
movzx r12d, byte ptr [rbx+r14+45h]
lea eax, ds:0[r12*4]
mov al, bpl
movzx esi, byte ptr [rbx+r15+8]
mov r8d, r12d
and r8d, 30h
shl r8d, 4
or r8d, esi
movzx esi, byte ptr [rbx+r15+7]
mov r13d, r12d
and r13d, 0Ch
shl r13d, 6
or r13d, esi
movzx esi, byte ptr [rbx+r15+6]
and r12d, 3
shl r12d, 8
or r12d, esi
vmovq xmm14, qword ptr [r10+rax*8]
vmovq xmm15, qword ptr [r10+r8*8]
vmovq xmm16, qword ptr [r10+r13*8]
vmovq xmm17, qword ptr [r10+r12*8]
vpunpcklqdq xmm14, xmm15, xmm14
vpunpcklqdq xmm15, xmm17, xmm16
vinserti128 ymm14, ymm15, xmm14, 1
vmovd xmm15, dword ptr [rbx+r15+22h]
vpermq ymm15, ymm15, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm12
vmovdqu8 ymm15{k1}, ymm12
vmovd xmm12, dword ptr [rbx+r15+26h]
vpmaddubsw ymm13, ymm13, ymm15
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpsubb ymm12, ymm0, ymm11
vmovdqu8 ymm12{k1}, ymm11
vpmaddubsw ymm11, ymm14, ymm12
vpshufb ymm12, ymm8, ymmword ptr [r11+r15*8]
vpmaddwd ymm12, ymm13, ymm12
vpshufb ymm13, ymm8, ymmword ptr [r11+r15*8+20h]
vpaddd ymm9, ymm12, ymm9
vpmaddwd ymm11, ymm11, ymm13
vpaddd ymm10, ymm11, ymm10
add r14, 2
add r15, 8
cmp r14, 6
jb loc_33A3F
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm9, ymm10
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
inc rdi
add rbx, 52h ; 'R'
add rdx, 124h
vmovaps ymm5, ymm6
cmp rdi, r9
jnz loc_339DA
jmp short loc_33BF0
loc_33BEC:
vxorps xmm6, xmm6, xmm6
loc_33BF0:
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmulss xmm0, xmm0, cs:dword_3A178
mov rax, [rsp+48h+var_38]
vmovss dword ptr [rax], xmm0
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
loc_33C2A:
lea rdi, aNQkK0; "n % QK_K == 0"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_16; "void ggml_vec_dot_iq2_s_q8_K(int, float"...
mov edx, 208Dh
call ___assert_fail
loc_33C49:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_16; "void ggml_vec_dot_iq2_s_q8_K(int, float"...
mov edx, 208Eh
call ___assert_fail
| long long ggml_vec_dot_iq2_s_q8_K(
int a1,
long long a2,
__m128 _XMM0,
double a4,
double a5,
double a6,
double a7,
__m128 _XMM5,
__m128 _XMM6,
long long a10,
long long a11,
long long a12,
long long a13,
int a14,
int a15)
{
int v20; // edi
long long v21; // r9
long long v24; // rdi
unsigned long long v45; // r14
int v50; // esi
long long result; // rax
if ( (_BYTE)a1 )
__assert_fail(
"n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
8333LL,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
if ( a15 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
8334LL,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
v20 = a1 >> 8;
if ( v20 <= 0 )
{
__asm { vxorps xmm6, xmm6, xmm6 }
}
else
{
v21 = (unsigned int)v20;
_RDX = a13 + 4;
__asm { vpxor xmm0, xmm0, xmm0 }
v24 = 0LL;
__asm
{
vpbroadcastb xmm1, cs:byte_3A418
vpbroadcastb xmm2, cs:byte_3A419
}
_R10 = &iq2s_grid;
__asm
{
vmovdqa ymm3, cs:ymmword_3A1A0
vpbroadcastq ymm4, cs:qword_3A3D8
}
_RBX = a11;
__asm { vxorps xmm5, xmm5, xmm5 }
do
{
_R15 = *(unsigned __int16 *)(a11 + 82 * v24);
_RAX = &ggml_table_f32_f16;
__asm { vmovss xmm6, dword ptr [rax+r15*4] }
_R15 = 292 * v24;
_RAX = a13;
__asm { vmovss xmm7, dword ptr [rax+r15] }
_R14 = *(_QWORD *)(a11 + 82 * v24 + 74);
__asm { vmovq xmm8, r14 }
_R14 >>= 4;
__asm
{
vmovq xmm9, r14
vpunpcklqdq xmm8, xmm8, xmm9
vpaddw xmm8, xmm8, xmm8
vpternlogq xmm8, xmm2, xmm1, 0ECh
vpmovzxbw ymm8, xmm8
}
v45 = -2LL;
_R15 = 0LL;
__asm
{
vpxor xmm9, xmm9, xmm9
vpxor xmm10, xmm10, xmm10
}
do
{
__asm
{
vmovdqu ymm12, ymmword ptr [rdx+r15*8]
vmovdqu ymm11, ymmword ptr [rdx+r15*8+20h]
}
v50 = *(unsigned __int8 *)(_RBX + v45 + 68);
_R13 = (unsigned int)(4 * v50);
LOBYTE(_R13) = *(_BYTE *)(_RBX + _R15 + 5);
_RAX = *(unsigned __int8 *)(_RBX + _R15 + 4) | (16 * (*(_BYTE *)(_RBX + v45 + 68) & 0x30u));
_R12 = *(unsigned __int8 *)(_RBX + _R15 + 3) | ((unsigned __int8)(*(_BYTE *)(_RBX + v45 + 68) & 0xC) << 6);
__asm
{
vmovq xmm13, qword ptr [r10+r13*8]
vmovq xmm14, qword ptr [r10+rax*8]
}
_RSI = *(unsigned __int8 *)(_RBX + _R15 + 2) | ((unsigned __int8)(v50 & 3) << 8);
__asm
{
vpunpcklqdq xmm13, xmm14, xmm13
vmovq xmm14, qword ptr [r10+r12*8]
vmovq xmm15, qword ptr [r10+rsi*8]
vpunpcklqdq xmm14, xmm15, xmm14
vinserti128 ymm13, ymm14, xmm13, 1
}
LODWORD(_R12) = *(unsigned __int8 *)(_RBX + v45 + 69);
_RAX = (unsigned int)(4 * _R12);
LOBYTE(_RAX) = *(_BYTE *)(_RBX + _R15 + 9);
_R8 = *(unsigned __int8 *)(_RBX + _R15 + 8) | (16 * (*(_BYTE *)(_RBX + v45 + 69) & 0x30u));
_R13 = *(unsigned __int8 *)(_RBX + _R15 + 7) | ((unsigned __int8)(*(_BYTE *)(_RBX + v45 + 69) & 0xC) << 6);
_R12 = *(unsigned __int8 *)(_RBX + _R15 + 6) | ((unsigned __int8)(_R12 & 3) << 8);
__asm
{
vmovq xmm14, qword ptr [r10+rax*8]
vmovq xmm15, qword ptr [r10+r8*8]
vmovq xmm16, qword ptr [r10+r13*8]
vmovq xmm17, qword ptr [r10+r12*8]
vpunpcklqdq xmm14, xmm15, xmm14
vpunpcklqdq xmm15, xmm17, xmm16
vinserti128 ymm14, ymm15, xmm14, 1
vmovd xmm15, dword ptr [rbx+r15+22h]
vpermq ymm15, ymm15, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm12
vmovdqu8 ymm15{k1}, ymm12
vmovd xmm12, dword ptr [rbx+r15+26h]
vpmaddubsw ymm13, ymm13, ymm15
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpsubb ymm12, ymm0, ymm11
vmovdqu8 ymm12{k1}, ymm11
vpmaddubsw ymm11, ymm14, ymm12
vpshufb ymm12, ymm8, ymmword ptr [r11+r15*8]
vpmaddwd ymm12, ymm13, ymm12
vpshufb ymm13, ymm8, ymmword ptr [r11+r15*8+20h]
vpaddd ymm9, ymm12, ymm9
vpmaddwd ymm11, ymm11, ymm13
vpaddd ymm10, ymm11, ymm10
}
v45 += 2LL;
_R15 += 8LL;
}
while ( v45 < 6 );
__asm
{
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm9, ymm10
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
}
++v24;
_RBX += 82LL;
_RDX += 292LL;
__asm { vmovaps ymm5, ymm6 }
}
while ( v24 != v21 );
}
__asm
{
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmulss xmm0, xmm0, cs:dword_3A178
}
result = a2;
__asm
{
vmovss dword ptr [rax], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_iq2_s_q8_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],R9
TEST DIL,DIL
JNZ 0x00133c2a
CMP dword ptr [RSP + 0x58],0x1
JNZ 0x00133c49
MOV qword ptr [RSP + 0x10],RSI
SAR EDI,0x8
TEST EDI,EDI
JLE 0x00133bec
MOV R9D,EDI
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RAX + 0x4]
VPXOR XMM0,XMM0,XMM0
XOR EDI,EDI
VPBROADCASTB XMM1,byte ptr [0x0013a418]
VPBROADCASTB XMM2,byte ptr [0x0013a419]
LEA R10,[0x13c030]
VMOVDQA YMM3,ymmword ptr [0x0013a1a0]
VPBROADCASTQ YMM4,qword ptr [0x0013a3d8]
LEA R11,[0x142c30]
MOV RBX,RCX
VXORPS XMM5,XMM5,XMM5
LAB_001339da:
IMUL R14,RDI,0x52
MOVZX R15D,word ptr [RCX + R14*0x1]
MOV RAX,qword ptr [0x00148f68]
VMOVSS XMM6,dword ptr [RAX + R15*0x4]
IMUL R15,RDI,0x124
MOV RAX,qword ptr [RSP + 0x8]
VMOVSS XMM7,dword ptr [RAX + R15*0x1]
MOV R14,qword ptr [RCX + R14*0x1 + 0x4a]
VMOVQ XMM8,R14
SHR R14,0x4
VMOVQ XMM9,R14
VPUNPCKLQDQ XMM8,XMM8,XMM9
VPADDW XMM8,XMM8,XMM8
VPTERNLOGQ XMM8,XMM2,XMM1,0xec
VPMOVZXBW YMM8,XMM8
MOV R14,-0x2
XOR R15D,R15D
VPXOR XMM9,XMM9,XMM9
VPXOR XMM10,XMM10,XMM10
LAB_00133a3f:
VMOVDQU YMM12,ymmword ptr [RDX + R15*0x8]
VMOVDQU YMM11,ymmword ptr [RDX + R15*0x8 + 0x20]
MOVZX ESI,byte ptr [RBX + R14*0x1 + 0x44]
LEA R13D,[RSI*0x4]
MOV R13B,byte ptr [RBX + R15*0x1 + 0x5]
MOV BPL,byte ptr [RBX + R15*0x1 + 0x9]
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x4]
MOV EAX,ESI
AND EAX,0x30
SHL EAX,0x4
OR EAX,R8D
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x3]
MOV R12D,ESI
AND R12D,0xc
SHL R12D,0x6
OR R12D,R8D
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x2]
AND ESI,0x3
SHL ESI,0x8
VMOVQ XMM13,qword ptr [R10 + R13*0x8]
VMOVQ XMM14,qword ptr [R10 + RAX*0x8]
OR ESI,R8D
VPUNPCKLQDQ XMM13,XMM14,XMM13
VMOVQ XMM14,qword ptr [R10 + R12*0x8]
VMOVQ XMM15,qword ptr [R10 + RSI*0x8]
VPUNPCKLQDQ XMM14,XMM15,XMM14
VINSERTI128 YMM13,YMM14,XMM13,0x1
MOVZX R12D,byte ptr [RBX + R14*0x1 + 0x45]
LEA EAX,[R12*0x4]
MOV AL,BPL
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x8]
MOV R8D,R12D
AND R8D,0x30
SHL R8D,0x4
OR R8D,ESI
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x7]
MOV R13D,R12D
AND R13D,0xc
SHL R13D,0x6
OR R13D,ESI
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x6]
AND R12D,0x3
SHL R12D,0x8
OR R12D,ESI
VMOVQ XMM14,qword ptr [R10 + RAX*0x8]
VMOVQ XMM15,qword ptr [R10 + R8*0x8]
VMOVQ XMM0,qword ptr [R10 + R13*0x8]
VMOVQ XMM1,qword ptr [R10 + R12*0x8]
VPUNPCKLQDQ XMM14,XMM15,XMM14
VPUNPCKLQDQ XMM15,XMM1,XMM0
VINSERTI128 YMM14,YMM15,XMM14,0x1
VMOVD XMM15,dword ptr [RBX + R15*0x1 + 0x22]
VPERMQ YMM15,YMM15,0x44
VPSHUFB YMM15,YMM15,YMM3
VPTESTNMB K1 {K0},YMM15,YMM4
VPSUBB YMM15,YMM0,YMM12
VMOVDQU8 YMM15{K1},YMM12
VMOVD XMM12,dword ptr [RBX + R15*0x1 + 0x26]
VPMADDUBSW YMM13,YMM13,YMM15
VPERMQ YMM12,YMM12,0x44
VPSHUFB YMM12,YMM12,YMM3
VPTESTNMB K1 {K0},YMM12,YMM4
VPSUBB YMM12,YMM0,YMM11
VMOVDQU8 YMM12{K1},YMM11
VPMADDUBSW YMM11,YMM14,YMM12
VPSHUFB YMM12,YMM8,ymmword ptr [R11 + R15*0x8]
VPMADDWD YMM12,YMM13,YMM12
VPSHUFB YMM13,YMM8,ymmword ptr [R11 + R15*0x8 + 0x20]
VPADDD YMM9,YMM12,YMM9
VPMADDWD YMM11,YMM11,YMM13
VPADDD YMM10,YMM11,YMM10
ADD R14,0x2
ADD R15,0x8
CMP R14,0x6
JC 0x00133a3f
VMULSS XMM6,XMM6,XMM7
VBROADCASTSS YMM7,XMM6
VPADDD YMM6,YMM9,YMM10
VCVTDQ2PS YMM6,YMM6
VFMADD213PS YMM6,YMM7,YMM5
INC RDI
ADD RBX,0x52
ADD RDX,0x124
VMOVAPS YMM5,YMM6
CMP RDI,R9
JNZ 0x001339da
JMP 0x00133bf0
LAB_00133bec:
VXORPS XMM6,XMM6,XMM6
LAB_00133bf0:
VEXTRACTF128 XMM0,YMM6,0x1
VADDPS XMM0,XMM0,XMM6
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMULSS XMM0,XMM0,dword ptr [0x0013a178]
MOV RAX,qword ptr [RSP + 0x10]
VMOVSS dword ptr [RAX],XMM0
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
LAB_00133c2a:
LEA RDI,[0x143440]
LEA RSI,[0x142df0]
LEA RCX,[0x143735]
MOV EDX,0x208d
CALL 0x001083b0
LAB_00133c49:
LEA RDI,[0x136a8e]
LEA RSI,[0x142df0]
LEA RCX,[0x143735]
MOV EDX,0x208e
CALL 0x001083b0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_iq2_s_q8_K
(int param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
ulong uVar1;
byte bVar2;
bool bVar3;
float fVar4;
int1 auVar5 [32];
long lVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
uint in_K0;
ulong uVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar15 [32];
int1 auVar17 [32];
int1 auVar18 [16];
int1 auVar19 [16];
int1 auVar20 [16];
int1 auVar21 [16];
int1 auVar22 [64];
int1 auVar23 [16];
int1 auVar24 [32];
int1 auVar25 [16];
int1 auVar26 [32];
int1 auVar27 [64];
int1 auVar28 [64];
int1 auVar29 [16];
int1 auVar30 [32];
int1 auVar31 [16];
int1 auVar32 [16];
int1 auVar33 [16];
int1 auVar34 [32];
int1 auVar35 [16];
int1 auVar36 [16];
int1 auVar14 [32];
int1 auVar16 [32];
if ((char)param_1 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x208d,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
if (param_8 == 1) {
if (param_1 >> 8 < 1) {
auVar25 = ZEXT816(0) << 0x40;
}
else {
lVar6 = param_6 + 4;
uVar8 = 0;
auVar22 = ZEXT1664(CONCAT115(DAT_0013a418,
CONCAT114(DAT_0013a418,
CONCAT113(DAT_0013a418,
CONCAT112(DAT_0013a418,
CONCAT111(DAT_0013a418,
CONCAT110(DAT_0013a418,
CONCAT19(
DAT_0013a418,
CONCAT18(DAT_0013a418,
CONCAT17(DAT_0013a418,
CONCAT16(DAT_0013a418,
CONCAT15(DAT_0013a418,
CONCAT14(
DAT_0013a418,
CONCAT13(DAT_0013a418,
CONCAT12(DAT_0013a418,
CONCAT11(DAT_0013a418,
DAT_0013a418)))))))))))
)))));
auVar23[1] = DAT_0013a419;
auVar23[0] = DAT_0013a419;
auVar23[2] = DAT_0013a419;
auVar23[3] = DAT_0013a419;
auVar23[4] = DAT_0013a419;
auVar23[5] = DAT_0013a419;
auVar23[6] = DAT_0013a419;
auVar23[7] = DAT_0013a419;
auVar23[8] = DAT_0013a419;
auVar23[9] = DAT_0013a419;
auVar23[10] = DAT_0013a419;
auVar23[0xb] = DAT_0013a419;
auVar23[0xc] = DAT_0013a419;
auVar23[0xd] = DAT_0013a419;
auVar23[0xe] = DAT_0013a419;
auVar23[0xf] = DAT_0013a419;
auVar24._8_8_ = DAT_0013a3d8;
auVar24._0_8_ = DAT_0013a3d8;
auVar24._16_8_ = DAT_0013a3d8;
auVar24._24_8_ = DAT_0013a3d8;
auVar25 = ZEXT816(0) << 0x40;
lVar7 = param_4;
do {
uVar9 = *(ulong *)(param_4 + 0x4a + uVar8 * 0x52);
auVar12._8_8_ = 0;
auVar12._0_8_ = uVar9;
auVar13._8_8_ = 0;
auVar13._0_8_ = uVar9 >> 4;
auVar12 = vpunpcklqdq_avx(auVar12,auVar13);
auVar12 = vpaddw_avx(auVar12,auVar12);
auVar12 = vpternlogq_avx512vl(auVar12,auVar23,auVar22._0_16_,0xec);
auVar5 = vpmovzxbw_avx2(auVar12);
uVar9 = 0xfffffffffffffffe;
lVar10 = 0;
auVar27 = ZEXT1664((int1 [16])0x0);
auVar28 = ZEXT1664((int1 [16])0x0);
do {
auVar14 = *(int1 (*) [32])(lVar6 + lVar10 * 8);
auVar16 = *(int1 (*) [32])(lVar6 + 0x20 + lVar10 * 8);
bVar2 = *(byte *)(lVar7 + 0x44 + uVar9);
auVar29._8_8_ = 0;
auVar29._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)CONCAT31((int3)((uint)bVar2 * 4 >> 8),
*(int1 *)(lVar7 + 5 + lVar10)) * 8);
auVar31._8_8_ = 0;
auVar31._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0x30) << 4 | (uint)*(byte *)(lVar7 + 4 + lVar10)) * 8);
auVar12 = vpunpcklqdq_avx(auVar31,auVar29);
auVar32._8_8_ = 0;
auVar32._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0xc) << 6 | (uint)*(byte *)(lVar7 + 3 + lVar10)) * 8);
auVar35._8_8_ = 0;
auVar35._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 2 + lVar10)) * 8);
auVar13 = vpunpcklqdq_avx(auVar35,auVar32);
auVar30._0_16_ = ZEXT116(0) * auVar12 + ZEXT116(1) * auVar13;
auVar30._16_16_ = ZEXT116(1) * auVar12;
bVar2 = *(byte *)(lVar7 + 0x45 + uVar9);
uVar1 = *(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0xc) << 6 | (uint)*(byte *)(lVar7 + 7 + lVar10)) * 8);
auVar22 = ZEXT864(*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 6 + lVar10)
) * 8));
auVar33._8_8_ = 0;
auVar33._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)CONCAT31((int3)((uint)bVar2 * 4 >> 8),
*(int1 *)(lVar7 + 9 + lVar10)) * 8);
auVar36._8_8_ = 0;
auVar36._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0x30) << 4 | (uint)*(byte *)(lVar7 + 8 + lVar10)) * 8);
auVar12 = vpunpcklqdq_avx(auVar36,auVar33);
auVar18._8_8_ = 0;
auVar18._0_8_ = uVar1;
auVar21._8_8_ = 0;
auVar21._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 6 + lVar10)) * 8);
auVar13 = vpunpcklqdq_avx512vl(auVar21,auVar18);
auVar34._0_16_ = ZEXT116(0) * auVar12 + ZEXT116(1) * auVar13;
auVar34._16_16_ = ZEXT116(1) * auVar12;
auVar26 = vpermq_avx2(ZEXT432(*(uint *)(lVar7 + 0x22 + lVar10)),0x44);
auVar26 = vpshufb_avx2(auVar26,_DAT_0013a1a0);
uVar11 = vptestnmb_avx512vl(auVar26,auVar24);
uVar11 = in_K0 & uVar11;
auVar26 = vpsubb_avx2(ZEXT832(uVar1),auVar14);
auVar14 = vmovdqu8_avx512vl(auVar14);
bVar3 = (bool)((byte)uVar11 & 1);
auVar15[0] = bVar3 * auVar14[0] | !bVar3 * auVar26[0];
bVar3 = (bool)((byte)(uVar11 >> 1) & 1);
auVar15[1] = bVar3 * auVar14[1] | !bVar3 * auVar26[1];
bVar3 = (bool)((byte)(uVar11 >> 2) & 1);
auVar15[2] = bVar3 * auVar14[2] | !bVar3 * auVar26[2];
bVar3 = (bool)((byte)(uVar11 >> 3) & 1);
auVar15[3] = bVar3 * auVar14[3] | !bVar3 * auVar26[3];
bVar3 = (bool)((byte)(uVar11 >> 4) & 1);
auVar15[4] = bVar3 * auVar14[4] | !bVar3 * auVar26[4];
bVar3 = (bool)((byte)(uVar11 >> 5) & 1);
auVar15[5] = bVar3 * auVar14[5] | !bVar3 * auVar26[5];
bVar3 = (bool)((byte)(uVar11 >> 6) & 1);
auVar15[6] = bVar3 * auVar14[6] | !bVar3 * auVar26[6];
bVar3 = (bool)((byte)(uVar11 >> 7) & 1);
auVar15[7] = bVar3 * auVar14[7] | !bVar3 * auVar26[7];
bVar3 = (bool)((byte)(uVar11 >> 8) & 1);
auVar15[8] = bVar3 * auVar14[8] | !bVar3 * auVar26[8];
bVar3 = (bool)((byte)(uVar11 >> 9) & 1);
auVar15[9] = bVar3 * auVar14[9] | !bVar3 * auVar26[9];
bVar3 = (bool)((byte)(uVar11 >> 10) & 1);
auVar15[10] = bVar3 * auVar14[10] | !bVar3 * auVar26[10];
bVar3 = (bool)((byte)(uVar11 >> 0xb) & 1);
auVar15[0xb] = bVar3 * auVar14[0xb] | !bVar3 * auVar26[0xb];
bVar3 = (bool)((byte)(uVar11 >> 0xc) & 1);
auVar15[0xc] = bVar3 * auVar14[0xc] | !bVar3 * auVar26[0xc];
bVar3 = (bool)((byte)(uVar11 >> 0xd) & 1);
auVar15[0xd] = bVar3 * auVar14[0xd] | !bVar3 * auVar26[0xd];
bVar3 = (bool)((byte)(uVar11 >> 0xe) & 1);
auVar15[0xe] = bVar3 * auVar14[0xe] | !bVar3 * auVar26[0xe];
bVar3 = (bool)((byte)(uVar11 >> 0xf) & 1);
auVar15[0xf] = bVar3 * auVar14[0xf] | !bVar3 * auVar26[0xf];
bVar3 = (bool)((byte)(uVar11 >> 0x10) & 1);
auVar15[0x10] = bVar3 * auVar14[0x10] | !bVar3 * auVar26[0x10];
bVar3 = (bool)((byte)(uVar11 >> 0x11) & 1);
auVar15[0x11] = bVar3 * auVar14[0x11] | !bVar3 * auVar26[0x11];
bVar3 = (bool)((byte)(uVar11 >> 0x12) & 1);
auVar15[0x12] = bVar3 * auVar14[0x12] | !bVar3 * auVar26[0x12];
bVar3 = (bool)((byte)(uVar11 >> 0x13) & 1);
auVar15[0x13] = bVar3 * auVar14[0x13] | !bVar3 * auVar26[0x13];
bVar3 = (bool)((byte)(uVar11 >> 0x14) & 1);
auVar15[0x14] = bVar3 * auVar14[0x14] | !bVar3 * auVar26[0x14];
bVar3 = (bool)((byte)(uVar11 >> 0x15) & 1);
auVar15[0x15] = bVar3 * auVar14[0x15] | !bVar3 * auVar26[0x15];
bVar3 = (bool)((byte)(uVar11 >> 0x16) & 1);
auVar15[0x16] = bVar3 * auVar14[0x16] | !bVar3 * auVar26[0x16];
bVar3 = (bool)((byte)(uVar11 >> 0x17) & 1);
auVar15[0x17] = bVar3 * auVar14[0x17] | !bVar3 * auVar26[0x17];
bVar3 = (bool)((byte)(uVar11 >> 0x18) & 1);
auVar15[0x18] = bVar3 * auVar14[0x18] | !bVar3 * auVar26[0x18];
bVar3 = (bool)((byte)(uVar11 >> 0x19) & 1);
auVar15[0x19] = bVar3 * auVar14[0x19] | !bVar3 * auVar26[0x19];
bVar3 = (bool)((byte)(uVar11 >> 0x1a) & 1);
auVar15[0x1a] = bVar3 * auVar14[0x1a] | !bVar3 * auVar26[0x1a];
bVar3 = (bool)((byte)(uVar11 >> 0x1b) & 1);
auVar15[0x1b] = bVar3 * auVar14[0x1b] | !bVar3 * auVar26[0x1b];
bVar3 = (bool)((byte)(uVar11 >> 0x1c) & 1);
auVar15[0x1c] = bVar3 * auVar14[0x1c] | !bVar3 * auVar26[0x1c];
bVar3 = (bool)((byte)(uVar11 >> 0x1d) & 1);
auVar15._30_2_ = auVar14._30_2_;
auVar15[0x1d] = bVar3 * auVar14[0x1d] | !bVar3 * auVar26[0x1d];
auVar14 = vpmaddubsw_avx2(auVar30,auVar15);
auVar26 = vpermq_avx2(ZEXT432(*(uint *)(lVar7 + 0x26 + lVar10)),0x44);
auVar26 = vpshufb_avx2(auVar26,_DAT_0013a1a0);
uVar11 = vptestnmb_avx512vl(auVar26,auVar24);
uVar11 = in_K0 & uVar11;
auVar26 = vpsubb_avx2(ZEXT832(uVar1),auVar16);
auVar16 = vmovdqu8_avx512vl(auVar16);
bVar3 = (bool)((byte)uVar11 & 1);
auVar17[0] = bVar3 * auVar16[0] | !bVar3 * auVar26[0];
bVar3 = (bool)((byte)(uVar11 >> 1) & 1);
auVar17[1] = bVar3 * auVar16[1] | !bVar3 * auVar26[1];
bVar3 = (bool)((byte)(uVar11 >> 2) & 1);
auVar17[2] = bVar3 * auVar16[2] | !bVar3 * auVar26[2];
bVar3 = (bool)((byte)(uVar11 >> 3) & 1);
auVar17[3] = bVar3 * auVar16[3] | !bVar3 * auVar26[3];
bVar3 = (bool)((byte)(uVar11 >> 4) & 1);
auVar17[4] = bVar3 * auVar16[4] | !bVar3 * auVar26[4];
bVar3 = (bool)((byte)(uVar11 >> 5) & 1);
auVar17[5] = bVar3 * auVar16[5] | !bVar3 * auVar26[5];
bVar3 = (bool)((byte)(uVar11 >> 6) & 1);
auVar17[6] = bVar3 * auVar16[6] | !bVar3 * auVar26[6];
bVar3 = (bool)((byte)(uVar11 >> 7) & 1);
auVar17[7] = bVar3 * auVar16[7] | !bVar3 * auVar26[7];
bVar3 = (bool)((byte)(uVar11 >> 8) & 1);
auVar17[8] = bVar3 * auVar16[8] | !bVar3 * auVar26[8];
bVar3 = (bool)((byte)(uVar11 >> 9) & 1);
auVar17[9] = bVar3 * auVar16[9] | !bVar3 * auVar26[9];
bVar3 = (bool)((byte)(uVar11 >> 10) & 1);
auVar17[10] = bVar3 * auVar16[10] | !bVar3 * auVar26[10];
bVar3 = (bool)((byte)(uVar11 >> 0xb) & 1);
auVar17[0xb] = bVar3 * auVar16[0xb] | !bVar3 * auVar26[0xb];
bVar3 = (bool)((byte)(uVar11 >> 0xc) & 1);
auVar17[0xc] = bVar3 * auVar16[0xc] | !bVar3 * auVar26[0xc];
bVar3 = (bool)((byte)(uVar11 >> 0xd) & 1);
auVar17[0xd] = bVar3 * auVar16[0xd] | !bVar3 * auVar26[0xd];
bVar3 = (bool)((byte)(uVar11 >> 0xe) & 1);
auVar17[0xe] = bVar3 * auVar16[0xe] | !bVar3 * auVar26[0xe];
bVar3 = (bool)((byte)(uVar11 >> 0xf) & 1);
auVar17[0xf] = bVar3 * auVar16[0xf] | !bVar3 * auVar26[0xf];
bVar3 = (bool)((byte)(uVar11 >> 0x10) & 1);
auVar17[0x10] = bVar3 * auVar16[0x10] | !bVar3 * auVar26[0x10];
bVar3 = (bool)((byte)(uVar11 >> 0x11) & 1);
auVar17[0x11] = bVar3 * auVar16[0x11] | !bVar3 * auVar26[0x11];
bVar3 = (bool)((byte)(uVar11 >> 0x12) & 1);
auVar17[0x12] = bVar3 * auVar16[0x12] | !bVar3 * auVar26[0x12];
bVar3 = (bool)((byte)(uVar11 >> 0x13) & 1);
auVar17[0x13] = bVar3 * auVar16[0x13] | !bVar3 * auVar26[0x13];
bVar3 = (bool)((byte)(uVar11 >> 0x14) & 1);
auVar17[0x14] = bVar3 * auVar16[0x14] | !bVar3 * auVar26[0x14];
bVar3 = (bool)((byte)(uVar11 >> 0x15) & 1);
auVar17[0x15] = bVar3 * auVar16[0x15] | !bVar3 * auVar26[0x15];
bVar3 = (bool)((byte)(uVar11 >> 0x16) & 1);
auVar17[0x16] = bVar3 * auVar16[0x16] | !bVar3 * auVar26[0x16];
bVar3 = (bool)((byte)(uVar11 >> 0x17) & 1);
auVar17[0x17] = bVar3 * auVar16[0x17] | !bVar3 * auVar26[0x17];
bVar3 = (bool)((byte)(uVar11 >> 0x18) & 1);
auVar17[0x18] = bVar3 * auVar16[0x18] | !bVar3 * auVar26[0x18];
bVar3 = (bool)((byte)(uVar11 >> 0x19) & 1);
auVar17[0x19] = bVar3 * auVar16[0x19] | !bVar3 * auVar26[0x19];
bVar3 = (bool)((byte)(uVar11 >> 0x1a) & 1);
auVar17[0x1a] = bVar3 * auVar16[0x1a] | !bVar3 * auVar26[0x1a];
bVar3 = (bool)((byte)(uVar11 >> 0x1b) & 1);
auVar17[0x1b] = bVar3 * auVar16[0x1b] | !bVar3 * auVar26[0x1b];
bVar3 = (bool)((byte)(uVar11 >> 0x1c) & 1);
auVar17[0x1c] = bVar3 * auVar16[0x1c] | !bVar3 * auVar26[0x1c];
bVar3 = (bool)((byte)(uVar11 >> 0x1d) & 1);
auVar17._30_2_ = auVar16._30_2_;
auVar17[0x1d] = bVar3 * auVar16[0x1d] | !bVar3 * auVar26[0x1d];
auVar16 = vpmaddubsw_avx2(auVar34,auVar17);
auVar26 = vpshufb_avx2(auVar5,*(int1 (*) [32])
(get_scale_shuffle_k4_k_shuffle + lVar10 * 8));
auVar14 = vpmaddwd_avx2(auVar14,auVar26);
auVar26 = vpshufb_avx2(auVar5,*(int1 (*) [32])
(get_scale_shuffle_k4_k_shuffle + lVar10 * 8 + 0x20));
auVar14 = vpaddd_avx2(auVar14,auVar27._0_32_);
auVar27 = ZEXT3264(auVar14);
auVar16 = vpmaddwd_avx2(auVar16,auVar26);
auVar16 = vpaddd_avx2(auVar16,auVar28._0_32_);
auVar28 = ZEXT3264(auVar16);
uVar9 = uVar9 + 2;
lVar10 = lVar10 + 8;
} while (uVar9 < 6);
fVar4 = *(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + uVar8 * 0x52) * 4) *
*(float *)(param_6 + uVar8 * 0x124);
auVar26._4_4_ = fVar4;
auVar26._0_4_ = fVar4;
auVar26._8_4_ = fVar4;
auVar26._12_4_ = fVar4;
auVar26._16_4_ = fVar4;
auVar26._20_4_ = fVar4;
auVar26._24_4_ = fVar4;
auVar26._28_4_ = fVar4;
auVar5 = vpaddd_avx2(auVar14,auVar16);
auVar5 = vcvtdq2ps_avx(auVar5);
auVar25 = vfmadd213ps_fma(auVar5,auVar26,ZEXT1632(auVar25));
uVar8 = uVar8 + 1;
lVar7 = lVar7 + 0x52;
lVar6 = lVar6 + 0x124;
} while (uVar8 != (uint)(param_1 >> 8));
}
auVar19._0_4_ = auVar25._0_4_ + 0.0;
auVar19._4_4_ = auVar25._4_4_ + 0.0;
auVar19._8_4_ = auVar25._8_4_ + 0.0;
auVar19._12_4_ = auVar25._12_4_ + 0.0;
auVar25 = vshufpd_avx(auVar19,auVar19,1);
auVar20._0_4_ = auVar19._0_4_ + auVar25._0_4_;
auVar20._4_4_ = auVar19._4_4_ + auVar25._4_4_;
auVar20._8_4_ = auVar19._8_4_ + auVar25._8_4_;
auVar20._12_4_ = auVar19._12_4_ + auVar25._12_4_;
auVar25 = vhaddps_avx(auVar20,auVar20);
*param_2 = auVar25._0_4_ * DAT_0013a178;
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x208e,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
|
|
1,684 | ggml_vec_dot_iq2_s_q8_K | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c | void ggml_vec_dot_iq2_s_q8_K(int n, float * restrict s, size_t bs, const void * restrict vx, size_t bx, const void * restrict vy, size_t by, int nrc) {
assert(n % QK_K == 0);
assert(nrc == 1);
UNUSED(nrc);
UNUSED(bx);
UNUSED(by);
UNUSED(bs);
const block_iq2_s * restrict x = vx;
const block_q8_K * restrict y = vy;
const int nb = n / QK_K;
#if defined(__ARM_NEON)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
const ggml_uint8x16x2_t mask1 = ggml_vld1q_u8_x2(k_mask1);
const uint8x16_t mask2 = vld1q_u8(k_mask2);
const uint8x16_t m1 = vdupq_n_u8(1);
const int32x4_t vzero = vdupq_n_s32(0);
uint8x16x2_t vs;
ggml_int8x16x4_t q2s;
ggml_int8x16x4_t q8b;
float sumf = 0;
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
int sumi1 = 0, sumi2 = 0;
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
q8b = ggml_vld1q_s8_x4(q8); q8 += 64;
q2s.val[0] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[0] | ((qh[ib32+0] << 8) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[1] | ((qh[ib32+0] << 6) & 0x300)))));
q2s.val[1] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[2] | ((qh[ib32+0] << 4) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[3] | ((qh[ib32+0] << 2) & 0x300)))));
q2s.val[2] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[4] | ((qh[ib32+1] << 8) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[5] | ((qh[ib32+1] << 6) & 0x300)))));
q2s.val[3] = vcombine_s8(vld1_s8((const int8_t *)(iq2s_grid + (qs[6] | ((qh[ib32+1] << 4) & 0x300)))),
vld1_s8((const int8_t *)(iq2s_grid + (qs[7] | ((qh[ib32+1] << 2) & 0x300)))));
qs += 8;
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[0] | ((uint32_t) signs[1] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vceqq_u8(vs.val[0], mask2);
vs.val[1] = vceqq_u8(vs.val[1], mask2);
q2s.val[0] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[0], m1)), q2s.val[0]);
q2s.val[1] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[1], m1)), q2s.val[1]);
vs.val[0] = vreinterpretq_u8_u32(vdupq_n_u32(signs[2] | ((uint32_t) signs[3] << 16)));
vs.val[1] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[1]), mask2);
vs.val[0] = vandq_u8(ggml_vqtbl1q_u8(vs.val[0], mask1.val[0]), mask2);
vs.val[0] = vceqq_u8(vs.val[0], mask2);
vs.val[1] = vceqq_u8(vs.val[1], mask2);
signs += 4;
q2s.val[2] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[0], m1)), q2s.val[2]);
q2s.val[3] = vmulq_s8(vreinterpretq_s8_u8(vorrq_u8(vs.val[1], m1)), q2s.val[3]);
const int32x4_t p1 = ggml_vdotq_s32(vzero, q2s.val[0], q8b.val[0]);
const int32x4_t p2 = ggml_vdotq_s32(vzero, q2s.val[1], q8b.val[1]);
const int32x4_t p3 = ggml_vdotq_s32(vzero, q2s.val[2], q8b.val[2]);
const int32x4_t p4 = ggml_vdotq_s32(vzero, q2s.val[3], q8b.val[3]);
sumi1 += vaddvq_s32(p1) * (1 + 2*(x[i].scales[ib32+0] & 0xf));
sumi2 += vaddvq_s32(p2) * (1 + 2*(x[i].scales[ib32+0] >> 4));
sumi1 += vaddvq_s32(p3) * (1 + 2*(x[i].scales[ib32+1] & 0xf));
sumi2 += vaddvq_s32(p4) * (1 + 2*(x[i].scales[ib32+1] >> 4));
}
sumf += d*(sumi1 + sumi2);
}
*s = 0.125f * sumf;
#elif defined(__AVX2__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = _mm_set1_epi8(0xf);
const __m128i m1 = _mm_set1_epi8(1);
const __m256i mask1 = _mm256_loadu_si256((const __m256i*)k_mask1);
const __m256i mask2 = _mm256_loadu_si256((const __m256i*)k_mask2);
uint64_t aux64;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
memcpy(&aux64, x[i].scales, 8);
const __m128i scales8 = _mm_add_epi8(_mm_slli_epi16(_mm_and_si128(_mm_set_epi64x(aux64 >> 4, aux64), m4), 1), m1);
const __m256i scales16 = _mm256_cvtepi8_epi16(scales8); // 0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15
__m256i sumi1 = _mm256_setzero_si256();
__m256i sumi2 = _mm256_setzero_si256();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i q8_2 = _mm256_loadu_si256((const __m256i *)q8); q8 += 32;
const __m256i q2_1 = _mm256_set_epi64x(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)],
iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m256i q2_2 = _mm256_set_epi64x(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)],
iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
qs += 8;
__m256i aux256 = _mm256_set1_epi32(signs[0] | ((uint32_t) signs[1] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_1 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_1 = _mm256_sub_epi8(_mm256_xor_si256(s2_1, q8_1), s2_1);
aux256 = _mm256_set1_epi32(signs[2] | ((uint32_t) signs[3] << 16));
aux256 = _mm256_and_si256(_mm256_shuffle_epi8(aux256,mask1), mask2);
const __m256i s2_2 = _mm256_cmpeq_epi8(aux256, mask2);
const __m256i q8s_2 = _mm256_sub_epi8(_mm256_xor_si256(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = _mm256_maddubs_epi16(q2_1, q8s_1); // blocks 2*ib32+0, 2*ib32+1
const __m256i dot2 = _mm256_maddubs_epi16(q2_2, q8s_2); // blocks 2*ib32+2, 2*ib32+3
const __m256i p1 = _mm256_madd_epi16(dot1, _mm256_shuffle_epi8(scales16, get_scale_shuffle_k4(ib32+0)));
const __m256i p2 = _mm256_madd_epi16(dot2, _mm256_shuffle_epi8(scales16, get_scale_shuffle_k4(ib32+1)));
sumi1 = _mm256_add_epi32(sumi1, p1);
sumi2 = _mm256_add_epi32(sumi2, p2);
}
accumf = _mm256_fmadd_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(_mm256_add_epi32(sumi1, sumi2)), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#elif defined(__AVX__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = _mm_set1_epi8(0xf);
const __m128i m1 = _mm_set1_epi8(1);
const __m128i mask1_0 = _mm_loadu_si128((const __m128i*)k_mask1);
const __m128i mask1_1 = _mm_loadu_si128((const __m128i*)k_mask1 + 1);
const __m128i mask2_0 = _mm_loadu_si128((const __m128i*)k_mask2);
const __m128i mask2_1 = _mm_loadu_si128((const __m128i*)k_mask2 + 1);
uint64_t aux64;
__m256 accumf = _mm256_setzero_ps();
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
memcpy(&aux64, x[i].scales, 8);
const __m128i scales8 = _mm_add_epi8(_mm_slli_epi16(_mm_and_si128(_mm_set_epi64x(aux64 >> 4, aux64), m4), 1), m1);
const __m128i scales16_0 = _mm_cvtepi8_epi16(scales8);
const __m128i scales16_1 = _mm_cvtepi8_epi16(_mm_srli_si128(scales8, 8));
__m128i sumi1_0 = _mm_setzero_si128();
__m128i sumi1_1 = _mm_setzero_si128();
__m128i sumi2_0 = _mm_setzero_si128();
__m128i sumi2_1 = _mm_setzero_si128();
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m128i q8_1_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_1_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_0 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q8_2_1 = _mm_loadu_si128((const __m128i *)q8); q8 += 16;
const __m128i q2_1_0 = _mm_set_epi64x(iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m128i q2_1_1 = _mm_set_epi64x(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)]);
const __m128i q2_2_0 = _mm_set_epi64x(iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
const __m128i q2_2_1 = _mm_set_epi64x(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)]);
qs += 8;
__m128i aux128_0 = _mm_set1_epi32(signs[0] | ((uint32_t) signs[1] << 16));
__m128i aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_1_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_1_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_1_0 = _mm_sub_epi8(_mm_xor_si128(s2_1_0, q8_1_0), s2_1_0);
const __m128i q8s_1_1 = _mm_sub_epi8(_mm_xor_si128(s2_1_1, q8_1_1), s2_1_1);
aux128_0 = _mm_set1_epi32(signs[2] | ((uint32_t) signs[3] << 16));
aux128_1 = aux128_0;
aux128_0 = _mm_and_si128(_mm_shuffle_epi8(aux128_0,mask1_0), mask2_0);
aux128_1 = _mm_and_si128(_mm_shuffle_epi8(aux128_1,mask1_1), mask2_1);
const __m128i s2_2_0 = _mm_cmpeq_epi8(aux128_0, mask2_0);
const __m128i s2_2_1 = _mm_cmpeq_epi8(aux128_1, mask2_1);
const __m128i q8s_2_0 = _mm_sub_epi8(_mm_xor_si128(s2_2_0, q8_2_0), s2_2_0);
const __m128i q8s_2_1 = _mm_sub_epi8(_mm_xor_si128(s2_2_1, q8_2_1), s2_2_1);
signs += 4;
const __m128i dot1_0 = _mm_maddubs_epi16(q2_1_0, q8s_1_0);
const __m128i dot1_1 = _mm_maddubs_epi16(q2_1_1, q8s_1_1);
const __m128i dot2_0 = _mm_maddubs_epi16(q2_2_0, q8s_2_0);
const __m128i dot2_1 = _mm_maddubs_epi16(q2_2_1, q8s_2_1);
const __m128i p1_0 = _mm_madd_epi16(dot1_0, _mm_shuffle_epi8(scales16_0, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+0), 0)));
const __m128i p1_1 = _mm_madd_epi16(dot1_1, _mm_shuffle_epi8(scales16_1, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+0), 1)));
const __m128i p2_0 = _mm_madd_epi16(dot2_0, _mm_shuffle_epi8(scales16_0, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+1), 0)));
const __m128i p2_1 = _mm_madd_epi16(dot2_1, _mm_shuffle_epi8(scales16_1, _mm256_extractf128_si256(get_scale_shuffle_k4(ib32+1), 1)));
sumi1_0 = _mm_add_epi32(sumi1_0, p1_0);
sumi1_1 = _mm_add_epi32(sumi1_1, p1_1);
sumi2_0 = _mm_add_epi32(sumi2_0, p2_0);
sumi2_1 = _mm_add_epi32(sumi2_1, p2_1);
}
accumf = _mm256_add_ps(_mm256_mul_ps(_mm256_set1_ps(d), _mm256_cvtepi32_ps(MM256_SET_M128I(_mm_add_epi32(sumi1_1, sumi2_1), _mm_add_epi32(sumi1_0, sumi2_0)))), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#elif defined(__POWER9_VECTOR__)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,};
const vector int v0 = vec_splats((int32_t)0);
vector float vsumf0 = vec_splats(0.0f);
vector float vsumf1 = vec_splats(0.0f);
vector float vsumf2 = vec_splats(0.0f);
vector float vsumf3 = vec_splats(0.0f);
const vector unsigned char mask0 = vec_xl( 0, k_mask1);
const vector unsigned char mask1 = vec_xl(16, k_mask1);
const vector signed char mask2 = (vector signed char)vec_xl( 0, k_mask2);
for (int i = 0; i < nb; ++i) {
vector float vxd = vec_splats(GGML_FP16_TO_FP32(x[i].d));
vector float vyd = vec_splats(y[i].d);
vector float vd = vec_mul(vxd, vyd);
vector signed int vsumi0 = v0;
vector signed int vsumi1 = v0;
vector signed int vsumi2 = v0;
vector signed int vsumi3 = v0;
const uint8_t * restrict q2 = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const uint8_t * restrict sc = x[i].scales;
const int8_t * restrict q8 = y[i].qs;
for (int j = 0; j < QK_K/32; j += 2) {
__builtin_prefetch(q2, 0, 1);
__builtin_prefetch(q8, 0, 1);
vector signed long long aux64x2_0 = {*(const int64_t *)(iq2s_grid + (q2[0] | ((qh[0] << 8) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[1] | ((qh[0] << 6) & 0x300)))};
vector signed long long aux64x2_1 = {*(const int64_t *)(iq2s_grid + (q2[2] | ((qh[0] << 4) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[3] | ((qh[0] << 2) & 0x300)))};
vector signed long long aux64x2_2 = {*(const int64_t *)(iq2s_grid + (q2[4] | ((qh[1] << 8) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[5] | ((qh[1] << 6) & 0x300)))};
vector signed long long aux64x2_3 = {*(const int64_t *)(iq2s_grid + (q2[6] | ((qh[1] << 4) & 0x300))), *(const int64_t *)(iq2s_grid + (q2[7] | ((qh[1] << 2) & 0x300)))};
q2 += 8;
qh += 2;
vector signed char vsigns01 = (vector signed char)vec_splats(*(const uint32_t *)&signs[0]);
vector signed char vsigns23 = (vector signed char)vec_splats(*(const uint32_t *)&signs[2]);
signs += 4;
vector signed char vsigns0 = vec_perm(vsigns01, vsigns01, mask0);
vector signed char vsigns1 = vec_perm(vsigns01, vsigns01, mask1);
vector signed char vsigns2 = vec_perm(vsigns23, vsigns23, mask0);
vector signed char vsigns3 = vec_perm(vsigns23, vsigns23, mask1);
vsigns0 = (vector signed char)vec_cmpeq(vec_and(vsigns0, mask2), mask2);
vsigns1 = (vector signed char)vec_cmpeq(vec_and(vsigns1, mask2), mask2);
vsigns2 = (vector signed char)vec_cmpeq(vec_and(vsigns2, mask2), mask2);
vsigns3 = (vector signed char)vec_cmpeq(vec_and(vsigns3, mask2), mask2);
vector signed char q2x0 = vec_sub(vec_xor(vsigns0, (vector signed char)aux64x2_0), vsigns0);
vector signed char q2x1 = vec_sub(vec_xor(vsigns1, (vector signed char)aux64x2_1), vsigns1);
vector signed char q2x2 = vec_sub(vec_xor(vsigns2, (vector signed char)aux64x2_2), vsigns2);
vector signed char q2x3 = vec_sub(vec_xor(vsigns3, (vector signed char)aux64x2_3), vsigns3);
vector signed char q8y0 = vec_xl( 0, q8);
vector signed char q8y1 = vec_xl(16, q8);
vector signed char q8y2 = vec_xl(32, q8);
vector signed char q8y3 = vec_xl(48, q8);
q8 += 64;
vector signed short qv0 = vec_add(vec_mule(q2x0, q8y0), vec_mulo(q2x0, q8y0));
vector signed short qv1 = vec_add(vec_mule(q2x1, q8y1), vec_mulo(q2x1, q8y1));
vector signed short qv2 = vec_add(vec_mule(q2x2, q8y2), vec_mulo(q2x2, q8y2));
vector signed short qv3 = vec_add(vec_mule(q2x3, q8y3), vec_mulo(q2x3, q8y3));
const uint16_t ls0 = (uint16_t)(sc[0] & 0xf);
const uint16_t ls1 = (uint16_t)(sc[0] >> 4);
const uint16_t ls2 = (uint16_t)(sc[1] & 0xf);
const uint16_t ls3 = (uint16_t)(sc[1] >> 4);
sc += 2;
vector signed short vscales0 = vec_splats((int16_t)(2*ls0+1));
vector signed short vscales1 = vec_splats((int16_t)(2*ls1+1));
vector signed short vscales2 = vec_splats((int16_t)(2*ls2+1));
vector signed short vscales3 = vec_splats((int16_t)(2*ls3+1));
vsumi0 = vec_msum(qv0, vscales0, vsumi0);
vsumi1 = vec_msum(qv1, vscales1, vsumi1);
vsumi2 = vec_msum(qv2, vscales2, vsumi2);
vsumi3 = vec_msum(qv3, vscales3, vsumi3);
}
vsumf0 = vec_madd(vec_ctf(vsumi0, 0), vd, vsumf0);
vsumf1 = vec_madd(vec_ctf(vsumi1, 0), vd, vsumf1);
vsumf2 = vec_madd(vec_ctf(vsumi2, 0), vd, vsumf2);
vsumf3 = vec_madd(vec_ctf(vsumi3, 0), vd, vsumf3);
}
vsumf0 = vec_add(vsumf0, vsumf2);
vsumf1 = vec_add(vsumf1, vsumf3);
vsumf0 = vec_add(vsumf0, vsumf1);
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 4));
vsumf0 = vec_add(vsumf0, vec_sld(vsumf0, vsumf0, 8));
*s = 0.125f * vec_extract(vsumf0, 0);
#elif defined(__loongarch_asx)
static const uint8_t k_mask1[32] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03
};
static const uint8_t k_mask2[32] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
};
const __m128i m4 = __lsx_vreplgr2vr_b(0xf);
const __m128i m1 = __lsx_vreplgr2vr_b(1);
const __m256i mask1 = __lasx_xvld((const __m256i*)k_mask1, 0);
const __m256i mask2 = __lasx_xvld((const __m256i*)k_mask2, 0);
uint64_t aux64;
__m256 accumf = (__m256)__lasx_xvldi(0);
for (int i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const uint8_t * restrict qs = x[i].qs;
const uint8_t * restrict qh = x[i].qh;
const uint16_t * restrict signs = (const uint16_t *)(x[i].qs + QK_K/8);
const int8_t * restrict q8 = y[i].qs;
__m128i tmp1;
memcpy(&aux64, x[i].scales, 8);
tmp1 = __lsx_vinsgr2vr_d(tmp1, aux64, 0);
tmp1 = __lsx_vinsgr2vr_d(tmp1, aux64 >> 4, 1);
const __m128i scales8 = __lsx_vadd_b(__lsx_vslli_h(__lsx_vand_v(tmp1, m4), 1), m1);
const __m256i scales16 = lasx_ext8_16(scales8); // 0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15
__m256i sumi1 = __lasx_xvldi(0);
__m256i sumi2 = __lasx_xvldi(0);
for (int ib32 = 0; ib32 < QK_K/32; ib32 += 2) {
const __m256i q8_1 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i q8_2 = __lasx_xvld((const __m256i *)q8, 0); q8 += 32;
const __m256i q2_1 = lasx_set_d(iq2s_grid[qs[3] | ((qh[ib32+0] << 2) & 0x300)],
iq2s_grid[qs[2] | ((qh[ib32+0] << 4) & 0x300)],
iq2s_grid[qs[1] | ((qh[ib32+0] << 6) & 0x300)],
iq2s_grid[qs[0] | ((qh[ib32+0] << 8) & 0x300)]);
const __m256i q2_2 = lasx_set_d(iq2s_grid[qs[7] | ((qh[ib32+1] << 2) & 0x300)],
iq2s_grid[qs[6] | ((qh[ib32+1] << 4) & 0x300)],
iq2s_grid[qs[5] | ((qh[ib32+1] << 6) & 0x300)],
iq2s_grid[qs[4] | ((qh[ib32+1] << 8) & 0x300)]);
qs += 8;
__m256i aux256 = __lasx_xvreplgr2vr_w(signs[0] | ((uint32_t) signs[1] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_1 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_1 = __lasx_xvsub_b(__lasx_xvxor_v(s2_1, q8_1), s2_1);
aux256 = __lasx_xvreplgr2vr_w(signs[2] | ((uint32_t) signs[3] << 16));
aux256 = __lasx_xvand_v(lasx_shuffle_b(aux256,mask1), mask2);
const __m256i s2_2 = __lasx_xvseq_b(aux256, mask2);
const __m256i q8s_2 = __lasx_xvsub_b(__lasx_xvxor_v(s2_2, q8_2), s2_2);
signs += 4;
const __m256i dot1 = lasx_maddubs_h(q2_1, q8s_1); // blocks 2*ib32+0, 2*ib32+1
const __m256i dot2 = lasx_maddubs_h(q2_2, q8s_2); // blocks 2*ib32+2, 2*ib32+3
const __m256i p1 = lasx_madd_h(dot1, lasx_shuffle_b(scales16, get_scale_shuffle_k4(ib32+0)));
const __m256i p2 = lasx_madd_h(dot2, lasx_shuffle_b(scales16, get_scale_shuffle_k4(ib32+1)));
sumi1 = __lasx_xvadd_w(sumi1, p1);
sumi2 = __lasx_xvadd_w(sumi2, p2);
}
accumf = __lasx_xvfmadd_s(__lasx_xvreplfr2vr_s(d), __lasx_xvffint_s_w(__lasx_xvadd_w(sumi1, sumi2)), accumf);
}
*s = 0.125f * hsum_float_8(accumf);
#else
float sumf = 0;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d) * y[i].d;
const int8_t * q8 = y[i].qs;
const uint8_t * qs = x[i].qs;
const uint8_t * qh = x[i].qh;
const uint8_t * signs = qs + QK_K/8;
int bsum = 0;
for (int ib32 = 0; ib32 < QK_K/32; ++ib32) {
int ls1 = 1 + 2*(x[i].scales[ib32] & 0xf);
int ls2 = 1 + 2*(x[i].scales[ib32] >> 4);
int sumi1 = 0, sumi2 = 0;
for (int l = 0; l < 2; ++l) {
const uint8_t * grid = (const uint8_t *)(iq2s_grid + (qs[l] | (qh[ib32] << (8-2*l) & 0x300)));
for (int j = 0; j < 8; ++j) {
sumi1 += q8[j] * grid[j] * (signs[l] & kmask_iq2xs[j] ? -1 : 1);
}
q8 += 8;
}
for (int l = 2; l < 4; ++l) {
const uint8_t * grid = (const uint8_t *)(iq2s_grid + (qs[l] | (qh[ib32] << (8-2*l) & 0x300)));
for (int j = 0; j < 8; ++j) {
sumi2 += q8[j] * grid[j] * (signs[l] & kmask_iq2xs[j] ? -1 : 1);
}
q8 += 8;
}
bsum += ls1 * sumi1 + ls2 * sumi2;
qs += 4;
signs += 4;
}
sumf += d * bsum;
}
*s = 0.125f * sumf;
#endif
} | O3 | c | ggml_vec_dot_iq2_s_q8_K:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
testb %dil, %dil
jne 0x34736
cmpl $0x1, 0x58(%rsp)
jne 0x34755
movq %rsi, 0x10(%rsp)
sarl $0x8, %edi
testl %edi, %edi
jle 0x346f8
movl %edi, %r9d
movq 0x8(%rsp), %rax
leaq 0x4(%rax), %rdx
vpxor %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vpbroadcastb 0x613b(%rip), %xmm1 # 0x3a5f2
vpbroadcastb 0x6133(%rip), %xmm2 # 0x3a5f3
leaq 0x7d39(%rip), %r10 # 0x3c200
vmovdqa 0x5e91(%rip), %ymm3 # 0x3a360
vpbroadcastq 0x60c8(%rip), %ymm4 # 0x3a5a0
leaq 0xe921(%rip), %r11 # 0x42e00
movq %rcx, %rbx
vxorps %xmm5, %xmm5, %xmm5
imulq $0x52, %rdi, %r14
movzwl (%rcx,%r14), %r15d
movq 0x14a72(%rip), %rax # 0x48f68
vmovss (%rax,%r15,4), %xmm6
imulq $0x124, %rdi, %r15 # imm = 0x124
movq 0x8(%rsp), %rax
vmovss (%rax,%r15), %xmm7
movq 0x4a(%rcx,%r14), %r14
vmovq %r14, %xmm8
shrq $0x4, %r14
vmovq %r14, %xmm9
vpunpcklqdq %xmm9, %xmm8, %xmm8 # xmm8 = xmm8[0],xmm9[0]
vpaddw %xmm8, %xmm8, %xmm8
vpternlogq $0xec, %xmm1, %xmm2, %xmm8
vpmovzxbw %xmm8, %ymm8 # ymm8 = xmm8[0],zero,xmm8[1],zero,xmm8[2],zero,xmm8[3],zero,xmm8[4],zero,xmm8[5],zero,xmm8[6],zero,xmm8[7],zero,xmm8[8],zero,xmm8[9],zero,xmm8[10],zero,xmm8[11],zero,xmm8[12],zero,xmm8[13],zero,xmm8[14],zero,xmm8[15],zero
movq $-0x2, %r14
xorl %r15d, %r15d
vpxor %xmm9, %xmm9, %xmm9
vpxor %xmm10, %xmm10, %xmm10
vmovdqu (%rdx,%r15,8), %ymm12
vmovdqu 0x20(%rdx,%r15,8), %ymm11
movzbl 0x44(%rbx,%r14), %esi
leal (,%rsi,4), %r13d
movb 0x5(%rbx,%r15), %r13b
movb 0x9(%rbx,%r15), %bpl
movzbl 0x4(%rbx,%r15), %r8d
movl %esi, %eax
andl $0x30, %eax
shll $0x4, %eax
orl %r8d, %eax
movzbl 0x3(%rbx,%r15), %r8d
movl %esi, %r12d
andl $0xc, %r12d
shll $0x6, %r12d
orl %r8d, %r12d
movzbl 0x2(%rbx,%r15), %r8d
andl $0x3, %esi
shll $0x8, %esi
vmovq (%r10,%r13,8), %xmm13
vmovq (%r10,%rax,8), %xmm14
orl %r8d, %esi
vpunpcklqdq %xmm13, %xmm14, %xmm13 # xmm13 = xmm14[0],xmm13[0]
vmovq (%r10,%r12,8), %xmm14
vmovq (%r10,%rsi,8), %xmm15
vpunpcklqdq %xmm14, %xmm15, %xmm14 # xmm14 = xmm15[0],xmm14[0]
vinserti128 $0x1, %xmm13, %ymm14, %ymm13
movzbl 0x45(%rbx,%r14), %r12d
leal (,%r12,4), %eax
movb %bpl, %al
movzbl 0x8(%rbx,%r15), %esi
movl %r12d, %r8d
andl $0x30, %r8d
shll $0x4, %r8d
orl %esi, %r8d
movzbl 0x7(%rbx,%r15), %esi
movl %r12d, %r13d
andl $0xc, %r13d
shll $0x6, %r13d
orl %esi, %r13d
movzbl 0x6(%rbx,%r15), %esi
andl $0x3, %r12d
shll $0x8, %r12d
orl %esi, %r12d
vmovq (%r10,%rax,8), %xmm14
vmovq (%r10,%r8,8), %xmm15
vmovq (%r10,%r13,8), %xmm16
vmovq (%r10,%r12,8), %xmm17
vpunpcklqdq %xmm14, %xmm15, %xmm14 # xmm14 = xmm15[0],xmm14[0]
vpunpcklqdq %xmm16, %xmm17, %xmm15 # xmm15 = xmm17[0],xmm16[0]
vinserti128 $0x1, %xmm14, %ymm15, %ymm14
vmovd 0x22(%rbx,%r15), %xmm15
vpermq $0x44, %ymm15, %ymm15 # ymm15 = ymm15[0,1,0,1]
vpshufb %ymm3, %ymm15, %ymm15
vptestnmb %ymm4, %ymm15, %k1
vpsubb %ymm12, %ymm0, %ymm15
vmovdqu8 %ymm12, %ymm15 {%k1}
vmovd 0x26(%rbx,%r15), %xmm12
vpmaddubsw %ymm15, %ymm13, %ymm13
vpermq $0x44, %ymm12, %ymm12 # ymm12 = ymm12[0,1,0,1]
vpshufb %ymm3, %ymm12, %ymm12
vptestnmb %ymm4, %ymm12, %k1
vpsubb %ymm11, %ymm0, %ymm12
vmovdqu8 %ymm11, %ymm12 {%k1}
vpmaddubsw %ymm12, %ymm14, %ymm11
vpshufb (%r11,%r15,8), %ymm8, %ymm12
vpmaddwd %ymm12, %ymm13, %ymm12
vpshufb 0x20(%r11,%r15,8), %ymm8, %ymm13
vpaddd %ymm9, %ymm12, %ymm9
vpmaddwd %ymm13, %ymm11, %ymm11
vpaddd %ymm10, %ymm11, %ymm10
addq $0x2, %r14
addq $0x8, %r15
cmpq $0x6, %r14
jb 0x3454b
vmulss %xmm7, %xmm6, %xmm6
vbroadcastss %xmm6, %ymm7
vpaddd %ymm10, %ymm9, %ymm6
vcvtdq2ps %ymm6, %ymm6
vfmadd213ps %ymm5, %ymm7, %ymm6 # ymm6 = (ymm7 * ymm6) + ymm5
incq %rdi
addq $0x52, %rbx
addq $0x124, %rdx # imm = 0x124
vmovaps %ymm6, %ymm5
cmpq %r9, %rdi
jne 0x344e6
jmp 0x346fc
vxorps %xmm6, %xmm6, %xmm6
vextractf128 $0x1, %ymm6, %xmm0
vaddps %xmm6, %xmm0, %xmm0
vshufpd $0x1, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[1,0]
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
vmulss 0x5c25(%rip), %xmm0, %xmm0 # 0x3a340
movq 0x10(%rsp), %rax
vmovss %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0xef03(%rip), %rdi # 0x43640
leaq 0xe8ac(%rip), %rsi # 0x42ff0
leaq 0xf1ea(%rip), %rcx # 0x43935
movl $0x208d, %edx # imm = 0x208D
callq 0x83b0
leaq 0x24da(%rip), %rdi # 0x36c36
leaq 0xe88d(%rip), %rsi # 0x42ff0
leaq 0xf1cb(%rip), %rcx # 0x43935
movl $0x208e, %edx # imm = 0x208E
callq 0x83b0
| ggml_vec_dot_iq2_s_q8_K:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], r9
test dil, dil
jnz loc_34736
cmp [rsp+48h+arg_8], 1
jnz loc_34755
mov [rsp+48h+var_38], rsi
sar edi, 8
test edi, edi
jle loc_346F8
mov r9d, edi
mov rax, [rsp+48h+var_40]
lea rdx, [rax+4]
vpxor xmm0, xmm0, xmm0
xor edi, edi
vpbroadcastb xmm1, cs:byte_3A5F2
vpbroadcastb xmm2, cs:byte_3A5F3
lea r10, iq2s_grid
vmovdqa ymm3, cs:ymmword_3A360
vpbroadcastq ymm4, cs:qword_3A5A0
lea r11, get_scale_shuffle_k4_k_shuffle
mov rbx, rcx
vxorps xmm5, xmm5, xmm5
loc_344E6:
imul r14, rdi, 52h ; 'R'
movzx r15d, word ptr [rcx+r14]
mov rax, cs:ggml_table_f32_f16_ptr
vmovss xmm6, dword ptr [rax+r15*4]
imul r15, rdi, 124h
mov rax, [rsp+48h+var_40]
vmovss xmm7, dword ptr [rax+r15]
mov r14, [rcx+r14+4Ah]
vmovq xmm8, r14
shr r14, 4
vmovq xmm9, r14
vpunpcklqdq xmm8, xmm8, xmm9
vpaddw xmm8, xmm8, xmm8
vpternlogq xmm8, xmm2, xmm1, 0ECh
vpmovzxbw ymm8, xmm8
mov r14, 0FFFFFFFFFFFFFFFEh
xor r15d, r15d
vpxor xmm9, xmm9, xmm9
vpxor xmm10, xmm10, xmm10
loc_3454B:
vmovdqu ymm12, ymmword ptr [rdx+r15*8]
vmovdqu ymm11, ymmword ptr [rdx+r15*8+20h]
movzx esi, byte ptr [rbx+r14+44h]
lea r13d, ds:0[rsi*4]
mov r13b, [rbx+r15+5]
mov bpl, [rbx+r15+9]
movzx r8d, byte ptr [rbx+r15+4]
mov eax, esi
and eax, 30h
shl eax, 4
or eax, r8d
movzx r8d, byte ptr [rbx+r15+3]
mov r12d, esi
and r12d, 0Ch
shl r12d, 6
or r12d, r8d
movzx r8d, byte ptr [rbx+r15+2]
and esi, 3
shl esi, 8
vmovq xmm13, qword ptr [r10+r13*8]
vmovq xmm14, qword ptr [r10+rax*8]
or esi, r8d
vpunpcklqdq xmm13, xmm14, xmm13
vmovq xmm14, qword ptr [r10+r12*8]
vmovq xmm15, qword ptr [r10+rsi*8]
vpunpcklqdq xmm14, xmm15, xmm14
vinserti128 ymm13, ymm14, xmm13, 1
movzx r12d, byte ptr [rbx+r14+45h]
lea eax, ds:0[r12*4]
mov al, bpl
movzx esi, byte ptr [rbx+r15+8]
mov r8d, r12d
and r8d, 30h
shl r8d, 4
or r8d, esi
movzx esi, byte ptr [rbx+r15+7]
mov r13d, r12d
and r13d, 0Ch
shl r13d, 6
or r13d, esi
movzx esi, byte ptr [rbx+r15+6]
and r12d, 3
shl r12d, 8
or r12d, esi
vmovq xmm14, qword ptr [r10+rax*8]
vmovq xmm15, qword ptr [r10+r8*8]
vmovq xmm16, qword ptr [r10+r13*8]
vmovq xmm17, qword ptr [r10+r12*8]
vpunpcklqdq xmm14, xmm15, xmm14
vpunpcklqdq xmm15, xmm17, xmm16
vinserti128 ymm14, ymm15, xmm14, 1
vmovd xmm15, dword ptr [rbx+r15+22h]
vpermq ymm15, ymm15, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm12
vmovdqu8 ymm15{k1}, ymm12
vmovd xmm12, dword ptr [rbx+r15+26h]
vpmaddubsw ymm13, ymm13, ymm15
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpsubb ymm12, ymm0, ymm11
vmovdqu8 ymm12{k1}, ymm11
vpmaddubsw ymm11, ymm14, ymm12
vpshufb ymm12, ymm8, ymmword ptr [r11+r15*8]
vpmaddwd ymm12, ymm13, ymm12
vpshufb ymm13, ymm8, ymmword ptr [r11+r15*8+20h]
vpaddd ymm9, ymm12, ymm9
vpmaddwd ymm11, ymm11, ymm13
vpaddd ymm10, ymm11, ymm10
add r14, 2
add r15, 8
cmp r14, 6
jb loc_3454B
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm9, ymm10
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
inc rdi
add rbx, 52h ; 'R'
add rdx, 124h
vmovaps ymm5, ymm6
cmp rdi, r9
jnz loc_344E6
jmp short loc_346FC
loc_346F8:
vxorps xmm6, xmm6, xmm6
loc_346FC:
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmulss xmm0, xmm0, cs:dword_3A340
mov rax, [rsp+48h+var_38]
vmovss dword ptr [rax], xmm0
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
loc_34736:
lea rdi, aNQkK0; "n % QK_K == 0"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_16; "void ggml_vec_dot_iq2_s_q8_K(int, float"...
mov edx, 208Dh
call ___assert_fail
loc_34755:
lea rdi, aNrc1; "nrc == 1"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGgmlVecDot_16; "void ggml_vec_dot_iq2_s_q8_K(int, float"...
mov edx, 208Eh
call ___assert_fail
| long long ggml_vec_dot_iq2_s_q8_K(
int a1,
long long a2,
__m128 _XMM0,
double a4,
double a5,
double a6,
double a7,
__m128 _XMM5,
__m128 _XMM6,
long long a10,
long long a11,
long long a12,
long long a13,
int a14,
int a15)
{
int v20; // edi
long long v21; // r9
long long v24; // rdi
unsigned long long v45; // r14
int v50; // esi
long long result; // rax
if ( (_BYTE)a1 )
__assert_fail(
"n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
8333LL,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
if ( a15 != 1 )
__assert_fail(
"nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c",
8334LL,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)");
v20 = a1 >> 8;
if ( v20 <= 0 )
{
__asm { vxorps xmm6, xmm6, xmm6 }
}
else
{
v21 = (unsigned int)v20;
_RDX = a13 + 4;
__asm { vpxor xmm0, xmm0, xmm0 }
v24 = 0LL;
__asm
{
vpbroadcastb xmm1, cs:byte_3A5F2
vpbroadcastb xmm2, cs:byte_3A5F3
}
_R10 = &iq2s_grid;
__asm
{
vmovdqa ymm3, cs:ymmword_3A360
vpbroadcastq ymm4, cs:qword_3A5A0
}
_RBX = a11;
__asm { vxorps xmm5, xmm5, xmm5 }
do
{
_R15 = *(unsigned __int16 *)(a11 + 82 * v24);
_RAX = &ggml_table_f32_f16;
__asm { vmovss xmm6, dword ptr [rax+r15*4] }
_R15 = 292 * v24;
_RAX = a13;
__asm { vmovss xmm7, dword ptr [rax+r15] }
_R14 = *(_QWORD *)(a11 + 82 * v24 + 74);
__asm { vmovq xmm8, r14 }
_R14 >>= 4;
__asm
{
vmovq xmm9, r14
vpunpcklqdq xmm8, xmm8, xmm9
vpaddw xmm8, xmm8, xmm8
vpternlogq xmm8, xmm2, xmm1, 0ECh
vpmovzxbw ymm8, xmm8
}
v45 = -2LL;
_R15 = 0LL;
__asm
{
vpxor xmm9, xmm9, xmm9
vpxor xmm10, xmm10, xmm10
}
do
{
__asm
{
vmovdqu ymm12, ymmword ptr [rdx+r15*8]
vmovdqu ymm11, ymmword ptr [rdx+r15*8+20h]
}
v50 = *(unsigned __int8 *)(_RBX + v45 + 68);
_R13 = (unsigned int)(4 * v50);
LOBYTE(_R13) = *(_BYTE *)(_RBX + _R15 + 5);
_RAX = *(unsigned __int8 *)(_RBX + _R15 + 4) | (16 * (*(_BYTE *)(_RBX + v45 + 68) & 0x30u));
_R12 = *(unsigned __int8 *)(_RBX + _R15 + 3) | ((unsigned __int8)(*(_BYTE *)(_RBX + v45 + 68) & 0xC) << 6);
__asm
{
vmovq xmm13, qword ptr [r10+r13*8]
vmovq xmm14, qword ptr [r10+rax*8]
}
_RSI = *(unsigned __int8 *)(_RBX + _R15 + 2) | ((unsigned __int8)(v50 & 3) << 8);
__asm
{
vpunpcklqdq xmm13, xmm14, xmm13
vmovq xmm14, qword ptr [r10+r12*8]
vmovq xmm15, qword ptr [r10+rsi*8]
vpunpcklqdq xmm14, xmm15, xmm14
vinserti128 ymm13, ymm14, xmm13, 1
}
LODWORD(_R12) = *(unsigned __int8 *)(_RBX + v45 + 69);
_RAX = (unsigned int)(4 * _R12);
LOBYTE(_RAX) = *(_BYTE *)(_RBX + _R15 + 9);
_R8 = *(unsigned __int8 *)(_RBX + _R15 + 8) | (16 * (*(_BYTE *)(_RBX + v45 + 69) & 0x30u));
_R13 = *(unsigned __int8 *)(_RBX + _R15 + 7) | ((unsigned __int8)(*(_BYTE *)(_RBX + v45 + 69) & 0xC) << 6);
_R12 = *(unsigned __int8 *)(_RBX + _R15 + 6) | ((unsigned __int8)(_R12 & 3) << 8);
__asm
{
vmovq xmm14, qword ptr [r10+rax*8]
vmovq xmm15, qword ptr [r10+r8*8]
vmovq xmm16, qword ptr [r10+r13*8]
vmovq xmm17, qword ptr [r10+r12*8]
vpunpcklqdq xmm14, xmm15, xmm14
vpunpcklqdq xmm15, xmm17, xmm16
vinserti128 ymm14, ymm15, xmm14, 1
vmovd xmm15, dword ptr [rbx+r15+22h]
vpermq ymm15, ymm15, 44h ; 'D'
vpshufb ymm15, ymm15, ymm3
vptestnmb k1, ymm15, ymm4
vpsubb ymm15, ymm0, ymm12
vmovdqu8 ymm15{k1}, ymm12
vmovd xmm12, dword ptr [rbx+r15+26h]
vpmaddubsw ymm13, ymm13, ymm15
vpermq ymm12, ymm12, 44h ; 'D'
vpshufb ymm12, ymm12, ymm3
vptestnmb k1, ymm12, ymm4
vpsubb ymm12, ymm0, ymm11
vmovdqu8 ymm12{k1}, ymm11
vpmaddubsw ymm11, ymm14, ymm12
vpshufb ymm12, ymm8, ymmword ptr [r11+r15*8]
vpmaddwd ymm12, ymm13, ymm12
vpshufb ymm13, ymm8, ymmword ptr [r11+r15*8+20h]
vpaddd ymm9, ymm12, ymm9
vpmaddwd ymm11, ymm11, ymm13
vpaddd ymm10, ymm11, ymm10
}
v45 += 2LL;
_R15 += 8LL;
}
while ( v45 < 6 );
__asm
{
vmulss xmm6, xmm6, xmm7
vbroadcastss ymm7, xmm6
vpaddd ymm6, ymm9, ymm10
vcvtdq2ps ymm6, ymm6
vfmadd213ps ymm6, ymm7, ymm5
}
++v24;
_RBX += 82LL;
_RDX += 292LL;
__asm { vmovaps ymm5, ymm6 }
}
while ( v24 != v21 );
}
__asm
{
vextractf128 xmm0, ymm6, 1
vaddps xmm0, xmm0, xmm6
vshufpd xmm1, xmm0, xmm0, 1
vaddps xmm0, xmm0, xmm1
vhaddps xmm0, xmm0, xmm0
vmulss xmm0, xmm0, cs:dword_3A340
}
result = a2;
__asm
{
vmovss dword ptr [rax], xmm0
vzeroupper
}
return result;
}
| ggml_vec_dot_iq2_s_q8_K:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],R9
TEST DIL,DIL
JNZ 0x00134736
CMP dword ptr [RSP + 0x58],0x1
JNZ 0x00134755
MOV qword ptr [RSP + 0x10],RSI
SAR EDI,0x8
TEST EDI,EDI
JLE 0x001346f8
MOV R9D,EDI
MOV RAX,qword ptr [RSP + 0x8]
LEA RDX,[RAX + 0x4]
VPXOR XMM0,XMM0,XMM0
XOR EDI,EDI
VPBROADCASTB XMM1,byte ptr [0x0013a5f2]
VPBROADCASTB XMM2,byte ptr [0x0013a5f3]
LEA R10,[0x13c200]
VMOVDQA YMM3,ymmword ptr [0x0013a360]
VPBROADCASTQ YMM4,qword ptr [0x0013a5a0]
LEA R11,[0x142e00]
MOV RBX,RCX
VXORPS XMM5,XMM5,XMM5
LAB_001344e6:
IMUL R14,RDI,0x52
MOVZX R15D,word ptr [RCX + R14*0x1]
MOV RAX,qword ptr [0x00148f68]
VMOVSS XMM6,dword ptr [RAX + R15*0x4]
IMUL R15,RDI,0x124
MOV RAX,qword ptr [RSP + 0x8]
VMOVSS XMM7,dword ptr [RAX + R15*0x1]
MOV R14,qword ptr [RCX + R14*0x1 + 0x4a]
VMOVQ XMM8,R14
SHR R14,0x4
VMOVQ XMM9,R14
VPUNPCKLQDQ XMM8,XMM8,XMM9
VPADDW XMM8,XMM8,XMM8
VPTERNLOGQ XMM8,XMM2,XMM1,0xec
VPMOVZXBW YMM8,XMM8
MOV R14,-0x2
XOR R15D,R15D
VPXOR XMM9,XMM9,XMM9
VPXOR XMM10,XMM10,XMM10
LAB_0013454b:
VMOVDQU YMM12,ymmword ptr [RDX + R15*0x8]
VMOVDQU YMM11,ymmword ptr [RDX + R15*0x8 + 0x20]
MOVZX ESI,byte ptr [RBX + R14*0x1 + 0x44]
LEA R13D,[RSI*0x4]
MOV R13B,byte ptr [RBX + R15*0x1 + 0x5]
MOV BPL,byte ptr [RBX + R15*0x1 + 0x9]
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x4]
MOV EAX,ESI
AND EAX,0x30
SHL EAX,0x4
OR EAX,R8D
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x3]
MOV R12D,ESI
AND R12D,0xc
SHL R12D,0x6
OR R12D,R8D
MOVZX R8D,byte ptr [RBX + R15*0x1 + 0x2]
AND ESI,0x3
SHL ESI,0x8
VMOVQ XMM13,qword ptr [R10 + R13*0x8]
VMOVQ XMM14,qword ptr [R10 + RAX*0x8]
OR ESI,R8D
VPUNPCKLQDQ XMM13,XMM14,XMM13
VMOVQ XMM14,qword ptr [R10 + R12*0x8]
VMOVQ XMM15,qword ptr [R10 + RSI*0x8]
VPUNPCKLQDQ XMM14,XMM15,XMM14
VINSERTI128 YMM13,YMM14,XMM13,0x1
MOVZX R12D,byte ptr [RBX + R14*0x1 + 0x45]
LEA EAX,[R12*0x4]
MOV AL,BPL
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x8]
MOV R8D,R12D
AND R8D,0x30
SHL R8D,0x4
OR R8D,ESI
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x7]
MOV R13D,R12D
AND R13D,0xc
SHL R13D,0x6
OR R13D,ESI
MOVZX ESI,byte ptr [RBX + R15*0x1 + 0x6]
AND R12D,0x3
SHL R12D,0x8
OR R12D,ESI
VMOVQ XMM14,qword ptr [R10 + RAX*0x8]
VMOVQ XMM15,qword ptr [R10 + R8*0x8]
VMOVQ XMM0,qword ptr [R10 + R13*0x8]
VMOVQ XMM1,qword ptr [R10 + R12*0x8]
VPUNPCKLQDQ XMM14,XMM15,XMM14
VPUNPCKLQDQ XMM15,XMM1,XMM0
VINSERTI128 YMM14,YMM15,XMM14,0x1
VMOVD XMM15,dword ptr [RBX + R15*0x1 + 0x22]
VPERMQ YMM15,YMM15,0x44
VPSHUFB YMM15,YMM15,YMM3
VPTESTNMB K1 {K0},YMM15,YMM4
VPSUBB YMM15,YMM0,YMM12
VMOVDQU8 YMM15{K1},YMM12
VMOVD XMM12,dword ptr [RBX + R15*0x1 + 0x26]
VPMADDUBSW YMM13,YMM13,YMM15
VPERMQ YMM12,YMM12,0x44
VPSHUFB YMM12,YMM12,YMM3
VPTESTNMB K1 {K0},YMM12,YMM4
VPSUBB YMM12,YMM0,YMM11
VMOVDQU8 YMM12{K1},YMM11
VPMADDUBSW YMM11,YMM14,YMM12
VPSHUFB YMM12,YMM8,ymmword ptr [R11 + R15*0x8]
VPMADDWD YMM12,YMM13,YMM12
VPSHUFB YMM13,YMM8,ymmword ptr [R11 + R15*0x8 + 0x20]
VPADDD YMM9,YMM12,YMM9
VPMADDWD YMM11,YMM11,YMM13
VPADDD YMM10,YMM11,YMM10
ADD R14,0x2
ADD R15,0x8
CMP R14,0x6
JC 0x0013454b
VMULSS XMM6,XMM6,XMM7
VBROADCASTSS YMM7,XMM6
VPADDD YMM6,YMM9,YMM10
VCVTDQ2PS YMM6,YMM6
VFMADD213PS YMM6,YMM7,YMM5
INC RDI
ADD RBX,0x52
ADD RDX,0x124
VMOVAPS YMM5,YMM6
CMP RDI,R9
JNZ 0x001344e6
JMP 0x001346fc
LAB_001346f8:
VXORPS XMM6,XMM6,XMM6
LAB_001346fc:
VEXTRACTF128 XMM0,YMM6,0x1
VADDPS XMM0,XMM0,XMM6
VSHUFPD XMM1,XMM0,XMM0,0x1
VADDPS XMM0,XMM0,XMM1
VHADDPS XMM0,XMM0,XMM0
VMULSS XMM0,XMM0,dword ptr [0x0013a340]
MOV RAX,qword ptr [RSP + 0x10]
VMOVSS dword ptr [RAX],XMM0
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
LAB_00134736:
LEA RDI,[0x143640]
LEA RSI,[0x142ff0]
LEA RCX,[0x143935]
MOV EDX,0x208d
CALL 0x001083b0
LAB_00134755:
LEA RDI,[0x136c36]
LEA RSI,[0x142ff0]
LEA RCX,[0x143935]
MOV EDX,0x208e
CALL 0x001083b0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void ggml_vec_dot_iq2_s_q8_K
(int param_1,float *param_2,int8 param_3,long param_4,int8 param_5,
long param_6,int8 param_7,int param_8)
{
ulong uVar1;
byte bVar2;
bool bVar3;
float fVar4;
int1 auVar5 [32];
long lVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
long lVar10;
uint in_K0;
ulong uVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar15 [32];
int1 auVar17 [32];
int1 auVar18 [16];
int1 auVar19 [16];
int1 auVar20 [16];
int1 auVar21 [16];
int1 auVar22 [64];
int1 auVar23 [16];
int1 auVar24 [32];
int1 auVar25 [16];
int1 auVar26 [32];
int1 auVar27 [64];
int1 auVar28 [64];
int1 auVar29 [16];
int1 auVar30 [32];
int1 auVar31 [16];
int1 auVar32 [16];
int1 auVar33 [16];
int1 auVar34 [32];
int1 auVar35 [16];
int1 auVar36 [16];
int1 auVar14 [32];
int1 auVar16 [32];
if ((char)param_1 != '\0') {
/* WARNING: Subroutine does not return */
__assert_fail("n % QK_K == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x208d,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
if (param_8 == 1) {
if (param_1 >> 8 < 1) {
auVar25 = ZEXT816(0) << 0x40;
}
else {
lVar6 = param_6 + 4;
uVar8 = 0;
auVar22 = ZEXT1664(CONCAT115(DAT_0013a5f2,
CONCAT114(DAT_0013a5f2,
CONCAT113(DAT_0013a5f2,
CONCAT112(DAT_0013a5f2,
CONCAT111(DAT_0013a5f2,
CONCAT110(DAT_0013a5f2,
CONCAT19(
DAT_0013a5f2,
CONCAT18(DAT_0013a5f2,
CONCAT17(DAT_0013a5f2,
CONCAT16(DAT_0013a5f2,
CONCAT15(DAT_0013a5f2,
CONCAT14(
DAT_0013a5f2,
CONCAT13(DAT_0013a5f2,
CONCAT12(DAT_0013a5f2,
CONCAT11(DAT_0013a5f2,
DAT_0013a5f2)))))))))))
)))));
auVar23[1] = DAT_0013a5f3;
auVar23[0] = DAT_0013a5f3;
auVar23[2] = DAT_0013a5f3;
auVar23[3] = DAT_0013a5f3;
auVar23[4] = DAT_0013a5f3;
auVar23[5] = DAT_0013a5f3;
auVar23[6] = DAT_0013a5f3;
auVar23[7] = DAT_0013a5f3;
auVar23[8] = DAT_0013a5f3;
auVar23[9] = DAT_0013a5f3;
auVar23[10] = DAT_0013a5f3;
auVar23[0xb] = DAT_0013a5f3;
auVar23[0xc] = DAT_0013a5f3;
auVar23[0xd] = DAT_0013a5f3;
auVar23[0xe] = DAT_0013a5f3;
auVar23[0xf] = DAT_0013a5f3;
auVar24._8_8_ = DAT_0013a5a0;
auVar24._0_8_ = DAT_0013a5a0;
auVar24._16_8_ = DAT_0013a5a0;
auVar24._24_8_ = DAT_0013a5a0;
auVar25 = ZEXT816(0) << 0x40;
lVar7 = param_4;
do {
uVar9 = *(ulong *)(param_4 + 0x4a + uVar8 * 0x52);
auVar12._8_8_ = 0;
auVar12._0_8_ = uVar9;
auVar13._8_8_ = 0;
auVar13._0_8_ = uVar9 >> 4;
auVar12 = vpunpcklqdq_avx(auVar12,auVar13);
auVar12 = vpaddw_avx(auVar12,auVar12);
auVar12 = vpternlogq_avx512vl(auVar12,auVar23,auVar22._0_16_,0xec);
auVar5 = vpmovzxbw_avx2(auVar12);
uVar9 = 0xfffffffffffffffe;
lVar10 = 0;
auVar27 = ZEXT1664((int1 [16])0x0);
auVar28 = ZEXT1664((int1 [16])0x0);
do {
auVar14 = *(int1 (*) [32])(lVar6 + lVar10 * 8);
auVar16 = *(int1 (*) [32])(lVar6 + 0x20 + lVar10 * 8);
bVar2 = *(byte *)(lVar7 + 0x44 + uVar9);
auVar29._8_8_ = 0;
auVar29._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)CONCAT31((int3)((uint)bVar2 * 4 >> 8),
*(int1 *)(lVar7 + 5 + lVar10)) * 8);
auVar31._8_8_ = 0;
auVar31._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0x30) << 4 | (uint)*(byte *)(lVar7 + 4 + lVar10)) * 8);
auVar12 = vpunpcklqdq_avx(auVar31,auVar29);
auVar32._8_8_ = 0;
auVar32._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0xc) << 6 | (uint)*(byte *)(lVar7 + 3 + lVar10)) * 8);
auVar35._8_8_ = 0;
auVar35._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 2 + lVar10)) * 8);
auVar13 = vpunpcklqdq_avx(auVar35,auVar32);
auVar30._0_16_ = ZEXT116(0) * auVar12 + ZEXT116(1) * auVar13;
auVar30._16_16_ = ZEXT116(1) * auVar12;
bVar2 = *(byte *)(lVar7 + 0x45 + uVar9);
uVar1 = *(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0xc) << 6 | (uint)*(byte *)(lVar7 + 7 + lVar10)) * 8);
auVar22 = ZEXT864(*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 6 + lVar10)
) * 8));
auVar33._8_8_ = 0;
auVar33._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)CONCAT31((int3)((uint)bVar2 * 4 >> 8),
*(int1 *)(lVar7 + 9 + lVar10)) * 8);
auVar36._8_8_ = 0;
auVar36._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 0x30) << 4 | (uint)*(byte *)(lVar7 + 8 + lVar10)) * 8);
auVar12 = vpunpcklqdq_avx(auVar36,auVar33);
auVar18._8_8_ = 0;
auVar18._0_8_ = uVar1;
auVar21._8_8_ = 0;
auVar21._0_8_ =
*(ulong *)(iq2s_grid +
(ulong)((bVar2 & 3) << 8 | (uint)*(byte *)(lVar7 + 6 + lVar10)) * 8);
auVar13 = vpunpcklqdq_avx512vl(auVar21,auVar18);
auVar34._0_16_ = ZEXT116(0) * auVar12 + ZEXT116(1) * auVar13;
auVar34._16_16_ = ZEXT116(1) * auVar12;
auVar26 = vpermq_avx2(ZEXT432(*(uint *)(lVar7 + 0x22 + lVar10)),0x44);
auVar26 = vpshufb_avx2(auVar26,_DAT_0013a360);
uVar11 = vptestnmb_avx512vl(auVar26,auVar24);
uVar11 = in_K0 & uVar11;
auVar26 = vpsubb_avx2(ZEXT832(uVar1),auVar14);
auVar14 = vmovdqu8_avx512vl(auVar14);
bVar3 = (bool)((byte)uVar11 & 1);
auVar15[0] = bVar3 * auVar14[0] | !bVar3 * auVar26[0];
bVar3 = (bool)((byte)(uVar11 >> 1) & 1);
auVar15[1] = bVar3 * auVar14[1] | !bVar3 * auVar26[1];
bVar3 = (bool)((byte)(uVar11 >> 2) & 1);
auVar15[2] = bVar3 * auVar14[2] | !bVar3 * auVar26[2];
bVar3 = (bool)((byte)(uVar11 >> 3) & 1);
auVar15[3] = bVar3 * auVar14[3] | !bVar3 * auVar26[3];
bVar3 = (bool)((byte)(uVar11 >> 4) & 1);
auVar15[4] = bVar3 * auVar14[4] | !bVar3 * auVar26[4];
bVar3 = (bool)((byte)(uVar11 >> 5) & 1);
auVar15[5] = bVar3 * auVar14[5] | !bVar3 * auVar26[5];
bVar3 = (bool)((byte)(uVar11 >> 6) & 1);
auVar15[6] = bVar3 * auVar14[6] | !bVar3 * auVar26[6];
bVar3 = (bool)((byte)(uVar11 >> 7) & 1);
auVar15[7] = bVar3 * auVar14[7] | !bVar3 * auVar26[7];
bVar3 = (bool)((byte)(uVar11 >> 8) & 1);
auVar15[8] = bVar3 * auVar14[8] | !bVar3 * auVar26[8];
bVar3 = (bool)((byte)(uVar11 >> 9) & 1);
auVar15[9] = bVar3 * auVar14[9] | !bVar3 * auVar26[9];
bVar3 = (bool)((byte)(uVar11 >> 10) & 1);
auVar15[10] = bVar3 * auVar14[10] | !bVar3 * auVar26[10];
bVar3 = (bool)((byte)(uVar11 >> 0xb) & 1);
auVar15[0xb] = bVar3 * auVar14[0xb] | !bVar3 * auVar26[0xb];
bVar3 = (bool)((byte)(uVar11 >> 0xc) & 1);
auVar15[0xc] = bVar3 * auVar14[0xc] | !bVar3 * auVar26[0xc];
bVar3 = (bool)((byte)(uVar11 >> 0xd) & 1);
auVar15[0xd] = bVar3 * auVar14[0xd] | !bVar3 * auVar26[0xd];
bVar3 = (bool)((byte)(uVar11 >> 0xe) & 1);
auVar15[0xe] = bVar3 * auVar14[0xe] | !bVar3 * auVar26[0xe];
bVar3 = (bool)((byte)(uVar11 >> 0xf) & 1);
auVar15[0xf] = bVar3 * auVar14[0xf] | !bVar3 * auVar26[0xf];
bVar3 = (bool)((byte)(uVar11 >> 0x10) & 1);
auVar15[0x10] = bVar3 * auVar14[0x10] | !bVar3 * auVar26[0x10];
bVar3 = (bool)((byte)(uVar11 >> 0x11) & 1);
auVar15[0x11] = bVar3 * auVar14[0x11] | !bVar3 * auVar26[0x11];
bVar3 = (bool)((byte)(uVar11 >> 0x12) & 1);
auVar15[0x12] = bVar3 * auVar14[0x12] | !bVar3 * auVar26[0x12];
bVar3 = (bool)((byte)(uVar11 >> 0x13) & 1);
auVar15[0x13] = bVar3 * auVar14[0x13] | !bVar3 * auVar26[0x13];
bVar3 = (bool)((byte)(uVar11 >> 0x14) & 1);
auVar15[0x14] = bVar3 * auVar14[0x14] | !bVar3 * auVar26[0x14];
bVar3 = (bool)((byte)(uVar11 >> 0x15) & 1);
auVar15[0x15] = bVar3 * auVar14[0x15] | !bVar3 * auVar26[0x15];
bVar3 = (bool)((byte)(uVar11 >> 0x16) & 1);
auVar15[0x16] = bVar3 * auVar14[0x16] | !bVar3 * auVar26[0x16];
bVar3 = (bool)((byte)(uVar11 >> 0x17) & 1);
auVar15[0x17] = bVar3 * auVar14[0x17] | !bVar3 * auVar26[0x17];
bVar3 = (bool)((byte)(uVar11 >> 0x18) & 1);
auVar15[0x18] = bVar3 * auVar14[0x18] | !bVar3 * auVar26[0x18];
bVar3 = (bool)((byte)(uVar11 >> 0x19) & 1);
auVar15[0x19] = bVar3 * auVar14[0x19] | !bVar3 * auVar26[0x19];
bVar3 = (bool)((byte)(uVar11 >> 0x1a) & 1);
auVar15[0x1a] = bVar3 * auVar14[0x1a] | !bVar3 * auVar26[0x1a];
bVar3 = (bool)((byte)(uVar11 >> 0x1b) & 1);
auVar15[0x1b] = bVar3 * auVar14[0x1b] | !bVar3 * auVar26[0x1b];
bVar3 = (bool)((byte)(uVar11 >> 0x1c) & 1);
auVar15[0x1c] = bVar3 * auVar14[0x1c] | !bVar3 * auVar26[0x1c];
bVar3 = (bool)((byte)(uVar11 >> 0x1d) & 1);
auVar15._30_2_ = auVar14._30_2_;
auVar15[0x1d] = bVar3 * auVar14[0x1d] | !bVar3 * auVar26[0x1d];
auVar14 = vpmaddubsw_avx2(auVar30,auVar15);
auVar26 = vpermq_avx2(ZEXT432(*(uint *)(lVar7 + 0x26 + lVar10)),0x44);
auVar26 = vpshufb_avx2(auVar26,_DAT_0013a360);
uVar11 = vptestnmb_avx512vl(auVar26,auVar24);
uVar11 = in_K0 & uVar11;
auVar26 = vpsubb_avx2(ZEXT832(uVar1),auVar16);
auVar16 = vmovdqu8_avx512vl(auVar16);
bVar3 = (bool)((byte)uVar11 & 1);
auVar17[0] = bVar3 * auVar16[0] | !bVar3 * auVar26[0];
bVar3 = (bool)((byte)(uVar11 >> 1) & 1);
auVar17[1] = bVar3 * auVar16[1] | !bVar3 * auVar26[1];
bVar3 = (bool)((byte)(uVar11 >> 2) & 1);
auVar17[2] = bVar3 * auVar16[2] | !bVar3 * auVar26[2];
bVar3 = (bool)((byte)(uVar11 >> 3) & 1);
auVar17[3] = bVar3 * auVar16[3] | !bVar3 * auVar26[3];
bVar3 = (bool)((byte)(uVar11 >> 4) & 1);
auVar17[4] = bVar3 * auVar16[4] | !bVar3 * auVar26[4];
bVar3 = (bool)((byte)(uVar11 >> 5) & 1);
auVar17[5] = bVar3 * auVar16[5] | !bVar3 * auVar26[5];
bVar3 = (bool)((byte)(uVar11 >> 6) & 1);
auVar17[6] = bVar3 * auVar16[6] | !bVar3 * auVar26[6];
bVar3 = (bool)((byte)(uVar11 >> 7) & 1);
auVar17[7] = bVar3 * auVar16[7] | !bVar3 * auVar26[7];
bVar3 = (bool)((byte)(uVar11 >> 8) & 1);
auVar17[8] = bVar3 * auVar16[8] | !bVar3 * auVar26[8];
bVar3 = (bool)((byte)(uVar11 >> 9) & 1);
auVar17[9] = bVar3 * auVar16[9] | !bVar3 * auVar26[9];
bVar3 = (bool)((byte)(uVar11 >> 10) & 1);
auVar17[10] = bVar3 * auVar16[10] | !bVar3 * auVar26[10];
bVar3 = (bool)((byte)(uVar11 >> 0xb) & 1);
auVar17[0xb] = bVar3 * auVar16[0xb] | !bVar3 * auVar26[0xb];
bVar3 = (bool)((byte)(uVar11 >> 0xc) & 1);
auVar17[0xc] = bVar3 * auVar16[0xc] | !bVar3 * auVar26[0xc];
bVar3 = (bool)((byte)(uVar11 >> 0xd) & 1);
auVar17[0xd] = bVar3 * auVar16[0xd] | !bVar3 * auVar26[0xd];
bVar3 = (bool)((byte)(uVar11 >> 0xe) & 1);
auVar17[0xe] = bVar3 * auVar16[0xe] | !bVar3 * auVar26[0xe];
bVar3 = (bool)((byte)(uVar11 >> 0xf) & 1);
auVar17[0xf] = bVar3 * auVar16[0xf] | !bVar3 * auVar26[0xf];
bVar3 = (bool)((byte)(uVar11 >> 0x10) & 1);
auVar17[0x10] = bVar3 * auVar16[0x10] | !bVar3 * auVar26[0x10];
bVar3 = (bool)((byte)(uVar11 >> 0x11) & 1);
auVar17[0x11] = bVar3 * auVar16[0x11] | !bVar3 * auVar26[0x11];
bVar3 = (bool)((byte)(uVar11 >> 0x12) & 1);
auVar17[0x12] = bVar3 * auVar16[0x12] | !bVar3 * auVar26[0x12];
bVar3 = (bool)((byte)(uVar11 >> 0x13) & 1);
auVar17[0x13] = bVar3 * auVar16[0x13] | !bVar3 * auVar26[0x13];
bVar3 = (bool)((byte)(uVar11 >> 0x14) & 1);
auVar17[0x14] = bVar3 * auVar16[0x14] | !bVar3 * auVar26[0x14];
bVar3 = (bool)((byte)(uVar11 >> 0x15) & 1);
auVar17[0x15] = bVar3 * auVar16[0x15] | !bVar3 * auVar26[0x15];
bVar3 = (bool)((byte)(uVar11 >> 0x16) & 1);
auVar17[0x16] = bVar3 * auVar16[0x16] | !bVar3 * auVar26[0x16];
bVar3 = (bool)((byte)(uVar11 >> 0x17) & 1);
auVar17[0x17] = bVar3 * auVar16[0x17] | !bVar3 * auVar26[0x17];
bVar3 = (bool)((byte)(uVar11 >> 0x18) & 1);
auVar17[0x18] = bVar3 * auVar16[0x18] | !bVar3 * auVar26[0x18];
bVar3 = (bool)((byte)(uVar11 >> 0x19) & 1);
auVar17[0x19] = bVar3 * auVar16[0x19] | !bVar3 * auVar26[0x19];
bVar3 = (bool)((byte)(uVar11 >> 0x1a) & 1);
auVar17[0x1a] = bVar3 * auVar16[0x1a] | !bVar3 * auVar26[0x1a];
bVar3 = (bool)((byte)(uVar11 >> 0x1b) & 1);
auVar17[0x1b] = bVar3 * auVar16[0x1b] | !bVar3 * auVar26[0x1b];
bVar3 = (bool)((byte)(uVar11 >> 0x1c) & 1);
auVar17[0x1c] = bVar3 * auVar16[0x1c] | !bVar3 * auVar26[0x1c];
bVar3 = (bool)((byte)(uVar11 >> 0x1d) & 1);
auVar17._30_2_ = auVar16._30_2_;
auVar17[0x1d] = bVar3 * auVar16[0x1d] | !bVar3 * auVar26[0x1d];
auVar16 = vpmaddubsw_avx2(auVar34,auVar17);
auVar26 = vpshufb_avx2(auVar5,*(int1 (*) [32])
(get_scale_shuffle_k4_k_shuffle + lVar10 * 8));
auVar14 = vpmaddwd_avx2(auVar14,auVar26);
auVar26 = vpshufb_avx2(auVar5,*(int1 (*) [32])
(get_scale_shuffle_k4_k_shuffle + lVar10 * 8 + 0x20));
auVar14 = vpaddd_avx2(auVar14,auVar27._0_32_);
auVar27 = ZEXT3264(auVar14);
auVar16 = vpmaddwd_avx2(auVar16,auVar26);
auVar16 = vpaddd_avx2(auVar16,auVar28._0_32_);
auVar28 = ZEXT3264(auVar16);
uVar9 = uVar9 + 2;
lVar10 = lVar10 + 8;
} while (uVar9 < 6);
fVar4 = *(float *)(PTR_ggml_table_f32_f16_00148f68 +
(ulong)*(ushort *)(param_4 + uVar8 * 0x52) * 4) *
*(float *)(param_6 + uVar8 * 0x124);
auVar26._4_4_ = fVar4;
auVar26._0_4_ = fVar4;
auVar26._8_4_ = fVar4;
auVar26._12_4_ = fVar4;
auVar26._16_4_ = fVar4;
auVar26._20_4_ = fVar4;
auVar26._24_4_ = fVar4;
auVar26._28_4_ = fVar4;
auVar5 = vpaddd_avx2(auVar14,auVar16);
auVar5 = vcvtdq2ps_avx(auVar5);
auVar25 = vfmadd213ps_fma(auVar5,auVar26,ZEXT1632(auVar25));
uVar8 = uVar8 + 1;
lVar7 = lVar7 + 0x52;
lVar6 = lVar6 + 0x124;
} while (uVar8 != (uint)(param_1 >> 8));
}
auVar19._0_4_ = auVar25._0_4_ + 0.0;
auVar19._4_4_ = auVar25._4_4_ + 0.0;
auVar19._8_4_ = auVar25._8_4_ + 0.0;
auVar19._12_4_ = auVar25._12_4_ + 0.0;
auVar25 = vshufpd_avx(auVar19,auVar19,1);
auVar20._0_4_ = auVar19._0_4_ + auVar25._0_4_;
auVar20._4_4_ = auVar19._4_4_ + auVar25._4_4_;
auVar20._8_4_ = auVar19._8_4_ + auVar25._8_4_;
auVar20._12_4_ = auVar19._12_4_ + auVar25._12_4_;
auVar25 = vhaddps_avx(auVar20,auVar20);
*param_2 = auVar25._0_4_ * DAT_0013a340;
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("nrc == 1",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-quants.c"
,0x208e,
"void ggml_vec_dot_iq2_s_q8_K(int, float *restrict, size_t, const void *restrict, size_t, const void *restrict, size_t, int)"
);
}
|
|
1,685 | httplib::detail::SocketStream::read(char*, unsigned long) | hkr04[P]cpp-mcp/common/httplib.h | inline ssize_t SocketStream::read(char *ptr, size_t size) {
#ifdef _WIN32
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#else
size = (std::min)(size,
static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
#endif
if (read_buff_off_ < read_buff_content_size_) {
auto remaining_size = read_buff_content_size_ - read_buff_off_;
if (size <= remaining_size) {
memcpy(ptr, read_buff_.data() + read_buff_off_, size);
read_buff_off_ += size;
return static_cast<ssize_t>(size);
} else {
memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size);
read_buff_off_ += remaining_size;
return static_cast<ssize_t>(remaining_size);
}
}
if (!is_readable()) { return -1; }
read_buff_off_ = 0;
read_buff_content_size_ = 0;
if (size < read_buff_size_) {
auto n = read_socket(sock_, read_buff_.data(), read_buff_size_,
CPPHTTPLIB_RECV_FLAGS);
if (n <= 0) {
return n;
} else if (n <= static_cast<ssize_t>(size)) {
memcpy(ptr, read_buff_.data(), static_cast<size_t>(n));
return n;
} else {
memcpy(ptr, read_buff_.data(), size);
read_buff_off_ = size;
read_buff_content_size_ = static_cast<size_t>(n);
return static_cast<ssize_t>(size);
}
} else {
return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS);
}
} | O2 | c | httplib::detail::SocketStream::read(char*, unsigned long):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %r15, %rdx
cmovbq %rdx, %r15
movq %rdi, %rbx
movq 0x58(%rdi), %rsi
movq 0x60(%rdi), %r13
subq %rsi, %r13
jbe 0x194e7
addq 0x40(%rbx), %rsi
cmpq %r13, %r15
cmovbq %r15, %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0xa5a0
addq %r13, 0x58(%rbx)
jmp 0x19549
movq %rdx, %r12
movq %rbx, %rdi
callq 0x19408
testb %al, %al
je 0x19545
leaq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl 0x8(%rbx), %edi
cmpq $0xfff, %r12 # imm = 0xFFF
ja 0x19556
movq 0x40(%rbx), %rsi
movl $0x1000, %edx # imm = 0x1000
xorl %ecx, %ecx
callq 0x26d52
movq %rax, %r13
testq %rax, %rax
jle 0x19549
movq 0x40(%rbx), %rsi
movq %r14, %rdi
cmpq %r12, %r13
jbe 0x1956c
movq %r15, %rdx
callq 0xa5a0
movq %r15, 0x58(%rbx)
movq %r13, 0x60(%rbx)
movq %r12, %r13
jmp 0x19549
pushq $-0x1
popq %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26d52
movq %r13, %rdx
callq 0xa5a0
jmp 0x19549
| _ZN7httplib6detail12SocketStream4readEPcm:
push r15
push r14
push r13
push r12
push rbx
mov r14, rsi
mov r15, 7FFFFFFFFFFFFFFFh
cmp rdx, r15
cmovb r15, rdx
mov rbx, rdi
mov rsi, [rdi+58h]
mov r13, [rdi+60h]
sub r13, rsi
jbe short loc_194E7
add rsi, [rbx+40h]
cmp r15, r13
cmovb r13, r15
mov rdi, r14
mov rdx, r13
call _memcpy
add [rbx+58h], r13
jmp short loc_19549
loc_194E7:
mov r12, rdx
mov rdi, rbx; this
call _ZNK7httplib6detail12SocketStream11is_readableEv; httplib::detail::SocketStream::is_readable(void)
test al, al
jz short loc_19545
lea rax, [rbx+58h]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov edi, [rbx+8]; this
cmp r12, 0FFFh
ja short loc_19556
mov rsi, [rbx+40h]; int
mov edx, offset stru_FF8.st_value; void *
xor ecx, ecx; unsigned __int64
call _ZN7httplib6detail11read_socketEiPvmi; httplib::detail::read_socket(int,void *,ulong,int)
mov r13, rax
test rax, rax
jle short loc_19549
mov rsi, [rbx+40h]
mov rdi, r14
cmp r13, r12
jbe short loc_1956C
mov rdx, r15
call _memcpy
mov [rbx+58h], r15
mov [rbx+60h], r13
mov r13, r12
jmp short loc_19549
loc_19545:
push 0FFFFFFFFFFFFFFFFh
pop r13
loc_19549:
mov rax, r13
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_19556:
mov rsi, r14; int
mov rdx, r15; void *
xor ecx, ecx; unsigned __int64
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp _ZN7httplib6detail11read_socketEiPvmi; httplib::detail::read_socket(int,void *,ulong,int)
loc_1956C:
mov rdx, r13
call _memcpy
jmp short loc_19549
| unsigned long long httplib::detail::SocketStream::read(
httplib::detail::SocketStream *this,
char *a2,
unsigned long long a3)
{
unsigned long long v4; // r15
unsigned long long v6; // rsi
unsigned long long v7; // r13
bool v8; // cc
unsigned long long v9; // r13
unsigned long long v10; // rsi
int v12; // r8d
httplib::detail *v13; // rdi
long long socket; // rax
long long v15; // rsi
v4 = 0x7FFFFFFFFFFFFFFFLL;
if ( a3 < 0x7FFFFFFFFFFFFFFFLL )
v4 = a3;
v6 = *((_QWORD *)this + 11);
v7 = *((_QWORD *)this + 12);
v8 = v7 <= v6;
v9 = v7 - v6;
if ( !v8 )
{
v10 = *((_QWORD *)this + 8) + v6;
if ( v4 < v9 )
v9 = v4;
memcpy(a2, v10, v9);
*((_QWORD *)this + 11) += v9;
return v9;
}
if ( !httplib::detail::SocketStream::is_readable(this) )
return -1LL;
*(_OWORD *)((char *)this + 88) = 0LL;
v13 = (httplib::detail *)*((unsigned int *)this + 2);
if ( a3 <= 0xFFF )
{
socket = httplib::detail::read_socket(v13, *((_QWORD *)this + 8), &stru_FF8.st_value, 0LL, v12);
v9 = socket;
if ( socket > 0 )
{
v15 = *((_QWORD *)this + 8);
if ( socket <= a3 )
{
memcpy(a2, v15, socket);
}
else
{
memcpy(a2, v15, v4);
*((_QWORD *)this + 11) = v4;
*((_QWORD *)this + 12) = v9;
return a3;
}
}
return v9;
}
return httplib::detail::read_socket(v13, (int)a2, (void *)v4, 0LL, v12);
}
| read:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RSI
MOV R15,0x7fffffffffffffff
CMP RDX,R15
CMOVC R15,RDX
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x58]
MOV R13,qword ptr [RDI + 0x60]
SUB R13,RSI
JBE 0x001194e7
ADD RSI,qword ptr [RBX + 0x40]
CMP R15,R13
CMOVC R13,R15
MOV RDI,R14
MOV RDX,R13
CALL 0x0010a5a0
ADD qword ptr [RBX + 0x58],R13
JMP 0x00119549
LAB_001194e7:
MOV R12,RDX
MOV RDI,RBX
CALL 0x00119408
TEST AL,AL
JZ 0x00119545
LEA RAX,[RBX + 0x58]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV EDI,dword ptr [RBX + 0x8]
CMP R12,0xfff
JA 0x00119556
MOV RSI,qword ptr [RBX + 0x40]
MOV EDX,0x1000
XOR ECX,ECX
CALL 0x00126d52
MOV R13,RAX
TEST RAX,RAX
JLE 0x00119549
MOV RSI,qword ptr [RBX + 0x40]
MOV RDI,R14
CMP R13,R12
JBE 0x0011956c
MOV RDX,R15
CALL 0x0010a5a0
MOV qword ptr [RBX + 0x58],R15
MOV qword ptr [RBX + 0x60],R13
MOV R13,R12
JMP 0x00119549
LAB_00119545:
PUSH -0x1
POP R13
LAB_00119549:
MOV RAX,R13
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00119556:
MOV RSI,R14
MOV RDX,R15
XOR ECX,ECX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00126d52
LAB_0011956c:
MOV RDX,R13
CALL 0x0010a5a0
JMP 0x00119549
|
/* httplib::detail::SocketStream::read(char*, unsigned long) */
ulong __thiscall httplib::detail::SocketStream::read(SocketStream *this,char *param_1,ulong param_2)
{
ulong uVar1;
char cVar2;
ulong uVar3;
ulong __n;
uVar3 = 0x7fffffffffffffff;
if (param_2 < 0x7fffffffffffffff) {
uVar3 = param_2;
}
uVar1 = *(ulong *)(this + 0x58);
__n = *(ulong *)(this + 0x60) - uVar1;
if (*(ulong *)(this + 0x60) < uVar1 || __n == 0) {
cVar2 = is_readable(this);
if (cVar2 == '\0') {
__n = 0xffffffffffffffff;
}
else {
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
if (0xfff < param_2) {
uVar3 = read_socket(*(int *)(this + 8),param_1,uVar3,0);
return uVar3;
}
__n = read_socket(*(int *)(this + 8),*(void **)(this + 0x40),0x1000,0);
if (0 < (long)__n) {
if (param_2 < __n) {
memcpy(param_1,*(void **)(this + 0x40),uVar3);
*(ulong *)(this + 0x58) = uVar3;
*(ulong *)(this + 0x60) = __n;
__n = param_2;
}
else {
memcpy(param_1,*(void **)(this + 0x40),__n);
}
}
}
}
else {
if (uVar3 < __n) {
__n = uVar3;
}
memcpy(param_1,(void *)(uVar1 + *(long *)(this + 0x40)),__n);
*(ulong *)(this + 0x58) = *(long *)(this + 0x58) + __n;
}
return __n;
}
|
|
1,686 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*) | monkey531[P]llama/common/./json.hpp | reference operator[](T* key)
{
return operator[](typename object_t::key_type(key));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x233f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fb22
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x690cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x690f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rdi
callq 0x18b90
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_:
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 _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[](std::string)
mov rbx, rax
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_690CD
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_690CD:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_690F6
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_690F6:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
long long a1,
long long a2)
{
long long v2; // rbx
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(v4, a2);
v2 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
a1,
v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
return v2;
}
| operator[]<char_const>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x001233f4
LAB_001690a4:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016fb22
LAB_001690af:
MOV RBX,RAX
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001690cd
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_001690cd:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[]<char const>(char const*) */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,char *param_1)
{
basic_json *pbVar1;
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 001690a4 to 001690ae has its CatchHandler @ 001690d8 */
pbVar1 = (basic_json *)operator[](this,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return pbVar1;
}
|
|
1,687 | bool nlohmann::json_abi_v3_11_3::operator==<unsigned long, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, unsigned long) | monkey531[P]llama/common/json.hpp | bool operator==(const_reference lhs, ScalarType rhs) noexcept
{
return lhs == basic_json(rhs);
} | O1 | cpp | bool nlohmann::json_abi_v3_11_3::operator==<unsigned long, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, unsigned long):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0x4c18e
movq %r14, %rdi
movl $0x1, %esi
callq 0x3da52
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4eb2f
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3da52
movq %r14, %rdi
callq 0x4a9be
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_unsigned_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov rsi, r14
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&)
mov ebx, eax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
retn
| long long ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
unsigned __int8 *a1,
long long a2)
{
unsigned int v2; // ebx
_OWORD v4[2]; // [rsp+0h] [rbp-28h] BYREF
v4[0] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)v4,
a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v4);
v2 = nlohmann::json_abi_v3_11_3::operator==(a1, (unsigned __int8 *)v4, (__m128d)0LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)v4);
return v2;
}
| _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
CALL 0x0014c18e
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013da52
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014eb2f
MOV EBX,EAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013da52
MOV RDI,R14
CALL 0x0014a9be
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
RET
|
int4
_ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(basic_json *param_1)
{
int4 uVar1;
int8 local_28;
int8 uStack_20;
local_28 = 0;
uStack_20 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
uVar1 = nlohmann::json_abi_v3_11_3::operator==(param_1,(basic_json *)&local_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_28);
return uVar1;
}
|
|
1,688 | maria_rnext | eloqsql/storage/maria/ma_rnext.c | int maria_rnext(MARIA_HA *info, uchar *buf, int inx)
{
int error,changed;
uint flag;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo;
check_result_t check= CHECK_POS;
uint update_mask= HA_STATE_NEXT_FOUND;
DBUG_ENTER("maria_rnext");
if ((inx = _ma_check_index(info,inx)) < 0)
DBUG_RETURN(my_errno);
flag=SEARCH_BIGGER; /* Read next */
if (info->cur_row.lastpos == HA_OFFSET_ERROR &&
info->update & HA_STATE_PREV_FOUND)
flag=0; /* Read first */
if (fast_ma_readinfo(info))
DBUG_RETURN(my_errno);
keyinfo= share->keyinfo + inx;
if (share->lock_key_trees)
mysql_rwlock_rdlock(&keyinfo->root_lock);
changed= _ma_test_if_changed(info);
if (!flag)
{
switch (keyinfo->key_alg){
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
error=maria_rtree_get_first(info, inx,
info->last_key.data_length +
info->last_key.ref_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
error= _ma_search_first(info, keyinfo, share->state.key_root[inx]);
break;
}
/*
"search first" failed. This means we have no pivot for
"search next", or in other words MI_INFO::lastkey is
likely uninitialized.
Normally SQL layer would never request "search next" if
"search first" failed. But HANDLER may do anything.
As mi_rnext() without preceding mi_rkey()/mi_rfirst()
equals to mi_rfirst(), we must restore original state
as if failing mi_rfirst() was not called.
*/
if (error)
update_mask|= HA_STATE_PREV_FOUND;
}
else
{
switch (keyinfo->key_alg) {
#ifdef HAVE_RTREE_KEYS
case HA_KEY_ALG_RTREE:
/*
Note that rtree doesn't support that the table
may be changed since last call, so we do need
to skip rows inserted by other threads like in btree
*/
error= maria_rtree_get_next(info, inx, info->last_key.data_length +
info->last_key.ref_length);
break;
#endif
case HA_KEY_ALG_BTREE:
default:
if (!changed)
error= _ma_search_next(info, &info->last_key,
flag | info->last_key.flag,
share->state.key_root[inx]);
else
error= _ma_search(info, &info->last_key, flag | info->last_key.flag,
share->state.key_root[inx]);
}
}
if (!error)
{
while (!(*share->row_is_visible)(info) ||
((check= ma_check_index_cond(info, inx, buf)) == CHECK_NEG))
{
/*
If we are at the last key on the key page, allow writers to
access the index.
*/
if (info->int_keypos >= info->int_maxpos &&
ma_yield_and_check_if_killed(info, inx))
{
/* my_errno is set by ma_yield_and_check_if_killed() */
error= 1;
break;
}
/* Skip rows inserted by other threads since we got a lock */
if ((error= _ma_search_next(info, &info->last_key,
SEARCH_BIGGER,
share->state.key_root[inx])))
break;
}
}
if (share->lock_key_trees)
mysql_rwlock_unlock(&keyinfo->root_lock);
/* Don't clear if database-changed */
info->update&= (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
info->update|= update_mask;
if (error || check != CHECK_POS)
{
fast_ma_writeinfo(info);
if (my_errno == HA_ERR_KEY_NOT_FOUND)
my_errno= HA_ERR_END_OF_FILE;
}
else if (!buf)
{
fast_ma_writeinfo(info);
DBUG_RETURN(info->cur_row.lastpos == HA_OFFSET_ERROR ? my_errno : 0);
}
else if (!(*info->read_record)(info, buf, info->cur_row.lastpos))
{
info->update|= HA_STATE_AKTIV; /* Record is read */
DBUG_RETURN(0);
}
DBUG_PRINT("error",("Got error: %d, errno: %d",error, my_errno));
DBUG_RETURN(my_errno);
} | O0 | c | maria_rnext:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x3c(%rbp)
movl $0x10, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x38190
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x37cc1
jmp 0x37cb2
callq 0xf9990
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3809a
movl $0x8, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x98(%rax)
jne 0x37cef
movq -0x10(%rbp), %rax
movl 0x624(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x37cef
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x664(%rax)
jne 0x37d22
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x43ea0
cmpl $0x0, %eax
je 0x37d22
jmp 0x37d13
callq 0xf9990
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3809a
movq -0x30(%rbp), %rax
movq 0x570(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x37d65
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq 0x11b956(%rip), %rsi # 0x1536b1
movl $0x30, %edx
callq 0x380b0
movq -0x10(%rbp), %rdi
callq 0x43df0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x37df4
movq -0x38(%rbp), %rax
movzbl 0xa4(%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x37dbb
jmp 0x37d8c
movl -0x44(%rbp), %eax
subl $0x2, %eax
jne 0x37dbd
jmp 0x37d96
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x210(%rax), %edx
movq -0x10(%rbp), %rax
addl 0x214(%rax), %edx
callq 0x77ac0
movl %eax, -0x20(%rbp)
jmp 0x37de0
jmp 0x37dbd
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x3c3c0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x37def
movl -0x40(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x40(%rbp)
jmp 0x37eb4
movq -0x38(%rbp), %rax
movzbl 0xa4(%rax), %eax
movl %eax, -0x48(%rbp)
subl $0x1, %eax
je 0x37e38
jmp 0x37e09
movl -0x48(%rbp), %eax
subl $0x2, %eax
jne 0x37e3a
jmp 0x37e13
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x210(%rax), %edx
movq -0x10(%rbp), %rax
addl 0x214(%rax), %edx
callq 0x78090
movl %eax, -0x20(%rbp)
jmp 0x37eb2
jmp 0x37e3a
cmpl $0x0, -0x24(%rbp)
jne 0x37e79
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
orl 0x218(%rax), %edx
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x3bec0
movl %eax, -0x20(%rbp)
jmp 0x37eb0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
orl 0x218(%rax), %edx
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x38320
movl %eax, -0x20(%rbp)
jmp 0x37eb2
jmp 0x37eb4
cmpl $0x0, -0x20(%rbp)
jne 0x37f74
jmp 0x37ec0
movq -0x30(%rbp), %rax
movq 0x6d8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movb %al, %cl
movb $0x1, %al
cmpb $0x0, %cl
movb %al, -0x49(%rbp)
je 0x37ef9
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x433f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x37f02
jmp 0x37f72
movq -0x10(%rbp), %rax
movq 0x3b0(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jb 0x37f37
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x37b40
movsbl %al, %eax
cmpl $0x0, %eax
je 0x37f37
movl $0x1, -0x20(%rbp)
jmp 0x37f72
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x8, %edx
callq 0x3bec0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x37f6d
jmp 0x37f72
jmp 0x37ec0
jmp 0x37f74
movq -0x30(%rbp), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x37f8e
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x38120
movq -0x10(%rbp), %rax
movl 0x624(%rax), %ecx
andl $0x401, %ecx # imm = 0x401
movl %ecx, 0x624(%rax)
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
orl 0x624(%rax), %ecx
movl %ecx, 0x624(%rax)
cmpl $0x0, -0x20(%rbp)
jne 0x37fc3
cmpl $0x1, -0x3c(%rbp)
je 0x37ff8
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x37fde
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x43ec0
callq 0xf9990
cmpl $0x78, (%rax)
jne 0x37ff3
callq 0xf9990
movl $0x89, (%rax)
jmp 0x3808a
cmpq $0x0, -0x18(%rbp)
jne 0x38045
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x7b8(%rax)
jne 0x3801a
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x43ec0
jmp 0x3801c
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x98(%rax)
jne 0x38036
callq 0xf9990
movl (%rax), %eax
movl %eax, -0x50(%rbp)
jmp 0x3803d
xorl %eax, %eax
movl %eax, -0x50(%rbp)
jmp 0x3803d
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3809a
movq -0x10(%rbp), %rax
movq 0x3d8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq 0x98(%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x38086
movq -0x10(%rbp), %rax
movl 0x624(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x624(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3809a
jmp 0x38088
jmp 0x3808a
jmp 0x3808c
jmp 0x3808e
jmp 0x38090
callq 0xf9990
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_rnext:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov [rbp+var_3C], 1
mov [rbp+var_40], 10h
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
call _ma_check_index
mov [rbp+var_1C], eax
cmp eax, 0
jge short loc_37CC1
jmp short $+2
loc_37CB2:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3809A
loc_37CC1:
mov [rbp+var_28], 8
mov rax, [rbp+var_10]
cmp qword ptr [rax+98h], 0FFFFFFFFFFFFFFFFh
jnz short loc_37CEF
mov rax, [rbp+var_10]
mov eax, [rax+624h]
and eax, 20h
cmp eax, 0
jz short loc_37CEF
mov [rbp+var_28], 0
loc_37CEF:
mov rax, [rbp+var_10]
cmp dword ptr [rax+664h], 2
jnz short loc_37D22
mov rdi, [rbp+var_10]
xor esi, esi
mov edx, 1
call _ma_readinfo
cmp eax, 0
jz short loc_37D22
jmp short $+2
loc_37D13:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3809A
loc_37D22:
mov rax, [rbp+var_30]
mov rax, [rax+570h]
movsxd rcx, [rbp+var_1C]
imul rcx, 118h
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
cmp byte ptr [rax+7E3h], 0
jz short loc_37D65
mov rdi, [rbp+var_38]
add rdi, 8
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 30h ; '0'
call inline_mysql_rwlock_rdlock_0
loc_37D65:
mov rdi, [rbp+var_10]
call _ma_test_if_changed
mov [rbp+var_24], eax
cmp [rbp+var_28], 0
jnz short loc_37DF4
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax+0A4h]
mov [rbp+var_44], eax
sub eax, 1
jz short loc_37DBB
jmp short $+2
loc_37D8C:
mov eax, [rbp+var_44]
sub eax, 2
jnz short loc_37DBD
jmp short $+2
loc_37D96:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
mov rax, [rbp+var_10]
mov edx, [rax+210h]
mov rax, [rbp+var_10]
add edx, [rax+214h]
call maria_rtree_get_first
mov [rbp+var_20], eax
jmp short loc_37DE0
loc_37DBB:
jmp short $+2
loc_37DBD:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
mov rax, [rax+118h]
movsxd rcx, [rbp+var_1C]
mov rdx, [rax+rcx*8]
call _ma_search_first
mov [rbp+var_20], eax
loc_37DE0:
cmp [rbp+var_20], 0
jz short loc_37DEF
mov eax, [rbp+var_40]
or eax, 20h
mov [rbp+var_40], eax
loc_37DEF:
jmp loc_37EB4
loc_37DF4:
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax+0A4h]
mov [rbp+var_48], eax
sub eax, 1
jz short loc_37E38
jmp short $+2
loc_37E09:
mov eax, [rbp+var_48]
sub eax, 2
jnz short loc_37E3A
jmp short $+2
loc_37E13:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
mov rax, [rbp+var_10]
mov edx, [rax+210h]
mov rax, [rbp+var_10]
add edx, [rax+214h]
call maria_rtree_get_next
mov [rbp+var_20], eax
jmp short loc_37EB2
loc_37E38:
jmp short $+2
loc_37E3A:
cmp [rbp+var_24], 0
jnz short loc_37E79
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 200h
mov edx, [rbp+var_28]
mov rax, [rbp+var_10]
or edx, [rax+218h]
mov rax, [rbp+var_30]
mov rax, [rax+118h]
movsxd rcx, [rbp+var_1C]
mov rcx, [rax+rcx*8]
call _ma_search_next
mov [rbp+var_20], eax
jmp short loc_37EB0
loc_37E79:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 200h
mov edx, [rbp+var_28]
mov rax, [rbp+var_10]
or edx, [rax+218h]
mov rax, [rbp+var_30]
mov rax, [rax+118h]
movsxd rcx, [rbp+var_1C]
mov rcx, [rax+rcx*8]
call _ma_search
mov [rbp+var_20], eax
loc_37EB0:
jmp short $+2
loc_37EB2:
jmp short $+2
loc_37EB4:
cmp [rbp+var_20], 0
jnz loc_37F74
jmp short $+2
loc_37EC0:
mov rax, [rbp+var_30]
mov rax, [rax+6D8h]
mov rdi, [rbp+var_10]
call rax
mov cl, al
mov al, 1
cmp cl, 0
mov [rbp+var_49], al
jz short loc_37EF9
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
mov rdx, [rbp+var_18]
call ma_check_index_cond
mov [rbp+var_3C], eax
cmp eax, 0
setz al
mov [rbp+var_49], al
loc_37EF9:
mov al, [rbp+var_49]
test al, 1
jnz short loc_37F02
jmp short loc_37F72
loc_37F02:
mov rax, [rbp+var_10]
mov rax, [rax+3B0h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+3B8h]
jb short loc_37F37
mov rdi, [rbp+var_10]
mov esi, [rbp+var_1C]
call ma_yield_and_check_if_killed
movsx eax, al
cmp eax, 0
jz short loc_37F37
mov [rbp+var_20], 1
jmp short loc_37F72
loc_37F37:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 200h
mov rax, [rbp+var_30]
mov rax, [rax+118h]
movsxd rcx, [rbp+var_1C]
mov rcx, [rax+rcx*8]
mov edx, 8
call _ma_search_next
mov [rbp+var_20], eax
cmp eax, 0
jz short loc_37F6D
jmp short loc_37F72
loc_37F6D:
jmp loc_37EC0
loc_37F72:
jmp short $+2
loc_37F74:
mov rax, [rbp+var_30]
cmp byte ptr [rax+7E3h], 0
jz short loc_37F8E
mov rdi, [rbp+var_38]
add rdi, 8
call inline_mysql_rwlock_unlock_0
loc_37F8E:
mov rax, [rbp+var_10]
mov ecx, [rax+624h]
and ecx, 401h
mov [rax+624h], ecx
mov ecx, [rbp+var_40]
mov rax, [rbp+var_10]
or ecx, [rax+624h]
mov [rax+624h], ecx
cmp [rbp+var_20], 0
jnz short loc_37FC3
cmp [rbp+var_3C], 1
jz short loc_37FF8
loc_37FC3:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+7B8h], 0
jnz short loc_37FDE
mov rdi, [rbp+var_10]
xor esi, esi
call _ma_writeinfo
loc_37FDE:
call _my_thread_var
cmp dword ptr [rax], 78h ; 'x'
jnz short loc_37FF3
call _my_thread_var
mov dword ptr [rax], 89h
loc_37FF3:
jmp loc_3808A
loc_37FF8:
cmp [rbp+var_18], 0
jnz short loc_38045
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+7B8h], 0
jnz short loc_3801A
mov rdi, [rbp+var_10]
xor esi, esi
call _ma_writeinfo
loc_3801A:
jmp short $+2
loc_3801C:
mov rax, [rbp+var_10]
cmp qword ptr [rax+98h], 0FFFFFFFFFFFFFFFFh
jnz short loc_38036
call _my_thread_var
mov eax, [rax]
mov [rbp+var_50], eax
jmp short loc_3803D
loc_38036:
xor eax, eax
mov [rbp+var_50], eax
jmp short $+2
loc_3803D:
mov eax, [rbp+var_50]
mov [rbp+var_4], eax
jmp short loc_3809A
loc_38045:
mov rax, [rbp+var_10]
mov rax, [rax+3D8h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rdx, [rcx+98h]
call rax
cmp eax, 0
jnz short loc_38086
mov rax, [rbp+var_10]
mov ecx, [rax+624h]
or ecx, 2
mov [rax+624h], ecx
mov [rbp+var_4], 0
jmp short loc_3809A
loc_38086:
jmp short $+2
loc_38088:
jmp short $+2
loc_3808A:
jmp short $+2
loc_3808C:
jmp short $+2
loc_3808E:
jmp short $+2
loc_38090:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4], eax
loc_3809A:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long maria_rnext(long long a1, const char *a2, unsigned int a3)
{
long long v3; // rsi
bool v6; // [rsp+7h] [rbp-49h]
int v7; // [rsp+10h] [rbp-40h]
int v8; // [rsp+14h] [rbp-3Ch]
long long v9; // [rsp+18h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-30h]
int v11; // [rsp+28h] [rbp-28h]
int v12; // [rsp+2Ch] [rbp-24h]
int next; // [rsp+30h] [rbp-20h]
unsigned int v14; // [rsp+34h] [rbp-1Ch]
long long v16; // [rsp+40h] [rbp-10h]
v16 = a1;
v10 = *(_QWORD *)a1;
v8 = 1;
v7 = 16;
v3 = a3;
v14 = ma_check_index(a1, a3);
if ( (v14 & 0x80000000) != 0 )
return *(unsigned int *)my_thread_var(a1, (const char *)v3);
v11 = 8;
if ( *(_QWORD *)(a1 + 152) == -1LL && (*(_DWORD *)(a1 + 1572) & 0x20) != 0 )
v11 = 0;
if ( *(_DWORD *)(a1 + 1636) == 2 )
{
v3 = 0LL;
if ( (unsigned int)ma_readinfo(a1, 0LL) )
return *(unsigned int *)my_thread_var(a1, (const char *)v3);
}
v9 = 280LL * (int)v14 + *(_QWORD *)(v10 + 1392);
if ( *(_BYTE *)(v10 + 2019) )
inline_mysql_rwlock_rdlock_0(v9 + 8, "/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_rnext.c", 48LL);
v12 = ma_test_if_changed(a1);
if ( v11 )
{
if ( *(_BYTE *)(v9 + 164) == 2 )
{
v3 = v14;
next = maria_rtree_get_next(a1, v14, (unsigned int)(*(_DWORD *)(a1 + 532) + *(_DWORD *)(a1 + 528)));
}
else
{
v3 = a1 + 512;
if ( v12 )
next = ma_search(
a1,
a1 + 512,
*(_DWORD *)(a1 + 536) | (unsigned int)v11,
*(_QWORD *)(*(_QWORD *)(v10 + 280) + 8LL * (int)v14));
else
next = ma_search_next(
a1,
a1 + 512,
*(_DWORD *)(a1 + 536) | (unsigned int)v11,
*(_QWORD *)(*(_QWORD *)(v10 + 280) + 8LL * (int)v14));
}
}
else
{
if ( *(_BYTE *)(v9 + 164) == 2 )
{
v3 = v14;
next = maria_rtree_get_first(a1, v14, (unsigned int)(*(_DWORD *)(a1 + 532) + *(_DWORD *)(a1 + 528)));
}
else
{
v3 = v9;
next = ma_search_first(a1, v9, *(_QWORD *)(*(_QWORD *)(v10 + 280) + 8LL * (int)v14));
}
if ( next )
v7 = 48;
}
for ( ; !next; next = ma_search_next(v16, v16 + 512, 8LL, *(_QWORD *)(*(_QWORD *)(v10 + 280) + 8LL * (int)v14)) )
{
a1 = v16;
v6 = 1;
if ( (*(unsigned __int8 ( **)(long long))(v10 + 1752))(v16) )
{
a1 = v16;
v3 = v14;
v8 = ma_check_index_cond(v16, v14, a2);
v6 = v8 == 0;
}
if ( !v6 )
break;
if ( *(_QWORD *)(v16 + 944) >= *(_QWORD *)(v16 + 952) )
{
a1 = v16;
v3 = v14;
if ( ma_yield_and_check_if_killed((_QWORD *)v16, (const char *)v14) )
{
next = 1;
break;
}
}
a1 = v16;
v3 = v16 + 512;
}
if ( *(_BYTE *)(v10 + 2019) )
{
a1 = v9 + 8;
inline_mysql_rwlock_unlock_0(v9 + 8);
}
*(_DWORD *)(v16 + 1572) &= 0x401u;
*(_DWORD *)(v16 + 1572) |= v7;
if ( next || v8 != 1 )
{
if ( !*(_DWORD *)(*(_QWORD *)v16 + 1976LL) )
{
a1 = v16;
v3 = 0LL;
ma_writeinfo(v16, 0LL);
}
if ( *(_DWORD *)my_thread_var(a1, (const char *)v3) == 120 )
*(_DWORD *)my_thread_var(a1, (const char *)v3) = 137;
return *(unsigned int *)my_thread_var(a1, (const char *)v3);
}
if ( a2 )
{
a1 = v16;
v3 = (long long)a2;
if ( (*(unsigned int ( **)(long long, const char *, _QWORD))(v16 + 984))(v16, a2, *(_QWORD *)(v16 + 152)) )
return *(unsigned int *)my_thread_var(a1, (const char *)v3);
*(_DWORD *)(v16 + 1572) |= 2u;
return 0;
}
else
{
if ( !*(_DWORD *)(*(_QWORD *)v16 + 1976LL) )
{
a1 = v16;
v3 = 0LL;
ma_writeinfo(v16, 0LL);
}
if ( *(_QWORD *)(v16 + 152) == -1LL )
return *(unsigned int *)my_thread_var(a1, (const char *)v3);
else
return 0;
}
}
| maria_rnext:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x3c],0x1
MOV dword ptr [RBP + -0x40],0x10
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00138190
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JGE 0x00137cc1
JMP 0x00137cb2
LAB_00137cb2:
CALL 0x001f9990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013809a
LAB_00137cc1:
MOV dword ptr [RBP + -0x28],0x8
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x98],-0x1
JNZ 0x00137cef
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x624]
AND EAX,0x20
CMP EAX,0x0
JZ 0x00137cef
MOV dword ptr [RBP + -0x28],0x0
LAB_00137cef:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x664],0x2
JNZ 0x00137d22
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
MOV EDX,0x1
CALL 0x00143ea0
CMP EAX,0x0
JZ 0x00137d22
JMP 0x00137d13
LAB_00137d13:
CALL 0x001f9990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013809a
LAB_00137d22:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x570]
MOVSXD RCX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x00137d65
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x8
LEA RSI,[0x2536b1]
MOV EDX,0x30
CALL 0x001380b0
LAB_00137d65:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00143df0
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x28],0x0
JNZ 0x00137df4
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX + 0xa4]
MOV dword ptr [RBP + -0x44],EAX
SUB EAX,0x1
JZ 0x00137dbb
JMP 0x00137d8c
LAB_00137d8c:
MOV EAX,dword ptr [RBP + -0x44]
SUB EAX,0x2
JNZ 0x00137dbd
JMP 0x00137d96
LAB_00137d96:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x210]
MOV RAX,qword ptr [RBP + -0x10]
ADD EDX,dword ptr [RAX + 0x214]
CALL 0x00177ac0
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00137de0
LAB_00137dbb:
JMP 0x00137dbd
LAB_00137dbd:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x118]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RAX + RCX*0x8]
CALL 0x0013c3c0
MOV dword ptr [RBP + -0x20],EAX
LAB_00137de0:
CMP dword ptr [RBP + -0x20],0x0
JZ 0x00137def
MOV EAX,dword ptr [RBP + -0x40]
OR EAX,0x20
MOV dword ptr [RBP + -0x40],EAX
LAB_00137def:
JMP 0x00137eb4
LAB_00137df4:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX + 0xa4]
MOV dword ptr [RBP + -0x48],EAX
SUB EAX,0x1
JZ 0x00137e38
JMP 0x00137e09
LAB_00137e09:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,0x2
JNZ 0x00137e3a
JMP 0x00137e13
LAB_00137e13:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x210]
MOV RAX,qword ptr [RBP + -0x10]
ADD EDX,dword ptr [RAX + 0x214]
CALL 0x00178090
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00137eb2
LAB_00137e38:
JMP 0x00137e3a
LAB_00137e3a:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00137e79
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x200
MOV EDX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
OR EDX,dword ptr [RAX + 0x218]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x118]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RAX + RCX*0x8]
CALL 0x0013bec0
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00137eb0
LAB_00137e79:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x200
MOV EDX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
OR EDX,dword ptr [RAX + 0x218]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x118]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RAX + RCX*0x8]
CALL 0x00138320
MOV dword ptr [RBP + -0x20],EAX
LAB_00137eb0:
JMP 0x00137eb2
LAB_00137eb2:
JMP 0x00137eb4
LAB_00137eb4:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00137f74
JMP 0x00137ec0
LAB_00137ec0:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x6d8]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV CL,AL
MOV AL,0x1
CMP CL,0x0
MOV byte ptr [RBP + -0x49],AL
JZ 0x00137ef9
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001433f0
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x49],AL
LAB_00137ef9:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x00137f02
JMP 0x00137f72
LAB_00137f02:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3b0]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x3b8]
JC 0x00137f37
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00137b40
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00137f37
MOV dword ptr [RBP + -0x20],0x1
JMP 0x00137f72
LAB_00137f37:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x200
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x118]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV EDX,0x8
CALL 0x0013bec0
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JZ 0x00137f6d
JMP 0x00137f72
LAB_00137f6d:
JMP 0x00137ec0
LAB_00137f72:
JMP 0x00137f74
LAB_00137f74:
MOV RAX,qword ptr [RBP + -0x30]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x00137f8e
MOV RDI,qword ptr [RBP + -0x38]
ADD RDI,0x8
CALL 0x00138120
LAB_00137f8e:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x624]
AND ECX,0x401
MOV dword ptr [RAX + 0x624],ECX
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
OR ECX,dword ptr [RAX + 0x624]
MOV dword ptr [RAX + 0x624],ECX
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00137fc3
CMP dword ptr [RBP + -0x3c],0x1
JZ 0x00137ff8
LAB_00137fc3:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x00137fde
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00143ec0
LAB_00137fde:
CALL 0x001f9990
CMP dword ptr [RAX],0x78
JNZ 0x00137ff3
CALL 0x001f9990
MOV dword ptr [RAX],0x89
LAB_00137ff3:
JMP 0x0013808a
LAB_00137ff8:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00138045
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x7b8],0x0
JNZ 0x0013801a
MOV RDI,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x00143ec0
LAB_0013801a:
JMP 0x0013801c
LAB_0013801c:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x98],-0x1
JNZ 0x00138036
CALL 0x001f9990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
JMP 0x0013803d
LAB_00138036:
XOR EAX,EAX
MOV dword ptr [RBP + -0x50],EAX
JMP 0x0013803d
LAB_0013803d:
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013809a
LAB_00138045:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3d8]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x98]
CALL RAX
CMP EAX,0x0
JNZ 0x00138086
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x624]
OR ECX,0x2
MOV dword ptr [RAX + 0x624],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013809a
LAB_00138086:
JMP 0x00138088
LAB_00138088:
JMP 0x0013808a
LAB_0013808a:
JMP 0x0013808c
LAB_0013808c:
JMP 0x0013808e
LAB_0013808e:
JMP 0x00138090
LAB_00138090:
CALL 0x001f9990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013809a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 maria_rnext(long *param_1,long param_2,int4 param_3)
{
long lVar1;
char cVar2;
int iVar3;
int iVar4;
int4 *puVar5;
long lVar6;
int *piVar7;
bool bVar8;
int4 local_58;
uint local_48;
int local_44;
uint local_30;
int local_28;
int4 local_c;
lVar1 = *param_1;
local_44 = 1;
local_48 = 0x10;
iVar3 = _ma_check_index(param_1,param_3);
if (iVar3 < 0) {
puVar5 = (int4 *)_my_thread_var();
local_c = *puVar5;
}
else {
local_30 = 8;
if ((param_1[0x13] == -1) && ((*(uint *)((long)param_1 + 0x624) & 0x20) != 0)) {
local_30 = 0;
}
if ((*(int *)((long)param_1 + 0x664) == 2) && (iVar4 = _ma_readinfo(param_1,0,1), iVar4 != 0)) {
puVar5 = (int4 *)_my_thread_var();
local_c = *puVar5;
}
else {
lVar6 = *(long *)(lVar1 + 0x570) + (long)iVar3 * 0x118;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
inline_mysql_rwlock_rdlock
(lVar6 + 8,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_rnext.c",
0x30);
}
iVar4 = _ma_test_if_changed(param_1);
if (local_30 == 0) {
if ((*(char *)(lVar6 + 0xa4) == '\x01') || (*(char *)(lVar6 + 0xa4) != '\x02')) {
local_28 = _ma_search_first(param_1,lVar6,
*(int8 *)(*(long *)(lVar1 + 0x118) + (long)iVar3 * 8));
}
else {
local_28 = maria_rtree_get_first
(param_1,iVar3,(int)param_1[0x42] + *(int *)((long)param_1 + 0x214));
}
if (local_28 != 0) {
local_48 = 0x30;
}
}
else if ((*(char *)(lVar6 + 0xa4) == '\x01') || (*(char *)(lVar6 + 0xa4) != '\x02')) {
if (iVar4 == 0) {
local_28 = _ma_search_next(param_1,param_1 + 0x40,local_30 | *(uint *)(param_1 + 0x43),
*(int8 *)(*(long *)(lVar1 + 0x118) + (long)iVar3 * 8));
}
else {
local_28 = _ma_search(param_1,param_1 + 0x40,local_30 | *(uint *)(param_1 + 0x43),
*(int8 *)(*(long *)(lVar1 + 0x118) + (long)iVar3 * 8));
}
}
else {
local_28 = maria_rtree_get_next
(param_1,iVar3,(int)param_1[0x42] + *(int *)((long)param_1 + 0x214));
}
while (local_28 == 0) {
cVar2 = (**(code **)(lVar1 + 0x6d8))(param_1);
bVar8 = true;
if (cVar2 != '\0') {
local_44 = ma_check_index_cond(param_1,iVar3,param_2);
bVar8 = local_44 == 0;
}
if (!bVar8) break;
if (((ulong)param_1[0x77] <= (ulong)param_1[0x76]) &&
(cVar2 = ma_yield_and_check_if_killed(param_1,iVar3), cVar2 != '\0')) {
local_28 = 1;
break;
}
local_28 = _ma_search_next(param_1,param_1 + 0x40,8,
*(int8 *)(*(long *)(lVar1 + 0x118) + (long)iVar3 * 8));
}
if (*(char *)(lVar1 + 0x7e3) != '\0') {
inline_mysql_rwlock_unlock(lVar6 + 8);
}
*(uint *)((long)param_1 + 0x624) = *(uint *)((long)param_1 + 0x624) & 0x401;
*(uint *)((long)param_1 + 0x624) = local_48 | *(uint *)((long)param_1 + 0x624);
if ((local_28 == 0) && (local_44 == 1)) {
if (param_2 == 0) {
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
if (param_1[0x13] == -1) {
puVar5 = (int4 *)_my_thread_var();
local_58 = *puVar5;
}
else {
local_58 = 0;
}
return local_58;
}
iVar3 = (*(code *)param_1[0x7b])(param_1,param_2,param_1[0x13]);
if (iVar3 == 0) {
*(uint *)((long)param_1 + 0x624) = *(uint *)((long)param_1 + 0x624) | 2;
return 0;
}
}
else {
if (*(int *)(*param_1 + 0x7b8) == 0) {
_ma_writeinfo(param_1,0);
}
piVar7 = (int *)_my_thread_var();
if (*piVar7 == 0x78) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x89;
}
}
puVar5 = (int4 *)_my_thread_var();
local_c = *puVar5;
}
}
return local_c;
}
|
|
1,689 | pfs_refine_statement_v1 | eloqsql/storage/perfschema/pfs.cc | PSI_statement_locker*
pfs_refine_statement_v1(PSI_statement_locker *locker,
PSI_statement_key key)
{
PSI_statement_locker_state *state= reinterpret_cast<PSI_statement_locker_state*> (locker);
if (state == NULL)
return NULL;
assert(state->m_class != NULL);
PFS_statement_class *klass;
/* Only refine statements for mutable instrumentation */
klass= reinterpret_cast<PFS_statement_class*> (state->m_class);
assert(klass->is_mutable());
klass= find_statement_class(key);
uint flags= state->m_flags;
if (unlikely(klass == NULL) || !klass->m_enabled)
{
/* pop statement stack */
if (flags & STATE_FLAG_THREAD)
{
PFS_thread *pfs_thread= reinterpret_cast<PFS_thread *> (state->m_thread);
assert(pfs_thread != NULL);
if (pfs_thread->m_events_statements_count > 0)
pfs_thread->m_events_statements_count--;
}
state->m_discarded= true;
return NULL;
}
if ((flags & STATE_FLAG_TIMED) && ! klass->m_timed)
flags= flags & ~STATE_FLAG_TIMED;
if (flags & STATE_FLAG_EVENT)
{
PFS_events_statements *pfs= reinterpret_cast<PFS_events_statements*> (state->m_statement);
assert(pfs != NULL);
/* mutate EVENTS_STATEMENTS_CURRENT.EVENT_NAME */
pfs->m_event.m_class= klass;
}
state->m_class= klass;
state->m_flags= flags;
return reinterpret_cast<PSI_statement_locker*> (state);
} | O0 | cpp | pfs_refine_statement_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x52a1b
movq $0x0, -0x8(%rbp)
jmp 0x52b02
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x433a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x52a59
movq -0x28(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0x52aa3
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x52a92
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x14b8(%rax)
jbe 0x52a90
movq -0x38(%rbp), %rax
movl 0x14b8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14b8(%rax)
jmp 0x52a92
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x52b02
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x52ac1
movq -0x28(%rbp), %rax
testb $0x1, 0x5(%rax)
jne 0x52ac1
movl -0x2c(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x52ae4
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| pfs_refine_statement_v1:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_52A1B
mov [rbp+var_8], 0
jmp loc_52B02
loc_52A1B:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov [rbp+var_28], rax
mov edi, [rbp+var_14]; unsigned int
call _Z20find_statement_classj; find_statement_class(uint)
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov eax, [rax+4]
mov [rbp+var_2C], eax
cmp [rbp+var_28], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jnz short loc_52A59
mov rax, [rbp+var_28]
test byte ptr [rax+4], 1
jnz short loc_52AA3
loc_52A59:
mov eax, [rbp+var_2C]
and eax, 2
cmp eax, 0
jz short loc_52A92
mov rax, [rbp+var_20]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
cmp dword ptr [rax+14B8h], 0
jbe short loc_52A90
mov rax, [rbp+var_38]
mov ecx, [rax+14B8h]
add ecx, 0FFFFFFFFh
mov [rax+14B8h], ecx
loc_52A90:
jmp short $+2
loc_52A92:
mov rax, [rbp+var_20]
mov byte ptr [rax], 1
mov [rbp+var_8], 0
jmp short loc_52B02
loc_52AA3:
mov eax, [rbp+var_2C]
and eax, 1
cmp eax, 0
jz short loc_52AC1
mov rax, [rbp+var_28]
test byte ptr [rax+5], 1
jnz short loc_52AC1
mov eax, [rbp+var_2C]
and eax, 0FFFFFFFEh
mov [rbp+var_2C], eax
loc_52AC1:
mov eax, [rbp+var_2C]
and eax, 4
cmp eax, 0
jz short loc_52AE4
mov rax, [rbp+var_20]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_40]
mov [rax+30h], rcx
loc_52AE4:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rax+8], rcx
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_20]
mov [rax+4], ecx
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_52B02:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pfs_refine_statement_v1(long long a1, unsigned int a2)
{
long long v3; // [rsp+8h] [rbp-38h]
int v4; // [rsp+14h] [rbp-2Ch]
long long statement_class; // [rsp+18h] [rbp-28h]
if ( !a1 )
return 0LL;
statement_class = find_statement_class(a2);
v4 = *(_DWORD *)(a1 + 4);
if ( statement_class && (*(_BYTE *)(statement_class + 4) & 1) != 0 )
{
if ( (v4 & 1) != 0 && (*(_BYTE *)(statement_class + 5) & 1) == 0 )
v4 &= ~1u;
if ( (v4 & 4) != 0 )
*(_QWORD *)(*(_QWORD *)(a1 + 40) + 48LL) = statement_class;
*(_QWORD *)(a1 + 8) = statement_class;
*(_DWORD *)(a1 + 4) = v4;
return a1;
}
else
{
if ( (v4 & 2) != 0 )
{
v3 = *(_QWORD *)(a1 + 16);
if ( *(_DWORD *)(v3 + 5304) )
--*(_DWORD *)(v3 + 5304);
}
*(_BYTE *)a1 = 1;
return 0LL;
}
}
| pfs_refine_statement_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00152a1b
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00152b02
LAB_00152a1b:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x001433a0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x2c],EAX
CMP qword ptr [RBP + -0x28],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JNZ 0x00152a59
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x00152aa3
LAB_00152a59:
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00152a92
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP dword ptr [RAX + 0x14b8],0x0
JBE 0x00152a90
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x14b8]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x14b8],ECX
LAB_00152a90:
JMP 0x00152a92
LAB_00152a92:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x1
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00152b02
LAB_00152aa3:
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00152ac1
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x5],0x1
JNZ 0x00152ac1
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xfffffffe
MOV dword ptr [RBP + -0x2c],EAX
LAB_00152ac1:
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00152ae4
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x30],RCX
LAB_00152ae4:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00152b02:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int1 * pfs_refine_statement_v1(int1 *param_1,uint param_2)
{
long lVar1;
uint local_34;
int1 *local_10;
if (param_1 == (int1 *)0x0) {
local_10 = (int1 *)0x0;
}
else {
lVar1 = find_statement_class(param_2);
local_34 = *(uint *)(param_1 + 4);
if ((lVar1 == 0) || ((*(byte *)(lVar1 + 4) & 1) == 0)) {
if (((local_34 & 2) != 0) &&
(lVar1 = *(long *)(param_1 + 0x10), *(int *)(lVar1 + 0x14b8) != 0)) {
*(int *)(lVar1 + 0x14b8) = *(int *)(lVar1 + 0x14b8) + -1;
}
*param_1 = 1;
local_10 = (int1 *)0x0;
}
else {
if (((local_34 & 1) != 0) && ((*(byte *)(lVar1 + 5) & 1) == 0)) {
local_34 = local_34 & 0xfffffffe;
}
if ((local_34 & 4) != 0) {
*(long *)(*(long *)(param_1 + 0x28) + 0x30) = lVar1;
}
*(long *)(param_1 + 8) = lVar1;
*(uint *)(param_1 + 4) = local_34;
local_10 = param_1;
}
}
return local_10;
}
|
|
1,690 | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*) | ng-log[P]ng-log/src/symbolize.cc | static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
ElfW(Half) sh_num,
const size_t sh_offset,
ElfW(Word) type,
ElfW(Shdr) * out) {
// Read at most 16 section headers at a time to save read calls.
ElfW(Shdr) buf[16];
for (size_t i = 0; i < sh_num;) {
const size_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
const size_t num_bytes_to_read =
(sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
sh_offset + i * sizeof(buf[0]));
if (len == -1) {
return false;
}
NGLOG_SAFE_ASSERT(static_cast<size_t>(len) % sizeof(buf[0]) == 0);
const size_t num_headers_in_buf = static_cast<size_t>(len) / sizeof(buf[0]);
NGLOG_SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
for (size_t j = 0; j < num_headers_in_buf; ++j) {
if (buf[j].sh_type == type) {
*out = buf[j];
return true;
}
}
i += num_headers_in_buf;
}
return false;
} | O1 | cpp | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, 0x8(%rsp)
movl %edi, %r15d
movl %esi, %r12d
xorl %r13d, %r13d
movl $0x400, %r14d # imm = 0x400
movl %eax, 0x4(%rsp)
movq %r12, %rdx
subq %r13, %rdx
jbe 0x220da
shlq $0x6, %rdx
cmpq %r14, %rdx
cmovaeq %r14, %rdx
movq %r13, %rcx
shlq $0x6, %rcx
addq 0x8(%rsp), %rcx
movl %r15d, %edi
leaq 0x10(%rsp), %rsi
callq 0x21604
cmpq $-0x1, %rax
je 0x220bf
testb $0x3f, %al
jne 0x220fa
cmpq $0x43f, %rax # imm = 0x43F
ja 0x220fa
movq %rax, %rcx
shrq $0x6, %rcx
testq %rax, %rax
sete %al
je 0x220cd
leaq 0x10(%rsp), %rdx
cmpl %ebp, 0x14(%rsp)
je 0x22097
leaq -0x1(%rcx), %rax
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
cmpq %rsi, %rax
je 0x220cb
leaq 0x40(%rdi), %rdx
incq %rsi
cmpl %ebp, 0x44(%rdi)
movq %rdx, %rdi
jne 0x2207d
cmpq %rcx, %rsi
setae %al
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups 0x30(%rdx), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, %cl
movl %ecx, 0x4(%rsp)
xorl %ecx, %ecx
jmp 0x220cd
xorl %eax, %eax
movl $0x0, 0x4(%rsp)
jmp 0x220d0
movb $0x1, %al
addq %rcx, %r13
testb %al, %al
jne 0x2200e
jmp 0x220e2
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
andb $0x1, %al
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x72b0
| _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov rbx, r8
mov ebp, ecx
mov [rsp+448h+var_440], rdx
mov r15d, edi
mov r12d, esi
xor r13d, r13d
mov r14d, offset stru_3F0.st_size
mov [rsp+448h+var_444], eax
loc_2200E:
mov rdx, r12
sub rdx, r13
jbe loc_220DA
shl rdx, 6
cmp rdx, r14
cmovnb rdx, r14; void *
mov rcx, r13
shl rcx, 6
add rcx, [rsp+448h+var_440]; unsigned __int64
mov edi, r15d; this
lea rsi, [rsp+448h+var_438]; int
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_220BF
test al, 3Fh
jnz loc_220FA
cmp rax, 43Fh
ja loc_220FA
mov rcx, rax
shr rcx, 6
test rax, rax
setz al
jz short loc_220CD
lea rdx, [rsp+448h+var_438]
cmp [rsp+448h+var_434], ebp
jz short loc_22097
lea rax, [rcx-1]
lea rdi, [rsp+448h+var_438]
xor esi, esi
loc_2207D:
cmp rax, rsi
jz short loc_220CB
lea rdx, [rdi+40h]
inc rsi
cmp [rdi+44h], ebp
mov rdi, rdx
jnz short loc_2207D
cmp rsi, rcx
setnb al
loc_22097:
movups xmm0, xmmword ptr [rdx]
movups xmm1, xmmword ptr [rdx+10h]
movups xmm2, xmmword ptr [rdx+20h]
movups xmm3, xmmword ptr [rdx+30h]
movups xmmword ptr [rbx+30h], xmm3
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov cl, 1
mov [rsp+448h+var_444], ecx
xor ecx, ecx
jmp short loc_220CD
loc_220BF:
xor eax, eax
mov [rsp+448h+var_444], 0
jmp short loc_220D0
loc_220CB:
mov al, 1
loc_220CD:
add r13, rcx
loc_220D0:
test al, al
jnz loc_2200E
jmp short loc_220E2
loc_220DA:
mov [rsp+448h+var_444], 0
loc_220E2:
mov eax, [rsp+448h+var_444]
and al, 1
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_220FA:
call _abort
| char nglog::tools::GetSectionHeaderByType(
nglog::tools *this,
unsigned int a2,
long long a3,
int a4,
_OWORD *a5)
{
char v5; // al
unsigned int v8; // r15d
unsigned long long v9; // r12
unsigned long long v10; // r13
unsigned long long *p_st_size; // rdx
unsigned long long v12; // rax
unsigned long long v13; // rcx
bool v14; // al
int *v15; // rdx
int *v16; // rdi
unsigned long long v17; // rsi
bool v18; // zf
__int128 v19; // xmm0
__int128 v20; // xmm1
__int128 v21; // xmm2
char v23; // [rsp+4h] [rbp-444h]
int v25[270]; // [rsp+10h] [rbp-438h] BYREF
v8 = (unsigned int)this;
v9 = a2;
v10 = 0LL;
v23 = v5;
while ( v9 > v10 )
{
p_st_size = (unsigned long long *)((v9 - v10) << 6);
if ( p_st_size >= &stru_3F0.st_size )
p_st_size = &stru_3F0.st_size;
v12 = nglog::tools::ReadFromOffset(v8, (long long)v25, (char *)p_st_size, a3 + (v10 << 6));
if ( v12 == -1LL )
{
v14 = 0;
v23 = 0;
}
else
{
if ( (v12 & 0x3F) != 0 || v12 > 0x43F )
abort(v8);
v13 = v12 >> 6;
v14 = v12 == 0;
if ( !v14 )
{
v15 = v25;
if ( v25[1] == a4 )
{
LABEL_14:
v19 = *(_OWORD *)v15;
v20 = *((_OWORD *)v15 + 1);
v21 = *((_OWORD *)v15 + 2);
a5[3] = *((_OWORD *)v15 + 3);
a5[2] = v21;
a5[1] = v20;
*a5 = v19;
v23 = 1;
v13 = 0LL;
}
else
{
v16 = v25;
v17 = 0LL;
while ( v13 - 1 != v17 )
{
v15 = v16 + 16;
++v17;
v18 = v16[17] == a4;
v16 += 16;
if ( v18 )
{
v14 = v17 >= v13;
goto LABEL_14;
}
}
v14 = 1;
}
}
v10 += v13;
}
if ( !v14 )
return v23 & 1;
}
v23 = 0;
return v23 & 1;
}
| GetSectionHeaderByType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV RBX,R8
MOV EBP,ECX
MOV qword ptr [RSP + 0x8],RDX
MOV R15D,EDI
MOV R12D,ESI
XOR R13D,R13D
MOV R14D,0x400
MOV dword ptr [RSP + 0x4],EAX
LAB_0012200e:
MOV RDX,R12
SUB RDX,R13
JBE 0x001220da
SHL RDX,0x6
CMP RDX,R14
CMOVNC RDX,R14
MOV RCX,R13
SHL RCX,0x6
ADD RCX,qword ptr [RSP + 0x8]
MOV EDI,R15D
LEA RSI,[RSP + 0x10]
CALL 0x00121604
CMP RAX,-0x1
JZ 0x001220bf
TEST AL,0x3f
JNZ 0x001220fa
CMP RAX,0x43f
JA 0x001220fa
MOV RCX,RAX
SHR RCX,0x6
TEST RAX,RAX
SETZ AL
JZ 0x001220cd
LEA RDX,[RSP + 0x10]
CMP dword ptr [RSP + 0x14],EBP
JZ 0x00122097
LEA RAX,[RCX + -0x1]
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
LAB_0012207d:
CMP RAX,RSI
JZ 0x001220cb
LEA RDX,[RDI + 0x40]
INC RSI
CMP dword ptr [RDI + 0x44],EBP
MOV RDI,RDX
JNZ 0x0012207d
CMP RSI,RCX
SETNC AL
LAB_00122097:
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS XMM1,xmmword ptr [RDX + 0x10]
MOVUPS XMM2,xmmword ptr [RDX + 0x20]
MOVUPS XMM3,xmmword ptr [RDX + 0x30]
MOVUPS xmmword ptr [RBX + 0x30],XMM3
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV CL,0x1
MOV dword ptr [RSP + 0x4],ECX
XOR ECX,ECX
JMP 0x001220cd
LAB_001220bf:
XOR EAX,EAX
MOV dword ptr [RSP + 0x4],0x0
JMP 0x001220d0
LAB_001220cb:
MOV AL,0x1
LAB_001220cd:
ADD R13,RCX
LAB_001220d0:
TEST AL,AL
JNZ 0x0012200e
JMP 0x001220e2
LAB_001220da:
MOV dword ptr [RSP + 0x4],0x0
LAB_001220e2:
MOV EAX,dword ptr [RSP + 0x4]
AND AL,0x1
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001220fa:
CALL 0x001072b0
|
/* nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int,
Elf64_Shdr*) */
uint nglog::tools::GetSectionHeaderByType
(int param_1,ushort param_2,ulong param_3,uint param_4,Elf64_Shdr *param_5)
{
uint *puVar1;
int8 uVar2;
qword qVar3;
qword qVar4;
qword qVar5;
qword qVar6;
int8 uVar7;
qword qVar8;
uint in_EAX;
ulong uVar9;
long lVar10;
ulong uVar11;
int8 *puVar12;
int6 in_register_00000032;
ulong uVar13;
int8 *puVar14;
ulong uVar15;
ulong uVar16;
bool bVar17;
uint local_444;
int8 local_438;
uVar15 = CONCAT62(in_register_00000032,param_2) & 0xffffffff;
uVar16 = 0;
local_444 = in_EAX;
do {
lVar10 = uVar15 - uVar16;
if (uVar15 < uVar16 || lVar10 == 0) {
local_444 = 0;
break;
}
uVar11 = lVar10 * 0x40;
if (0x3ff < uVar11) {
uVar11 = 0x400;
}
uVar11 = ReadFromOffset(param_1,&local_438,uVar11,uVar16 * 0x40 + param_3);
if (uVar11 == 0xffffffffffffffff) {
bVar17 = false;
local_444 = 0;
}
else {
if (((uVar11 & 0x3f) != 0) || (0x43f < uVar11)) {
/* WARNING: Subroutine does not return */
abort();
}
uVar9 = uVar11 >> 6;
bVar17 = uVar11 == 0;
if (!bVar17) {
puVar12 = &local_438;
if (local_438._4_4_ != param_4) {
uVar13 = 0;
puVar14 = &local_438;
do {
if (uVar9 - 1 == uVar13) {
bVar17 = true;
goto LAB_001220cd;
}
puVar12 = puVar14 + 8;
uVar13 = uVar13 + 1;
puVar1 = (uint *)((long)puVar14 + 0x44);
puVar14 = puVar12;
} while (*puVar1 != param_4);
bVar17 = uVar9 <= uVar13;
}
uVar2 = *puVar12;
qVar3 = puVar12[1];
qVar4 = puVar12[2];
qVar5 = puVar12[3];
qVar6 = puVar12[4];
uVar7 = puVar12[5];
qVar8 = puVar12[7];
param_5->sh_addralign = puVar12[6];
param_5->sh_entsize = qVar8;
param_5->sh_size = qVar6;
param_5->sh_link = (int)uVar7;
param_5->sh_info = (int)((ulong)uVar7 >> 0x20);
param_5->sh_addr = qVar4;
param_5->sh_offset = qVar5;
param_5->sh_name = (int)uVar2;
param_5->sh_type = (int)((ulong)uVar2 >> 0x20);
param_5->sh_flags = qVar3;
local_444 = (uint)CONCAT71((uint7)(uVar11 >> 0xe),1);
uVar9 = 0;
}
LAB_001220cd:
uVar16 = uVar16 + uVar9;
}
} while (bVar17);
return local_444 & 0xffffff01;
}
|
|
1,691 | mark_blocks_free | eloqsql/mysys/my_alloc.c | static inline void mark_blocks_free(MEM_ROOT* root)
{
reg1 USED_MEM *next;
reg2 USED_MEM **last;
/* iterate through (partially) free blocks, mark them free */
last= &root->free;
for (next= root->free; next; next= *(last= &next->next))
{
next->left= next->size - ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(next);
}
/* Combine the free and the used list */
*last= next=root->used;
/* now go through the used blocks and mark them free */
for (; next; next= next->next)
{
next->left= next->size - ALIGN_SIZE(sizeof(USED_MEM));
TRASH_MEM(next);
}
/* Now everything is set; Indicate that nothing is used anymore */
root->used= 0;
root->first_block_usage= 0;
root->block_num= 4;
} | O0 | c | mark_blocks_free:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf2bbf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xf2ba8
jmp 0xf2baa
jmp 0xf2bac
jmp 0xf2bae
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf2b8b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0xf2c02
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x18, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xf2bef
jmp 0xf2bf1
jmp 0xf2bf3
jmp 0xf2bf5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf2bd2
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mark_blocks_free:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
loc_F2B8B:
cmp [rbp+var_10], 0
jz short loc_F2BBF
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short $+2
loc_F2BA8:
jmp short $+2
loc_F2BAA:
jmp short $+2
loc_F2BAC:
jmp short $+2
loc_F2BAE:
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_F2B8B
loc_F2BBF:
mov rax, [rbp+var_8]
mov rcx, [rax+8]
mov [rbp+var_10], rcx
mov rax, [rbp+var_18]
mov [rax], rcx
loc_F2BD2:
cmp [rbp+var_10], 0
jz short loc_F2C02
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
sub rcx, 18h
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short $+2
loc_F2BEF:
jmp short $+2
loc_F2BF1:
jmp short $+2
loc_F2BF3:
jmp short $+2
loc_F2BF5:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_F2BD2
loc_F2C02:
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
pop rbp
retn
| long long mark_blocks_free(long long a1)
{
long long result; // rax
_QWORD *v2; // [rsp+0h] [rbp-18h]
_QWORD *i; // [rsp+8h] [rbp-10h]
_QWORD *v4; // [rsp+8h] [rbp-10h]
v2 = (_QWORD *)a1;
for ( i = *(_QWORD **)a1; i; i = (_QWORD *)*i )
{
i[1] = i[2] - 24LL;
v2 = i;
}
v4 = *(_QWORD **)(a1 + 8);
*v2 = v4;
while ( v4 )
{
v4[1] = v4[2] - 24LL;
v4 = (_QWORD *)*v4;
}
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 44) = 0;
result = a1;
*(_DWORD *)(a1 + 40) = 4;
return result;
}
| mark_blocks_free:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001f2b8b:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001f2bbf
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001f2ba8
LAB_001f2ba8:
JMP 0x001f2baa
LAB_001f2baa:
JMP 0x001f2bac
LAB_001f2bac:
JMP 0x001f2bae
LAB_001f2bae:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f2b8b
LAB_001f2bbf:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
LAB_001f2bd2:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001f2c02
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001f2bef
LAB_001f2bef:
JMP 0x001f2bf1
LAB_001f2bf1:
JMP 0x001f2bf3
LAB_001f2bf3:
JMP 0x001f2bf5
LAB_001f2bf5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f2bd2
LAB_001f2c02:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
POP RBP
RET
|
void mark_blocks_free(int8 *param_1)
{
int8 *local_20;
int8 *local_18;
local_20 = param_1;
for (local_18 = (int8 *)*param_1; local_18 != (int8 *)0x0;
local_18 = (int8 *)*local_18) {
local_18[1] = local_18[2] + -0x18;
local_20 = local_18;
}
local_18 = (int8 *)param_1[1];
*local_20 = local_18;
for (; local_18 != (int8 *)0x0; local_18 = (int8 *)*local_18) {
local_18[1] = local_18[2] + -0x18;
}
param_1[1] = 0;
*(int4 *)((long)param_1 + 0x2c) = 0;
*(int4 *)(param_1 + 5) = 4;
return;
}
|
|
1,692 | get_range(SEL_ARG**, SEL_ARG**, SEL_ARG*) | eloqsql/sql/opt_range.cc | static bool
get_range(SEL_ARG **e1,SEL_ARG **e2,SEL_ARG *root1)
{
(*e1)=root1->find_range(*e2); // first e1->min < e2->min
if ((*e1)->cmp_max_to_min(*e2) < 0)
{
if (!((*e1)=(*e1)->next))
return 1;
if ((*e1)->cmp_min_to_max(*e2) > 0)
{
(*e2)=(*e2)->next;
return 1;
}
}
return 0;
} | O0 | cpp | get_range(SEL_ARG**, SEL_ARG**, SEL_ARG*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xd8d4a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xd9e390
cmpl $0x0, %eax
jge 0xd97736
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xd97704
movb $0x1, -0x1(%rbp)
jmp 0xd9773a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xd9e3d0
cmpl $0x0, %eax
jle 0xd97734
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xd9773a
jmp 0xd97736
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL9get_rangePP7SEL_ARGS1_S0_:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_20]; this
mov rax, [rbp+var_18]
mov rsi, [rax]; SEL_ARG *
call _ZN7SEL_ARG10find_rangeEPS_; SEL_ARG::find_range(SEL_ARG*)
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rdi, [rax]; this
mov rax, [rbp+var_18]
mov rsi, [rax]; SEL_ARG *
call _ZNK7SEL_ARG14cmp_max_to_minEPKS_; SEL_ARG::cmp_max_to_min(SEL_ARG const*)
cmp eax, 0
jge short loc_D97736
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov [rcx], rax
cmp rax, 0
jnz short loc_D97704
mov [rbp+var_1], 1
jmp short loc_D9773A
loc_D97704:
mov rax, [rbp+var_10]
mov rdi, [rax]; this
mov rax, [rbp+var_18]
mov rsi, [rax]; SEL_ARG *
call _ZNK7SEL_ARG14cmp_min_to_maxEPKS_; SEL_ARG::cmp_min_to_max(SEL_ARG const*)
cmp eax, 0
jle short loc_D97734
mov rax, [rbp+var_18]
mov rax, [rax]
mov rcx, [rax+40h]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_1], 1
jmp short loc_D9773A
loc_D97734:
jmp short $+2
loc_D97736:
mov [rbp+var_1], 0
loc_D9773A:
mov al, [rbp+var_1]
and al, 1
add rsp, 20h
pop rbp
retn
| char get_range(SEL_ARG **a1, SEL_ARG **a2, SEL_ARG *a3)
{
SEL_ARG *v3; // rax
*a1 = SEL_ARG::find_range(a3, *a2);
if ( (int)SEL_ARG::cmp_max_to_min(*a1, *a2) >= 0 )
return 0;
v3 = (SEL_ARG *)*((_QWORD *)*a1 + 8);
*a1 = v3;
if ( v3 )
{
if ( (int)SEL_ARG::cmp_min_to_max(*a1, *a2) > 0 )
{
*a2 = (SEL_ARG *)*((_QWORD *)*a2 + 8);
return 1;
}
return 0;
}
return 1;
}
| val_real:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00d976b6
LAB_00d976b6:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x18],XMM0
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x20],XMM0
MOV RAX,qword ptr [RAX + 0x70]
MOV RCX,qword ptr [RAX]
MOV AL,0x1
TEST byte ptr [RCX + 0x64],0x1
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00d97711
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x70]
MOV RAX,qword ptr [RAX + 0x8]
MOV AL,byte ptr [RAX + 0x64]
MOV byte ptr [RBP + -0x29],AL
LAB_00d97711:
MOV RCX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RBP + -0x29]
MOV DL,AL
AND DL,0x1
MOV byte ptr [RCX + 0x64],DL
TEST AL,0x1
JNZ 0x00d97726
JMP 0x00d97730
LAB_00d97726:
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x8],XMM0
JMP 0x00d9774d
LAB_00d97730:
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVSD XMM1,qword ptr [RBP + -0x20]
CALL 0x008596f0
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00da6cb0
MOVSD qword ptr [RBP + -0x8],XMM0
LAB_00d9774d:
MOVSD XMM0,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* Item_func_pow::val_real() */
int8 __thiscall Item_func_pow::val_real(Item_func_pow *this)
{
double dVar1;
double __y;
byte local_31;
int8 local_10;
dVar1 = (double)(**(code **)(*(long *)**(int8 **)(this + 0x70) + 0xe8))();
__y = (double)(**(code **)(**(long **)(*(long *)(this + 0x70) + 8) + 0xe8))();
local_31 = 1;
if ((*(byte *)(**(long **)(this + 0x70) + 100) & 1) == 0) {
local_31 = *(byte *)(*(long *)(*(long *)(this + 0x70) + 8) + 100);
}
this[100] = (Item_func_pow)(local_31 & 1);
if ((local_31 & 1) == 0) {
dVar1 = pow(dVar1,__y);
local_10 = Item_func::check_float_overflow((Item_func *)this,dVar1);
}
else {
local_10 = 0;
}
return local_10;
}
|
|
1,693 | get_range(SEL_ARG**, SEL_ARG**, SEL_ARG*) | eloqsql/sql/opt_range.cc | static bool
get_range(SEL_ARG **e1,SEL_ARG **e2,SEL_ARG *root1)
{
(*e1)=root1->find_range(*e2); // first e1->min < e2->min
if ((*e1)->cmp_max_to_min(*e2) < 0)
{
if (!((*e1)=(*e1)->next))
return 1;
if ((*e1)->cmp_min_to_max(*e2) > 0)
{
(*e2)=(*e2)->next;
return 1;
}
}
return 0;
} | O3 | cpp | get_range(SEL_ARG**, SEL_ARG**, SEL_ARG*):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq %rdx, %rdi
callq 0x9eb952
movq %rax, (%r14)
movq (%rbx), %r8
movq 0x18(%rax), %rdi
movq 0x28(%rax), %rsi
movq 0x20(%r8), %rdx
movzbl 0x1(%rax), %ecx
movzbl (%r8), %r8d
callq 0x9dde16
testl %eax, %eax
js 0x9f1408
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rax
movq 0x40(%rax), %rax
movq %rax, (%r14)
movb $0x1, %r14b
testq %rax, %rax
je 0x9f1400
movq (%rbx), %r8
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
movq 0x28(%r8), %rdx
movzbl (%rax), %ecx
movzbl 0x1(%r8), %r8d
callq 0x9dde16
testl %eax, %eax
jle 0x9f13fd
movq (%rbx), %rax
movq 0x40(%rax), %rax
movq %rax, (%rbx)
jmp 0x9f1400
| _ZL9get_rangePP7SEL_ARGS1_S0_:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rsi, [rsi]; SEL_ARG *
mov rdi, rdx; this
call _ZN7SEL_ARG10find_rangeEPS_; SEL_ARG::find_range(SEL_ARG*)
mov [r14], rax
mov r8, [rbx]
mov rdi, [rax+18h]; this
mov rsi, [rax+28h]; Field *
mov rdx, [r8+20h]; unsigned __int8 *
movzx ecx, byte ptr [rax+1]; unsigned __int8 *
movzx r8d, byte ptr [r8]; unsigned __int8
call _ZN7SEL_ARG7sel_cmpEP5FieldPhS2_hh; SEL_ARG::sel_cmp(Field *,uchar *,uchar *,uchar,uchar)
test eax, eax
js short loc_9F1408
loc_9F13FD:
xor r14d, r14d
loc_9F1400:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_9F1408:
mov rax, [r14]
mov rax, [rax+40h]
mov [r14], rax
mov r14b, 1
test rax, rax
jz short loc_9F1400
mov r8, [rbx]
mov rdi, [rax+18h]; this
mov rsi, [rax+20h]; Field *
mov rdx, [r8+28h]; unsigned __int8 *
movzx ecx, byte ptr [rax]; unsigned __int8 *
movzx r8d, byte ptr [r8+1]; unsigned __int8
call _ZN7SEL_ARG7sel_cmpEP5FieldPhS2_hh; SEL_ARG::sel_cmp(Field *,uchar *,uchar *,uchar,uchar)
test eax, eax
jle short loc_9F13FD
mov rax, [rbx]
mov rax, [rax+40h]
mov [rbx], rax
jmp short loc_9F1400
| long long get_range(SEL_ARG **a1, SEL_ARG **a2, SEL_ARG *a3)
{
unsigned int v3; // r14d
SEL_ARG *range; // rax
SEL_ARG **v6; // rax
v3 = (unsigned int)a1;
range = SEL_ARG::find_range(a3, (unsigned __int8 **)*a2);
*a1 = range;
if ( (int)SEL_ARG::sel_cmp(
*((SEL_ARG **)range + 3),
*((Field **)range + 5),
*((unsigned __int8 **)*a2 + 4),
(unsigned __int8 *)*((unsigned __int8 *)range + 1),
*(_BYTE *)*a2) < 0 )
{
v6 = (SEL_ARG **)*((_QWORD *)*a1 + 8);
*a1 = (SEL_ARG *)v6;
LOBYTE(v3) = 1;
if ( !v6 )
return v3;
if ( (int)SEL_ARG::sel_cmp(
v6[3],
v6[4],
*((unsigned __int8 **)*a2 + 5),
(unsigned __int8 *)*(unsigned __int8 *)v6,
*((_BYTE *)*a2 + 1)) > 0 )
{
*a2 = (SEL_ARG *)*((_QWORD *)*a2 + 8);
return v3;
}
}
return 0;
}
| |||
1,694 | my_tell | eloqsql/mysys/my_seek.c | my_off_t my_tell(File fd, myf MyFlags)
{
os_off_t pos;
DBUG_ENTER("my_tell");
DBUG_PRINT("my",("fd: %d MyFlags: %lu",fd, MyFlags));
DBUG_ASSERT(fd >= 0);
#if defined (HAVE_TELL) && !defined (_WIN32) && !defined(_AIX)
pos= tell(fd);
#else
pos= my_seek(fd, 0L, MY_SEEK_CUR,0);
#endif
if (pos == (os_off_t) -1)
{
my_errno= errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SEEK, MYF(0), my_filename(fd), my_errno);
DBUG_PRINT("error", ("tell: %llu errno: %d", (ulonglong) pos, my_errno));
}
DBUG_PRINT("exit",("pos: %llu", (ulonglong) pos));
DBUG_RETURN((my_off_t) pos);
} | O0 | c | my_tell:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x380a1
jmp 0x380a3
jmp 0x380a5
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x37fd0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x38113
callq 0x29040
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x38d10
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x3810d
movl -0x4(%rbp), %edi
callq 0x427b0
movq %rax, -0x28(%rbp)
callq 0x38d10
movq -0x28(%rbp), %rdx
movl (%rax), %ecx
movl $0x21, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x315c0
jmp 0x3810f
jmp 0x38111
jmp 0x38113
jmp 0x38115
jmp 0x38117
jmp 0x38119
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_tell:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
jmp short $+2
loc_380A1:
jmp short $+2
loc_380A3:
jmp short $+2
loc_380A5:
mov edi, [rbp+var_4]
xor eax, eax
mov ecx, eax
mov edx, 1
mov rsi, rcx
call my_seek
mov [rbp+var_18], rax
cmp [rbp+var_18], 0FFFFFFFFFFFFFFFFh
jnz short loc_38113
call ___errno_location
mov eax, [rax]
mov [rbp+var_1C], eax
call _my_thread_var
mov ecx, [rbp+var_1C]
mov [rax], ecx
mov rax, [rbp+var_10]
and rax, 10h
cmp rax, 0
jz short loc_3810D
mov edi, [rbp+var_4]
call my_filename
mov [rbp+var_28], rax
call _my_thread_var
mov rdx, [rbp+var_28]
mov ecx, [rax]
mov edi, 21h ; '!'
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_3810D:
jmp short $+2
loc_3810F:
jmp short $+2
loc_38111:
jmp short $+2
loc_38113:
jmp short $+2
loc_38115:
jmp short $+2
loc_38117:
jmp short $+2
loc_38119:
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_tell(unsigned int a1, char a2, double a3)
{
unsigned int *v3; // rax
long long v5; // [rsp+8h] [rbp-28h]
int v6; // [rsp+14h] [rbp-1Ch]
long long v7; // [rsp+18h] [rbp-18h]
v7 = my_seek(a1, 0LL, 1u, 0, a3);
if ( v7 == -1 )
{
v6 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a3) = v6;
if ( (a2 & 0x10) != 0 )
{
v5 = my_filename(a1);
v3 = (unsigned int *)my_thread_var(a3);
my_error(0x21u, 0LL, v5, *v3);
}
}
return v7;
}
| my_tell:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001380a1
LAB_001380a1:
JMP 0x001380a3
LAB_001380a3:
JMP 0x001380a5
LAB_001380a5:
MOV EDI,dword ptr [RBP + -0x4]
XOR EAX,EAX
MOV ECX,EAX
MOV EDX,0x1
MOV RSI,RCX
CALL 0x00137fd0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],-0x1
JNZ 0x00138113
CALL 0x00129040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
CALL 0x00138d10
MOV ECX,dword ptr [RBP + -0x1c]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0013810d
MOV EDI,dword ptr [RBP + -0x4]
CALL 0x001427b0
MOV qword ptr [RBP + -0x28],RAX
CALL 0x00138d10
MOV RDX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX]
MOV EDI,0x21
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001315c0
LAB_0013810d:
JMP 0x0013810f
LAB_0013810f:
JMP 0x00138111
LAB_00138111:
JMP 0x00138113
LAB_00138113:
JMP 0x00138115
LAB_00138115:
JMP 0x00138117
LAB_00138117:
JMP 0x00138119
LAB_00138119:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
long my_tell(int4 param_1,ulong param_2)
{
int iVar1;
long lVar2;
int *piVar3;
int8 uVar4;
int4 *puVar5;
lVar2 = my_seek(param_1,0,1);
if (lVar2 == -1) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_2 & 0x10) != 0) {
uVar4 = my_filename(param_1);
puVar5 = (int4 *)_my_thread_var();
my_error(0x21,0,uVar4,*puVar5);
}
}
return lVar2;
}
|
|
1,695 | js_parse_seek_token | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_seek_token(JSParseState *s, const JSParsePos *sp)
{
s->token.line_num = sp->last_line_num;
s->token.col_num = sp->last_col_num;
s->line_num = sp->line_num;
s->col_num = sp->col_num;
s->buf_ptr = sp->ptr;
s->eol = sp->eol;
s->mark = sp->mark;
s->got_lf = sp->got_lf;
return next_token(s);
} | O2 | c | js_parse_seek_token:
movq (%rsi), %rax
movq %rax, 0x24(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x70(%rdi)
movups 0x20(%rsi), %xmm0
movups %xmm0, 0x80(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x58(%rdi)
jmp 0x535fe
| js_parse_seek_token:
mov rax, [rsi]
mov [rdi+24h], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
mov rax, [rsi+18h]
mov [rdi+70h], rax
movups xmm0, xmmword ptr [rsi+20h]
movups xmmword ptr [rdi+80h], xmm0
mov eax, [rsi+10h]
mov [rdi+58h], eax
jmp next_token
| long long js_parse_seek_token(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
__m128 v14; // xmm0
*(_QWORD *)(a1 + 36) = *(_QWORD *)a2;
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a1 + 112) = *(_QWORD *)(a2 + 24);
v14 = *(__m128 *)(a2 + 32);
*(__m128 *)(a1 + 128) = v14;
*(_DWORD *)(a1 + 88) = *(_DWORD *)(a2 + 16);
return next_token(a1, a2, a3, v14, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
}
| js_parse_seek_token:
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x24],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x18]
MOV qword ptr [RDI + 0x70],RAX
MOVUPS XMM0,xmmword ptr [RSI + 0x20]
MOVUPS xmmword ptr [RDI + 0x80],XMM0
MOV EAX,dword ptr [RSI + 0x10]
MOV dword ptr [RDI + 0x58],EAX
JMP 0x001535fe
|
void js_parse_seek_token(long param_1,int8 *param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
*(int8 *)(param_1 + 0x24) = *param_2;
*(int8 *)(param_1 + 0x10) = param_2[1];
*(int8 *)(param_1 + 0x70) = param_2[3];
uVar1 = *(int4 *)((long)param_2 + 0x24);
uVar2 = *(int4 *)(param_2 + 5);
uVar3 = *(int4 *)((long)param_2 + 0x2c);
*(int4 *)(param_1 + 0x80) = *(int4 *)(param_2 + 4);
*(int4 *)(param_1 + 0x84) = uVar1;
*(int4 *)(param_1 + 0x88) = uVar2;
*(int4 *)(param_1 + 0x8c) = uVar3;
*(int4 *)(param_1 + 0x58) = *(int4 *)(param_2 + 2);
next_token();
return;
}
|
|
1,696 | process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | llama.cpp/common/chat.cpp | static common_chat_tool_call process_tool_call(const json & tool_call) {
const auto & arguments = tool_call.at("arguments");
return {
/* .name = */ tool_call.at("name"),
/* .arguments = */ arguments.is_string() ? arguments.get<std::string>() : arguments.dump(),
/* .id = */ tool_call.contains("id") ? tool_call.at("id") : "",
};
} | O3 | cpp | process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x744e7(%rip), %rsi # 0x11e8ec
movq %r14, %rdi
callq 0xaf1c0
movq %rax, %r15
leaq 0x7689b(%rip), %rsi # 0x120cb2
movq %r14, %rdi
callq 0xae818
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbdeb6
leaq 0x20(%rbx), %rdi
cmpb $0x3, (%r15)
jne 0xaa43e
movq %r15, %rsi
callq 0xbdeb6
jmp 0xaa456
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xae3fe
leaq 0x735cc(%rip), %rsi # 0x11da29
movq %r14, %rdi
callq 0xaf384
testb %al, %al
je 0xaa485
leaq 0x735b9(%rip), %rsi # 0x11da29
movq %r14, %rdi
callq 0xaf3e6
movq %rsp, %rdi
movq %rax, %rsi
callq 0x87d7a
jmp 0xaa494
leaq 0x66cc5(%rip), %rsi # 0x111151
movq %rsp, %rdi
callq 0xcdb66
leaq 0x40(%rbx), %rdi
movq %rsp, %rsi
callq 0xbdeb6
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x83b2c
movq %rbx, %rdi
callq 0x88246
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x83b2c
movq %r15, %rdi
callq 0x88246
jmp 0xaa4e1
movq %rax, %r14
jmp 0xaa4f9
movq %rax, %r14
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xaa4f9
movq (%rax), %rsi
incq %rsi
callq 0x20170
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xaa510
movq (%rbx), %rsi
incq %rsi
callq 0x20170
movq %r14, %rdi
callq 0x20ab0
| _ZL17process_tool_callRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEE:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
lea rsi, aKeywordArgumen+9; "arguments"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov r15, rax
lea rsi, aNamespacedSetO+2Fh; "name"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov rdi, rbx
mov rsi, rax
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
lea rdi, [rbx+20h]
cmp byte ptr [r15], 3
jnz short loc_AA43E
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
jmp short loc_AA456
loc_AA43E:
mov rsi, r15
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
loc_AA456:
lea rsi, aToolCallId+0Ah; "id"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz short loc_AA485
lea rsi, aToolCallId+0Ah; "id"
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov rdi, rsp
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_AA494
loc_AA485:
lea rsi, aExampleSpecifi+1Fh; ""
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
loc_AA494:
lea rdi, [rbx+40h]
mov rsi, rsp
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov r15, rsp
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_AA4E1
mov r14, rax
jmp short loc_AA4F9
mov r14, rax
loc_AA4E1:
mov rdi, [rbx+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_AA4F9
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AA4F9:
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_AA510
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AA510:
mov rdi, r14
call __Unwind_Resume
| long long process_tool_call(long long a1, long long a2)
{
_BYTE *v3; // r15
long long v4; // rax
long long v5; // rdi
unsigned __int8 *v6; // rax
unsigned __int8 v8[40]; // [rsp+0h] [rbp-28h] BYREF
v3 = (_BYTE *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"arguments");
v4 = ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"name");
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1,
v4);
v5 = a1 + 32;
if ( *v3 == 3 )
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
v5,
v3);
else
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
v5,
(_DWORD)v3,
-1,
32,
0,
0);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
a2,
"id") )
{
v6 = (unsigned __int8 *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"id");
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v8,
v6);
}
else
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_(
v8,
"");
}
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1 + 64,
v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v8);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v8);
}
| process_tool_call:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x21e8ec]
MOV RDI,R14
CALL 0x001af1c0
MOV R15,RAX
LEA RSI,[0x220cb2]
MOV RDI,R14
CALL 0x001ae818
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001bdeb6
LEA RDI,[RBX + 0x20]
CMP byte ptr [R15],0x3
JNZ 0x001aa43e
LAB_001aa434:
MOV RSI,R15
CALL 0x001bdeb6
JMP 0x001aa456
LAB_001aa43e:
MOV RSI,R15
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001ae3fe
LAB_001aa456:
LEA RSI,[0x21da29]
MOV RDI,R14
CALL 0x001af384
TEST AL,AL
JZ 0x001aa485
LEA RSI,[0x21da29]
MOV RDI,R14
CALL 0x001af3e6
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00187d7a
JMP 0x001aa494
LAB_001aa485:
LEA RSI,[0x211151]
MOV RDI,RSP
CALL 0x001cdb66
LAB_001aa494:
LEA RDI,[RBX + 0x40]
LAB_001aa498:
MOV RSI,RSP
CALL 0x001bdeb6
LAB_001aa4a0:
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00183b2c
MOV RDI,RBX
CALL 0x00188246
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* process_tool_call(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
void process_tool_call(basic_json *param_1)
{
char *pcVar1;
int8 uVar2;
basic_json *pbVar3;
char cVar4;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_28 [16];
pcVar1 = (char *)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
uVar2 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1,uVar2);
if (*pcVar1 == '\x03') {
/* try { // try from 001aa434 to 001aa455 has its CatchHandler @ 001aa4d9 */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1 + 0x20,pcVar1);
}
else {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(param_1 + 0x20,pcVar1,0xffffffff,0x20,0,0);
}
/* try { // try from 001aa456 to 001aa493 has its CatchHandler @ 001aa4de */
cVar4 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
();
if (cVar4 == '\0') {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRA1_KcA1_cTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SK_EE5valueEiE4typeELi0EEEOT_
(abStack_28,"");
}
else {
pbVar3 = (basic_json *)
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA3_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(abStack_28,pbVar3);
}
/* try { // try from 001aa498 to 001aa49f has its CatchHandler @ 001aa4bf */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(param_1 + 0x40,abStack_28);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(abStack_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)abStack_28);
return;
}
|
|
1,697 | spdlog::details::os::fopen_s(_IO_FILE**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/os-inl.h | SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
#ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES
*fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#else
*fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#endif
#if defined(SPDLOG_PREVENT_CHILD_FD)
if (*fp != nullptr) {
auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
::fclose(*fp);
*fp = nullptr;
}
}
#endif
#else // unix
#if defined(SPDLOG_PREVENT_CHILD_FD)
const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
const int fd =
::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
if (fd == -1) {
return true;
}
*fp = ::fdopen(fd, mode.c_str());
if (*fp == nullptr) {
::close(fd);
}
#else
*fp = ::fopen((filename.c_str()), mode.c_str());
#endif
#endif
return *fp == nullptr;
} | O0 | c | spdlog::details::os::fopen_s(_IO_FILE**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20e00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x20e00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x158d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| _ZN6spdlog7details2os7fopen_sEPP8_IO_FILERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESC_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov [rsp+28h+var_18], rdx
mov rdi, [rsp+28h+var_10]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_18]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+28h+var_20]
mov rsi, rax
call _fopen
mov rcx, rax
mov rax, [rsp+28h+var_8]
mov [rax], rcx
mov rax, [rsp+28h+var_8]
cmp qword ptr [rax], 0
setz al
and al, 1
add rsp, 28h
retn
| bool spdlog::details::os::fopen_s(_QWORD *a1, long long a2, long long a3)
{
long long v3; // rax
long long v5; // [rsp+8h] [rbp-20h]
v5 = std::string::c_str(a2);
v3 = std::string::c_str(a3);
*a1 = fopen(v5, v3);
return *a1 == 0LL;
}
| fopen_s:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x10],RDX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00120e00
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00120e00
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
CALL 0x001158d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x20]
CMP qword ptr [RAX],0x0
SETZ AL
AND AL,0x1
ADD RSP,0x28
RET
|
/* spdlog::details::os::fopen_s(_IO_FILE**, std::__cxx11::string const&, std::__cxx11::string
const&) */
bool spdlog::details::os::fopen_s(_IO_FILE **param_1,string *param_2,string *param_3)
{
char *__filename;
char *__modes;
FILE *pFVar1;
__filename = (char *)std::__cxx11::string::c_str(param_2);
__modes = (char *)std::__cxx11::string::c_str(param_3);
pFVar1 = fopen(__filename,__modes);
*param_1 = pFVar1;
return *param_1 == (_IO_FILE *)0x0;
}
|
|
1,698 | query_int_variable | eloqsql/libmariadb/unittest/libmariadb/my_test.h | my_bool query_int_variable(MYSQL *con, const char *var_name, int *var_value)
{
MYSQL_RES *rs;
MYSQL_ROW row;
char query_buffer[MAX_TEST_QUERY_LENGTH];
my_bool is_null;
sprintf(query_buffer,
"SELECT %s",
(const char *) var_name);
FAIL_IF(mysql_query(con, query_buffer), "Query failed");
FAIL_UNLESS(rs= mysql_store_result(con), "Invaliid result set");
FAIL_UNLESS(row= mysql_fetch_row(rs), "Nothing to fetch");
is_null= row[0] == NULL;
if (!is_null)
*var_value= atoi(row[0]);
mysql_free_result(rs);
return is_null;
} | O0 | c | query_int_variable:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x150(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x158(%rbp), %rdx
leaq 0x50865(%rip), %rsi # 0x65737
movb $0x0, %al
callq 0x140f0
movq -0x150(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x38a70
cmpl $0x0, %eax
je 0x14f1e
leaq 0x50698(%rip), %rdi # 0x65590
leaq 0x50842(%rip), %rsi # 0x65741
leaq 0x506b2(%rip), %rdx # 0x655b8
movl $0x1a2, %ecx # imm = 0x1A2
movb $0x0, %al
callq 0x2fc40
movb $0x1, -0x141(%rbp)
jmp 0x15005
jmp 0x14f20
jmp 0x14f22
movq -0x150(%rbp), %rdi
callq 0x3a0c0
movq %rax, -0x168(%rbp)
cmpq $0x0, %rax
jne 0x14f68
leaq 0x5064e(%rip), %rdi # 0x65590
leaq 0x50805(%rip), %rsi # 0x6574e
leaq 0x50668(%rip), %rdx # 0x655b8
movl $0x1a3, %ecx # imm = 0x1A3
movb $0x0, %al
callq 0x2fc40
movb $0x1, -0x141(%rbp)
jmp 0x15005
jmp 0x14f6a
jmp 0x14f6c
movq -0x168(%rbp), %rdi
callq 0x3a400
movq %rax, -0x170(%rbp)
cmpq $0x0, %rax
jne 0x14faf
leaq 0x50604(%rip), %rdi # 0x65590
leaq 0x507cf(%rip), %rsi # 0x65762
leaq 0x5061e(%rip), %rdx # 0x655b8
movl $0x1a4, %ecx # imm = 0x1A4
movb $0x0, %al
callq 0x2fc40
movb $0x1, -0x141(%rbp)
jmp 0x15005
jmp 0x14fb1
movq -0x170(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x171(%rbp)
cmpb $0x0, -0x171(%rbp)
jne 0x14fed
movq -0x170(%rbp), %rax
movq (%rax), %rdi
callq 0x146c0
movl %eax, %ecx
movq -0x160(%rbp), %rax
movl %ecx, (%rax)
movq -0x168(%rbp), %rdi
callq 0x31900
movb -0x171(%rbp), %al
movb %al, -0x141(%rbp)
movb -0x141(%rbp), %al
movb %al, -0x172(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x15032
movb -0x172(%rbp), %al
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
callq 0x144c0
nopw (%rax,%rax)
| query_int_variable:
push rbp
mov rbp, rsp
sub rsp, 180h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_150], rdi
mov [rbp+var_158], rsi
mov [rbp+var_160], rdx
lea rdi, [rbp+var_140]
mov rdx, [rbp+var_158]
lea rsi, aSelectS; "SELECT %s"
mov al, 0
call _sprintf
mov rdi, [rbp+var_150]
lea rsi, [rbp+var_140]
call mysql_query
cmp eax, 0
jz short loc_14F1E
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aQueryFailed; "Query failed"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A2h
mov al, 0
call diag
mov [rbp+var_141], 1
jmp loc_15005
loc_14F1E:
jmp short $+2
loc_14F20:
jmp short $+2
loc_14F22:
mov rdi, [rbp+var_150]
call mysql_store_result
mov [rbp+var_168], rax
cmp rax, 0
jnz short loc_14F68
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aInvaliidResult; "Invaliid result set"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A3h
mov al, 0
call diag
mov [rbp+var_141], 1
jmp loc_15005
loc_14F68:
jmp short $+2
loc_14F6A:
jmp short $+2
loc_14F6C:
mov rdi, [rbp+var_168]
call mysql_fetch_row
mov [rbp+var_170], rax
cmp rax, 0
jnz short loc_14FAF
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aNothingToFetch; "Nothing to fetch"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A4h
mov al, 0
call diag
mov [rbp+var_141], 1
jmp short loc_15005
loc_14FAF:
jmp short $+2
loc_14FB1:
mov rax, [rbp+var_170]
cmp qword ptr [rax], 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_171], al
cmp [rbp+var_171], 0
jnz short loc_14FED
mov rax, [rbp+var_170]
mov rdi, [rax]
call _atoi
mov ecx, eax
mov rax, [rbp+var_160]
mov [rax], ecx
loc_14FED:
mov rdi, [rbp+var_168]
call mysql_free_result
mov al, [rbp+var_171]
mov [rbp+var_141], al
loc_15005:
mov al, [rbp+var_141]
mov [rbp+var_172], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_15032
mov al, [rbp+var_172]
add rsp, 180h
pop rbp
retn
loc_15032:
call ___stack_chk_fail
| char query_int_variable(long long a1, const char *a2, _DWORD *a3)
{
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
int v7; // r8d
int v8; // r9d
bool v10; // [rsp+Fh] [rbp-171h]
_QWORD *row; // [rsp+10h] [rbp-170h]
long long v12; // [rsp+18h] [rbp-168h]
_BYTE v15[312]; // [rsp+40h] [rbp-140h] BYREF
unsigned long long v16; // [rsp+178h] [rbp-8h]
v16 = __readfsqword(0x28u);
sprintf(v15, "SELECT %s", a2);
if ( (unsigned int)mysql_query(a1, v15) )
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Query failed",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
418,
v3,
v4);
return 1;
}
else
{
v12 = mysql_store_result(a1);
if ( v12 )
{
row = (_QWORD *)mysql_fetch_row(v12);
if ( row )
{
v10 = *row == 0LL;
if ( *row )
*a3 = atoi(*row);
mysql_free_result(v12);
return v10;
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Nothing to fetch",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
420,
v7,
v8);
return 1;
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Invaliid result set",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
419,
v5,
v6);
return 1;
}
}
}
| query_int_variable:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x150],RDI
MOV qword ptr [RBP + -0x158],RSI
MOV qword ptr [RBP + -0x160],RDX
LEA RDI,[RBP + -0x140]
MOV RDX,qword ptr [RBP + -0x158]
LEA RSI,[0x165737]
MOV AL,0x0
CALL 0x001140f0
MOV RDI,qword ptr [RBP + -0x150]
LEA RSI,[RBP + -0x140]
CALL 0x00138a70
CMP EAX,0x0
JZ 0x00114f1e
LEA RDI,[0x165590]
LEA RSI,[0x165741]
LEA RDX,[0x1655b8]
MOV ECX,0x1a2
MOV AL,0x0
CALL 0x0012fc40
MOV byte ptr [RBP + -0x141],0x1
JMP 0x00115005
LAB_00114f1e:
JMP 0x00114f20
LAB_00114f20:
JMP 0x00114f22
LAB_00114f22:
MOV RDI,qword ptr [RBP + -0x150]
CALL 0x0013a0c0
MOV qword ptr [RBP + -0x168],RAX
CMP RAX,0x0
JNZ 0x00114f68
LEA RDI,[0x165590]
LEA RSI,[0x16574e]
LEA RDX,[0x1655b8]
MOV ECX,0x1a3
MOV AL,0x0
CALL 0x0012fc40
MOV byte ptr [RBP + -0x141],0x1
JMP 0x00115005
LAB_00114f68:
JMP 0x00114f6a
LAB_00114f6a:
JMP 0x00114f6c
LAB_00114f6c:
MOV RDI,qword ptr [RBP + -0x168]
CALL 0x0013a400
MOV qword ptr [RBP + -0x170],RAX
CMP RAX,0x0
JNZ 0x00114faf
LEA RDI,[0x165590]
LEA RSI,[0x165762]
LEA RDX,[0x1655b8]
MOV ECX,0x1a4
MOV AL,0x0
CALL 0x0012fc40
MOV byte ptr [RBP + -0x141],0x1
JMP 0x00115005
LAB_00114faf:
JMP 0x00114fb1
LAB_00114fb1:
MOV RAX,qword ptr [RBP + -0x170]
CMP qword ptr [RAX],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x171],AL
CMP byte ptr [RBP + -0x171],0x0
JNZ 0x00114fed
MOV RAX,qword ptr [RBP + -0x170]
MOV RDI,qword ptr [RAX]
CALL 0x001146c0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x160]
MOV dword ptr [RAX],ECX
LAB_00114fed:
MOV RDI,qword ptr [RBP + -0x168]
CALL 0x00131900
MOV AL,byte ptr [RBP + -0x171]
MOV byte ptr [RBP + -0x141],AL
LAB_00115005:
MOV AL,byte ptr [RBP + -0x141]
MOV byte ptr [RBP + -0x172],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00115032
MOV AL,byte ptr [RBP + -0x172]
ADD RSP,0x180
POP RBP
RET
LAB_00115032:
CALL 0x001144c0
|
int8 query_int_variable(int8 param_1,int8 param_2,int *param_3)
{
int iVar1;
long lVar2;
long *plVar3;
long in_FS_OFFSET;
bool local_149;
char local_148 [312];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sprintf(local_148,"SELECT %s",param_2);
iVar1 = mysql_query(param_1,local_148);
if (iVar1 == 0) {
lVar2 = mysql_store_result(param_1);
if (lVar2 == 0) {
diag("Error: %s (%s: %d)","Invaliid result set",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x1a3
);
local_149 = true;
}
else {
plVar3 = (long *)mysql_fetch_row(lVar2);
if (plVar3 == (long *)0x0) {
diag("Error: %s (%s: %d)","Nothing to fetch",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
0x1a4);
local_149 = true;
}
else {
local_149 = *plVar3 == 0;
if (!local_149) {
iVar1 = atoi((char *)*plVar3);
*param_3 = iVar1;
}
mysql_free_result(lVar2);
}
}
}
else {
diag("Error: %s (%s: %d)","Query failed",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",0x1a2);
local_149 = true;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_149);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,699 | query_int_variable | eloqsql/libmariadb/unittest/libmariadb/my_test.h | my_bool query_int_variable(MYSQL *con, const char *var_name, int *var_value)
{
MYSQL_RES *rs;
MYSQL_ROW row;
char query_buffer[MAX_TEST_QUERY_LENGTH];
my_bool is_null;
sprintf(query_buffer,
"SELECT %s",
(const char *) var_name);
FAIL_IF(mysql_query(con, query_buffer), "Query failed");
FAIL_UNLESS(rs= mysql_store_result(con), "Invaliid result set");
FAIL_UNLESS(row= mysql_fetch_row(rs), "Nothing to fetch");
is_null= row[0] == NULL;
if (!is_null)
*var_value= atoi(row[0]);
mysql_free_result(rs);
return is_null;
} | O3 | c | query_int_variable:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, %rbx
movq %rsi, %r8
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x3160d(%rip), %rcx # 0x46387
leaq -0x150(%rbp), %r15
movl $0x12c, %edx # imm = 0x12C
movq %r15, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x142b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bbf9
testl %eax, %eax
je 0x14dec
leaq 0x31435(%rip), %rdi # 0x461e0
leaq 0x315df(%rip), %rsi # 0x46391
leaq 0x3144f(%rip), %rdx # 0x46208
movl $0x1a2, %ecx # imm = 0x1A2
xorl %eax, %eax
callq 0x264ef
movb $0x1, %r14b
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x14e64
movl %r14d, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2caf1
testq %rax, %rax
je 0x14e26
movq %rax, %r15
movq %rax, %rdi
callq 0x2ccf4
testq %rax, %rax
je 0x14e45
movq (%rax), %rdi
testq %rdi, %rdi
sete %r14b
je 0x14e1c
callq 0x14710
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x278a6
jmp 0x14dc8
leaq 0x313b3(%rip), %rdi # 0x461e0
leaq 0x3156a(%rip), %rsi # 0x4639e
leaq 0x313cd(%rip), %rdx # 0x46208
movl $0x1a3, %ecx # imm = 0x1A3
jmp 0x14dbe
leaq 0x31394(%rip), %rdi # 0x461e0
leaq 0x3155f(%rip), %rsi # 0x463b2
leaq 0x313ae(%rip), %rdx # 0x46208
movl $0x1a4, %ecx # imm = 0x1A4
jmp 0x14dbe
callq 0x14520
| query_int_variable:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 138h
mov rbx, rdx
mov r8, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
lea rcx, aSelectS; "SELECT %s"
lea r15, [rbp+var_150]
mov edx, 12Ch
mov rdi, r15
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov rdi, r14
mov rsi, r15
call mysql_query
test eax, eax
jz short loc_14DEC
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aQueryFailed; "Query failed"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A2h
loc_14DBE:
xor eax, eax
call diag
mov r14b, 1
loc_14DC8:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz loc_14E64
mov eax, r14d
add rsp, 138h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_14DEC:
mov rdi, r14
call mysql_store_result
test rax, rax
jz short loc_14E26
mov r15, rax
mov rdi, rax
call mysql_fetch_row
test rax, rax
jz short loc_14E45
mov rdi, [rax]
test rdi, rdi
setz r14b
jz short loc_14E1C
call _atoi
mov [rbx], eax
loc_14E1C:
mov rdi, r15
call mysql_free_result
jmp short loc_14DC8
loc_14E26:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aInvaliidResult; "Invaliid result set"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A3h
jmp loc_14DBE
loc_14E45:
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aNothingToFetch; "Nothing to fetch"
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 1A4h
jmp loc_14DBE
loc_14E64:
call ___stack_chk_fail
| long long query_int_variable(long long a1, const char *a2, _DWORD *a3)
{
unsigned int v4; // r14d
int v5; // r8d
int v6; // r9d
const char *v7; // rsi
int v8; // ecx
long long v10; // rax
long long v11; // r15
_QWORD *row; // rax
_BYTE v13[304]; // [rsp+0h] [rbp-150h] BYREF
unsigned long long v14; // [rsp+130h] [rbp-20h]
v4 = a1;
v14 = __readfsqword(0x28u);
__sprintf_chk(v13, 1LL, 300LL, "SELECT %s", a2);
if ( (unsigned int)mysql_query(a1, v13) )
{
v7 = "Query failed";
v8 = 418;
LABEL_3:
diag(
(unsigned int)"Error: %s (%s: %d)",
(_DWORD)v7,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",
v8,
v5,
v6);
LOBYTE(v4) = 1;
return v4;
}
v10 = mysql_store_result(a1);
if ( !v10 )
{
v7 = "Invaliid result set";
v8 = 419;
goto LABEL_3;
}
v11 = v10;
row = (_QWORD *)mysql_fetch_row(v10);
if ( !row )
{
v7 = "Nothing to fetch";
v8 = 420;
goto LABEL_3;
}
LOBYTE(v4) = *row == 0LL;
if ( *row )
*a3 = atoi();
mysql_free_result(v11);
return v4;
}
| query_int_variable:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x138
MOV RBX,RDX
MOV R8,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RCX,[0x146387]
LEA R15,[RBP + -0x150]
MOV EDX,0x12c
MOV RDI,R15
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001142b0
MOV RDI,R14
MOV RSI,R15
CALL 0x0012bbf9
TEST EAX,EAX
JZ 0x00114dec
LEA RDI,[0x1461e0]
LEA RSI,[0x146391]
LEA RDX,[0x146208]
MOV ECX,0x1a2
LAB_00114dbe:
XOR EAX,EAX
CALL 0x001264ef
MOV R14B,0x1
LAB_00114dc8:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00114e64
MOV EAX,R14D
ADD RSP,0x138
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00114dec:
MOV RDI,R14
CALL 0x0012caf1
TEST RAX,RAX
JZ 0x00114e26
MOV R15,RAX
MOV RDI,RAX
CALL 0x0012ccf4
TEST RAX,RAX
JZ 0x00114e45
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
SETZ R14B
JZ 0x00114e1c
CALL 0x00114710
MOV dword ptr [RBX],EAX
LAB_00114e1c:
MOV RDI,R15
CALL 0x001278a6
JMP 0x00114dc8
LAB_00114e26:
LEA RDI,[0x1461e0]
LEA RSI,[0x14639e]
LEA RDX,[0x146208]
MOV ECX,0x1a3
JMP 0x00114dbe
LAB_00114e45:
LEA RDI,[0x1461e0]
LEA RSI,[0x1463b2]
LEA RDX,[0x146208]
MOV ECX,0x1a4
JMP 0x00114dbe
LAB_00114e64:
CALL 0x00114520
|
ulong query_int_variable(int8 param_1,int8 param_2,int *param_3)
{
int iVar1;
long lVar2;
int8 *puVar3;
int8 uVar4;
char *pcVar5;
int7 uVar7;
ulong uVar6;
long in_FS_OFFSET;
int1 local_158 [304];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
__sprintf_chk(local_158,1,300,"SELECT %s",param_2);
iVar1 = mysql_query(param_1,local_158);
uVar7 = (int7)((ulong)param_1 >> 8);
if (iVar1 == 0) {
lVar2 = mysql_store_result(param_1);
if (lVar2 == 0) {
pcVar5 = "Invaliid result set";
uVar4 = 0x1a3;
}
else {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if (puVar3 != (int8 *)0x0) {
pcVar5 = (char *)*puVar3;
uVar6 = CONCAT71(uVar7,pcVar5 == (char *)0x0);
if (pcVar5 != (char *)0x0) {
iVar1 = atoi(pcVar5);
*param_3 = iVar1;
}
mysql_free_result(lVar2);
goto LAB_00114dc8;
}
pcVar5 = "Nothing to fetch";
uVar4 = 0x1a4;
}
}
else {
pcVar5 = "Query failed";
uVar4 = 0x1a2;
}
diag("Error: %s (%s: %d)",pcVar5,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h",uVar4);
uVar6 = CONCAT71(uVar7,1);
LAB_00114dc8:
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return uVar6 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.