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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
64,000 |
ma_fetch_keypage
|
eloqsql/storage/maria/ma_page.c
|
my_bool _ma_fetch_keypage(MARIA_PAGE *page, MARIA_HA *info,
const MARIA_KEYDEF *keyinfo,
my_off_t pos, enum pagecache_page_lock lock,
int level, uchar *buff,
my_bool return_buffer __attribute__ ((unused)))
{
uchar *tmp;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
DBUG_ENTER("_ma_fetch_keypage");
DBUG_PRINT("enter",("page: %lu", (ulong) (pos / block_size)));
tmp= pagecache_read(share->pagecache, &share->kfile,
(pgcache_page_no_t) (pos / block_size), level, buff,
share->page_type, lock, &page_link.link);
if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED)
{
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE || lock == PAGECACHE_LOCK_READ);
page_link.unlock= (lock == PAGECACHE_LOCK_WRITE ?
PAGECACHE_LOCK_WRITE_UNLOCK :
PAGECACHE_LOCK_READ_UNLOCK);
page_link.changed= 0;
push_dynamic(&info->pinned_pages, (void*) &page_link);
page->link_offset= info->pinned_pages.elements-1;
}
if (tmp == info->buff)
info->keyread_buff_used=1;
else if (!tmp)
{
DBUG_PRINT("error",("Got errno: %d from pagecache_read",my_errno));
info->last_keypage=HA_OFFSET_ERROR;
_ma_set_fatal_error(info, my_errno);
DBUG_RETURN(1);
}
info->last_keypage= pos;
/*
Setup page structure to make pages easy to use
This is same as page_fill_info, but here inlined as this si used
so often.
*/
page->info= info;
page->keyinfo= keyinfo;
page->buff= tmp;
page->pos= pos;
page->size= _ma_get_page_used(share, tmp);
page->org_size= page->size; /* For debugging */
page->flag= _ma_get_keypage_flag(share, tmp);
page->node= ((page->flag & KEYPAGE_FLAG_ISNOD) ?
share->base.key_reflength : 0);
#ifdef EXTRA_DEBUG
{
uint page_size= page->size;
if (page_size < 4 || page_size > share->max_index_block_size ||
_ma_get_keynr(share, tmp) != keyinfo->key_nr)
{
DBUG_PRINT("error",("page %lu had wrong page length: %u page_header: %u keynr: %u",
(ulong) (pos / block_size), page_size,
share->keypage_header,
_ma_get_keynr(share, tmp)));
DBUG_DUMP("page", tmp, page_size);
info->last_keypage = HA_OFFSET_ERROR;
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
}
}
#endif
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_fetch_keypage:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r10d
movl %r8d, %r12d
movq %rcx, %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rbp), %r8
movq (%rsi), %r15
movl 0x7bc(%r15), %ecx
movq 0x600(%r15), %rdi
leaq 0x750(%r15), %rsi
movq %rax, -0x38(%rbp)
xorl %edx, %edx
divq %rcx
movl 0x7d4(%r15), %r9d
leaq -0x50(%rbp), %r11
movq %rax, %rdx
movl %r10d, %ecx
pushq %r11
pushq %r12
callq 0x3b9ca
addq $0x10, %rsp
movq %rax, %r13
testl %r12d, %r12d
je 0x709fc
xorl %eax, %eax
cmpl $0x4, %r12d
sete %al
addl $0x5, %eax
leaq -0x50(%rbp), %rsi
movl %eax, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x2e8(%r14), %rdi
callq 0x92dda
movl 0x2f0(%r14), %eax
decl %eax
movl %eax, 0x30(%rbx)
cmpq 0x378(%r14), %r13
je 0x70a28
testq %r13, %r13
jne 0x70a30
movq $-0x1, 0x440(%r14)
callq 0xa63fe
movl (%rax), %esi
movq %r14, %rdi
callq 0x4056c
movb $0x1, %al
jmp 0x70a8e
movb $0x1, 0x685(%r14)
movq -0x38(%rbp), %rax
movq %rax, 0x440(%r14)
movq %r14, (%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movl 0x744(%r15), %eax
movzwl -0x2(%r13,%rax), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x20(%rbx)
movl %eax, 0x24(%rbx)
movl 0x744(%r15), %eax
addl $-0x3, %eax
movzbl (%r13,%rax), %ecx
movl %ecx, 0x2c(%rbx)
xorl %eax, %eax
testb $0x1, %cl
je 0x70a89
movl 0x3e4(%r15), %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_fetch_keypage:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r10d, r9d
mov r12d, r8d
mov rax, rcx
mov [rbp+var_30], rdx
mov r14, rsi
mov rbx, rdi
mov r8, [rbp+arg_0]
mov r15, [rsi]
mov ecx, [r15+7BCh]
mov rdi, [r15+600h]
lea rsi, [r15+750h]
mov [rbp+var_38], rax
xor edx, edx
div rcx
mov r9d, [r15+7D4h]
lea r11, [rbp+var_50]
mov rdx, rax
mov ecx, r10d
push r11
push r12
call pagecache_read
add rsp, 10h
mov r13, rax
test r12d, r12d
jz short loc_709FC
xor eax, eax
cmp r12d, 4
setz al
add eax, 5
lea rsi, [rbp+var_50]
mov [rsi+8], eax
mov byte ptr [rsi+10h], 0
lea rdi, [r14+2E8h]
call insert_dynamic
mov eax, [r14+2F0h]
dec eax
mov [rbx+30h], eax
loc_709FC:
cmp r13, [r14+378h]
jz short loc_70A28
test r13, r13
jnz short loc_70A30
mov qword ptr [r14+440h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov esi, [rax]
mov rdi, r14
call _ma_set_fatal_error
mov al, 1
jmp short loc_70A8E
loc_70A28:
mov byte ptr [r14+685h], 1
loc_70A30:
mov rax, [rbp+var_38]
mov [r14+440h], rax
mov [rbx], r14
mov rcx, [rbp+var_30]
mov [rbx+8], rcx
mov [rbx+10h], r13
mov [rbx+18h], rax
mov eax, [r15+744h]
movzx eax, word ptr [r13+rax-2]
rol ax, 8
movzx eax, ax
mov [rbx+20h], eax
mov [rbx+24h], eax
mov eax, [r15+744h]
add eax, 0FFFFFFFDh
movzx ecx, byte ptr [r13+rax+0]
mov [rbx+2Ch], ecx
xor eax, eax
test cl, 1
jz short loc_70A89
mov eax, [r15+3E4h]
loc_70A89:
mov [rbx+28h], eax
xor eax, eax
loc_70A8E:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char ma_fetch_keypage(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
unsigned int a5,
int a6,
long long a7)
{
_DWORD *v11; // r15
unsigned long long v12; // rcx
long long v13; // rdi
const char *v14; // rsi
long long v15; // r13
unsigned int *v16; // rax
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
int v20; // r9d
long long v22; // rax
int v23; // ecx
int v24; // eax
long long v25; // [rsp+0h] [rbp-50h] BYREF
int v26; // [rsp+8h] [rbp-48h]
char v27; // [rsp+10h] [rbp-40h]
long long v28; // [rsp+18h] [rbp-38h]
long long v29; // [rsp+20h] [rbp-30h]
v29 = a3;
v11 = *(_DWORD **)a2;
v12 = *(unsigned int *)(*(_QWORD *)a2 + 1980LL);
v13 = *(_QWORD *)(*(_QWORD *)a2 + 1536LL);
v14 = (const char *)(*(_QWORD *)a2 + 1872LL);
v28 = a4;
v15 = pagecache_read(v13, (long long)v14, a4 / v12, a6, a7, v11[501], a5, &v25);
if ( a5 )
{
v14 = (const char *)&v25;
v26 = (a5 == 4) + 5;
v27 = 0;
v13 = a2 + 744;
insert_dynamic(a2 + 744, &v25);
*(_DWORD *)(a1 + 48) = *(_DWORD *)(a2 + 752) - 1;
}
if ( v15 == *(_QWORD *)(a2 + 888) )
{
*(_BYTE *)(a2 + 1669) = 1;
}
else if ( !v15 )
{
*(_QWORD *)(a2 + 1088) = -1LL;
v16 = (unsigned int *)my_thread_var(v13, v14);
ma_set_fatal_error((_DWORD *)a2, *v16, v17, v18, v19, v20);
return 1;
}
v22 = v28;
*(_QWORD *)(a2 + 1088) = v28;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = v29;
*(_QWORD *)(a1 + 16) = v15;
*(_QWORD *)(a1 + 24) = v22;
LOWORD(v22) = __ROL2__(*(_WORD *)(v15 + (unsigned int)v11[465] - 2), 8);
*(_DWORD *)(a1 + 32) = (unsigned __int16)v22;
*(_DWORD *)(a1 + 36) = (unsigned __int16)v22;
v23 = *(unsigned __int8 *)(v15 + (unsigned int)(v11[465] - 3));
*(_DWORD *)(a1 + 44) = v23;
v24 = 0;
if ( (v23 & 1) != 0 )
v24 = v11[249];
*(_DWORD *)(a1 + 40) = v24;
return 0;
}
|
_ma_fetch_keypage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R10D,R9D
MOV R12D,R8D
MOV RAX,RCX
MOV qword ptr [RBP + -0x30],RDX
MOV R14,RSI
MOV RBX,RDI
MOV R8,qword ptr [RBP + 0x10]
MOV R15,qword ptr [RSI]
MOV ECX,dword ptr [R15 + 0x7bc]
MOV RDI,qword ptr [R15 + 0x600]
LEA RSI,[R15 + 0x750]
MOV qword ptr [RBP + -0x38],RAX
XOR EDX,EDX
DIV RCX
MOV R9D,dword ptr [R15 + 0x7d4]
LEA R11,[RBP + -0x50]
MOV RDX,RAX
MOV ECX,R10D
PUSH R11
PUSH R12
CALL 0x0013b9ca
ADD RSP,0x10
MOV R13,RAX
TEST R12D,R12D
JZ 0x001709fc
XOR EAX,EAX
CMP R12D,0x4
SETZ AL
ADD EAX,0x5
LEA RSI,[RBP + -0x50]
MOV dword ptr [RSI + 0x8],EAX
MOV byte ptr [RSI + 0x10],0x0
LEA RDI,[R14 + 0x2e8]
CALL 0x00192dda
MOV EAX,dword ptr [R14 + 0x2f0]
DEC EAX
MOV dword ptr [RBX + 0x30],EAX
LAB_001709fc:
CMP R13,qword ptr [R14 + 0x378]
JZ 0x00170a28
TEST R13,R13
JNZ 0x00170a30
MOV qword ptr [R14 + 0x440],-0x1
CALL 0x001a63fe
MOV ESI,dword ptr [RAX]
MOV RDI,R14
CALL 0x0014056c
MOV AL,0x1
JMP 0x00170a8e
LAB_00170a28:
MOV byte ptr [R14 + 0x685],0x1
LAB_00170a30:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [R14 + 0x440],RAX
MOV qword ptr [RBX],R14
MOV RCX,qword ptr [RBP + -0x30]
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RBX + 0x10],R13
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R15 + 0x744]
MOVZX EAX,word ptr [R13 + RAX*0x1 + -0x2]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBX + 0x20],EAX
MOV dword ptr [RBX + 0x24],EAX
MOV EAX,dword ptr [R15 + 0x744]
ADD EAX,-0x3
MOVZX ECX,byte ptr [R13 + RAX*0x1]
MOV dword ptr [RBX + 0x2c],ECX
XOR EAX,EAX
TEST CL,0x1
JZ 0x00170a89
MOV EAX,dword ptr [R15 + 0x3e4]
LAB_00170a89:
MOV dword ptr [RBX + 0x28],EAX
XOR EAX,EAX
LAB_00170a8e:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
_ma_fetch_keypage(int8 *param_1,long *param_2,int8 param_3,ulong param_4,int param_5,
int4 param_6,int8 param_7)
{
byte bVar1;
ushort uVar2;
long lVar3;
uint uVar4;
int4 uVar5;
long lVar6;
int4 *puVar7;
int1 local_58 [8];
int local_50;
int1 local_48;
ulong local_40;
int8 local_38;
lVar3 = *param_2;
local_40 = param_4;
local_38 = param_3;
lVar6 = pagecache_read(*(int8 *)(lVar3 + 0x600),lVar3 + 0x750,
param_4 / *(uint *)(lVar3 + 0x7bc),param_6,param_7,
*(int4 *)(lVar3 + 0x7d4),param_5,local_58);
if (param_5 != 0) {
local_50 = (param_5 == 4) + 5;
local_48 = 0;
insert_dynamic(param_2 + 0x5d);
*(int *)(param_1 + 6) = (int)param_2[0x5e] + -1;
}
if (lVar6 == param_2[0x6f]) {
*(int1 *)((long)param_2 + 0x685) = 1;
}
else if (lVar6 == 0) {
param_2[0x88] = -1;
puVar7 = (int4 *)_my_thread_var();
_ma_set_fatal_error(param_2,*puVar7);
return 1;
}
param_2[0x88] = local_40;
*param_1 = param_2;
param_1[1] = local_38;
param_1[2] = lVar6;
param_1[3] = local_40;
uVar2 = *(ushort *)(lVar6 + -2 + (ulong)*(uint *)(lVar3 + 0x744));
uVar4 = (uint)(ushort)(uVar2 << 8 | uVar2 >> 8);
*(uint *)(param_1 + 4) = uVar4;
*(uint *)((long)param_1 + 0x24) = uVar4;
bVar1 = *(byte *)(lVar6 + (ulong)(*(int *)(lVar3 + 0x744) - 3));
*(uint *)((long)param_1 + 0x2c) = (uint)bVar1;
uVar5 = 0;
if ((bVar1 & 1) != 0) {
uVar5 = *(int4 *)(lVar3 + 0x3e4);
}
*(int4 *)(param_1 + 5) = uVar5;
return 0;
}
|
|
64,001 |
mysql_stmt_reset_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_reset_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_reset,
(parms->stmt),
parms->stmt->mysql,
my_bool,
r_my_bool)
}
|
O0
|
c
|
mysql_stmt_reset_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x46b80
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_reset_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_reset
mov [rbp+var_11], al
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+8], cl
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
|
long long mysql_stmt_reset_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_stmt_reset(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_stmt_reset_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00146b80
MOV byte ptr [RBP + -0x11],AL
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x8],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_stmt_reset_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_reset(*param_1);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
64,002 |
minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const
|
monkey531[P]llama/common/minja.hpp
|
std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
switch (*it) {
case 'n': result += '\n'; break;
case 'r': result += '\r'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'f': result += '\f'; break;
case '\\': result += '\\'; break;
default:
if (*it == quote) {
result += quote;
} else {
result += *it;
}
break;
}
} else if (*it == '\\') {
escape = true;
} else if (*it == quote) {
++it;
return std::make_unique<std::string>(std::move(result));
} else {
result += *it;
}
}
return nullptr;
};
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"') return doParse('"');
if (*it == '\'') return doParse('\'');
return nullptr;
}
|
O2
|
cpp
|
minja::Parser::parseString[abi:cxx11]()::'lambda'(char)::operator()[abi:cxx11](char) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rax
cmpq %rcx, %rax
je 0x67bcd
movl %edx, %ebp
cmpb %bpl, (%rax)
jne 0x67bcd
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb $0x0, (%rdx)
xorl %edx, %edx
movl $0x1a29, %r12d # imm = 0x1A29
leaq 0x4cafe(%rip), %r13 # 0xb4674
leaq 0x8(%rsp), %r14
leaq 0x1(%rax), %rsi
movq %rsi, 0x20(%r15)
cmpq %rcx, %rsi
je 0x67bd3
movb (%rsi), %cl
testb $0x1, %dl
je 0x67baa
movsbl %cl, %eax
addl $-0x5c, %eax
rorl %eax
cmpl $0xc, %eax
ja 0x67bb6
btl %eax, %r12d
jae 0x67bb6
movl %eax, %eax
movb (%rax,%r13), %cl
jmp 0x67bb6
movb $0x1, %dl
cmpb $0x5c, %cl
je 0x67bc3
cmpb %bpl, %cl
je 0x67bf3
movsbl %cl, %esi
movq %r14, %rdi
callq 0x24760
xorl %edx, %edx
movq 0x18(%r15), %rcx
movq 0x20(%r15), %rax
jmp 0x67b7b
andq $0x0, (%rbx)
jmp 0x67be1
andq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x251d8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2, %rax
movq %rax, 0x20(%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x67c21
jmp 0x67bd7
jmp 0x67c0c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x251d8
movq %rbx, %rdi
callq 0x24f80
|
_ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov r15, [rsi]
mov rcx, [r15+18h]
mov rax, [r15+20h]
cmp rax, rcx
jz short loc_67BCD
mov ebp, edx
cmp [rax], bpl
jnz short loc_67BCD
lea rdx, [rsp+58h+var_40]
mov [rdx-10h], rdx
and qword ptr [rdx-8], 0
mov byte ptr [rdx], 0
xor edx, edx
mov r12d, 1A29h
lea r13, unk_B4674
lea r14, [rsp+58h+var_50]
loc_67B7B:
lea rsi, [rax+1]
mov [r15+20h], rsi
cmp rsi, rcx
jz short loc_67BD3
mov cl, [rsi]
test dl, 1
jz short loc_67BAA
movsx eax, cl
add eax, 0FFFFFFA4h
ror eax, 1
cmp eax, 0Ch
ja short loc_67BB6
bt r12d, eax
jnb short loc_67BB6
mov eax, eax
mov cl, [rax+r13]
jmp short loc_67BB6
loc_67BAA:
mov dl, 1
cmp cl, 5Ch ; '\'
jz short loc_67BC3
cmp cl, bpl
jz short loc_67BF3
loc_67BB6:
movsx esi, cl
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
xor edx, edx
loc_67BC3:
mov rcx, [r15+18h]
mov rax, [r15+20h]
jmp short loc_67B7B
loc_67BCD:
and qword ptr [rbx], 0
jmp short loc_67BE1
loc_67BD3:
and qword ptr [rbx], 0
loc_67BD7:
lea rdi, [rsp+58h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_67BE1:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_67BF3:
add rax, 2
mov [r15+20h], rax
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZSt11make_uniqueINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS5_EENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<std::string,std::string>(std::string &&)
jmp short loc_67BD7
jmp short $+2
loc_67C0C:
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
_QWORD *a1,
long long *a2,
char a3)
{
long long v3; // r15
_BYTE *v4; // rcx
_BYTE *v5; // rax
long long v7; // rdx
int v8; // r12d
char v9; // cl
unsigned int v10; // eax
_QWORD v12[2]; // [rsp+8h] [rbp-50h] BYREF
char v13; // [rsp+18h] [rbp-40h] BYREF
v3 = *a2;
v4 = *(_BYTE **)(*a2 + 24);
v5 = *(_BYTE **)(*a2 + 32);
if ( v5 == v4 || *v5 != a3 )
{
*a1 = 0LL;
return a1;
}
v12[0] = &v13;
v12[1] = 0LL;
v13 = 0;
v7 = 0LL;
v8 = 6697;
while ( 1 )
{
*(_QWORD *)(v3 + 32) = v5 + 1;
if ( v5 + 1 == v4 )
{
*a1 = 0LL;
goto LABEL_15;
}
v9 = v5[1];
if ( (v7 & 1) != 0 )
{
v10 = __ROR4__(v9 - 92, 1);
if ( v10 <= 0xC )
{
if ( _bittest(&v8, v10) )
v9 = byte_B4674[v10];
}
goto LABEL_11;
}
LOBYTE(v7) = 1;
if ( v9 == 92 )
goto LABEL_12;
if ( v9 == a3 )
break;
LABEL_11:
std::string::push_back(v12, (unsigned int)v9);
v7 = 0LL;
LABEL_12:
v4 = *(_BYTE **)(v3 + 24);
v5 = *(_BYTE **)(v3 + 32);
}
*(_QWORD *)(v3 + 32) = v5 + 2;
std::make_unique<std::string,std::string>(a1, v12, v7);
LABEL_15:
std::string::~string(v12);
return a1;
}
|
operator()[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV R15,qword ptr [RSI]
MOV RCX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [R15 + 0x20]
CMP RAX,RCX
JZ 0x00167bcd
MOV EBP,EDX
CMP byte ptr [RAX],BPL
JNZ 0x00167bcd
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX + -0x10],RDX
AND qword ptr [RDX + -0x8],0x0
MOV byte ptr [RDX],0x0
XOR EDX,EDX
MOV R12D,0x1a29
LEA R13,[0x1b4674]
LEA R14,[RSP + 0x8]
LAB_00167b7b:
LEA RSI,[RAX + 0x1]
MOV qword ptr [R15 + 0x20],RSI
CMP RSI,RCX
JZ 0x00167bd3
MOV CL,byte ptr [RSI]
TEST DL,0x1
JZ 0x00167baa
MOVSX EAX,CL
ADD EAX,-0x5c
ROR EAX,0x1
CMP EAX,0xc
JA 0x00167bb6
BT R12D,EAX
JNC 0x00167bb6
MOV EAX,EAX
MOV CL,byte ptr [RAX + R13*0x1]
JMP 0x00167bb6
LAB_00167baa:
MOV DL,0x1
CMP CL,0x5c
JZ 0x00167bc3
CMP CL,BPL
JZ 0x00167bf3
LAB_00167bb6:
MOVSX ESI,CL
MOV RDI,R14
CALL 0x00124760
XOR EDX,EDX
LAB_00167bc3:
MOV RCX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [R15 + 0x20]
JMP 0x00167b7b
LAB_00167bcd:
AND qword ptr [RBX],0x0
JMP 0x00167be1
LAB_00167bd3:
AND qword ptr [RBX],0x0
LAB_00167bd7:
LEA RDI,[RSP + 0x8]
CALL 0x001251d8
LAB_00167be1:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00167bf3:
ADD RAX,0x2
MOV qword ptr [R15 + 0x20],RAX
LAB_00167bfb:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00167c21
LAB_00167c08:
JMP 0x00167bd7
|
/* operator()[abi:cxx11](char) const */
string * minja::Parser::parseString[abi:cxx11]()::{lambda(char)#1}::operator()[abi_cxx11_
(char param_1)
{
char *pcVar1;
long lVar2;
char *pcVar3;
char *pcVar4;
char in_DL;
bool bVar5;
long *in_RSI;
int7 in_register_00000039;
string *psVar6;
int1 *local_50;
int8 local_48;
int1 local_40 [16];
psVar6 = (string *)CONCAT71(in_register_00000039,param_1);
lVar2 = *in_RSI;
pcVar4 = *(char **)(lVar2 + 0x18);
pcVar3 = *(char **)(lVar2 + 0x20);
if ((pcVar3 == pcVar4) || (*pcVar3 != in_DL)) {
*(int8 *)psVar6 = 0;
}
else {
local_50 = local_40;
local_48 = 0;
local_40[0] = 0;
bVar5 = false;
while( true ) {
pcVar1 = pcVar3 + 1;
*(char **)(lVar2 + 0x20) = pcVar1;
if (pcVar1 == pcVar4) break;
if (bVar5) {
LAB_00167bb6:
/* try { // try from 00167bb6 to 00167bc0 has its CatchHandler @ 00167c0c */
std::__cxx11::string::push_back((char)&local_50);
bVar5 = false;
}
else {
bVar5 = true;
if (*pcVar1 != '\\') {
if (*pcVar1 != in_DL) goto LAB_00167bb6;
*(char **)(lVar2 + 0x20) = pcVar3 + 2;
/* try { // try from 00167bfb to 00167c07 has its CatchHandler @ 00167c0a */
std::make_unique<std::__cxx11::string,std::__cxx11::string>(psVar6);
goto LAB_00167bd7;
}
}
pcVar4 = *(char **)(lVar2 + 0x18);
pcVar3 = *(char **)(lVar2 + 0x20);
}
*(int8 *)psVar6 = 0;
LAB_00167bd7:
std::__cxx11::string::~string((string *)&local_50);
}
return psVar6;
}
|
|
64,003 |
my_copy_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
}
|
O0
|
c
|
my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa4156
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xa4158
jmp 0xa415a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xa416c
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xa416e
cmpq $0x0, -0x28(%rbp)
je 0xa4186
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x285c0
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_copy_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_A4156
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_A4156:
jmp short $+2
loc_A4158:
jmp short $+2
loc_A415A:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jbe short loc_A416C
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_A416C:
jmp short $+2
loc_A416E:
cmp [rbp+var_28], 0
jz short loc_A4186
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memmove
loc_A4186:
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+arg_0]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // [rsp+8h] [rbp-28h]
v8 = a5;
if ( a5 > a3 )
v8 = a3;
if ( v8 > a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
|
my_copy_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001a4156
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a4156:
JMP 0x001a4158
LAB_001a4158:
JMP 0x001a415a
LAB_001a415a:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x001a416c
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a416c:
JMP 0x001a416e
LAB_001a416e:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001a4186
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001285c0
LAB_001a4186:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
ulong local_30;
local_30 = param_5;
if (param_3 < param_5) {
local_30 = param_3;
}
if (param_6 < local_30) {
local_30 = param_6;
}
if (local_30 != 0) {
memmove(param_2,param_4,local_30);
}
*param_7 = (long)param_4 + local_30;
param_7[1] = 0;
return local_30;
}
|
|
64,004 |
eth_ssz_type_for_denep
|
corpus-core[P]colibri-stateless/src/chains/eth/ssz/beacon_denep.c
|
const ssz_def_t* eth_ssz_type_for_denep(eth_ssz_type_t type) {
switch (type) {
#ifdef PROOFER
case ETH_SSZ_SIGNED_BEACON_BLOCK_CONTAINER:
return &SIGNED_BEACON_BLOCK_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_BODY_CONTAINER:
return &BEACON_BLOCK_BODY_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_HEADER:
return &BEACON_BLOCKHEADER_CONTAINER;
#endif
default:
return eth_ssz_verification_type(type);
}
}
|
O0
|
c
|
eth_ssz_type_for_denep:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x2813c
jmp 0x28128
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x28149
jmp 0x28132
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x28156
jmp 0x28163
leaq 0xfcd5d(%rip), %rax # 0x124ea0
movq %rax, -0x8(%rbp)
jmp 0x2816f
leaq 0xfcd70(%rip), %rax # 0x124ec0
movq %rax, -0x8(%rbp)
jmp 0x2816f
leaq 0xfcd83(%rip), %rax # 0x124ee0
movq %rax, -0x8(%rbp)
jmp 0x2816f
movl -0xc(%rbp), %edi
callq 0x27de0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
eth_ssz_type_for_denep:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
sub eax, 1
jz short loc_2813C
jmp short $+2
loc_28128:
mov eax, [rbp+var_10]
sub eax, 2
jz short loc_28149
jmp short $+2
loc_28132:
mov eax, [rbp+var_10]
sub eax, 3
jz short loc_28156
jmp short loc_28163
loc_2813C:
lea rax, SIGNED_BEACON_BLOCK_CONTAINER
mov [rbp+var_8], rax
jmp short loc_2816F
loc_28149:
lea rax, BEACON_BLOCK_BODY_CONTAINER
mov [rbp+var_8], rax
jmp short loc_2816F
loc_28156:
lea rax, BEACON_BLOCKHEADER_CONTAINER
mov [rbp+var_8], rax
jmp short loc_2816F
loc_28163:
mov edi, [rbp+var_C]
call eth_ssz_verification_type
mov [rbp+var_8], rax
loc_2816F:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
|
char ** eth_ssz_type_for_denep(int a1)
{
switch ( a1 )
{
case 1:
return &SIGNED_BEACON_BLOCK_CONTAINER;
case 2:
return &BEACON_BLOCK_BODY_CONTAINER;
case 3:
return &BEACON_BLOCKHEADER_CONTAINER;
}
return eth_ssz_verification_type(a1);
}
|
eth_ssz_type_for_denep:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
SUB EAX,0x1
JZ 0x0012813c
JMP 0x00128128
LAB_00128128:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x2
JZ 0x00128149
JMP 0x00128132
LAB_00128132:
MOV EAX,dword ptr [RBP + -0x10]
SUB EAX,0x3
JZ 0x00128156
JMP 0x00128163
LAB_0012813c:
LEA RAX,[0x224ea0]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012816f
LAB_00128149:
LEA RAX,[0x224ec0]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012816f
LAB_00128156:
LEA RAX,[0x224ee0]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012816f
LAB_00128163:
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x00127de0
MOV qword ptr [RBP + -0x8],RAX
LAB_0012816f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int1 * eth_ssz_type_for_denep(int param_1)
{
int1 *local_10;
if (param_1 == 1) {
local_10 = SIGNED_BEACON_BLOCK_CONTAINER;
}
else if (param_1 == 2) {
local_10 = BEACON_BLOCK_BODY_CONTAINER;
}
else if (param_1 == 3) {
local_10 = BEACON_BLOCKHEADER_CONTAINER;
}
else {
local_10 = (int1 *)eth_ssz_verification_type(param_1);
}
return local_10;
}
|
|
64,005 |
eth_ssz_type_for_denep
|
corpus-core[P]colibri-stateless/src/chains/eth/ssz/beacon_denep.c
|
const ssz_def_t* eth_ssz_type_for_denep(eth_ssz_type_t type) {
switch (type) {
#ifdef PROOFER
case ETH_SSZ_SIGNED_BEACON_BLOCK_CONTAINER:
return &SIGNED_BEACON_BLOCK_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_BODY_CONTAINER:
return &BEACON_BLOCK_BODY_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_HEADER:
return &BEACON_BLOCKHEADER_CONTAINER;
#endif
default:
return eth_ssz_verification_type(type);
}
}
|
O2
|
c
|
eth_ssz_type_for_denep:
leal -0x1(%rdi), %eax
cmpl $0x3, %eax
jae 0x25a21
movl %eax, %eax
leaq 0x4f847(%rip), %rcx # 0x75260
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
jmp 0x258a4
nop
|
eth_ssz_type_for_denep:
lea eax, [rdi-1]
cmp eax, 3
jnb short loc_25A21
mov eax, eax
lea rcx, unk_75260
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_25A21:
jmp eth_ssz_verification_type
|
char ** eth_ssz_type_for_denep(int a1)
{
if ( (unsigned int)(a1 - 1) >= 3 )
return eth_ssz_verification_type(a1);
else
return (char **)((char *)dword_75260 + dword_75260[a1 - 1]);
}
|
eth_ssz_type_for_denep:
LEA EAX,[RDI + -0x1]
CMP EAX,0x3
JNC 0x00125a21
MOV EAX,EAX
LEA RCX,[0x175260]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00125a21:
JMP 0x001258a4
|
int * eth_ssz_type_for_denep(int param_1)
{
int *puVar1;
if (param_1 - 1U < 3) {
return &DAT_00175260 + *(int *)(&DAT_00175260 + (ulong)(param_1 - 1U) * 4);
}
puVar1 = (int *)eth_ssz_verification_type();
return puVar1;
}
|
|
64,006 |
eth_ssz_type_for_denep
|
corpus-core[P]colibri-stateless/src/chains/eth/ssz/beacon_denep.c
|
const ssz_def_t* eth_ssz_type_for_denep(eth_ssz_type_t type) {
switch (type) {
#ifdef PROOFER
case ETH_SSZ_SIGNED_BEACON_BLOCK_CONTAINER:
return &SIGNED_BEACON_BLOCK_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_BODY_CONTAINER:
return &BEACON_BLOCK_BODY_CONTAINER;
case ETH_SSZ_BEACON_BLOCK_HEADER:
return &BEACON_BLOCKHEADER_CONTAINER;
#endif
default:
return eth_ssz_verification_type(type);
}
}
|
O3
|
c
|
eth_ssz_type_for_denep:
leal -0x1(%rdi), %eax
cmpl $0x3, %eax
jae 0x268a1
movl %eax, %eax
leaq 0x5b9c7(%rip), %rcx # 0x82260
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
jmp 0x26680
nop
|
eth_ssz_type_for_denep:
lea eax, [rdi-1]
cmp eax, 3
jnb short loc_268A1
mov eax, eax
lea rcx, unk_82260
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_268A1:
jmp eth_ssz_verification_type
|
char ** eth_ssz_type_for_denep(int a1)
{
if ( (unsigned int)(a1 - 1) >= 3 )
return eth_ssz_verification_type(a1);
else
return (char **)((char *)dword_82260 + dword_82260[a1 - 1]);
}
|
eth_ssz_type_for_denep:
LEA EAX,[RDI + -0x1]
CMP EAX,0x3
JNC 0x001268a1
MOV EAX,EAX
LEA RCX,[0x182260]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_001268a1:
JMP 0x00126680
|
int * eth_ssz_type_for_denep(int param_1)
{
int *puVar1;
if (param_1 - 1U < 3) {
return &DAT_00182260 + *(int *)(&DAT_00182260 + (ulong)(param_1 - 1U) * 4);
}
puVar1 = (int *)eth_ssz_verification_type();
return puVar1;
}
|
|
64,007 |
BAIL_OUT
|
eloqsql/libmariadb/unittest/mytap/tap.c
|
void
BAIL_OUT(char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(tapout, "Bail out! ");
vfprintf(tapout, fmt, ap);
emit_endl();
va_end(ap);
exit(255);
}
|
O0
|
c
|
BAIL_OUT:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2fba5
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 -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x4e3d1(%rip), %rax # 0x7dfc8
movq (%rax), %rdi
leaq 0x3af0a(%rip), %rsi # 0x6ab0b
movb $0x0, %al
callq 0x14650
movq 0x4e3b9(%rip), %rax # 0x7dfc8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x145d0
callq 0x30360
leaq -0x20(%rbp), %rax
movl $0xff, %edi
callq 0x14540
nopw %cs:(%rax,%rax)
|
BAIL_OUT:
push rbp
mov rbp, rsp
sub rsp, 0D0h
test al, al
jz short loc_2FBA5
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_2FBA5:
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_20]
lea rcx, [rbp+var_D0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, aBailOut; "Bail out! "
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov rsi, [rbp+var_8]
lea rdx, [rbp+var_20]
call _vfprintf
call emit_endl
lea rax, [rbp+var_20]
mov edi, 0FFh
call _exit
|
void __noreturn BAIL_OUT(
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 v15; // [rsp+0h] [rbp-D0h] BYREF
long long v16; // [rsp+8h] [rbp-C8h]
long long v17; // [rsp+10h] [rbp-C0h]
long long v18; // [rsp+18h] [rbp-B8h]
long long v19; // [rsp+20h] [rbp-B0h]
long long v20; // [rsp+28h] [rbp-A8h]
__m128 v21; // [rsp+30h] [rbp-A0h]
__m128 v22; // [rsp+40h] [rbp-90h]
__m128 v23; // [rsp+50h] [rbp-80h]
__m128 v24; // [rsp+60h] [rbp-70h]
__m128 v25; // [rsp+70h] [rbp-60h]
__m128 v26; // [rsp+80h] [rbp-50h]
__m128 v27; // [rsp+90h] [rbp-40h]
__m128 v28; // [rsp+A0h] [rbp-30h]
_DWORD v29[2]; // [rsp+B0h] [rbp-20h] BYREF
char *v30; // [rsp+B8h] [rbp-18h]
char *v31; // [rsp+C0h] [rbp-10h]
long long v32; // [rsp+C8h] [rbp-8h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v20 = a6;
v19 = a5;
v18 = a4;
v17 = a3;
v16 = a2;
v32 = a1;
v31 = &v15;
v30 = &a15;
v29[1] = 48;
v29[0] = 8;
fprintf(stdout, "Bail out! ");
vfprintf(stdout, v32, v29);
emit_endl();
exit(255LL);
}
|
BAIL_OUT:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
TEST AL,AL
JZ 0x0012fba5
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_0012fba5:
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 + -0x20]
LEA RCX,[RBP + -0xd0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV RAX,qword ptr [0x0017dfc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x16ab0b]
MOV AL,0x0
CALL 0x00114650
MOV RAX,qword ptr [0x0017dfc8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
LEA RDX,[RBP + -0x20]
CALL 0x001145d0
CALL 0x00130360
LEA RAX,[RBP + -0x20]
MOV EDI,0xff
CALL 0x00114540
|
void BAIL_OUT(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)
{
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;
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_0017dfc8,"Bail out! ");
vfprintf(*(FILE **)PTR_stdout_0017dfc8,local_10,&local_28);
emit_endl();
/* WARNING: Subroutine does not return */
exit(0xff);
}
|
|
64,008 |
google::protobuf::compiler::java::ClassNameResolver::GetClassFullName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::FileDescriptor const*, bool, bool, bool)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/name_resolver.cc
|
std::string ClassNameResolver::GetClassFullName(
const std::string& name_without_package, const FileDescriptor* file,
bool immutable, bool is_own_file, bool kotlin) {
std::string result;
if (is_own_file) {
result = FileJavaPackage(file, immutable);
} else {
result = GetClassName(file, immutable, kotlin);
}
if (!result.empty()) {
result += '.';
}
result += name_without_package;
if (kotlin) result += "Kt";
return result;
}
|
O0
|
cpp
|
google::protobuf::compiler::java::ClassNameResolver::GetClassFullName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, google::protobuf::FileDescriptor const*, bool, bool, bool):
subq $0xa8, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %eax
movq %rcx, %r8
movl 0xc(%rsp), %ecx
movq %r8, 0x10(%rsp)
movq %rdx, %r8
movq %rsi, %r9
movq 0x10(%rsp), %rsi
movq %rdi, 0x18(%rsp)
movb %al, %dl
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movb 0xb0(%rsp), %al
movq %rdi, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
andb $0x1, %dl
movb %dl, 0x87(%rsp)
andb $0x1, %cl
movb %cl, 0x86(%rsp)
andb $0x1, %al
movb %al, 0x85(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x84(%rsp)
callq 0x21390
testb $0x1, 0x86(%rsp)
je 0x7c8e4
movq 0x88(%rsp), %rsi
movzbl 0x87(%rsp), %edx
andl $0x1, %edx
leaq 0x60(%rsp), %rdi
callq 0x73f60
jmp 0x7c8ac
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x215e0
leaq 0x60(%rsp), %rdi
callq 0x21cc8
jmp 0x7c92e
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x21cc8
jmp 0x7c9ab
movq 0x28(%rsp), %rsi
movq 0x88(%rsp), %rdx
movzbl 0x85(%rsp), %r8d
movzbl 0x87(%rsp), %ecx
andl $0x1, %ecx
andl $0x1, %r8d
leaq 0x30(%rsp), %rdi
callq 0x7c630
jmp 0x7c915
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x215e0
leaq 0x30(%rsp), %rdi
callq 0x21cc8
movq 0x18(%rsp), %rdi
callq 0x212d0
testb $0x1, %al
jne 0x7c94f
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
callq 0x21750
jmp 0x7c94d
jmp 0x7c94f
movq 0x18(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x21100
jmp 0x7c963
testb $0x1, 0x85(%rsp)
je 0x7c982
movq 0x18(%rsp), %rdi
leaq 0x333953(%rip), %rsi # 0x3b02cc
callq 0x21190
jmp 0x7c980
jmp 0x7c982
movb $0x1, 0x84(%rsp)
testb $0x1, 0x84(%rsp)
jne 0x7c99e
movq 0x18(%rsp), %rdi
callq 0x21cc8
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x21700
nopw %cs:(%rax,%rax)
|
_ZN6google8protobuf8compiler4java17ClassNameResolver16GetClassFullNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKNS0_14FileDescriptorEbbb:
sub rsp, 0A8h
mov [rsp+0A8h+var_9C], r9d
mov eax, r8d
mov r8, rcx
mov ecx, [rsp+0A8h+var_9C]
mov qword ptr [rsp+0A8h+var_98], r8; char
mov r8, rdx
mov r9, rsi
mov rsi, qword ptr [rsp+0A8h+var_98]
mov [rsp+0A8h+var_90], rdi; int
mov dl, al
mov rax, rdi
mov [rsp+0A8h+var_88], rax; int
mov al, [rsp+0A8h+arg_0]
mov [rsp+0A8h+var_8], rdi
mov qword ptr [rsp+0A8h+var_10], r9
mov [rsp+0A8h+var_18], r8
mov qword ptr [rsp+0A8h+var_20], rsi
and dl, 1
mov [rsp+0A8h+var_21], dl
and cl, 1
mov [rsp+0A8h+var_22], cl
and al, 1
mov [rsp+0A8h+var_23], al
mov rax, qword ptr [rsp+0A8h+var_10]
mov qword ptr [rsp+0A8h+var_80], rax; int
mov [rsp+0A8h+var_24], 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
test [rsp+0A8h+var_22], 1
jz short loc_7C8E4
mov rsi, qword ptr [rsp+0A8h+var_20]; int
movzx edx, [rsp+0A8h+var_21]
and edx, 1; int
lea rdi, [rsp+0A8h+var_48]; int
call _ZN6google8protobuf8compiler4java15FileJavaPackageB5cxx11EPKNS0_14FileDescriptorEb; google::protobuf::compiler::java::FileJavaPackage(google::protobuf::FileDescriptor const*,bool)
jmp short $+2
loc_7C8AC:
mov rdi, [rsp+0A8h+var_90]
lea rsi, [rsp+0A8h+var_48]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+0A8h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_7C92E
mov rdi, [rsp+arg_10]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_7C9AB
loc_7C8E4:
mov rsi, qword ptr [rsp+0A8h+var_80]
mov rdx, qword ptr [rsp+0A8h+var_20]
movzx r8d, [rsp+0A8h+var_23]
movzx ecx, [rsp+0A8h+var_21]
and ecx, 1
and r8d, 1
lea rdi, [rsp+0A8h+var_78]; int
call _ZN6google8protobuf8compiler4java17ClassNameResolver12GetClassNameB5cxx11EPKNS0_14FileDescriptorEbb; google::protobuf::compiler::java::ClassNameResolver::GetClassName(google::protobuf::FileDescriptor const*,bool,bool)
jmp short $+2
loc_7C915:
mov rdi, [rsp+0A8h+var_90]
lea rsi, [rsp+0A8h+var_78]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+0A8h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_7C92E:
mov rdi, [rsp+0A8h+var_90]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_7C94F
mov rdi, [rsp+0A8h+var_90]
mov esi, 2Eh ; '.'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc; std::string::operator+=(char)
jmp short $+2
loc_7C94D:
jmp short $+2
loc_7C94F:
mov rdi, [rsp+0A8h+var_90]
mov rsi, [rsp+0A8h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLERKS4_; std::string::operator+=(std::string const&)
jmp short $+2
loc_7C963:
test [rsp+0A8h+var_23], 1
jz short loc_7C982
mov rdi, [rsp+0A8h+var_90]
lea rsi, aKt; "Kt"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEPKc; std::string::operator+=(char const*)
jmp short $+2
loc_7C980:
jmp short $+2
loc_7C982:
mov [rsp+0A8h+var_24], 1
test [rsp+0A8h+var_24], 1
jnz short loc_7C99E
mov rdi, [rsp+0A8h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_7C99E:
mov rax, [rsp+0A8h+var_88]
add rsp, 0A8h
retn
loc_7C9AB:
mov rdi, [rsp+arg_50]
call __Unwind_Resume
|
long long google::protobuf::compiler::java::ClassNameResolver::GetClassFullName(
long long a1,
long long a2,
long long a3,
long long a4,
char a5,
char a6,
char a7)
{
int v8[12]; // [rsp+30h] [rbp-78h] BYREF
int v9[9]; // [rsp+60h] [rbp-48h] BYREF
char v10; // [rsp+84h] [rbp-24h]
char v11; // [rsp+85h] [rbp-23h]
char v12; // [rsp+86h] [rbp-22h]
char v13; // [rsp+87h] [rbp-21h]
int v14[2]; // [rsp+88h] [rbp-20h]
long long v15; // [rsp+90h] [rbp-18h]
int v16[2]; // [rsp+98h] [rbp-10h]
long long v17; // [rsp+A0h] [rbp-8h]
v17 = a1;
*(_QWORD *)v16 = a2;
v15 = a3;
*(_QWORD *)v14 = a4;
v13 = a5 & 1;
v12 = a6 & 1;
v11 = a7 & 1;
v10 = 0;
std::string::basic_string(a1);
if ( (v12 & 1) != 0 )
{
google::protobuf::compiler::java::FileJavaPackage[abi:cxx11]((long long)v9, *(google::protobuf::FileDescriptor **)v14);
std::string::operator=(a1, v9);
std::string::~string(v9);
}
else
{
google::protobuf::compiler::java::ClassNameResolver::GetClassName[abi:cxx11](
(long long)v8,
a2,
*(google::protobuf::FileDescriptor **)v14,
v13 & 1,
v11 & 1);
std::string::operator=(a1, v8);
std::string::~string(v8);
}
if ( (std::string::empty(a1) & 1) == 0 )
std::string::operator+=(a1, 46LL);
std::string::operator+=(a1, v15);
if ( (v11 & 1) != 0 )
std::string::operator+=(a1, "Kt");
return a1;
}
|
GetClassFullName:
SUB RSP,0xa8
MOV dword ptr [RSP + 0xc],R9D
MOV EAX,R8D
MOV R8,RCX
MOV ECX,dword ptr [RSP + 0xc]
MOV qword ptr [RSP + 0x10],R8
MOV R8,RDX
MOV R9,RSI
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RDI
MOV DL,AL
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
MOV AL,byte ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],R9
MOV qword ptr [RSP + 0x90],R8
MOV qword ptr [RSP + 0x88],RSI
AND DL,0x1
MOV byte ptr [RSP + 0x87],DL
AND CL,0x1
MOV byte ptr [RSP + 0x86],CL
AND AL,0x1
MOV byte ptr [RSP + 0x85],AL
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x28],RAX
MOV byte ptr [RSP + 0x84],0x0
CALL 0x00121390
TEST byte ptr [RSP + 0x86],0x1
JZ 0x0017c8e4
MOV RSI,qword ptr [RSP + 0x88]
MOVZX EDX,byte ptr [RSP + 0x87]
LAB_0017c89d:
AND EDX,0x1
LEA RDI,[RSP + 0x60]
CALL 0x00173f60
JMP 0x0017c8ac
LAB_0017c8ac:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x60]
CALL 0x001215e0
LEA RDI,[RSP + 0x60]
CALL 0x00121cc8
JMP 0x0017c92e
LAB_0017c8e4:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x88]
MOVZX R8D,byte ptr [RSP + 0x85]
MOVZX ECX,byte ptr [RSP + 0x87]
AND ECX,0x1
AND R8D,0x1
LEA RDI,[RSP + 0x30]
CALL 0x0017c630
JMP 0x0017c915
LAB_0017c915:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x30]
CALL 0x001215e0
LEA RDI,[RSP + 0x30]
CALL 0x00121cc8
LAB_0017c92e:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001212d0
TEST AL,0x1
JNZ 0x0017c94f
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,0x2e
CALL 0x00121750
JMP 0x0017c94d
LAB_0017c94d:
JMP 0x0017c94f
LAB_0017c94f:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x90]
CALL 0x00121100
JMP 0x0017c963
LAB_0017c963:
TEST byte ptr [RSP + 0x85],0x1
JZ 0x0017c982
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[0x4b02cc]
CALL 0x00121190
LAB_0017c97e:
JMP 0x0017c980
LAB_0017c980:
JMP 0x0017c982
LAB_0017c982:
MOV byte ptr [RSP + 0x84],0x1
TEST byte ptr [RSP + 0x84],0x1
JNZ 0x0017c99e
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00121cc8
LAB_0017c99e:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0xa8
RET
|
/* WARNING: Removing unreachable block (ram,0x0017c994) */
/* google::protobuf::compiler::java::ClassNameResolver::GetClassFullName(std::__cxx11::string
const&, google::protobuf::FileDescriptor const*, bool, bool, bool) */
string * google::protobuf::compiler::java::ClassNameResolver::GetClassFullName
(string *param_1,FileDescriptor *param_2,bool param_3,bool param_4,bool param_5)
{
ulong uVar1;
int7 in_register_00000009;
int7 in_register_00000011;
byte in_R9B;
byte in_stack_00000008;
FileDescriptor local_78 [48];
FileDescriptor local_48 [36];
int1 local_24;
byte local_23;
byte local_22;
int1 local_21;
int8 local_20;
string *local_18;
FileDescriptor *local_10;
string *local_8;
local_18 = (string *)CONCAT71(in_register_00000011,param_3);
local_20 = CONCAT71(in_register_00000009,param_4);
local_22 = in_R9B & 1;
local_23 = in_stack_00000008 & 1;
local_24 = 0;
local_21 = param_5;
local_10 = param_2;
local_8 = param_1;
std::__cxx11::string::string(param_1);
if ((local_22 & 1) == 0) {
GetClassName_abi_cxx11_(local_78,SUB81(param_2,0),SUB81(local_20,0));
std::__cxx11::string::operator=(param_1,(string *)local_78);
std::__cxx11::string::~string((string *)local_78);
}
else {
/* try { // try from 0017c89d to 0017c97d has its CatchHandler @ 0017c8c7 */
FileJavaPackage_abi_cxx11_(local_48,SUB81(local_20,0));
std::__cxx11::string::operator=(param_1,(string *)local_48);
std::__cxx11::string::~string((string *)local_48);
}
uVar1 = std::__cxx11::string::empty();
if ((uVar1 & 1) == 0) {
std::__cxx11::string::operator+=(param_1,'.');
}
std::__cxx11::string::operator+=(param_1,local_18);
if ((local_23 & 1) != 0) {
std::__cxx11::string::operator+=(param_1,"Kt");
}
return param_1;
}
|
|
64,009 |
my_strntoll_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static longlong
my_strntoll_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative=0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr+l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do {
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]=EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]=EDOM;
return 0L;
}
if (negative)
{
if (res > (ulonglong) LONGLONG_MIN)
overflow = 1;
}
else if (res > (ulonglong) LONGLONG_MAX)
overflow = 1;
if (overflow)
{
err[0]=ERANGE;
return negative ? LONGLONG_MIN : LONGLONG_MAX;
}
return (negative ? -((longlong)res) : (longlong)res);
}
|
O3
|
c
|
my_strntoll_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xc3a12
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0xc39e2
cmpq $0x9, %rcx
je 0xc39fa
cmpq $0x20, %rcx
je 0xc39fa
jmp 0xc3a44
cmpq $0x2b, %rcx
je 0xc39fa
cmpq $0x2d, %rcx
jne 0xc3a44
xorl %ecx, %ecx
cmpl $0x0, -0x34(%rbp)
sete %cl
movl %ecx, -0x34(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0xc39ca
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0xc3a1e
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq -0x44(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
movq %rcx, -0x60(%rbp)
divq %rcx
movq %rdx, %rbx
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0xc3b25
movl %ebx, %ecx
movq %rcx, -0x68(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %r9d, %r9d
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0xc3aa1
movq %rax, -0x30(%rbp)
jmp 0xc3ac6
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0xc3ab1
addq $-0x37, %rsi
jmp 0xc3abf
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0xc3b36
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0xc3b36
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0xc3adb
movq %rcx, %rdi
jmp 0xc3af5
jne 0xc3ae7
movq -0x58(%rbp), %rdi
cmpq -0x68(%rbp), %rax
ja 0xc3af5
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movl %r9d, %esi
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *%r12
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rdi, %rcx
movl %esi, %r9d
testl %eax, %eax
jg 0xc3a85
jmp 0xc3b2c
xorl %edi, %edi
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0xc3b9f
movl %esi, %r9d
movq %rdi, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xc3b42
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0xc3b90
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rsi, %rcx
movl $0x1, %eax
movl %r9d, %edi
cmoval %eax, %edi
testq %rcx, %rcx
cmovsl %eax, %r9d
movl -0x34(%rbp), %r8d
testl %r8d, %r8d
cmovnel %edi, %r9d
testl %r9d, %r9d
je 0xc3bba
leaq -0x1(%rsi), %rax
testl %r8d, %r8d
movq -0x50(%rbp), %rcx
movl $0x22, (%rcx)
cmovneq %rsi, %rax
jmp 0xc3a35
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0xc3a33
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xc3bab
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0xc3a33
movq %rcx, %rax
negq %rax
testl %r8d, %r8d
cmoveq %rcx, %rax
jmp 0xc3a35
|
my_strntoll_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_40], r8
mov [rbp+var_44], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_C3A12
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_C39CA:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_C39E2
cmp rcx, 9
jz short loc_C39FA
cmp rcx, 20h ; ' '
jz short loc_C39FA
jmp short loc_C3A44
loc_C39E2:
cmp rcx, 2Bh ; '+'
jz short loc_C39FA
cmp rcx, 2Dh ; '-'
jnz short loc_C3A44
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_C39FA:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_C39CA
loc_C3A12:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_C3A1E
mov [rcx], r15
loc_C3A1E:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_C3A33:
xor eax, eax
loc_C3A35:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C3A44:
movsxd rcx, [rbp+var_44]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_60], rcx
div rcx
mov rbx, rdx
mov [rbp+var_58], rax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_C3B25
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor r9d, r9d
loc_C3A85:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_C3AA1
mov [rbp+var_30], rax
jmp short loc_C3AC6
loc_C3AA1:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_C3AB1
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_C3ABF
loc_C3AB1:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_C3B36
add rsi, 0FFFFFFFFFFFFFFA9h
loc_C3ABF:
mov [rbp+var_30], rsi
mov rax, rsi
loc_C3AC6:
cmp eax, [rbp+var_44]
jge short loc_C3B36
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_C3ADB
mov rdi, rcx
jmp short loc_C3AF5
loc_C3ADB:
jnz short loc_C3AE7
mov rdi, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_C3AF5
loc_C3AE7:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, r9d
mov rdi, rax
loc_C3AF5:
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call r12
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_78]
mov rcx, rdi
mov r9d, esi
test eax, eax
jg loc_C3A85
jmp short loc_C3B2C
loc_C3B25:
xor edi, edi
mov rbx, r15
xor esi, esi
loc_C3B2C:
test eax, eax
jz short loc_C3B9F
mov r9d, esi
mov rcx, rdi
loc_C3B36:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_C3B42
mov [rax], rbx
loc_C3B42:
cmp rbx, r15
jz short loc_C3B90
mov rsi, 8000000000000000h
cmp rcx, rsi
mov eax, 1
mov edi, r9d
cmova edi, eax
test rcx, rcx
cmovs r9d, eax
mov r8d, [rbp+var_34]
test r8d, r8d
cmovnz r9d, edi
test r9d, r9d
jz short loc_C3BBA
lea rax, [rsi-1]
test r8d, r8d
mov rcx, [rbp+var_50]
mov dword ptr [rcx], 22h ; '"'
cmovnz rax, rsi
jmp loc_C3A35
loc_C3B90:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_C3A33
loc_C3B9F:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_C3BAB
mov [rax], rbx
loc_C3BAB:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_C3A33
loc_C3BBA:
mov rax, rcx
neg rax
test r8d, r8d
cmovz rax, rcx
jmp loc_C3A35
|
unsigned long long my_strntoll_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
unsigned long long result; // rax
int v13; // eax
long long v14; // r8
long long v15; // rcx
long long v16; // rbx
long long v17; // r9
unsigned long long v18; // rax
long long v19; // rsi
unsigned int v20; // esi
unsigned long long v21; // rdi
int v22; // edi
unsigned long long v23; // [rsp+28h] [rbp-58h]
BOOL v27; // [rsp+4Ch] [rbp-34h]
_QWORD v28[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v28, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v27 = 0;
while ( v28[0] > 42LL )
{
if ( v28[0] != 43LL )
{
if ( v28[0] != 45LL )
goto LABEL_17;
v27 = !v27;
}
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v28, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
if ( v28[0] == 9LL || v28[0] == 32LL )
goto LABEL_10;
LABEL_17:
v23 = 0xFFFFFFFFFFFFFFFFLL / a4;
v13 = v8(a1, v28, v6, v9);
if ( v13 <= 0 )
{
v21 = 0LL;
v16 = v6;
v20 = 0;
LABEL_35:
if ( v13 )
{
LODWORD(v17) = v20;
v15 = v21;
goto LABEL_37;
}
if ( a5 )
*a5 = v16;
*a6 = 84;
return 0LL;
}
v15 = 0LL;
v16 = v6;
v17 = 0LL;
while ( 1 )
{
v16 += (unsigned int)v13;
v18 = v28[0] - 48LL;
if ( (unsigned long long)(v28[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v28[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v28[0] - 97LL) > 0x19 )
break;
v19 = v28[0] - 87LL;
}
else
{
v19 = v28[0] - 55LL;
}
v28[0] = v19;
v18 = v19;
}
else
{
v28[0] -= 48LL;
}
if ( (int)v18 >= a4 )
break;
v20 = 1;
if ( v15 <= v23 )
{
if ( v15 != v23 || (v21 = 0xFFFFFFFFFFFFFFFFLL / a4, v18 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v20 = v17;
v21 = a4 * v15 + v18;
}
}
else
{
v21 = v15;
}
v13 = ((long long ( *)(long long, _QWORD *, long long, long long, long long, long long))v8)(
a1,
v28,
v16,
v9,
v14,
v17);
v15 = v21;
v17 = v20;
if ( v13 <= 0 )
goto LABEL_35;
}
LABEL_37:
if ( a5 )
*a5 = v16;
if ( v16 == v6 )
{
*a6 = 33;
return 0LL;
}
v22 = v17;
if ( (unsigned long long)v15 > 0x8000000000000000LL )
v22 = 1;
if ( v15 < 0 )
LODWORD(v17) = 1;
if ( v27 )
LODWORD(v17) = v22;
if ( (_DWORD)v17 )
{
result = 0x7FFFFFFFFFFFFFFFLL;
*a6 = 34;
if ( v27 )
return 0x8000000000000000LL;
}
else
{
result = -v15;
if ( !v27 )
return v15;
}
return result;
}
|
my_strntoll_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001c3a12
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_001c39ca:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x001c39e2
CMP RCX,0x9
JZ 0x001c39fa
CMP RCX,0x20
JZ 0x001c39fa
JMP 0x001c3a44
LAB_001c39e2:
CMP RCX,0x2b
JZ 0x001c39fa
CMP RCX,0x2d
JNZ 0x001c3a44
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_001c39fa:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x001c39ca
LAB_001c3a12:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x001c3a1e
MOV qword ptr [RCX],R15
LAB_001c3a1e:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_001c3a33:
XOR EAX,EAX
LAB_001c3a35:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c3a44:
MOVSXD RCX,dword ptr [RBP + -0x44]
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x60],RCX
DIV RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x58],RAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001c3b25
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR R9D,R9D
LAB_001c3a85:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x001c3aa1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001c3ac6
LAB_001c3aa1:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x001c3ab1
ADD RSI,-0x37
JMP 0x001c3abf
LAB_001c3ab1:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x001c3b36
ADD RSI,-0x57
LAB_001c3abf:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_001c3ac6:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x001c3b36
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x001c3adb
MOV RDI,RCX
JMP 0x001c3af5
LAB_001c3adb:
JNZ 0x001c3ae7
MOV RDI,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x001c3af5
LAB_001c3ae7:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,R9D
MOV RDI,RAX
LAB_001c3af5:
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL R12
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RCX,RDI
MOV R9D,ESI
TEST EAX,EAX
JG 0x001c3a85
JMP 0x001c3b2c
LAB_001c3b25:
XOR EDI,EDI
MOV RBX,R15
XOR ESI,ESI
LAB_001c3b2c:
TEST EAX,EAX
JZ 0x001c3b9f
MOV R9D,ESI
MOV RCX,RDI
LAB_001c3b36:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001c3b42
MOV qword ptr [RAX],RBX
LAB_001c3b42:
CMP RBX,R15
JZ 0x001c3b90
MOV RSI,-0x8000000000000000
CMP RCX,RSI
MOV EAX,0x1
MOV EDI,R9D
CMOVA EDI,EAX
TEST RCX,RCX
CMOVS R9D,EAX
MOV R8D,dword ptr [RBP + -0x34]
TEST R8D,R8D
CMOVNZ R9D,EDI
TEST R9D,R9D
JZ 0x001c3bba
LEA RAX,[RSI + -0x1]
TEST R8D,R8D
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX],0x22
CMOVNZ RAX,RSI
JMP 0x001c3a35
LAB_001c3b90:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x001c3a33
LAB_001c3b9f:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001c3bab
MOV qword ptr [RAX],RBX
LAB_001c3bab:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x001c3a33
LAB_001c3bba:
MOV RAX,RCX
NEG RAX
TEST R8D,R8D
CMOVZ RAX,RCX
JMP 0x001c3a35
|
ulong my_strntoll_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
bool bVar4;
bool bVar5;
bool bVar6;
ulong uVar7;
uint uVar8;
ulong uVar9;
int4 uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar8) {
bVar4 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_001c3a44:
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
auVar3 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar9 = SUB168(auVar3 / auVar2,0);
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar12 = param_2;
if ((int)uVar8 < 1) {
uVar11 = 0;
bVar5 = false;
goto LAB_001c3b2c;
}
uVar11 = 0;
bVar5 = false;
goto LAB_001c3a85;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_001c3a44;
bVar4 = !bVar4;
}
param_2 = param_2 + (ulong)uVar8;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar8);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar10 = 0x21;
if (uVar8 == 0) {
uVar10 = 0x54;
}
*param_6 = uVar10;
return 0;
while( true ) {
if (param_4 <= (int)uVar13) goto LAB_001c3b36;
uVar7 = uVar11;
bVar6 = true;
if ((uVar11 <= uVar9) &&
((uVar11 != uVar9 || (uVar7 = uVar9, uVar13 <= (SUB168(auVar3 % auVar2,0) & 0xffffffff))))) {
uVar7 = uVar13 + uVar11 * (long)param_4;
bVar6 = bVar5;
}
bVar5 = bVar6;
uVar11 = uVar7;
local_38 = uVar13;
uVar8 = (*pcVar1)(param_1,&local_38,lVar12,param_3);
if ((int)uVar8 < 1) break;
LAB_001c3a85:
lVar12 = (ulong)uVar8 + lVar12;
uVar13 = local_38 - 0x30;
if (9 < uVar13) {
if (local_38 - 0x41 < 0x1a) {
uVar13 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_001c3b36;
uVar13 = local_38 - 0x57;
}
}
}
LAB_001c3b2c:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_001c3b36:
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
if (lVar12 != param_2) {
bVar6 = bVar5;
if (0x8000000000000000 < uVar11) {
bVar6 = true;
}
if ((long)uVar11 < 0) {
bVar5 = true;
}
if (bVar4) {
bVar5 = bVar6;
}
if (!bVar5) {
if (!bVar4) {
return uVar11;
}
return -uVar11;
}
*param_6 = 0x22;
if (bVar4) {
return 0x8000000000000000;
}
return 0x7fffffffffffffff;
}
*param_6 = 0x21;
}
return 0;
}
|
|
64,010 |
pagecache_delete_internal
|
eloqsql/storage/maria/ma_pagecache.c
|
static my_bool pagecache_delete_internal(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
PAGECACHE_HASH_LINK *page_link,
my_bool flush)
{
my_bool error= 0;
if (block->status & PCBLOCK_IN_FLUSH)
{
/*
this call is just 'hint' for the cache to free the page so we will
not interferes with flushing process but must return success
*/
goto out;
}
if (block->status & PCBLOCK_CHANGED)
{
flush= (flush || (block->status & PCBLOCK_DEL_WRITE));
if (flush)
{
/* The block contains a dirty page - push it out of the cache */
KEYCACHE_DBUG_PRINT("find_block", ("block is dirty"));
/*
The call is thread safe because only the current
thread might change the block->hash_link value
*/
DBUG_ASSERT(block->pins == 1);
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
error= pagecache_fwrite(pagecache,
&block->hash_link->file,
block->buffer,
block->hash_link->pageno,
block->type,
pagecache->readwrite_flags);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
pagecache->global_cache_write++;
if (error)
{
block->status|= PCBLOCK_ERROR;
block->error= (int16) my_errno;
my_debug_put_break_here();
goto out;
}
}
else
{
PAGECACHE_IO_HOOK_ARGS args;
PAGECACHE_FILE *filedesc= &block->hash_link->file;
args.page= block->buffer;
args.pageno= block->hash_link->pageno;
args.data= filedesc->callback_data;
/* We are not going to write the page but have to call callbacks */
DBUG_PRINT("info", ("flush_callback: %p data: %p",
filedesc->flush_log_callback,
filedesc->callback_data));
if ((*filedesc->flush_log_callback)(&args))
{
DBUG_PRINT("error", ("flush or write callback problem"));
error= 1;
goto out;
}
}
pagecache->blocks_changed--;
pagecache->global_blocks_changed--;
/*
free_block() will change the status and rec_lsn of the block so no
need to change them here.
*/
}
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
DBUG_ASSERT(block->hash_link->requests > 0);
page_link->requests--;
/* See NOTE for pagecache_unlock() about registering requests. */
free_block(pagecache, block, 0);
dec_counter_for_resize_op(pagecache);
return 0;
out:
/* Cache is locked, so we can relese page before freeing it */
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
page_link->requests--;
unreg_request(pagecache, block, 1);
dec_counter_for_resize_op(pagecache);
return error;
}
|
O0
|
c
|
pagecache_delete_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x96e52
jmp 0x97026
movq -0x18(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x96fd3
movsbl -0x21(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
jne 0x96e8a
movq -0x18(%rbp), %rax
movzwl 0x74(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
cmpb $0x0, -0x21(%rbp)
je 0x96f58
jmp 0x96ea1
jmp 0x96ea3
jmp 0x96ea5
jmp 0x96ea7
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x94920
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0x7c(%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x198(%rax), %r9
callq 0x97ac0
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xbc86a(%rip), %rsi # 0x153772
movl $0xfa2, %edx # imm = 0xFA2
callq 0x948b0
movq -0x10(%rbp), %rax
movq 0x178(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x178(%rax)
cmpb $0x0, -0x22(%rbp)
je 0x96f56
movq -0x18(%rbp), %rax
movzwl 0x74(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x74(%rax)
callq 0xf7b30
movl (%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x76(%rax)
jmp 0x96f51
jmp 0x97026
jmp 0x96fad
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x96f92
movq -0x50(%rbp), %rax
leaq -0x48(%rbp), %rdi
callq *0x38(%rax)
cmpb $0x0, %al
je 0x96fab
jmp 0x96fa3
jmp 0x96fa5
movb $0x1, -0x22(%rbp)
jmp 0x97026
jmp 0x96fad
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x168(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x95670
cmpb $0x0, %al
je 0x96ff7
jmp 0x96ff3
jmp 0x96ff5
jmp 0x96ff7
jmp 0x96ff9
jmp 0x96ffb
movq -0x20(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x98e20
movq -0x10(%rbp), %rdi
callq 0x95990
movb $0x0, -0x1(%rbp)
jmp 0x97078
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x95670
cmpb $0x0, %al
je 0x9704a
jmp 0x97046
jmp 0x97048
jmp 0x9704a
movq -0x20(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x95810
movq -0x10(%rbp), %rdi
callq 0x95990
movb -0x22(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
pagecache_delete_internal:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, cl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_21], al
mov [rbp+var_22], 0
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+74h]
and eax, 10h
cmp eax, 0
jz short loc_96E52
jmp loc_97026
loc_96E52:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+74h]
and eax, 20h
cmp eax, 0
jz loc_96FD3
movsx ecx, [rbp+var_21]
mov al, 1
cmp ecx, 0
mov [rbp+var_51], al
jnz short loc_96E8A
mov rax, [rbp+var_18]
movzx eax, word ptr [rax+74h]
and eax, 80h
cmp eax, 0
setnz al
mov [rbp+var_51], al
loc_96E8A:
mov al, [rbp+var_51]
and al, 1
movzx eax, al
mov [rbp+var_21], al
cmp [rbp+var_21], 0
jz loc_96F58
jmp short $+2
loc_96EA1:
jmp short $+2
loc_96EA3:
jmp short $+2
loc_96EA5:
jmp short $+2
loc_96EA7:
mov rdi, [rbp+var_10]
add rdi, 0C8h
call inline_mysql_mutex_unlock_13
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+20h]
add rsi, 18h
mov rax, [rbp+var_18]
mov rdx, [rax+30h]
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov rcx, [rax+60h]
mov rax, [rbp+var_18]
mov r8d, [rax+7Ch]
mov rax, [rbp+var_10]
mov r9, [rax+198h]
call pagecache_fwrite
mov [rbp+var_22], al
mov rdi, [rbp+var_10]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0FA2h
call inline_mysql_mutex_lock_12
mov rax, [rbp+var_10]
mov rcx, [rax+178h]
add rcx, 1
mov [rax+178h], rcx
cmp [rbp+var_22], 0
jz short loc_96F56
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax+74h]
or ecx, 1
mov [rax+74h], cx
call _my_thread_var
mov eax, [rax]
mov cx, ax
mov rax, [rbp+var_18]
mov [rax+76h], cx
jmp short $+2
loc_96F51:
jmp loc_97026
loc_96F56:
jmp short loc_96FAD
loc_96F58:
mov rax, [rbp+var_18]
mov rax, [rax+20h]
add rax, 18h
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov rax, [rax+60h]
mov [rbp+var_40], rax
mov rax, [rbp+var_50]
mov rax, [rax+40h]
mov [rbp+var_38], rax
jmp short $+2
loc_96F92:
mov rax, [rbp+var_50]
lea rdi, [rbp+var_48]
call qword ptr [rax+38h]
cmp al, 0
jz short loc_96FAB
jmp short $+2
loc_96FA3:
jmp short $+2
loc_96FA5:
mov [rbp+var_22], 1
jmp short loc_97026
loc_96FAB:
jmp short $+2
loc_96FAD:
mov rax, [rbp+var_10]
mov rcx, [rax+58h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+58h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+168h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+168h], rcx
loc_96FD3:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 6
mov ecx, 3
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_96FF7
jmp short $+2
loc_96FF3:
jmp short $+2
loc_96FF5:
jmp short $+2
loc_96FF7:
jmp short $+2
loc_96FF9:
jmp short $+2
loc_96FFB:
mov rax, [rbp+var_20]
mov ecx, [rax+68h]
add ecx, 0FFFFFFFFh
mov [rax+68h], ecx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
xor edx, edx
call free_block
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov [rbp+var_1], 0
jmp short loc_97078
loc_97026:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 6
mov ecx, 3
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_9704A
jmp short $+2
loc_97046:
jmp short $+2
loc_97048:
jmp short $+2
loc_9704A:
mov rax, [rbp+var_20]
mov ecx, [rax+68h]
add ecx, 0FFFFFFFFh
mov [rax+68h], ecx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 1
call unreg_request
mov rdi, [rbp+var_10]
call dec_counter_for_resize_op
mov al, [rbp+var_22]
mov [rbp+var_1], al
loc_97078:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
|
char pagecache_delete_internal(_QWORD *a1, long long a2, long long a3, bool a4)
{
_QWORD *v4; // rdi
long long v5; // rax
bool v7; // [rsp+Fh] [rbp-51h]
_QWORD v8[4]; // [rsp+18h] [rbp-48h] BYREF
char v9; // [rsp+3Eh] [rbp-22h]
bool v10; // [rsp+3Fh] [rbp-21h]
long long v11; // [rsp+40h] [rbp-20h]
long long v12; // [rsp+48h] [rbp-18h]
_QWORD *v13; // [rsp+50h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = 0;
if ( (*(_WORD *)(a2 + 116) & 0x10) != 0 )
goto LABEL_13;
if ( (*(_WORD *)(v12 + 116) & 0x20) != 0 )
{
v7 = 1;
if ( !v10 )
v7 = (*(_WORD *)(v12 + 116) & 0x80) != 0;
v10 = v7;
if ( v7 )
{
inline_mysql_mutex_unlock_13((long long)(v13 + 25));
v9 = pagecache_fwrite(
v13,
*(_QWORD *)(v12 + 32) + 24LL,
*(_QWORD *)(v12 + 48),
*(_QWORD *)(*(_QWORD *)(v12 + 32) + 96LL),
*(unsigned int *)(v12 + 124),
v13[51]);
v4 = v13 + 25;
inline_mysql_mutex_lock_12(
(long long)(v13 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0xFA2u);
++v13[47];
if ( v9 )
{
*(_WORD *)(v12 + 116) |= 1u;
*(_WORD *)(v12 + 118) = *(_DWORD *)my_thread_var(
v4,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c");
LABEL_13:
make_lock_and_pin((long long)v13, v12, 6, 3, 0);
--*(_DWORD *)(v11 + 104);
unreg_request(v13, v12, 1);
dec_counter_for_resize_op((long long)v13);
return v9;
}
}
else
{
v5 = *(_QWORD *)(v12 + 32);
v8[0] = *(_QWORD *)(v12 + 48);
v8[1] = *(_QWORD *)(*(_QWORD *)(v12 + 32) + 96LL);
v8[2] = *(_QWORD *)(v5 + 88);
if ( (*(unsigned __int8 ( **)(_QWORD *))(v5 + 80))(v8) )
{
v9 = 1;
goto LABEL_13;
}
}
--v13[11];
--v13[45];
}
make_lock_and_pin((long long)v13, v12, 6, 3, 0);
--*(_DWORD *)(v11 + 104);
free_block(v13, v12, 0LL);
dec_counter_for_resize_op((long long)v13);
return 0;
}
|
pagecache_delete_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RBP + -0x21],AL
MOV byte ptr [RBP + -0x22],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00196e52
JMP 0x00197026
LAB_00196e52:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x20
CMP EAX,0x0
JZ 0x00196fd3
MOVSX ECX,byte ptr [RBP + -0x21]
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x51],AL
JNZ 0x00196e8a
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX + 0x74]
AND EAX,0x80
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x51],AL
LAB_00196e8a:
MOV AL,byte ptr [RBP + -0x51]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x21],AL
CMP byte ptr [RBP + -0x21],0x0
JZ 0x00196f58
JMP 0x00196ea1
LAB_00196ea1:
JMP 0x00196ea3
LAB_00196ea3:
JMP 0x00196ea5
LAB_00196ea5:
JMP 0x00196ea7
LAB_00196ea7:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
CALL 0x00194920
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x20]
ADD RSI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RAX + 0x7c]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0x198]
CALL 0x00197ac0
MOV byte ptr [RBP + -0x22],AL
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc8
LEA RSI,[0x253772]
MOV EDX,0xfa2
CALL 0x001948b0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x178]
ADD RCX,0x1
MOV qword ptr [RAX + 0x178],RCX
CMP byte ptr [RBP + -0x22],0x0
JZ 0x00196f56
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX + 0x74]
OR ECX,0x1
MOV word ptr [RAX + 0x74],CX
CALL 0x001f7b30
MOV EAX,dword ptr [RAX]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x76],CX
JMP 0x00196f51
LAB_00196f51:
JMP 0x00197026
LAB_00196f56:
JMP 0x00196fad
LAB_00196f58:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00196f92
LAB_00196f92:
MOV RAX,qword ptr [RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL qword ptr [RAX + 0x38]
CMP AL,0x0
JZ 0x00196fab
JMP 0x00196fa3
LAB_00196fa3:
JMP 0x00196fa5
LAB_00196fa5:
MOV byte ptr [RBP + -0x22],0x1
JMP 0x00197026
LAB_00196fab:
JMP 0x00196fad
LAB_00196fad:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x58]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x168]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x168],RCX
LAB_00196fd3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
CALL 0x00195670
CMP AL,0x0
JZ 0x00196ff7
JMP 0x00196ff3
LAB_00196ff3:
JMP 0x00196ff5
LAB_00196ff5:
JMP 0x00196ff7
LAB_00196ff7:
JMP 0x00196ff9
LAB_00196ff9:
JMP 0x00196ffb
LAB_00196ffb:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x68],ECX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
XOR EDX,EDX
CALL 0x00198e20
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00195990
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00197078
LAB_00197026:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x6
MOV ECX,0x3
XOR R8D,R8D
CALL 0x00195670
CMP AL,0x0
JZ 0x0019704a
JMP 0x00197046
LAB_00197046:
JMP 0x00197048
LAB_00197048:
JMP 0x0019704a
LAB_0019704a:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x68],ECX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x1
CALL 0x00195810
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00195990
MOV AL,byte ptr [RBP + -0x22]
MOV byte ptr [RBP + -0x1],AL
LAB_00197078:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int8 pagecache_delete_internal(long param_1,long param_2,long param_3,char param_4)
{
char cVar1;
int4 *puVar2;
int7 extraout_var;
int8 uVar3;
int7 uVar4;
bool local_59;
int8 local_50;
int8 local_48;
int8 local_40;
char local_2a;
bool local_29;
long local_28;
long local_20;
long local_18;
char local_9;
local_2a = '\0';
local_29 = (bool)param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((*(ushort *)(param_2 + 0x74) & 0x10) != 0) goto LAB_00197026;
if ((*(ushort *)(param_2 + 0x74) & 0x20) == 0) {
LAB_00196fd3:
make_lock_and_pin(local_18,local_20,6,3,0);
*(int *)(local_28 + 0x68) = *(int *)(local_28 + 0x68) + -1;
free_block(local_18,local_20,0);
dec_counter_for_resize_op(local_18);
local_9 = '\0';
uVar4 = extraout_var;
}
else {
local_59 = true;
if (param_4 == '\0') {
local_59 = (*(ushort *)(param_2 + 0x74) & 0x80) != 0;
}
local_29 = local_59;
if (local_59 == false) {
local_50 = *(int8 *)(param_2 + 0x30);
local_48 = *(int8 *)(*(long *)(param_2 + 0x20) + 0x60);
local_40 = *(int8 *)(*(long *)(param_2 + 0x20) + 0x58);
cVar1 = (**(code **)(*(long *)(param_2 + 0x20) + 0x50))(&local_50);
if (cVar1 == '\0') goto LAB_00196fad;
local_2a = '\x01';
}
else {
inline_mysql_mutex_unlock(param_1 + 200);
local_2a = pagecache_fwrite(local_18,*(long *)(local_20 + 0x20) + 0x18,
*(int8 *)(local_20 + 0x30),
*(int8 *)(*(long *)(local_20 + 0x20) + 0x60),
*(int4 *)(local_20 + 0x7c),*(int8 *)(local_18 + 0x198)
);
inline_mysql_mutex_lock
(local_18 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0xfa2);
*(long *)(local_18 + 0x178) = *(long *)(local_18 + 0x178) + 1;
if (local_2a == '\0') {
LAB_00196fad:
*(long *)(local_18 + 0x58) = *(long *)(local_18 + 0x58) + -1;
*(long *)(local_18 + 0x168) = *(long *)(local_18 + 0x168) + -1;
goto LAB_00196fd3;
}
*(ushort *)(local_20 + 0x74) = *(ushort *)(local_20 + 0x74) | 1;
puVar2 = (int4 *)_my_thread_var();
*(short *)(local_20 + 0x76) = (short)*puVar2;
}
LAB_00197026:
make_lock_and_pin(local_18,local_20,6,3,0);
*(int *)(local_28 + 0x68) = *(int *)(local_28 + 0x68) + -1;
unreg_request(local_18,local_20,1);
uVar3 = dec_counter_for_resize_op(local_18);
uVar4 = (int7)((ulong)uVar3 >> 8);
local_9 = local_2a;
}
return CONCAT71(uVar4,local_9);
}
|
|
64,011 |
LefDefParser::defwNet(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwNet(const char *name)
{
defwFunc = DEFW_NET; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_NET_START &&
defwState != DEFW_NET_ENDNET)
return DEFW_BAD_ORDER;
defwState = DEFW_NET;
fprintf(defwFile, " - %s", name);
defwLineItemCounter = 0;
defwCounter--;
return DEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::defwNet(char const*):
pushq %rbx
movq %rdi, %rdx
leaq 0x10beb(%rip), %rax # 0x1e178
movl $0x3a, (%rax)
leaq 0x10bce(%rip), %rax # 0x1e168
movq (%rax), %rdi
testq %rdi, %rdi
je 0xd5e8
leaq 0x10bcb(%rip), %rax # 0x1e174
movl (%rax), %ecx
cmpl $0x3c, %ecx
je 0xd5ba
movl $0x2, %ebx
cmpl $0x39, %ecx
jne 0xd5ed
movl $0x3a, (%rax)
leaq 0x7db7(%rip), %rsi # 0x1537e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x10e0
leaq 0x10bb5(%rip), %rax # 0x1e18c
movl $0x0, (%rax)
leaq 0x10ba4(%rip), %rax # 0x1e188
decl (%rax)
jmp 0xd5ed
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
|
_ZN12LefDefParser7defwNetEPKc:
push rbx
mov rdx, rdi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 3Ah ; ':'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_D5E8
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov ecx, [rax]
cmp ecx, 3Ch ; '<'
jz short loc_D5BA
mov ebx, 2
cmp ecx, 39h ; '9'
jnz short loc_D5ED
loc_D5BA:
mov dword ptr [rax], 3Ah ; ':'
lea rsi, aS; " - %s"
xor ebx, ebx
xor eax, eax
call _fprintf
lea rax, _ZN12LefDefParser19defwLineItemCounterE; LefDefParser::defwLineItemCounter
mov dword ptr [rax], 0
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
dec dword ptr [rax]
jmp short loc_D5ED
loc_D5E8:
mov ebx, 1
loc_D5ED:
mov eax, ebx
pop rbx
retn
|
long long LefDefParser::defwNet(LefDefParser *this, const char *a2)
{
unsigned int v2; // ebx
LefDefParser::defwFunc = 58;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 60 || (v2 = 2, LefDefParser::defwState == 57) )
{
LefDefParser::defwState = 58;
v2 = 0;
fprintf(LefDefParser::defwFile, " - %s", (const char *)this);
LefDefParser::defwLineItemCounter = 0;
--LefDefParser::defwCounter;
}
}
else
{
return 1;
}
return v2;
}
|
defwNet:
PUSH RBX
MOV RDX,RDI
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0x3a
LEA RAX,[0x11e168]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x0010d5e8
LEA RAX,[0x11e174]
MOV ECX,dword ptr [RAX]
CMP ECX,0x3c
JZ 0x0010d5ba
MOV EBX,0x2
CMP ECX,0x39
JNZ 0x0010d5ed
LAB_0010d5ba:
MOV dword ptr [RAX],0x3a
LEA RSI,[0x11537e]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001010e0
LEA RAX,[0x11e18c]
MOV dword ptr [RAX],0x0
LEA RAX,[0x11e188]
DEC dword ptr [RAX]
JMP 0x0010d5ed
LAB_0010d5e8:
MOV EBX,0x1
LAB_0010d5ed:
MOV EAX,EBX
POP RBX
RET
|
/* LefDefParser::defwNet(char const*) */
int8 LefDefParser::defwNet(char *param_1)
{
int8 uVar1;
defwFunc = 0x3a;
if (defwFile == (FILE *)0x0) {
uVar1 = 1;
}
else if ((defwState == 0x3c) || (uVar1 = 2, defwState == 0x39)) {
defwState = 0x3a;
uVar1 = 0;
fprintf(defwFile," - %s",param_1);
defwLineItemCounter = 0;
defwCounter = defwCounter + -1;
}
return uVar1;
}
|
|
64,012 |
psi_cond_wait
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD int psi_cond_wait(mysql_cond_t *that, mysql_mutex_t *mutex,
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_WAIT, file, line);
int result= my_cond_wait(&that->m_cond, &mutex->m_mutex);
if (locker)
PSI_COND_CALL(end_cond_wait)(locker, result);
return result;
}
|
O0
|
c
|
psi_cond_wait:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x1a7db2(%rip), %rax # 0x1cf8f0
movq (%rax), %rax
movq 0x1c0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq -0x18(%rbp), %r8
movl -0x1c(%rbp), %r9d
leaq -0x58(%rbp), %rdi
xorl %ecx, %ecx
callq *%rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x244a0
movl %eax, -0x64(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x27b9d
leaq 0x1a7d66(%rip), %rax # 0x1cf8f0
movq (%rax), %rax
movq 0x1c8(%rax), %rax
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %esi
callq *%rax
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
psi_cond_wait:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1C0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+30h]
mov rcx, [rbp+var_10]
mov rdx, [rcx+40h]
mov r8, [rbp+var_18]
mov r9d, [rbp+var_1C]
lea rdi, [rbp+var_58]
xor ecx, ecx
call rax
mov [rbp+var_60], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _pthread_cond_wait
mov [rbp+var_64], eax
cmp [rbp+var_60], 0
jz short loc_27B9D
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1C8h]
mov rdi, [rbp+var_60]
mov esi, [rbp+var_64]
call rax
loc_27B9D:
mov eax, [rbp+var_64]
add rsp, 70h
pop rbp
retn
|
long long psi_cond_wait(long long a1, long long a2, long long a3, unsigned int a4)
{
unsigned int v5; // [rsp+Ch] [rbp-64h]
long long v6; // [rsp+10h] [rbp-60h]
_BYTE v7[60]; // [rsp+18h] [rbp-58h] BYREF
unsigned int v8; // [rsp+54h] [rbp-1Ch]
long long v9; // [rsp+58h] [rbp-18h]
long long v10; // [rsp+60h] [rbp-10h]
long long v11; // [rsp+68h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v6 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, _QWORD, long long, _QWORD))PSI_server[0] + 56))(
v7,
*(_QWORD *)(a1 + 48),
*(_QWORD *)(a2 + 64),
0LL,
a3,
a4);
v5 = pthread_cond_wait(v11, v10);
if ( v6 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 57))(v6, v5);
return v5;
}
|
psi_cond_wait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
LEA RAX,[0x2cf8f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1c0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x40]
MOV R8,qword ptr [RBP + -0x18]
MOV R9D,dword ptr [RBP + -0x1c]
LEA RDI,[RBP + -0x58]
XOR ECX,ECX
CALL RAX
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001244a0
MOV dword ptr [RBP + -0x64],EAX
CMP qword ptr [RBP + -0x60],0x0
JZ 0x00127b9d
LEA RAX,[0x2cf8f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1c8]
MOV RDI,qword ptr [RBP + -0x60]
MOV ESI,dword ptr [RBP + -0x64]
CALL RAX
LAB_00127b9d:
MOV EAX,dword ptr [RBP + -0x64]
ADD RSP,0x70
POP RBP
RET
|
int psi_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2,int8 param_3,
int4 param_4)
{
int iVar1;
long lVar2;
int1 local_60 [60];
int4 local_24;
int8 local_20;
pthread_mutex_t *local_18;
pthread_cond_t *local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1c0))
(local_60,param_1[1].__align,*(int8 *)((long)param_2 + 0x40),0,param_3,
param_4);
iVar1 = pthread_cond_wait(local_10,local_18);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1c8))(lVar2,iVar1);
}
return iVar1;
}
|
|
64,013 |
mj_comVel
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_core_smooth.c
|
void mj_comVel(const mjModel* m, mjData* d) {
mjtNum tmp[6], cvel[6], cdofdot[36];
// set world vel to 0
mju_zero(d->cvel, 6);
// forward pass over bodies
for (int i=1; i < m->nbody; i++) {
// get body's first dof address
int bda = m->body_dofadr[i];
// cvel = cvel_parent
mju_copy(cvel, d->cvel+6*m->body_parentid[i], 6);
// cvel = cvel_parent + cdof * qvel, cdofdot = cvel x cdof
for (int j=0; j < m->body_dofnum[i]; j++) {
// compute cvel and cdofdot
switch ((mjtJoint) m->jnt_type[m->dof_jntid[bda+j]]) {
case mjJNT_FREE:
// cdofdot = 0
mju_zero(cdofdot, 18);
// update velocity
mju_mulDofVec(tmp, d->cdof+6*bda, d->qvel+bda, 3);
mju_addTo(cvel, tmp, 6);
// continue with rotations
j += 3;
mjFALLTHROUGH;
case mjJNT_BALL:
// compute all 3 cdofdots using parent velocity
for (int k=0; k < 3; k++) {
mju_crossMotion(cdofdot+6*(j+k), cvel, d->cdof+6*(bda+j+k));
}
// update velocity
mju_mulDofVec(tmp, d->cdof+6*(bda+j), d->qvel+bda+j, 3);
mju_addTo(cvel, tmp, 6);
// adjust for 3-dof joint
j += 2;
break;
default:
// in principle we should use the new velocity to compute cdofdot,
// but it makes no difference becase crossMotion(cdof, cdof) = 0,
// and using the old velocity may be more accurate numerically
mju_crossMotion(cdofdot+6*j, cvel, d->cdof+6*(bda+j));
// update velocity
mju_mulDofVec(tmp, d->cdof+6*(bda+j), d->qvel+bda+j, 1);
mju_addTo(cvel, tmp, 6);
}
}
// assign cvel, cdofdot
mju_copy(d->cvel+6*i, cvel, 6);
mju_copy(d->cdof_dot+6*bda, cdofdot, 6*m->body_dofnum[i]);
}
}
|
O3
|
c
|
mj_comVel:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27970(%rsi), %rdi
movl $0x6, %esi
callq 0x2d1f0
cmpl $0x2, 0x10(%r14)
jl 0x4ba66
movl $0x1, %r13d
leaq 0x70(%rsp), %r15
movq %r14, 0x30(%rsp)
movq 0x530(%r14), %rax
movq 0x568(%r14), %rcx
movslq (%rcx,%r13,4), %r12
movslq (%rax,%r13,4), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq 0x27970(%rbx), %rsi
movq %r15, %rdi
movl $0x6, %edx
callq 0x2d120
movq 0x560(%r14), %rax
movq %r12, 0x10(%rsp)
leaq (%r12,%r12), %rcx
cmpl $0x0, (%rax,%r13,4)
leaq (%rcx,%rcx,2), %rax
movq %rax, 0x18(%rsp)
jle 0x4ba06
xorl %r12d, %r12d
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
leaq (,%rax,8), %rax
movq %rax, 0x28(%rsp)
movq %r13, 0x38(%rsp)
movq 0x638(%r14), %rcx
movq 0x6c8(%r14), %rdx
movslq %r12d, %rbp
movq 0x10(%rsp), %rax
addq %rbp, %rax
movslq (%rdx,%rax,4), %rdx
movl (%rcx,%rdx,4), %ecx
cmpl $0x1, %ecx
je 0x4b8db
testl %ecx, %ecx
jne 0x4b97e
leaq 0xa0(%rsp), %rdi
movl $0x12, %esi
callq 0x2d1f0
movq 0x27880(%rbx), %rsi
addq 0x28(%rsp), %rsi
movq 0x27780(%rbx), %rdx
addq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x3, %ecx
callq 0xa5827
movq %r15, %rdi
movq %r14, %rsi
movl $0x6, %edx
callq 0x2d830
movq 0x10(%rsp), %rax
addl %r12d, %eax
addl $0x3, %eax
movl %r12d, %ecx
addl $0x3, %ecx
movq %rax, 0x20(%rsp)
cltq
movl %ecx, %r12d
jmp 0x4b8e2
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
movslq %r12d, %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %rbp
leaq (%r12,%r12,2), %rax
shlq $0x4, %rax
leaq (%rsp,%rax), %r14
addq $0xa0, %r14
xorl %r13d, %r13d
leaq (%r14,%r13), %rdi
movq 0x27880(%rbx), %rdx
addq %rbp, %rdx
addq %r13, %rdx
movq %r15, %rsi
callq 0xa528d
addq $0x30, %r13
cmpq $0x90, %r13
jne 0x4b903
movq 0x20(%rsp), %rax
addl %eax, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rsi
shlq $0x3, %rsi
addq 0x27880(%rbx), %rsi
movq 0x27780(%rbx), %rax
addq 0x8(%rsp), %rax
leaq (%rax,%r12,8), %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x3, %ecx
callq 0xa5827
movq %r15, %rdi
movq %r14, %rsi
movl $0x6, %edx
callq 0x2d830
addl $0x2, %r12d
movq 0x30(%rsp), %r14
jmp 0x4b9ed
leal (%r12,%r12), %ecx
leal (%rcx,%rcx,2), %ecx
movslq %ecx, %rcx
leaq (%rsp,%rcx,8), %rdi
addq $0xa0, %rdi
addl %eax, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %r13
shlq $0x3, %r13
movq 0x27880(%rbx), %rdx
addq %r13, %rdx
movq %r15, %rsi
callq 0xa528d
addq 0x27880(%rbx), %r13
movq 0x27780(%rbx), %rax
addq 0x8(%rsp), %rax
leaq (%rax,%rbp,8), %rdx
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movl $0x1, %ecx
callq 0xa5827
movq %r15, %rdi
movq %rbp, %rsi
movl $0x6, %edx
callq 0x2d830
incl %r12d
movq 0x560(%r14), %rax
movq 0x38(%rsp), %r13
cmpl (%rax,%r13,4), %r12d
jl 0x4b845
leaq (,%r13,2), %rdi
addq %r13, %rdi
shlq $0x4, %rdi
addq 0x27970(%rbx), %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x2d120
movq 0x18(%rsp), %rdi
shlq $0x3, %rdi
addq 0x27978(%rbx), %rdi
movq 0x560(%r14), %rax
movl (%rax,%r13,4), %eax
addl %eax, %eax
leal (%rax,%rax,2), %edx
leaq 0xa0(%rsp), %rsi
callq 0x2d120
incq %r13
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jl 0x4b7c3
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mj_comVel:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1C8h
mov rbx, rsi
mov r14, rdi
mov rdi, [rsi+27970h]
mov esi, 6
call _mju_zero
cmp dword ptr [r14+10h], 2
jl loc_4BA66
mov r13d, 1
lea r15, [rsp+1F8h+var_188]
mov [rsp+1F8h+var_1C8], r14
loc_4B7C3:
mov rax, [r14+530h]
mov rcx, [r14+568h]
movsxd r12, dword ptr [rcx+r13*4]
movsxd rax, dword ptr [rax+r13*4]
lea rsi, [rax+rax*2]
shl rsi, 4
add rsi, [rbx+27970h]
mov rdi, r15
mov edx, 6
call _mju_copy
mov rax, [r14+560h]
mov [rsp+1F8h+var_1E8], r12
lea rcx, [r12+r12]
cmp dword ptr [rax+r13*4], 0
lea rax, [rcx+rcx*2]
mov [rsp+1F8h+var_1E0], rax
jle loc_4BA06
xor r12d, r12d
mov rax, [rsp+1F8h+var_1E8]
lea rax, ds:0[rax*8]
mov [rsp+1F8h+var_1F0], rax
mov rax, [rsp+1F8h+var_1E0]
lea rax, ds:0[rax*8]
mov [rsp+1F8h+var_1D0], rax
mov [rsp+1F8h+var_1C0], r13
loc_4B845:
mov rcx, [r14+638h]
mov rdx, [r14+6C8h]
movsxd rbp, r12d
mov rax, [rsp+1F8h+var_1E8]
add rax, rbp
movsxd rdx, dword ptr [rdx+rax*4]
mov ecx, [rcx+rdx*4]
cmp ecx, 1
jz short loc_4B8DB
test ecx, ecx
jnz loc_4B97E
lea rdi, [rsp+1F8h+var_158]
mov esi, 12h
call _mju_zero
mov rsi, [rbx+27880h]
add rsi, [rsp+1F8h+var_1D0]
mov rdx, qword ptr ds:stru_27780.r_offset[rbx]
add rdx, [rsp+1F8h+var_1F0]
lea r14, [rsp+1F8h+var_1B8]
mov rdi, r14
mov ecx, 3
call mju_mulDofVec
mov rdi, r15
mov rsi, r14
mov edx, 6
call _mju_addTo
mov rax, [rsp+1F8h+var_1E8]
add eax, r12d
add eax, 3
mov ecx, r12d
add ecx, 3
mov [rsp+1F8h+var_1D8], rax
cdqe
mov r12d, ecx
jmp short loc_4B8E2
loc_4B8DB:
mov ecx, eax
mov [rsp+1F8h+var_1D8], rcx
loc_4B8E2:
movsxd r12, r12d
shl rax, 4
lea rbp, [rax+rax*2]
lea rax, [r12+r12*2]
shl rax, 4
lea r14, [rsp+rax+1F8h+var_1F8]
add r14, 0A0h
xor r13d, r13d
loc_4B903:
lea rdi, [r14+r13]
mov rdx, [rbx+27880h]
add rdx, rbp
add rdx, r13
mov rsi, r15
call mju_crossMotion
add r13, 30h ; '0'
cmp r13, 90h
jnz short loc_4B903
mov rax, [rsp+1F8h+var_1D8]
add eax, eax
lea eax, [rax+rax*2]
movsxd rsi, eax
shl rsi, 3
add rsi, [rbx+27880h]
mov rax, qword ptr ds:stru_27780.r_offset[rbx]
add rax, [rsp+1F8h+var_1F0]
lea rdx, [rax+r12*8]
lea r14, [rsp+1F8h+var_1B8]
mov rdi, r14
mov ecx, 3
call mju_mulDofVec
mov rdi, r15
mov rsi, r14
mov edx, 6
call _mju_addTo
add r12d, 2
mov r14, [rsp+1F8h+var_1C8]
jmp short loc_4B9ED
loc_4B97E:
lea ecx, [r12+r12]
lea ecx, [rcx+rcx*2]
movsxd rcx, ecx
lea rdi, [rsp+rcx*8+1F8h+var_1F8]
add rdi, 0A0h
add eax, eax
lea eax, [rax+rax*2]
movsxd r13, eax
shl r13, 3
mov rdx, [rbx+27880h]
add rdx, r13
mov rsi, r15
call mju_crossMotion
add r13, [rbx+27880h]
mov rax, qword ptr ds:stru_27780.r_offset[rbx]
add rax, [rsp+1F8h+var_1F0]
lea rdx, [rax+rbp*8]
lea rbp, [rsp+1F8h+var_1B8]
mov rdi, rbp
mov rsi, r13
mov ecx, 1
call mju_mulDofVec
mov rdi, r15
mov rsi, rbp
mov edx, 6
call _mju_addTo
loc_4B9ED:
inc r12d
mov rax, [r14+560h]
mov r13, [rsp+1F8h+var_1C0]
cmp r12d, [rax+r13*4]
jl loc_4B845
loc_4BA06:
lea rdi, ds:0[r13*2]
add rdi, r13
shl rdi, 4
add rdi, [rbx+27970h]
mov rsi, r15
mov edx, 6
call _mju_copy
mov rdi, [rsp+1F8h+var_1E0]
shl rdi, 3
add rdi, qword ptr ds:stru_27978.r_offset[rbx]
mov rax, [r14+560h]
mov eax, [rax+r13*4]
add eax, eax
lea edx, [rax+rax*2]
lea rsi, [rsp+1F8h+var_158]
call _mju_copy
inc r13
movsxd rax, dword ptr [r14+10h]
cmp r13, rax
jl loc_4B7C3
loc_4BA66:
add rsp, 1C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void mj_comVel(
long long a1,
long long a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
double a9)
{
long long v9; // r14
long long v10; // r13
long long v11; // r12
double v12; // xmm0_8
double v13; // xmm4_8
double v14; // xmm5_8
int v15; // r12d
long long v16; // rax
int v17; // ecx
long long v18; // rbp
long long i; // r13
long long v20; // r13
long long v21; // [rsp+8h] [rbp-1F0h]
long long v22; // [rsp+10h] [rbp-1E8h]
long long v23; // [rsp+18h] [rbp-1E0h]
int v24; // [rsp+20h] [rbp-1D8h]
long long v25; // [rsp+38h] [rbp-1C0h]
_BYTE v26[48]; // [rsp+40h] [rbp-1B8h] BYREF
_BYTE v27[48]; // [rsp+70h] [rbp-188h] BYREF
_QWORD v28[43]; // [rsp+A0h] [rbp-158h] BYREF
v9 = a1;
mju_zero(*(_QWORD *)(a2 + 162160), 6LL, a3, a4, a5, a6, a7, a8, a9);
if ( *(int *)(a1 + 16) >= 2 )
{
v10 = 1LL;
while ( 1 )
{
v11 = *(int *)(*(_QWORD *)(v9 + 1384) + 4 * v10);
v12 = mju_copy(v27, *(_QWORD *)(a2 + 162160) + 48LL * *(int *)(*(_QWORD *)(v9 + 1328) + 4 * v10), 6LL);
v22 = v11;
v23 = 6 * v11;
if ( *(int *)(*(_QWORD *)(v9 + 1376) + 4 * v10) > 0 )
break;
LABEL_14:
mju_copy(*(_QWORD *)(a2 + 162160) + 48 * v10, v27, 6LL);
mju_copy(
*(unsigned long long *)((char *)&stru_27978.r_offset + a2) + 8 * v23,
v28,
(unsigned int)(6 * *(_DWORD *)(*(_QWORD *)(v9 + 1376) + 4 * v10++)));
if ( v10 >= *(int *)(v9 + 16) )
return;
}
v15 = 0;
v21 = 8 * v22;
v25 = v10;
while ( 1 )
{
v16 = v15 + v22;
v17 = *(_DWORD *)(*(_QWORD *)(v9 + 1592) + 4LL * *(int *)(*(_QWORD *)(v9 + 1736) + 4 * v16));
if ( v17 == 1 )
break;
if ( !v17 )
{
v12 = mju_zero(v28, 18LL, v12, a4, a5, a6, v13, v14, a9);
mju_mulDofVec(
v26,
8 * v23 + *(_QWORD *)(a2 + 161920),
v21 + *(unsigned long long *)((char *)&stru_27780.r_offset + a2),
3LL);
mju_addTo(v27, v26, 6LL);
v24 = v15 + v22 + 3;
v16 = v24;
v15 += 3;
goto LABEL_9;
}
v20 = 48LL * (_DWORD)v16;
mju_crossMotion(&v28[6 * v15], v27, v20 + *(_QWORD *)(a2 + 161920), v12);
mju_mulDofVec(
v26,
*(_QWORD *)(a2 + 161920) + v20,
v21 + *(unsigned long long *)((char *)&stru_27780.r_offset + a2) + 8LL * v15,
1LL);
mju_addTo(v27, v26, 6LL);
LABEL_13:
++v15;
v10 = v25;
if ( v15 >= *(_DWORD *)(*(_QWORD *)(v9 + 1376) + 4 * v25) )
goto LABEL_14;
}
v24 = v15 + v22;
LABEL_9:
v18 = 48 * v16;
for ( i = 0LL; i != 18; i += 6LL )
mju_crossMotion(&v28[6 * v15 + i], v27, i * 8 + v18 + *(_QWORD *)(a2 + 161920), v12);
mju_mulDofVec(
v26,
*(_QWORD *)(a2 + 161920) + 48LL * v24,
v21 + *(unsigned long long *)((char *)&stru_27780.r_offset + a2) + 8LL * v15,
3LL);
mju_addTo(v27, v26, 6LL);
v15 += 2;
v9 = a1;
goto LABEL_13;
}
}
|
mj_comVel:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1c8
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RSI + 0x27970]
MOV ESI,0x6
CALL 0x0012d1f0
CMP dword ptr [R14 + 0x10],0x2
JL 0x0014ba66
MOV R13D,0x1
LEA R15,[RSP + 0x70]
MOV qword ptr [RSP + 0x30],R14
LAB_0014b7c3:
MOV RAX,qword ptr [R14 + 0x530]
MOV RCX,qword ptr [R14 + 0x568]
MOVSXD R12,dword ptr [RCX + R13*0x4]
MOVSXD RAX,dword ptr [RAX + R13*0x4]
LEA RSI,[RAX + RAX*0x2]
SHL RSI,0x4
ADD RSI,qword ptr [RBX + 0x27970]
MOV RDI,R15
MOV EDX,0x6
CALL 0x0012d120
MOV RAX,qword ptr [R14 + 0x560]
MOV qword ptr [RSP + 0x10],R12
LEA RCX,[R12 + R12*0x1]
CMP dword ptr [RAX + R13*0x4],0x0
LEA RAX,[RCX + RCX*0x2]
MOV qword ptr [RSP + 0x18],RAX
JLE 0x0014ba06
XOR R12D,R12D
MOV RAX,qword ptr [RSP + 0x10]
LEA RAX,[RAX*0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x18]
LEA RAX,[RAX*0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x38],R13
LAB_0014b845:
MOV RCX,qword ptr [R14 + 0x638]
MOV RDX,qword ptr [R14 + 0x6c8]
MOVSXD RBP,R12D
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,RBP
MOVSXD RDX,dword ptr [RDX + RAX*0x4]
MOV ECX,dword ptr [RCX + RDX*0x4]
CMP ECX,0x1
JZ 0x0014b8db
TEST ECX,ECX
JNZ 0x0014b97e
LEA RDI,[RSP + 0xa0]
MOV ESI,0x12
CALL 0x0012d1f0
MOV RSI,qword ptr [RBX + 0x27880]
ADD RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RBX + 0x27780]
ADD RDX,qword ptr [RSP + 0x8]
LEA R14,[RSP + 0x40]
MOV RDI,R14
MOV ECX,0x3
CALL 0x001a5827
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x6
CALL 0x0012d830
MOV RAX,qword ptr [RSP + 0x10]
ADD EAX,R12D
ADD EAX,0x3
MOV ECX,R12D
ADD ECX,0x3
MOV qword ptr [RSP + 0x20],RAX
CDQE
MOV R12D,ECX
JMP 0x0014b8e2
LAB_0014b8db:
MOV ECX,EAX
MOV qword ptr [RSP + 0x20],RCX
LAB_0014b8e2:
MOVSXD R12,R12D
SHL RAX,0x4
LEA RBP,[RAX + RAX*0x2]
LEA RAX,[R12 + R12*0x2]
SHL RAX,0x4
LEA R14,[RSP + RAX*0x1]
ADD R14,0xa0
XOR R13D,R13D
LAB_0014b903:
LEA RDI,[R14 + R13*0x1]
MOV RDX,qword ptr [RBX + 0x27880]
ADD RDX,RBP
ADD RDX,R13
MOV RSI,R15
CALL 0x001a528d
ADD R13,0x30
CMP R13,0x90
JNZ 0x0014b903
MOV RAX,qword ptr [RSP + 0x20]
ADD EAX,EAX
LEA EAX,[RAX + RAX*0x2]
MOVSXD RSI,EAX
SHL RSI,0x3
ADD RSI,qword ptr [RBX + 0x27880]
MOV RAX,qword ptr [RBX + 0x27780]
ADD RAX,qword ptr [RSP + 0x8]
LEA RDX,[RAX + R12*0x8]
LEA R14,[RSP + 0x40]
MOV RDI,R14
MOV ECX,0x3
CALL 0x001a5827
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x6
CALL 0x0012d830
ADD R12D,0x2
MOV R14,qword ptr [RSP + 0x30]
JMP 0x0014b9ed
LAB_0014b97e:
LEA ECX,[R12 + R12*0x1]
LEA ECX,[RCX + RCX*0x2]
MOVSXD RCX,ECX
LEA RDI,[RSP + RCX*0x8]
ADD RDI,0xa0
ADD EAX,EAX
LEA EAX,[RAX + RAX*0x2]
MOVSXD R13,EAX
SHL R13,0x3
MOV RDX,qword ptr [RBX + 0x27880]
ADD RDX,R13
MOV RSI,R15
CALL 0x001a528d
ADD R13,qword ptr [RBX + 0x27880]
MOV RAX,qword ptr [RBX + 0x27780]
ADD RAX,qword ptr [RSP + 0x8]
LEA RDX,[RAX + RBP*0x8]
LEA RBP,[RSP + 0x40]
MOV RDI,RBP
MOV RSI,R13
MOV ECX,0x1
CALL 0x001a5827
MOV RDI,R15
MOV RSI,RBP
MOV EDX,0x6
CALL 0x0012d830
LAB_0014b9ed:
INC R12D
MOV RAX,qword ptr [R14 + 0x560]
MOV R13,qword ptr [RSP + 0x38]
CMP R12D,dword ptr [RAX + R13*0x4]
JL 0x0014b845
LAB_0014ba06:
LEA RDI,[R13*0x2]
ADD RDI,R13
SHL RDI,0x4
ADD RDI,qword ptr [RBX + 0x27970]
MOV RSI,R15
MOV EDX,0x6
CALL 0x0012d120
MOV RDI,qword ptr [RSP + 0x18]
SHL RDI,0x3
ADD RDI,qword ptr [RBX + 0x27978]
MOV RAX,qword ptr [R14 + 0x560]
MOV EAX,dword ptr [RAX + R13*0x4]
ADD EAX,EAX
LEA EDX,[RAX + RAX*0x2]
LEA RSI,[RSP + 0xa0]
CALL 0x0012d120
INC R13
MOVSXD RAX,dword ptr [R14 + 0x10]
CMP R13,RAX
JL 0x0014b7c3
LAB_0014ba66:
ADD RSP,0x1c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mj_comVel(long param_1,long param_2)
{
long lVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
long lVar7;
long lVar8;
int local_1d8;
int1 local_1b8 [48];
int1 local_188 [48];
int1 local_158 [296];
mju_zero(*(int8 *)(param_2 + 0x27970),6);
if (1 < *(int *)(param_1 + 0x10)) {
lVar7 = 1;
do {
iVar2 = *(int *)(*(long *)(param_1 + 0x568) + lVar7 * 4);
lVar6 = (long)iVar2;
mju_copy(local_188,
(long)*(int *)(*(long *)(param_1 + 0x530) + lVar7 * 4) * 0x30 +
*(long *)(param_2 + 0x27970),6);
if (0 < *(int *)(*(long *)(param_1 + 0x560) + lVar7 * 4)) {
iVar5 = 0;
lVar1 = lVar6 * 8;
do {
lVar4 = lVar6 + iVar5;
iVar3 = *(int *)(*(long *)(param_1 + 0x638) +
(long)*(int *)(*(long *)(param_1 + 0x6c8) + lVar4 * 4) * 4);
local_1d8 = (int)lVar4;
if (iVar3 == 1) {
LAB_0014b8e2:
lVar8 = 0;
do {
mju_crossMotion(local_158 + lVar8 + (long)iVar5 * 0x30,local_188,
*(long *)(param_2 + 0x27880) + lVar4 * 0x30 + lVar8);
lVar8 = lVar8 + 0x30;
} while (lVar8 != 0x90);
mju_mulDofVec(local_1b8,(long)(local_1d8 * 6) * 8 + *(long *)(param_2 + 0x27880),
*(long *)(param_2 + 0x27780) + lVar1 + (long)iVar5 * 8,3);
mju_addTo(local_188,local_1b8,6);
iVar5 = iVar5 + 2;
}
else {
if (iVar3 == 0) {
mju_zero(local_158,0x12);
mju_mulDofVec(local_1b8,*(long *)(param_2 + 0x27880) + lVar6 * 0x30,
*(long *)(param_2 + 0x27780) + lVar1,3);
mju_addTo(local_188,local_1b8,6);
local_1d8 = iVar2 + iVar5 + 3;
iVar5 = iVar5 + 3;
lVar4 = (long)local_1d8;
goto LAB_0014b8e2;
}
lVar4 = (long)(local_1d8 * 6) * 8;
mju_crossMotion(local_158 + (long)(iVar5 * 6) * 8,local_188,
*(long *)(param_2 + 0x27880) + lVar4);
mju_mulDofVec(local_1b8,lVar4 + *(long *)(param_2 + 0x27880),
*(long *)(param_2 + 0x27780) + lVar1 + (long)iVar5 * 8,1);
mju_addTo(local_188,local_1b8,6);
}
iVar5 = iVar5 + 1;
} while (iVar5 < *(int *)(*(long *)(param_1 + 0x560) + lVar7 * 4));
}
mju_copy(lVar7 * 0x30 + *(long *)(param_2 + 0x27970),local_188,6);
mju_copy(lVar6 * 0x30 + *(long *)(param_2 + 0x27978),local_158,
*(int *)(*(long *)(param_1 + 0x560) + lVar7 * 4) * 6);
lVar7 = lVar7 + 1;
} while (lVar7 < *(int *)(param_1 + 0x10));
}
return;
}
|
|
64,014 |
POINTonE1_double
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e1.c
|
void blst_p1_add(POINTonE1 *out, const POINTonE1 *a, const POINTonE1 *b)
{ POINTonE1_add(out, a, b); }
|
O3
|
c
|
POINTonE1_double:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r15
movq %rdi, %r12
leaq 0x60(%rdi), %rbx
movl $0x30, %esi
movq %rbx, %rdi
movq %rbx, -0x30(%rbp)
callq 0x6e900
movq %rax, -0x38(%rbp)
leaq 0x60(%r15), %r13
movl $0x30, %esi
movq %r13, %rdi
callq 0x6e900
movq %rax, %r14
leaq 0x31b99(%rip), %rdx # 0x8a910
leaq -0xa0(%rbp), %rdi
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
movq %rbx, %rsi
movq %rdx, %rbx
callq 0x726e0
leaq -0x70(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
callq 0x726e0
leaq -0x100(%rbp), %rdi
movq %r12, %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x72e60
leaq -0x160(%rbp), %rdi
movq %r15, %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x72e60
leaq -0xd0(%rbp), %rdi
addq $0x30, %r12
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
callq 0x72e60
leaq -0x130(%rbp), %r12
addq $0x30, %r15
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rcx
movabsq $-0x760c000300030003, %r8 # imm = 0x89F3FFFCFFFCFFFD
movq %r8, %r15
callq 0x72e60
leaq -0xd0(%rbp), %rdi
movq %rdi, %rsi
leaq -0x70(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x72e60
movq %r12, %rdi
movq %r12, %rsi
leaq -0xa0(%rbp), %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x72e60
movl $0x60, %edx
leaq -0x100(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x6e940
xorq -0x38(%rbp), %r14
xorq $0x1, %r14
andq %r14, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
POINTonE1_is_equal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 138h
mov r15, rsi
mov r12, rdi
lea rbx, [rdi+60h]
mov esi, 30h ; '0'
mov rdi, rbx
mov [rbp+var_30], rbx
call vec_is_zero_16x
mov [rbp+var_38], rax
lea r13, [r15+60h]
mov esi, 30h ; '0'
mov rdi, r13
call vec_is_zero_16x
mov r14, rax
lea rdx, BLS12_381_P
lea rdi, [rbp+var_A0]
mov rcx, 89F3FFFCFFFCFFFDh
mov rsi, rbx
mov rbx, rdx
call sqr_mont_384
lea rdi, [rbp+var_70]
mov rsi, r13
mov rdx, rbx
mov rcx, 89F3FFFCFFFCFFFDh
call sqr_mont_384
lea rdi, [rbp+var_100]
mov rsi, r12
lea rdx, [rbp+var_70]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384
lea rdi, [rbp+var_160]
mov rsi, r15
lea rdx, [rbp+var_A0]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384
lea rdi, [rbp+var_D0]
add r12, 30h ; '0'
mov rsi, r12
mov rdx, r13
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
call mul_mont_384
lea r12, [rbp+var_130]
add r15, 30h ; '0'
mov rdi, r12
mov rsi, r15
mov rdx, [rbp+var_30]
mov rcx, rbx
mov r8, 89F3FFFCFFFCFFFDh
mov r15, r8
call mul_mont_384
lea rdi, [rbp+var_D0]
mov rsi, rdi
lea rdx, [rbp+var_70]
mov rcx, rbx
mov r8, r15
call mul_mont_384
mov rdi, r12
mov rsi, r12
lea rdx, [rbp+var_A0]
mov rcx, rbx
mov r8, r15
call mul_mont_384
mov edx, 60h ; '`'
lea rdi, [rbp+var_100]
lea rsi, [rbp+var_160]
call vec_is_equal_16x
xor r14, [rbp+var_38]
xor r14, 1
and rax, r14
add rsp, 138h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long POINTonE1_is_equal(long long a1, long long a2)
{
long long v2; // r14
long long is_equal_16x; // rax
_BYTE v5[48]; // [rsp+0h] [rbp-160h] BYREF
_BYTE v6[48]; // [rsp+30h] [rbp-130h] BYREF
_BYTE v7[48]; // [rsp+60h] [rbp-100h] BYREF
_BYTE v8[48]; // [rsp+90h] [rbp-D0h] BYREF
_BYTE v9[48]; // [rsp+C0h] [rbp-A0h] BYREF
_BYTE v10[56]; // [rsp+F0h] [rbp-70h] BYREF
long long is_zero_16x; // [rsp+128h] [rbp-38h]
long long v12; // [rsp+130h] [rbp-30h]
v12 = a1 + 96;
is_zero_16x = vec_is_zero_16x(a1 + 96, 48LL);
v2 = vec_is_zero_16x(a2 + 96, 48LL);
sqr_mont_384(v9, a1 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384(v10, a2 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v7, a1, v10, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v5, a2, v9, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v8, a1 + 48, a2 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v6, a2 + 48, v12, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v8, v8, v10, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v6, v6, v9, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
is_equal_16x = vec_is_equal_16x(v7, v5, 96LL);
return (is_zero_16x ^ v2 ^ 1) & is_equal_16x;
}
|
POINTonE1_is_equal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x138
MOV R15,RSI
MOV R12,RDI
LEA RBX,[RDI + 0x60]
MOV ESI,0x30
MOV RDI,RBX
MOV qword ptr [RBP + -0x30],RBX
CALL 0x0016e900
MOV qword ptr [RBP + -0x38],RAX
LEA R13,[R15 + 0x60]
MOV ESI,0x30
MOV RDI,R13
CALL 0x0016e900
MOV R14,RAX
LEA RDX,[0x18a910]
LEA RDI,[RBP + -0xa0]
MOV RCX,-0x760c000300030003
MOV RSI,RBX
MOV RBX,RDX
CALL 0x001726e0
LEA RDI,[RBP + -0x70]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,-0x760c000300030003
CALL 0x001726e0
LEA RDI,[RBP + -0x100]
MOV RSI,R12
LEA RDX,[RBP + -0x70]
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00172e60
LEA RDI,[RBP + -0x160]
MOV RSI,R15
LEA RDX,[RBP + -0xa0]
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00172e60
LEA RDI,[RBP + -0xd0]
ADD R12,0x30
MOV RSI,R12
MOV RDX,R13
MOV RCX,RBX
MOV R8,-0x760c000300030003
CALL 0x00172e60
LEA R12,[RBP + -0x130]
ADD R15,0x30
MOV RDI,R12
MOV RSI,R15
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,RBX
MOV R8,-0x760c000300030003
MOV R15,R8
CALL 0x00172e60
LEA RDI,[RBP + -0xd0]
MOV RSI,RDI
LEA RDX,[RBP + -0x70]
MOV RCX,RBX
MOV R8,R15
CALL 0x00172e60
MOV RDI,R12
MOV RSI,R12
LEA RDX,[RBP + -0xa0]
MOV RCX,RBX
MOV R8,R15
CALL 0x00172e60
MOV EDX,0x60
LEA RDI,[RBP + -0x100]
LEA RSI,[RBP + -0x160]
CALL 0x0016e940
XOR R14,qword ptr [RBP + -0x38]
XOR R14,0x1
AND RAX,R14
ADD RSP,0x138
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong POINTonE1_is_equal(long param_1,long param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int1 local_168 [48];
int1 local_138 [48];
int1 local_108 [48];
int1 local_d8 [48];
int1 local_a8 [48];
int1 local_78 [56];
ulong local_40;
long local_38;
lVar1 = param_1 + 0x60;
local_38 = lVar1;
local_40 = vec_is_zero_16x(lVar1,0x30);
lVar2 = param_2 + 0x60;
uVar3 = vec_is_zero_16x(lVar2,0x30);
sqr_mont_384(local_a8,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384(local_78,lVar2,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_108,param_1,local_78,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_168,param_2,local_a8,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_d8,param_1 + 0x30,lVar2,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_138,param_2 + 0x30,local_38,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_d8,local_d8,local_78,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_138,local_138,local_a8,BLS12_381_P,0x89f3fffcfffcfffd);
uVar4 = vec_is_equal_16x(local_108,local_168,0x60);
return uVar4 & (uVar3 ^ local_40 ^ 1);
}
|
|
64,015 |
js_new_function_def
|
bluesky950520[P]quickjs/quickjs.c
|
static JSFunctionDef *js_new_function_def(JSContext *ctx,
JSFunctionDef *parent,
BOOL is_eval,
BOOL is_func_expr,
const char *filename,
int line_num,
int col_num)
{
JSFunctionDef *fd;
fd = js_mallocz(ctx, sizeof(*fd));
if (!fd)
return NULL;
fd->ctx = ctx;
init_list_head(&fd->child_list);
/* insert in parent list */
fd->parent = parent;
fd->parent_cpool_idx = -1;
if (parent) {
list_add_tail(&fd->link, &parent->child_list);
fd->is_strict_mode = parent->is_strict_mode;
fd->parent_scope_level = parent->scope_level;
}
fd->is_eval = is_eval;
fd->is_func_expr = is_func_expr;
js_dbuf_init(ctx, &fd->byte_code);
fd->last_opcode_pos = -1;
fd->func_name = JS_ATOM_NULL;
fd->var_object_idx = -1;
fd->arg_var_object_idx = -1;
fd->arguments_var_idx = -1;
fd->arguments_arg_idx = -1;
fd->func_var_idx = -1;
fd->eval_ret_idx = -1;
fd->this_var_idx = -1;
fd->new_target_var_idx = -1;
fd->this_active_func_var_idx = -1;
fd->home_object_var_idx = -1;
/* XXX: should distinguish arg, var and var object and body scopes */
fd->scopes = fd->def_scope_array;
fd->scope_size = countof(fd->def_scope_array);
fd->scope_count = 1;
fd->scopes[0].first = -1;
fd->scopes[0].parent = -1;
fd->scope_level = 0; /* 0: var/arg scope */
fd->scope_first = -1;
fd->body_scope = -1;
fd->filename = JS_NewAtom(ctx, filename);
fd->line_num = line_num;
fd->col_num = col_num;
js_dbuf_init(ctx, &fd->pc2line);
//fd->pc2line_last_line_num = line_num;
//fd->pc2line_last_pc = 0;
fd->ic = init_ic(ctx);
return fd;
}
|
O2
|
c
|
js_new_function_def:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %r8, %r15
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbp
movq %rdi, %r14
movl $0x238, %esi # imm = 0x238
callq 0x1adf1
movq %rax, %rbx
testq %rax, %rax
je 0x4f505
movq %r14, (%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbp, 0x8(%rbx)
orl $-0x1, 0x10(%rbx)
testq %rbp, %rbp
je 0x4f41a
leaq 0x28(%rbx), %rax
leaq 0x18(%rbp), %rcx
movq 0x18(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq %rax, 0x18(%rbp)
movl $0xffff8000, %eax # imm = 0xFFFF8000
andl 0x84(%rbp), %eax
movzwl 0x84(%rbx), %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
orl %eax, %ecx
movw %cx, 0x84(%rbx)
movl 0xe8(%rbp), %eax
movl %eax, 0x14(%rbx)
movl %r13d, 0x38(%rbx)
movl %r12d, 0x44(%rbx)
leaq 0x138(%rbx), %rsi
movq %r14, %rdi
callq 0x2d9d3
orl $-0x1, 0x168(%rbx)
andl $0x0, 0x88(%rbx)
leaq 0x100(%rbx), %rax
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0xbc(%rbx)
movdqu %xmm0, 0xcc(%rbx)
orq $-0x1, 0xdc(%rbx)
movq %rax, 0xf8(%rbx)
orq $-0x1, 0x100(%rbx)
movaps 0x39538(%rip), %xmm0 # 0x889b0
movups %xmm0, 0xe8(%rbx)
orl $-0x1, 0x120(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e021
movl %eax, 0x1d4(%rbx)
movl 0x4(%rsp), %eax
movl %eax, 0x1d8(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x1dc(%rbx)
movq %rbx, %rsi
addq $0x1e0, %rsi # imm = 0x1E0
movq %r14, %rdi
callq 0x2d9d3
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1adc4
movq %rax, %r15
testq %rax, %rax
je 0x4f517
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, (%r15)
movl $0x2, 0x8(%r15)
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1adf1
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x4f517
andq $0x0, 0x18(%r15)
movq %r15, 0x230(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ae1e
xorl %r15d, %r15d
jmp 0x4f4fe
|
js_new_function_def:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_34], r9d
mov r15, r8
mov r12d, ecx
mov r13d, edx
mov rbp, rsi
mov r14, rdi
mov esi, 238h
call js_mallocz
mov rbx, rax
test rax, rax
jz loc_4F505
mov [rbx], r14
lea rax, [rbx+18h]
mov [rbx+18h], rax
mov [rbx+20h], rax
mov [rbx+8], rbp
or dword ptr [rbx+10h], 0FFFFFFFFh
test rbp, rbp
jz short loc_4F41A
lea rax, [rbx+28h]
lea rcx, [rbp+18h]
mov rdx, [rbp+18h]
mov [rdx+8], rax
mov [rbx+28h], rdx
mov [rbx+30h], rcx
mov [rbp+18h], rax
mov eax, 0FFFF8000h
and eax, [rbp+84h]
movzx ecx, word ptr [rbx+84h]
and ecx, 7FFFh
or ecx, eax
mov [rbx+84h], cx
mov eax, [rbp+0E8h]
mov [rbx+14h], eax
loc_4F41A:
mov [rbx+38h], r13d
mov [rbx+44h], r12d
lea rsi, [rbx+138h]
mov rdi, r14
call js_dbuf_init
or dword ptr [rbx+168h], 0FFFFFFFFh
and dword ptr [rbx+88h], 0
lea rax, [rbx+100h]
pcmpeqd xmm0, xmm0
movdqu xmmword ptr [rbx+0BCh], xmm0
movdqu xmmword ptr [rbx+0CCh], xmm0
or qword ptr [rbx+0DCh], 0FFFFFFFFFFFFFFFFh
mov [rbx+0F8h], rax
or qword ptr [rbx+100h], 0FFFFFFFFFFFFFFFFh
movaps xmm0, cs:xmmword_889B0
movups xmmword ptr [rbx+0E8h], xmm0
or dword ptr [rbx+120h], 0FFFFFFFFh
mov rdi, r14
mov rsi, r15
call JS_NewAtom
mov [rbx+1D4h], eax
mov eax, [rsp+38h+var_34]
mov [rbx+1D8h], eax
mov eax, [rsp+38h+arg_0]
mov [rbx+1DCh], eax
mov rsi, rbx
add rsi, 1E0h
mov rdi, r14
call js_dbuf_init
push 20h ; ' '
pop rsi
mov rdi, r14
call js_malloc
mov r15, rax
test rax, rax
jz short loc_4F517
mov rax, 400000000h
mov [r15], rax
mov dword ptr [r15+8], 2
push 20h ; ' '
pop rsi
mov rdi, r14
call js_mallocz
mov [r15+10h], rax
test rax, rax
jz short loc_4F517
and qword ptr [r15+18h], 0
loc_4F4FE:
mov [rbx+230h], r15
loc_4F505:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4F517:
mov rdi, r14
mov rsi, r15
call js_free
xor r15d, r15d
jmp short loc_4F4FE
|
long long js_new_function_def(long long a1, long long a2, int a3, int a4, unsigned __int8 *a5, int a6, int a7)
{
long long v10; // rax
long long v11; // rbx
long long v12; // rdx
long long v13; // r15
long long v14; // rax
v10 = js_mallocz(a1, 0x238uLL);
v11 = v10;
if ( v10 )
{
*(_QWORD *)v10 = a1;
*(_QWORD *)(v10 + 24) = v10 + 24;
*(_QWORD *)(v10 + 32) = v10 + 24;
*(_QWORD *)(v10 + 8) = a2;
*(_DWORD *)(v10 + 16) = -1;
if ( a2 )
{
v12 = *(_QWORD *)(a2 + 24);
*(_QWORD *)(v12 + 8) = v10 + 40;
*(_QWORD *)(v10 + 40) = v12;
*(_QWORD *)(v10 + 48) = a2 + 24;
*(_QWORD *)(a2 + 24) = v10 + 40;
*(_WORD *)(v10 + 132) = *(_WORD *)(a2 + 132) & 0x8000 | *(_WORD *)(v10 + 132) & 0x7FFF;
*(_DWORD *)(v10 + 20) = *(_DWORD *)(a2 + 232);
}
*(_DWORD *)(v10 + 56) = a3;
*(_DWORD *)(v10 + 68) = a4;
js_dbuf_init(a1, v10 + 312);
*(_DWORD *)(v11 + 360) = -1;
*(_DWORD *)(v11 + 136) = 0;
*(_OWORD *)(v11 + 188) = -1LL;
*(_OWORD *)(v11 + 204) = -1LL;
*(_QWORD *)(v11 + 220) = -1LL;
*(_QWORD *)(v11 + 248) = v11 + 256;
*(_QWORD *)(v11 + 256) = -1LL;
*(_OWORD *)(v11 + 232) = xmmword_889B0;
*(_DWORD *)(v11 + 288) = -1;
*(_DWORD *)(v11 + 468) = JS_NewAtom(a1, a5);
*(_DWORD *)(v11 + 472) = a6;
*(_DWORD *)(v11 + 476) = a7;
js_dbuf_init(a1, v11 + 480);
v13 = js_malloc(a1, 32LL);
if ( v13
&& (*(_QWORD *)v13 = 0x400000000LL,
*(_DWORD *)(v13 + 8) = 2,
v14 = js_mallocz(a1, 0x20uLL),
(*(_QWORD *)(v13 + 16) = v14) != 0LL) )
{
*(_QWORD *)(v13 + 24) = 0LL;
}
else
{
js_free(a1, v13);
v13 = 0LL;
}
*(_QWORD *)(v11 + 560) = v13;
}
return v11;
}
|
js_new_function_def:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV dword ptr [RSP + 0x4],R9D
MOV R15,R8
MOV R12D,ECX
MOV R13D,EDX
MOV RBP,RSI
MOV R14,RDI
MOV ESI,0x238
CALL 0x0011adf1
MOV RBX,RAX
TEST RAX,RAX
JZ 0x0014f505
MOV qword ptr [RBX],R14
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x18],RAX
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x8],RBP
OR dword ptr [RBX + 0x10],0xffffffff
TEST RBP,RBP
JZ 0x0014f41a
LEA RAX,[RBX + 0x28]
LEA RCX,[RBP + 0x18]
MOV RDX,qword ptr [RBP + 0x18]
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RBX + 0x28],RDX
MOV qword ptr [RBX + 0x30],RCX
MOV qword ptr [RBP + 0x18],RAX
MOV EAX,0xffff8000
AND EAX,dword ptr [RBP + 0x84]
MOVZX ECX,word ptr [RBX + 0x84]
AND ECX,0x7fff
OR ECX,EAX
MOV word ptr [RBX + 0x84],CX
MOV EAX,dword ptr [RBP + 0xe8]
MOV dword ptr [RBX + 0x14],EAX
LAB_0014f41a:
MOV dword ptr [RBX + 0x38],R13D
MOV dword ptr [RBX + 0x44],R12D
LEA RSI,[RBX + 0x138]
MOV RDI,R14
CALL 0x0012d9d3
OR dword ptr [RBX + 0x168],0xffffffff
AND dword ptr [RBX + 0x88],0x0
LEA RAX,[RBX + 0x100]
PCMPEQD XMM0,XMM0
MOVDQU xmmword ptr [RBX + 0xbc],XMM0
MOVDQU xmmword ptr [RBX + 0xcc],XMM0
OR qword ptr [RBX + 0xdc],-0x1
MOV qword ptr [RBX + 0xf8],RAX
OR qword ptr [RBX + 0x100],-0x1
MOVAPS XMM0,xmmword ptr [0x001889b0]
MOVUPS xmmword ptr [RBX + 0xe8],XMM0
OR dword ptr [RBX + 0x120],0xffffffff
MOV RDI,R14
MOV RSI,R15
CALL 0x0011e021
MOV dword ptr [RBX + 0x1d4],EAX
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RBX + 0x1d8],EAX
MOV EAX,dword ptr [RSP + 0x40]
MOV dword ptr [RBX + 0x1dc],EAX
MOV RSI,RBX
ADD RSI,0x1e0
MOV RDI,R14
CALL 0x0012d9d3
PUSH 0x20
POP RSI
MOV RDI,R14
CALL 0x0011adc4
MOV R15,RAX
TEST RAX,RAX
JZ 0x0014f517
MOV RAX,0x400000000
MOV qword ptr [R15],RAX
MOV dword ptr [R15 + 0x8],0x2
PUSH 0x20
POP RSI
MOV RDI,R14
CALL 0x0011adf1
MOV qword ptr [R15 + 0x10],RAX
TEST RAX,RAX
JZ 0x0014f517
AND qword ptr [R15 + 0x18],0x0
LAB_0014f4fe:
MOV qword ptr [RBX + 0x230],R15
LAB_0014f505:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014f517:
MOV RDI,R14
MOV RSI,R15
CALL 0x0011ae1e
XOR R15D,R15D
JMP 0x0014f4fe
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 *
js_new_function_def(int8 param_1,long param_2,int4 param_3,int4 param_4,
int8 param_5,int4 param_6,int4 param_7)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int8 *puVar4;
int8 *puVar5;
long lVar6;
puVar4 = (int8 *)js_mallocz(param_1,0x238);
if (puVar4 == (int8 *)0x0) {
return (int8 *)0x0;
}
*puVar4 = param_1;
puVar4[3] = puVar4 + 3;
puVar4[4] = puVar4 + 3;
puVar4[1] = param_2;
*(int4 *)(puVar4 + 2) = 0xffffffff;
if (param_2 != 0) {
lVar6 = *(long *)(param_2 + 0x18);
*(int8 **)(lVar6 + 8) = puVar4 + 5;
puVar4[5] = lVar6;
puVar4[6] = param_2 + 0x18;
*(int8 **)(param_2 + 0x18) = puVar4 + 5;
*(ushort *)((long)puVar4 + 0x84) =
*(ushort *)((long)puVar4 + 0x84) & 0x7fff |
(ushort)*(int4 *)(param_2 + 0x84) & 0x8000;
*(int4 *)((long)puVar4 + 0x14) = *(int4 *)(param_2 + 0xe8);
}
*(int4 *)(puVar4 + 7) = param_3;
*(int4 *)((long)puVar4 + 0x44) = param_4;
js_dbuf_init(param_1,puVar4 + 0x27);
*(int4 *)(puVar4 + 0x2d) = 0xffffffff;
*(int4 *)(puVar4 + 0x11) = 0;
*(int4 *)((long)puVar4 + 0xbc) = 0xffffffff;
*(int4 *)(puVar4 + 0x18) = 0xffffffff;
*(int4 *)((long)puVar4 + 0xc4) = 0xffffffff;
*(int4 *)(puVar4 + 0x19) = 0xffffffff;
*(int4 *)((long)puVar4 + 0xcc) = 0xffffffff;
*(int4 *)(puVar4 + 0x1a) = 0xffffffff;
*(int4 *)((long)puVar4 + 0xd4) = 0xffffffff;
*(int4 *)(puVar4 + 0x1b) = 0xffffffff;
*(int8 *)((long)puVar4 + 0xdc) = 0xffffffffffffffff;
puVar4[0x1f] = puVar4 + 0x20;
puVar4[0x20] = 0xffffffffffffffff;
uVar2 = _UNK_001889bc;
uVar1 = _UNK_001889b8;
uVar3 = _UNK_001889b4;
*(int4 *)(puVar4 + 0x1d) = _DAT_001889b0;
*(int4 *)((long)puVar4 + 0xec) = uVar3;
*(int4 *)(puVar4 + 0x1e) = uVar1;
*(int4 *)((long)puVar4 + 0xf4) = uVar2;
*(int4 *)(puVar4 + 0x24) = 0xffffffff;
uVar3 = JS_NewAtom(param_1,param_5);
*(int4 *)((long)puVar4 + 0x1d4) = uVar3;
*(int4 *)(puVar4 + 0x3b) = param_6;
*(int4 *)((long)puVar4 + 0x1dc) = param_7;
js_dbuf_init(param_1,puVar4 + 0x3c);
puVar5 = (int8 *)js_malloc(param_1,0x20);
if (puVar5 != (int8 *)0x0) {
*puVar5 = 0x400000000;
*(int4 *)(puVar5 + 1) = 2;
lVar6 = js_mallocz(param_1,0x20);
puVar5[2] = lVar6;
if (lVar6 != 0) {
puVar5[3] = 0;
goto LAB_0014f4fe;
}
}
js_free(param_1,puVar5);
puVar5 = (int8 *)0x0;
LAB_0014f4fe:
puVar4[0x46] = puVar5;
return puVar4;
}
|
|
64,016 |
js_atomics_isLockFree
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_atomics_isLockFree(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv)
{
int v, ret;
if (JS_ToInt32Sat(ctx, &v, argv[0]))
return JS_EXCEPTION;
ret = (v == 1 || v == 2 || v == 4 || v == 8);
return js_bool(ret);
}
|
O1
|
c
|
js_atomics_isLockFree:
subq $0x18, %rsp
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rdx, 0x10(%rsp)
cmpl $-0x9, %ecx
jb 0x7e885
movq 0x10(%rsp), %rax
incl (%rax)
leaq 0xc(%rsp), %rsi
callq 0x26aaf
testl %eax, %eax
je 0x7e89c
movl $0x6, %edx
xorl %eax, %eax
jmp 0x7e8c3
movl $0x1, %edx
movl 0xc(%rsp), %ecx
cmpl $0x4, %ecx
ja 0x7e8bb
movl $0x16, %eax
btl %ecx, %eax
jae 0x7e8bb
movl $0x1, %eax
jmp 0x7e8c3
xorl %eax, %eax
cmpl $0x8, %ecx
sete %al
addq $0x18, %rsp
retq
|
js_atomics_isLockFree:
sub rsp, 18h
mov rdx, [r8]
mov rcx, [r8+8]
mov [rsp+18h+var_8], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_7E885
mov rax, [rsp+18h+var_8]
inc dword ptr [rax]
loc_7E885:
lea rsi, [rsp+18h+var_C]
call JS_ToInt32SatFree
test eax, eax
jz short loc_7E89C
mov edx, 6
xor eax, eax
jmp short loc_7E8C3
loc_7E89C:
mov edx, 1
mov ecx, [rsp+18h+var_C]
cmp ecx, 4
ja short loc_7E8BB
mov eax, 16h
bt eax, ecx
jnb short loc_7E8BB
mov eax, 1
jmp short loc_7E8C3
loc_7E8BB:
xor eax, eax
cmp ecx, 8
setz al
loc_7E8C3:
add rsp, 18h
retn
|
_BOOL8 js_atomics_isLockFree(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v5; // rdx
long long v6; // rcx
int v8; // eax
unsigned int v9; // [rsp+Ch] [rbp-Ch] BYREF
_DWORD *v10; // [rsp+10h] [rbp-8h]
v5 = *a5;
v6 = a5[1];
v10 = (_DWORD *)*a5;
if ( (unsigned int)v6 >= 0xFFFFFFF7 )
++*v10;
if ( (unsigned int)JS_ToInt32SatFree(a1, (int *)&v9, v5, v6) )
return 0LL;
if ( v9 <= 4 )
{
v8 = 22;
if ( _bittest(&v8, v9) )
return 1LL;
}
return v9 == 8;
}
|
js_atomics_isLockFree:
SUB RSP,0x18
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV qword ptr [RSP + 0x10],RDX
CMP ECX,-0x9
JC 0x0017e885
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
LAB_0017e885:
LEA RSI,[RSP + 0xc]
CALL 0x00126aaf
TEST EAX,EAX
JZ 0x0017e89c
MOV EDX,0x6
XOR EAX,EAX
JMP 0x0017e8c3
LAB_0017e89c:
MOV EDX,0x1
MOV ECX,dword ptr [RSP + 0xc]
CMP ECX,0x4
JA 0x0017e8bb
MOV EAX,0x16
BT EAX,ECX
JNC 0x0017e8bb
MOV EAX,0x1
JMP 0x0017e8c3
LAB_0017e8bb:
XOR EAX,EAX
CMP ECX,0x8
SETZ AL
LAB_0017e8c3:
ADD RSP,0x18
RET
|
bool js_atomics_isLockFree(int8 param_1)
{
int iVar1;
int8 *in_R8;
bool bVar2;
uint local_c;
int *local_8;
local_8 = (int *)*in_R8;
if (0xfffffff6 < (uint)in_R8[1]) {
*local_8 = *local_8 + 1;
}
iVar1 = JS_ToInt32SatFree(param_1,&local_c);
if (iVar1 == 0) {
if ((local_c < 5) && ((0x16U >> (local_c & 0x1f) & 1) != 0)) {
bVar2 = true;
}
else {
bVar2 = local_c == 8;
}
}
else {
bVar2 = false;
}
return bVar2;
}
|
|
64,017 |
js_atomics_isLockFree
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_atomics_isLockFree(JSContext *ctx,
JSValue this_obj,
int argc, JSValue *argv)
{
int v, ret;
if (JS_ToInt32Sat(ctx, &v, argv[0]))
return JS_EXCEPTION;
ret = (v == 1 || v == 2 || v == 4 || v == 8);
return js_bool(ret);
}
|
O3
|
c
|
js_atomics_isLockFree:
movq (%r8), %rdx
movq 0x8(%r8), %rcx
cmpl $-0x9, %ecx
jb 0x8131e
incl (%rdx)
pushq %rax
leaq 0x4(%rsp), %rsi
callq 0x27161
testl %eax, %eax
je 0x81336
movl $0x6, %edx
xorl %eax, %eax
jmp 0x8135d
movl $0x1, %edx
movl 0x4(%rsp), %ecx
cmpl $0x4, %ecx
ja 0x81355
movl $0x16, %eax
btl %ecx, %eax
jae 0x81355
movl $0x1, %eax
jmp 0x8135d
xorl %eax, %eax
cmpl $0x8, %ecx
sete %al
popq %rcx
retq
|
js_atomics_isLockFree:
mov rdx, [r8]
mov rcx, [r8+8]
cmp ecx, 0FFFFFFF7h
jb short loc_8131E
inc dword ptr [rdx]
loc_8131E:
push rax
lea rsi, [rsp+8+var_4]
call JS_ToInt32SatFree
test eax, eax
jz short loc_81336
mov edx, 6
xor eax, eax
jmp short loc_8135D
loc_81336:
mov edx, 1
mov ecx, [rsp+8+var_4]
cmp ecx, 4
ja short loc_81355
mov eax, 16h
bt eax, ecx
jnb short loc_81355
mov eax, 1
jmp short loc_8135D
loc_81355:
xor eax, eax
cmp ecx, 8
setz al
loc_8135D:
pop rcx
retn
|
_BOOL8 js_atomics_isLockFree(long long a1, long long a2, long long a3, long long a4, long long a5)
{
long long v5; // rax
_DWORD *v6; // rdx
long long v7; // rcx
int v9; // eax
unsigned int v10; // [rsp+0h] [rbp-4h] BYREF
v6 = *(_DWORD **)a5;
v7 = *(_QWORD *)(a5 + 8);
if ( (unsigned int)v7 >= 0xFFFFFFF7 )
++*v6;
v10 = HIDWORD(v5);
if ( (unsigned int)JS_ToInt32SatFree(a1, (int *)&v10, (long long)v6, v7) )
return 0LL;
if ( v10 <= 4 )
{
v9 = 22;
if ( _bittest(&v9, v10) )
return 1LL;
}
return v10 == 8;
}
|
js_atomics_isLockFree:
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
CMP ECX,-0x9
JC 0x0018131e
INC dword ptr [RDX]
LAB_0018131e:
PUSH RAX
LEA RSI,[RSP + 0x4]
CALL 0x00127161
TEST EAX,EAX
JZ 0x00181336
MOV EDX,0x6
XOR EAX,EAX
JMP 0x0018135d
LAB_00181336:
MOV EDX,0x1
MOV ECX,dword ptr [RSP + 0x4]
CMP ECX,0x4
JA 0x00181355
MOV EAX,0x16
BT EAX,ECX
JNC 0x00181355
MOV EAX,0x1
JMP 0x0018135d
LAB_00181355:
XOR EAX,EAX
CMP ECX,0x8
SETZ AL
LAB_0018135d:
POP RCX
RET
|
bool js_atomics_isLockFree(int8 param_1)
{
int iVar1;
int8 in_RAX;
int8 *in_R8;
bool bVar2;
uint local_4;
local_4 = (uint)((ulong)in_RAX >> 0x20);
if (0xfffffff6 < (uint)in_R8[1]) {
*(int *)*in_R8 = *(int *)*in_R8 + 1;
}
iVar1 = JS_ToInt32SatFree(param_1,&local_4);
if (iVar1 == 0) {
if ((local_4 < 5) && ((0x16U >> (local_4 & 0x1f) & 1) != 0)) {
bVar2 = true;
}
else {
bVar2 = local_4 == 8;
}
}
else {
bVar2 = false;
}
return bVar2;
}
|
|
64,018 |
get_short_trid
|
eloqsql/storage/maria/trnman.c
|
static uint get_short_trid(TRN *trn)
{
int i= (int) ((global_trid_generator + (intptr)trn) * 312089 %
SHORT_TRID_MAX) + 1;
uint res=0;
for ( ; !res ; i= 1)
{
for ( ; i <= SHORT_TRID_MAX; i++) /* the range is [1..SHORT_TRID_MAX] */
{
void *tmp= NULL;
if (short_trid_to_active_trn[i] == NULL &&
my_atomic_casptr((void **)&short_trid_to_active_trn[i], &tmp, trn))
{
res= i;
break;
}
}
}
return res;
}
|
O0
|
c
|
get_short_trid:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x42b401(%rip), %rax # 0x4792f0
movq -0x8(%rbp), %rcx
addq %rcx, %rax
imulq $0x4c319, %rax, %rax # imm = 0x4C319
movl $0xffff, %ecx # imm = 0xFFFF
xorl %edx, %edx
divq %rcx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4df28
jmp 0x4dfb8
jmp 0x4df2a
cmpl $0xffff, -0xc(%rbp) # imm = 0xFFFF
jg 0x4dfaa
movq $0x0, -0x18(%rbp)
movq 0x42b0ce(%rip), %rax # 0x479010
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4df9d
movq 0x42b0bc(%rip), %rcx # 0x479010
movslq -0xc(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
lock
cmpxchgq %rsi, (%rcx,%rdx,8)
movq %rax, %rcx
sete %al
movb %al, -0x31(%rbp)
movq %rcx, -0x30(%rbp)
testb $0x1, %al
jne 0x4df87
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x4df9d
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x4dfaa
jmp 0x4df9f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4df2a
jmp 0x4dfac
movl $0x1, -0xc(%rbp)
jmp 0x4df16
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
get_short_trid:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, cs:global_trid_generator
mov rcx, [rbp+var_8]
add rax, rcx
imul rax, 4C319h
mov ecx, 0FFFFh
xor edx, edx
div rcx
mov eax, edx
add eax, 1
mov [rbp+var_C], eax
mov [rbp+var_10], 0
loc_4DF16:
cmp [rbp+var_10], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_4DF28
jmp loc_4DFB8
loc_4DF28:
jmp short $+2
loc_4DF2A:
cmp [rbp+var_C], 0FFFFh
jg short loc_4DFAA
mov [rbp+var_18], 0
mov rax, cs:short_trid_to_active_trn
movsxd rcx, [rbp+var_C]
cmp qword ptr [rax+rcx*8], 0
jnz short loc_4DF9D
mov rcx, cs:short_trid_to_active_trn
movsxd rdx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rsi, [rbp+var_20]
lock cmpxchg [rcx+rdx*8], rsi
mov rcx, rax
setz al
mov [rbp+var_31], al
mov [rbp+var_30], rcx
test al, 1
jnz short loc_4DF87
mov rax, [rbp+var_30]
mov [rbp+var_18], rax
loc_4DF87:
mov al, [rbp+var_31]
and al, 1
mov [rbp+var_21], al
test [rbp+var_21], 1
jz short loc_4DF9D
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
jmp short loc_4DFAA
loc_4DF9D:
jmp short $+2
loc_4DF9F:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp short loc_4DF2A
loc_4DFAA:
jmp short $+2
loc_4DFAC:
mov [rbp+var_C], 1
jmp loc_4DF16
loc_4DFB8:
mov eax, [rbp+var_10]
pop rbp
retn
|
long long get_short_trid(signed long long a1)
{
unsigned int v2; // [rsp+22h] [rbp-10h]
int v3; // [rsp+26h] [rbp-Ch]
v3 = 312089 * (a1 + global_trid_generator) % 0xFFFFuLL + 1;
v2 = 0;
while ( !v2 )
{
while ( v3 <= 0xFFFF )
{
if ( !*(_QWORD *)(short_trid_to_active_trn + 8LL * v3)
&& !_InterlockedCompareExchange64((volatile signed long long *)(short_trid_to_active_trn + 8LL * v3), a1, 0LL) )
{
v2 = v3;
break;
}
++v3;
}
v3 = 1;
}
return v2;
}
|
get_short_trid:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [0x005792f0]
MOV RCX,qword ptr [RBP + -0x8]
ADD RAX,RCX
IMUL RAX,RAX,0x4c319
MOV ECX,0xffff
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x10],0x0
LAB_0014df16:
CMP dword ptr [RBP + -0x10],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x0014df28
JMP 0x0014dfb8
LAB_0014df28:
JMP 0x0014df2a
LAB_0014df2a:
CMP dword ptr [RBP + -0xc],0xffff
JG 0x0014dfaa
MOV qword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [0x00579010]
MOVSXD RCX,dword ptr [RBP + -0xc]
CMP qword ptr [RAX + RCX*0x8],0x0
JNZ 0x0014df9d
MOV RCX,qword ptr [0x00579010]
MOVSXD RDX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CMPXCHG.LOCK qword ptr [RCX + RDX*0x8],RSI
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x31],AL
MOV qword ptr [RBP + -0x30],RCX
TEST AL,0x1
JNZ 0x0014df87
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x18],RAX
LAB_0014df87:
MOV AL,byte ptr [RBP + -0x31]
AND AL,0x1
MOV byte ptr [RBP + -0x21],AL
TEST byte ptr [RBP + -0x21],0x1
JZ 0x0014df9d
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014dfaa
LAB_0014df9d:
JMP 0x0014df9f
LAB_0014df9f:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0014df2a
LAB_0014dfaa:
JMP 0x0014dfac
LAB_0014dfac:
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0014df16
LAB_0014dfb8:
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET
|
int get_short_trid(long param_1)
{
long *plVar1;
bool bVar2;
int4 local_18;
int4 local_14;
local_14 = (int)((ulong)((global_trid_generator + param_1) * 0x4c319) % 0xffff) + 1;
local_18 = 0;
do {
if (local_18 != 0) {
return local_18;
}
for (; local_14 < 0x10000; local_14 = local_14 + 1) {
if (*(long *)(short_trid_to_active_trn + (long)local_14 * 8) == 0) {
plVar1 = (long *)(short_trid_to_active_trn + (long)local_14 * 8);
LOCK();
bVar2 = *plVar1 == 0;
if (bVar2) {
*plVar1 = param_1;
}
UNLOCK();
if (bVar2) {
local_18 = local_14;
break;
}
}
}
local_14 = 1;
} while( true );
}
|
|
64,019 |
ma_pvio_tls_init
|
eloqsql/libmariadb/libmariadb/ma_tls.c
|
MARIADB_TLS *ma_pvio_tls_init(MYSQL *mysql)
{
MARIADB_TLS *ctls= NULL;
if (!ma_tls_initialized)
ma_tls_start(mysql->net.last_error, MYSQL_ERRMSG_SIZE);
if (!(ctls= (MARIADB_TLS *)calloc(1, sizeof(MARIADB_TLS))))
{
return NULL;
}
/* register error routine and methods */
ctls->pvio= mysql->net.pvio;
if (!(ctls->ssl= ma_tls_init(mysql)))
{
free(ctls);
ctls= NULL;
}
return ctls;
}
|
O3
|
c
|
ma_pvio_tls_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2b7c7(%rip), %rax # 0x48f20
cmpb $0x0, (%rax)
jne 0x1d76f
leaq 0x97(%r14), %rdi
movl $0x200, %esi # imm = 0x200
callq 0x27b54
movl $0x1, %edi
movl $0x18, %esi
callq 0x132e0
testq %rax, %rax
je 0x1d7a6
movq %rax, %rbx
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x27c8a
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x1d7a8
movq %rbx, %rdi
callq 0x13570
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
ma_pvio_tls_init:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdi
lea rax, ma_tls_initialized
cmp byte ptr [rax], 0
jnz short loc_1D76F
lea rdi, [r14+97h]
mov esi, 200h
call ma_tls_start
loc_1D76F:
mov edi, 1
mov esi, 18h
call _calloc
test rax, rax
jz short loc_1D7A6
mov rbx, rax
mov rax, [r14]
mov [rbx+8], rax
mov rdi, r14
call ma_tls_init
mov [rbx+10h], rax
test rax, rax
jnz short loc_1D7A8
mov rdi, rbx
call _free
loc_1D7A6:
xor ebx, ebx
loc_1D7A8:
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
|
long long ma_pvio_tls_init(_QWORD *a1)
{
long long v1; // rax
long long v2; // rbx
long long v3; // rax
if ( !ma_tls_initialized )
ma_tls_start((char *)a1 + 151, 512LL);
v1 = calloc(1LL, 24LL);
if ( !v1 )
return 0LL;
v2 = v1;
*(_QWORD *)(v1 + 8) = *a1;
v3 = ma_tls_init(a1);
*(_QWORD *)(v2 + 16) = v3;
if ( !v3 )
{
free(v2);
return 0LL;
}
return v2;
}
|
ma_pvio_tls_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDI
LEA RAX,[0x148f20]
CMP byte ptr [RAX],0x0
JNZ 0x0011d76f
LEA RDI,[R14 + 0x97]
MOV ESI,0x200
CALL 0x00127b54
LAB_0011d76f:
MOV EDI,0x1
MOV ESI,0x18
CALL 0x001132e0
TEST RAX,RAX
JZ 0x0011d7a6
MOV RBX,RAX
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,R14
CALL 0x00127c8a
MOV qword ptr [RBX + 0x10],RAX
TEST RAX,RAX
JNZ 0x0011d7a8
MOV RDI,RBX
CALL 0x00113570
LAB_0011d7a6:
XOR EBX,EBX
LAB_0011d7a8:
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
|
void * ma_pvio_tls_init(int8 *param_1)
{
void *__ptr;
long lVar1;
if (ma_tls_initialized == '\0') {
ma_tls_start((long)param_1 + 0x97,0x200);
}
__ptr = calloc(1,0x18);
if (__ptr != (void *)0x0) {
*(int8 *)((long)__ptr + 8) = *param_1;
lVar1 = ma_tls_init(param_1);
*(long *)((long)__ptr + 0x10) = lVar1;
if (lVar1 != 0) {
return __ptr;
}
free(__ptr);
}
return (void *)0x0;
}
|
|
64,020 |
parse_strsub_cb
|
navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_engine-src/src/port/engine_qoraal.c
|
static int32_t
parse_strsub_cb(STRSUB_REPLACE_CB cb, const char * str, size_t len, uint32_t offset, uintptr_t arg)
{
#define SERVICES_STRSUB_BUFFER_LEN 12
int32_t res = ENGINE_FAIL ;
char buffer[SERVICES_STRSUB_BUFFER_LEN] ;
uint32_t idx = 0 ;
int type = parseInvalid ;
if (len) {
if (isdigit((int)str[0])) {
if (sscanf(str, "%u", (unsigned int*)&idx) <= 0) return res ;
} else {
type = ParseGetIdentifierId(str, len, &idx) ;
}
}
if (type == parseVariable) {
res = snprintf (buffer, SERVICES_STRSUB_BUFFER_LEN, "[%u]", (unsigned int)idx) ;
} else if (type == parseEvent) {
res = snprintf (buffer, SERVICES_STRSUB_BUFFER_LEN, "%u", (unsigned int)idx) ;
}
if (res >= 0) {
res = cb (buffer, res, offset, arg) ;
}
return res ;
}
|
O3
|
c
|
parse_strsub_cb:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x0, -0x2c(%rbp)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0xe03a
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq %r8, -0x38(%rbp)
callq 0x65f0
movq (%rax), %rax
movsbq (%r13), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0xdfee
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
movl %ebx, %esi
callq 0xce6c
cmpl $0x1, %eax
je 0xe005
cmpl $0x2, %eax
jne 0xe03a
movl -0x2c(%rbp), %ecx
leaq 0x180e7(%rip), %rdx # 0x260d3
jmp 0xe00f
leaq 0x16fe6(%rip), %rsi # 0x24fdb
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
xorl %eax, %eax
callq 0x63e0
jmp 0xe03a
movl -0x2c(%rbp), %ecx
leaq 0x16fcc(%rip), %rdx # 0x24fdb
leaq -0x44(%rbp), %rdi
movl $0xc, %esi
xorl %eax, %eax
callq 0x6200
movl %eax, %r12d
testl %eax, %eax
movq -0x38(%rbp), %rcx
js 0xe03a
leaq -0x44(%rbp), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq *%r15
movl %eax, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
parse_strsub_cb:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_2C], 0
mov r12d, 0FFFFFFFFh
test rdx, rdx
jz loc_E03A
mov r14d, ecx
mov rbx, rdx
mov r13, rsi
mov r15, rdi
mov [rbp+var_38], r8
call ___ctype_b_loc
mov rax, [rax]
movsx rcx, byte ptr [r13+0]
test byte ptr [rax+rcx*2+1], 8
jnz short loc_DFEE
lea rdx, [rbp+var_2C]
mov rdi, r13
mov esi, ebx
call ParseGetIdentifierId
cmp eax, 1
jz short loc_E005
cmp eax, 2
jnz short loc_E03A
mov ecx, [rbp+var_2C]
lea rdx, aU_0; "[%u]"
jmp short loc_E00F
loc_DFEE:
lea rsi, aU; "%u"
lea rdx, [rbp+var_2C]
mov rdi, r13
xor eax, eax
call ___isoc99_sscanf
jmp short loc_E03A
loc_E005:
mov ecx, [rbp+var_2C]
lea rdx, aU; "%u"
loc_E00F:
lea rdi, [rbp+var_44]
mov esi, 0Ch
xor eax, eax
call _snprintf
mov r12d, eax
test eax, eax
mov rcx, [rbp+var_38]
js short loc_E03A
lea rdi, [rbp+var_44]
mov esi, r12d
mov edx, r14d
call r15
mov r12d, eax
loc_E03A:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long parse_strsub_cb(
unsigned int ( *a1)(_BYTE *, _QWORD, _QWORD, long long),
char *a2,
long long a3,
unsigned int a4,
long long a5)
{
unsigned int v5; // r12d
unsigned int v7; // ebx
int IdentifierId; // eax
int v9; // eax
_BYTE v11[12]; // [rsp+Ch] [rbp-44h] BYREF
long long v12; // [rsp+18h] [rbp-38h]
_DWORD v13[11]; // [rsp+24h] [rbp-2Ch] BYREF
v13[0] = 0;
v5 = -1;
if ( a3 )
{
v7 = a3;
v12 = a5;
if ( (*(_BYTE *)(*(_QWORD *)__ctype_b_loc(a1) + 2LL * *a2 + 1) & 8) != 0 )
{
__isoc99_sscanf(a2, "%u", v13);
return v5;
}
IdentifierId = ParseGetIdentifierId((long long)a2, v7, v13);
if ( IdentifierId == 1 )
{
v9 = snprintf(v11, 12LL, aU, v13[0]);
}
else
{
if ( IdentifierId != 2 )
return v5;
v9 = snprintf(v11, 12LL, aU_0, v13[0]);
}
v5 = v9;
if ( v9 >= 0 )
return a1(v11, (unsigned int)v9, a4, v12);
}
return v5;
}
|
parse_strsub_cb:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RBP + -0x2c],0x0
MOV R12D,0xffffffff
TEST RDX,RDX
JZ 0x0010e03a
MOV R14D,ECX
MOV RBX,RDX
MOV R13,RSI
MOV R15,RDI
MOV qword ptr [RBP + -0x38],R8
CALL 0x001065f0
MOV RAX,qword ptr [RAX]
MOVSX RCX,byte ptr [R13]
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x8
JNZ 0x0010dfee
LEA RDX,[RBP + -0x2c]
MOV RDI,R13
MOV ESI,EBX
CALL 0x0010ce6c
CMP EAX,0x1
JZ 0x0010e005
CMP EAX,0x2
JNZ 0x0010e03a
MOV ECX,dword ptr [RBP + -0x2c]
LEA RDX,[0x1260d3]
JMP 0x0010e00f
LAB_0010dfee:
LEA RSI,[0x124fdb]
LEA RDX,[RBP + -0x2c]
MOV RDI,R13
XOR EAX,EAX
CALL 0x001063e0
JMP 0x0010e03a
LAB_0010e005:
MOV ECX,dword ptr [RBP + -0x2c]
LEA RDX,[0x124fdb]
LAB_0010e00f:
LEA RDI,[RBP + -0x44]
MOV ESI,0xc
XOR EAX,EAX
CALL 0x00106200
MOV R12D,EAX
TEST EAX,EAX
MOV RCX,qword ptr [RBP + -0x38]
JS 0x0010e03a
LEA RDI,[RBP + -0x44]
MOV ESI,R12D
MOV EDX,R14D
CALL R15
MOV R12D,EAX
LAB_0010e03a:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int parse_strsub_cb(code *param_1,char *param_2,ulong param_3,int4 param_4,int8 param_5)
{
int iVar1;
ushort **ppuVar2;
char *__format;
char local_4c [12];
int8 local_40;
uint local_34;
local_34 = 0;
iVar1 = -1;
if (param_3 != 0) {
local_40 = param_5;
ppuVar2 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar2 + (long)*param_2 * 2 + 1) & 8) == 0) {
iVar1 = ParseGetIdentifierId(param_2,param_3 & 0xffffffff,&local_34);
if (iVar1 == 1) {
__format = &DAT_00124fdb;
}
else {
if (iVar1 != 2) {
return -1;
}
__format = &DAT_001260d3;
}
iVar1 = snprintf(local_4c,0xc,__format,(ulong)local_34);
if (-1 < iVar1) {
iVar1 = (*param_1)(local_4c,iVar1,param_4,local_40);
}
}
else {
__isoc99_sscanf(param_2,&DAT_00124fdb,&local_34);
}
}
return iVar1;
}
|
|
64,021 |
YAML::as_if<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::operator()() const
|
aimrt_mujoco_sim/_deps/yaml-cpp-src/include/yaml-cpp/node/impl.h
|
std::string operator()() const {
if (node.Type() == NodeType::Null)
return "null";
if (node.Type() != NodeType::Scalar)
throw TypedBadConversion<std::string>(node.Mark());
return node.Scalar();
}
|
O3
|
c
|
YAML::as_if<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::operator()() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r15
cmpb $0x0, (%r15)
je 0x4b103
movq %rdi, %rbx
movq 0x38(%r15), %rax
testq %rax, %rax
je 0x4b0b4
movq %rsi, %r14
movq (%rax), %rax
movq (%rax), %rax
movb (%rax), %dl
movl 0x10(%rax), %ecx
cmpl $0x1, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x4b0d3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11671b(%rip), %rsi # 0x1617dd
leaq 0x116718(%rip), %rdx # 0x1617e1
movq %rbx, %rdi
callq 0x2c610
jmp 0x4b0f6
testb %dl, %dl
je 0x4b135
cmpl $0x2, %ecx
jne 0x4b135
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c640
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
addq $0x8, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x47084
leaq 0x1be4b2(%rip), %rsi # 0x2095d8
leaq 0x155ff(%rip), %rdx # 0x6072c
movq %rbx, %rdi
callq 0x2e0f0
movl $0x40, %edi
callq 0x2c800
movq %rax, %rbx
movq (%r14), %rdi
callq 0x47518
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x48dd4
leaq 0x1bd99e(%rip), %rax # 0x208b00
movq %rax, (%rbx)
leaq 0x1bd96c(%rip), %rsi # 0x208ad8
leaq 0x155b9(%rip), %rdx # 0x6072c
jmp 0x4b12d
jmp 0x4b177
movq %rax, %r14
movq %rbx, %rdi
callq 0x2cc80
movq %r14, %rdi
callq 0x2e220
|
_ZNK4YAML5as_ifINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEclEv:
push r15
push r14
push rbx; __int64
sub rsp, 10h
mov r15, [rsi]
cmp byte ptr [r15], 0
jz short loc_4B103
mov rbx, rdi
mov rax, [r15+38h]
test rax, rax
jz short loc_4B0B4
mov r14, rsi
mov rax, [rax]
mov rax, [rax]
mov dl, [rax]
mov ecx, [rax+10h]
cmp ecx, 1
setz sil
and sil, dl
cmp sil, 1
jnz short loc_4B0D3
loc_4B0B4:
lea rax, [rbx+10h]
mov [rbx], rax
lea rsi, aStringPointerI+12h; "null"
lea rdx, aStringPointerI+16h; ""
mov rdi, rbx
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)
jmp short loc_4B0F6
loc_4B0D3:
test dl, dl
jz short loc_4B135
cmp ecx, 2
jnz short loc_4B135
lea rcx, [rbx+10h]
mov [rbx], rcx
mov rsi, [rax+40h]
mov rdx, [rax+48h]
add rdx, rsi
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
loc_4B0F6:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_4B103:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
add r15, 8
mov rdi, rax
mov rsi, r15
call _ZN4YAML11InvalidNodeC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; YAML::InvalidNode::InvalidNode(std::string const&)
lea rsi, _ZTIN4YAML11InvalidNodeE; lptinfo
lea rdx, _ZN4YAML9ExceptionD2Ev; void (*)(void *)
loc_4B12D:
mov rdi, rbx; void *
call ___cxa_throw
loc_4B135:
mov edi, 40h ; '@'; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, [r14]; this
call _ZNK4YAML4Node4MarkEv; YAML::Node::Mark(void)
mov rsi, rsp; int
mov [rsi], rax
mov [rsi+8], edx
mov rdi, rbx; int
call _ZN4YAML13BadConversionC2ERKNS_4MarkE; YAML::BadConversion::BadConversion(YAML::Mark const&)
lea rax, off_208B00
mov [rbx], rax
lea rsi, _ZTIN4YAML18TypedBadConversionINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE; `typeinfo for'YAML::TypedBadConversion<std::string>
lea rdx, _ZN4YAML9ExceptionD2Ev; YAML::Exception::~Exception()
jmp short loc_4B12D
jmp short $+2
loc_4B177:
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
|
_QWORD * YAML::as_if<std::string,void>::operator()(_QWORD *a1, YAML::Node **a2)
{
YAML::Node *v2; // r15
long long **v3; // rax
long long v4; // rax
int v5; // ecx
_QWORD *exception; // rbx
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
struct type_info *v12; // rsi
int v13; // edx
long long v14; // [rsp+0h] [rbp-28h] BYREF
int v15; // [rsp+8h] [rbp-20h]
v2 = *a2;
if ( !*(_BYTE *)*a2 )
{
exception = __cxa_allocate_exception(0x40uLL);
YAML::InvalidNode::InvalidNode((_DWORD)exception, (_DWORD)v2 + 8, v8, v9, v10, v11);
v12 = (struct type_info *)&`typeinfo for'YAML::InvalidNode;
goto LABEL_10;
}
v3 = (long long **)*((_QWORD *)v2 + 7);
if ( v3 )
{
v4 = **v3;
v5 = *(_DWORD *)(v4 + 16);
if ( (*(_BYTE *)v4 & (v5 == 1)) != 1 )
{
if ( *(_BYTE *)v4 && v5 == 2 )
{
*a1 = a1 + 2;
std::string::_M_construct<char *>(a1, *(_QWORD *)(v4 + 64), *(_QWORD *)(v4 + 64) + *(_QWORD *)(v4 + 72));
return a1;
}
exception = __cxa_allocate_exception(0x40uLL);
v14 = YAML::Node::Mark(*a2);
v15 = v13;
YAML::BadConversion::BadConversion(exception, (int)&v14);
*exception = &off_208B00;
v12 = (struct type_info *)&`typeinfo for'YAML::TypedBadConversion<std::string>;
LABEL_10:
__cxa_throw(exception, v12, YAML::Exception::~Exception);
}
}
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "null", "");
return a1;
}
|
operator():
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R15,qword ptr [RSI]
CMP byte ptr [R15],0x0
JZ 0x0014b103
MOV RBX,RDI
MOV RAX,qword ptr [R15 + 0x38]
TEST RAX,RAX
JZ 0x0014b0b4
MOV R14,RSI
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV DL,byte ptr [RAX]
MOV ECX,dword ptr [RAX + 0x10]
CMP ECX,0x1
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JNZ 0x0014b0d3
LAB_0014b0b4:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RSI,[0x2617dd]
LEA RDX,[0x2617e1]
MOV RDI,RBX
CALL 0x0012c610
JMP 0x0014b0f6
LAB_0014b0d3:
TEST DL,DL
JZ 0x0014b135
CMP ECX,0x2
JNZ 0x0014b135
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RAX + 0x48]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x0012c640
LAB_0014b0f6:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_0014b103:
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
ADD R15,0x8
LAB_0014b114:
MOV RDI,RAX
MOV RSI,R15
CALL 0x00147084
LAB_0014b11f:
LEA RSI,[0x3095d8]
LEA RDX,[0x16072c]
LAB_0014b12d:
MOV RDI,RBX
CALL 0x0012e0f0
LAB_0014b135:
MOV EDI,0x40
CALL 0x0012c800
MOV RBX,RAX
MOV RDI,qword ptr [R14]
LAB_0014b145:
CALL 0x00147518
MOV RSI,RSP
MOV qword ptr [RSI],RAX
MOV dword ptr [RSI + 0x8],EDX
MOV RDI,RBX
CALL 0x00148dd4
LAB_0014b15b:
LEA RAX,[0x308b00]
MOV qword ptr [RBX],RAX
LEA RSI,[0x308ad8]
LEA RDX,[0x16072c]
JMP 0x0014b12d
|
/* YAML::as_if<std::__cxx11::string, void>::TEMPNAMEPLACEHOLDERVALUE() const */
as_if<std::__cxx11::string,void> * __thiscall
YAML::as_if<std::__cxx11::string,void>::operator()(as_if<std::__cxx11::string,void> *this)
{
char *pcVar1;
byte *pbVar2;
BadConversion *this_00;
int8 *in_RSI;
pointer_____offset_0x10___ *ppuVar3;
int1 local_28 [12];
pcVar1 = (char *)*in_RSI;
if (*pcVar1 == '\0') {
this_00 = (BadConversion *)__cxa_allocate_exception(0x40);
/* try { // try from 0014b114 to 0014b11e has its CatchHandler @ 0014b177 */
InvalidNode::InvalidNode((InvalidNode *)this_00,(string *)(pcVar1 + 8));
ppuVar3 = &InvalidNode::typeinfo;
LAB_0014b12d:
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,ppuVar3,BadInsert::~BadInsert);
}
if (*(int8 **)(pcVar1 + 0x38) != (int8 *)0x0) {
pbVar2 = *(byte **)**(int8 **)(pcVar1 + 0x38);
if ((*(int *)(pbVar2 + 0x10) == 1 & *pbVar2) != 1) {
if ((*pbVar2 != 0) && (*(int *)(pbVar2 + 0x10) == 2)) {
*(as_if<std::__cxx11::string,void> **)this = this + 0x10;
std::__cxx11::string::_M_construct<char*>
(this,*(long *)(pbVar2 + 0x40),*(long *)(pbVar2 + 0x48) + *(long *)(pbVar2 + 0x40)
);
return this;
}
this_00 = (BadConversion *)__cxa_allocate_exception(0x40);
/* try { // try from 0014b145 to 0014b15a has its CatchHandler @ 0014b175 */
local_28 = Node::Mark((Node *)*in_RSI);
BadConversion::BadConversion(this_00,(Mark *)local_28);
*(int ***)this_00 = &PTR__BadInsert_00308b00;
ppuVar3 = &TypedBadConversion<std::__cxx11::string>::typeinfo;
goto LAB_0014b12d;
}
}
*(as_if<std::__cxx11::string,void> **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,"null","");
return this;
}
|
|
64,022 |
default_reporter
|
eloqsql/mysys/my_getopt.c
|
static void default_reporter(enum loglevel level, const char *format, ...)
{
va_list args;
DBUG_ENTER("default_reporter");
va_start(args, format);
if (level == WARNING_LEVEL)
fprintf(stderr, "%s", "Warning: ");
else if (level == INFORMATION_LEVEL)
fprintf(stderr, "%s", "Info: ");
vfprintf(stderr, format, args);
va_end(args);
fputc('\n', stderr);
fflush(stderr);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
default_reporter:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x27518
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x1, -0x4(%rbp)
jne 0x27586
movq 0x1b1a6c(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
leaq 0x5eb17(%rip), %rsi # 0x8608d
leaq 0x5b600(%rip), %rdx # 0x82b7d
movb $0x0, %al
callq 0x25470
jmp 0x275ad
cmpl $0x2, -0x4(%rbp)
jne 0x275ab
movq 0x1b1a45(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
leaq 0x5eaf0(%rip), %rsi # 0x8608d
leaq 0x5b5e3(%rip), %rdx # 0x82b87
movb $0x0, %al
callq 0x25470
jmp 0x275ad
movq 0x1b1a24(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x25430
leaq -0x30(%rbp), %rax
movq 0x1b1a09(%rip), %rax # 0x1d8fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x253f0
movq 0x1b19f5(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
callq 0x25380
jmp 0x275ed
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
default_reporter:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_27518
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_27518:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_E0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
cmp [rbp+var_4], 1
jnz short loc_27586
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aWarning; "Warning: "
mov al, 0
call _fprintf
jmp short loc_275AD
loc_27586:
cmp [rbp+var_4], 2
jnz short loc_275AB
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aAtLineDPosDS+13h; "%s"
lea rdx, aInfo; "Info: "
mov al, 0
call _fprintf
loc_275AB:
jmp short $+2
loc_275AD:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call _vfprintf
lea rax, [rbp+var_30]
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fflush
jmp short $+2
loc_275ED:
add rsp, 0E0h
pop rbp
retn
|
long long default_reporter(int a1, long long a2, ...)
{
va_list va; // [rsp+B0h] [rbp-30h] BYREF
long long v4; // [rsp+D0h] [rbp-10h]
int v5; // [rsp+DCh] [rbp-4h]
va_start(va, a2);
v5 = a1;
v4 = a2;
if ( a1 == 1 )
{
fprintf(stderr, "%s", "Warning: ");
}
else if ( v5 == 2 )
{
fprintf(stderr, "%s", "Info: ");
}
vfprintf(stderr, v4, va);
fputc(10LL, stderr);
return fflush(stderr);
}
|
default_reporter:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x00127518
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_00127518:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xe0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x00127586
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x18608d]
LEA RDX,[0x182b7d]
MOV AL,0x0
CALL 0x00125470
JMP 0x001275ad
LAB_00127586:
CMP dword ptr [RBP + -0x4],0x2
JNZ 0x001275ab
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x18608d]
LEA RDX,[0x182b87]
MOV AL,0x0
CALL 0x00125470
LAB_001275ab:
JMP 0x001275ad
LAB_001275ad:
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x00125430
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [0x002d8fd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x001253f0
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
CALL 0x00125380
JMP 0x001275ed
LAB_001275ed:
ADD RSP,0xe0
POP RBP
RET
|
void default_reporter(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int param_9,char *param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_e8 [16];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
char *local_18;
int local_c;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_c = param_9;
if (param_9 == 1) {
fprintf(*(FILE **)PTR_stderr_002d8fd8,"%s","Warning: ");
}
else if (param_9 == 2) {
fprintf(*(FILE **)PTR_stderr_002d8fd8,"%s","Info: ");
}
vfprintf(*(FILE **)PTR_stderr_002d8fd8,local_18,&local_38);
fputc(10,*(FILE **)PTR_stderr_002d8fd8);
fflush(*(FILE **)PTR_stderr_002d8fd8);
return;
}
|
|
64,023 |
my_strnxfrm_czech
|
eloqsql/strings/ctype-czech.c
|
static size_t
my_strnxfrm_czech(CHARSET_INFO *cs __attribute__((unused)),
uchar *dest, size_t len,
uint nweights_arg __attribute__((unused)),
const uchar *src, size_t srclen, uint flags)
{
int value;
const uchar *p, * store;
int pass = 0;
size_t totlen = 0;
p = src; store = src;
if (!(flags & 0x0F)) /* All levels by default */
flags|= 0x0F;
do
{
int add= (1 << pass) & flags; /* If this level is needed */
NEXT_CMP_VALUE(src, p, store, pass, value, (int)srclen);
if (add)
ADD_TO_RESULT(dest, len, totlen, value);
}
while (value);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len > totlen)
{
memset(dest + totlen, ' ', len - totlen);
totlen= len;
}
return totlen;
}
|
O3
|
c
|
my_strnxfrm_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, -0x48(%rbp)
movl 0x10(%rbp), %eax
movl %eax, %r11d
orl $0xf, %r11d
testb $0xf, %al
cmovnel %eax, %r11d
movslq %r9d, %rdx
movl $0x1, %eax
subq %r8, %rax
movq %rax, -0x50(%rbp)
xorl %ecx, %ecx
leaq 0x2d68a4(%rip), %r13 # 0x3641c0
movq %r8, %r14
xorl %r12d, %r12d
movq %rbx, -0x38(%rbp)
movl %r11d, -0x2c(%rbp)
movl $0x1, %esi
shll %cl, %esi
movq %r8, %rax
subq %r15, %rax
cmpq %rdx, %rax
jge 0x8d9bb
movslq %ecx, %rax
movq %rax, -0x58(%rbp)
movq (%r13,%rax,8), %r9
movzbl (%r8), %eax
movzbl (%r9,%rax), %eax
testl %eax, %eax
je 0x8d98a
cmpl $0x2, %eax
jne 0x8d9ef
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
cmpq %rdx, %rax
jge 0x8d998
movzbl (%r10), %edi
cmpb $0x2, (%r9,%rdi)
jne 0x8d998
incq %r10
incq %rax
movq %r10, %rdi
cmpq %rdx, %rax
jl 0x8d96f
jmp 0x8d99b
incq %r8
movq %r8, %rax
subq %r15, %rax
movq %r8, %r10
jmp 0x8d9b4
movq %r8, %rdi
cmpl $0x3, %ecx
cmovgeq %rdi, %r10
movq %r10, %rax
subq %r15, %rax
cmpq %rdx, %rax
jl 0x8da70
movq %r10, %r8
cmpq %rdx, %rax
jl 0x8d948
jmp 0x8d9be
movq %r8, %r10
cmpl $0x3, %ecx
jne 0x8d9d6
xorl %r9d, %r9d
movl $0x3, %ecx
movq %r14, %rax
movq %r10, %r8
jmp 0x8dac8
testl %ecx, %ecx
movq %r15, %r8
cmoveq %r14, %r8
incl %ecx
movl $0x1, %r9d
movq %r14, %rax
jmp 0x8dac8
cmpl $0xff, %eax
jne 0x8dabe
movq %r12, -0x40(%rbp)
movq %r8, %r9
subq %r15, %r9
movq -0x50(%rbp), %rax
addq %r8, %rax
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
movq %rbx, %r11
shlq $0x4, %r11
leaq 0x2d67c1(%rip), %rax # 0x3641e0
movq (%r11,%rax), %r13
movb (%r13), %al
testb %al, %al
je 0x8da5c
cmpq %rdx, %r9
jge 0x8da5c
incq %r13
movq -0x60(%rbp), %r10
movq %r8, %r12
cmpb %al, (%r12)
jne 0x8da63
incq %r12
movb (%r13), %al
testb %al, %al
je 0x8da5f
incq %r13
leaq 0x1(%r10), %rdi
cmpq %rdx, %r10
movq %rdi, %r10
jl 0x8da3a
jmp 0x8da5f
movq %r8, %r12
testb %al, %al
je 0x8da90
incq %rbx
cmpq $0x50, %rbx
jne 0x8da11
movb $-0x1, %al
jmp 0x8daab
movl $0x2, %r9d
cmpl $0x1, %ecx
jg 0x8d9cb
movl $0x1, %edi
subl %ecx, %edi
movq %r10, %rax
movl %edi, %ecx
movq %r14, %r8
jmp 0x8dac8
leaq 0x2d6749(%rip), %rax # 0x3641e0
addq %rax, %r11
movq 0x8(%r11), %rax
movq -0x58(%rbp), %rdi
movb (%rax,%rdi), %al
decq %r12
movq %r12, %r8
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r11d
movq -0x40(%rbp), %r12
leaq 0x2d6702(%rip), %r13 # 0x3641c0
movzbl %al, %r9d
incq %r8
movq %r14, %rax
testl %r11d, %esi
setne %r10b
cmpq %rbx, %r12
setb %dil
andb %r10b, %dil
cmpb $0x1, %dil
jne 0x8daea
movq -0x48(%rbp), %rsi
movb %r9b, (%rsi,%r12)
incq %r12
movq %rax, %r14
testl %r9d, %r9d
jne 0x8d92a
testb %r11b, %r11b
sets %al
movq %rbx, %rdx
subq %r12, %rdx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8db1f
movq -0x48(%rbp), %rdi
addq %r12, %rdi
movl $0x20, %esi
callq 0x3a3a0
jmp 0x8db22
movq %r12, %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnxfrm_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, r8
mov rbx, rdx
mov [rbp+var_48], rsi
mov eax, [rbp+arg_0]
mov r11d, eax
or r11d, 0Fh
test al, 0Fh
cmovnz r11d, eax
movsxd rdx, r9d
mov eax, 1
sub rax, r8
mov [rbp+var_50], rax
xor ecx, ecx
lea r13, CZ_SORT_TABLE
mov r14, r8
xor r12d, r12d
mov [rbp+var_38], rbx
mov [rbp+var_2C], r11d
loc_8D92A:
mov esi, 1
shl esi, cl
mov rax, r8
sub rax, r15
cmp rax, rdx
jge short loc_8D9BB
movsxd rax, ecx
mov [rbp+var_58], rax
mov r9, [r13+rax*8+0]
loc_8D948:
movzx eax, byte ptr [r8]
movzx eax, byte ptr [r9+rax]
test eax, eax
jz short loc_8D98A
cmp eax, 2
jnz loc_8D9EF
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
cmp rax, rdx
jge short loc_8D998
loc_8D96F:
movzx edi, byte ptr [r10]
cmp byte ptr [r9+rdi], 2
jnz short loc_8D998
inc r10
inc rax
mov rdi, r10
cmp rax, rdx
jl short loc_8D96F
jmp short loc_8D99B
loc_8D98A:
inc r8
mov rax, r8
sub rax, r15
mov r10, r8
jmp short loc_8D9B4
loc_8D998:
mov rdi, r8
loc_8D99B:
cmp ecx, 3
cmovge r10, rdi
mov rax, r10
sub rax, r15
cmp rax, rdx
jl loc_8DA70
mov r8, r10
loc_8D9B4:
cmp rax, rdx
jl short loc_8D948
jmp short loc_8D9BE
loc_8D9BB:
mov r10, r8
loc_8D9BE:
cmp ecx, 3
jnz short loc_8D9D6
xor r9d, r9d
mov ecx, 3
loc_8D9CB:
mov rax, r14
mov r8, r10
jmp loc_8DAC8
loc_8D9D6:
test ecx, ecx
mov r8, r15
cmovz r8, r14
inc ecx
mov r9d, 1
mov rax, r14
jmp loc_8DAC8
loc_8D9EF:
cmp eax, 0FFh
jnz loc_8DABE
mov [rbp+var_40], r12
mov r9, r8
sub r9, r15
mov rax, [rbp+var_50]
add rax, r8
mov [rbp+var_60], rax
xor ebx, ebx
loc_8DA11:
mov r11, rbx
shl r11, 4
lea rax, doubles
mov r13, [r11+rax]
mov al, [r13+0]
test al, al
jz short loc_8DA5C
cmp r9, rdx
jge short loc_8DA5C
inc r13
mov r10, [rbp+var_60]
mov r12, r8
loc_8DA3A:
cmp [r12], al
jnz short loc_8DA63
inc r12
mov al, [r13+0]
test al, al
jz short loc_8DA5F
inc r13
lea rdi, [r10+1]
cmp r10, rdx
mov r10, rdi
jl short loc_8DA3A
jmp short loc_8DA5F
loc_8DA5C:
mov r12, r8
loc_8DA5F:
test al, al
jz short loc_8DA90
loc_8DA63:
inc rbx
cmp rbx, 50h ; 'P'
jnz short loc_8DA11
mov al, 0FFh
jmp short loc_8DAAB
loc_8DA70:
mov r9d, 2
cmp ecx, 1
jg loc_8D9CB
mov edi, 1
sub edi, ecx
mov rax, r10
mov ecx, edi
mov r8, r14
jmp short loc_8DAC8
loc_8DA90:
lea rax, doubles
add r11, rax
mov rax, [r11+8]
mov rdi, [rbp+var_58]
mov al, [rax+rdi]
dec r12
mov r8, r12
loc_8DAAB:
mov rbx, [rbp+var_38]
mov r11d, [rbp+var_2C]
mov r12, [rbp+var_40]
lea r13, CZ_SORT_TABLE
loc_8DABE:
movzx r9d, al
inc r8
mov rax, r14
loc_8DAC8:
test esi, r11d
setnz r10b
cmp r12, rbx
setb dil
and dil, r10b
cmp dil, 1
jnz short loc_8DAEA
mov rsi, [rbp+var_48]
mov [rsi+r12], r9b
inc r12
loc_8DAEA:
mov r14, rax
test r9d, r9d
jnz loc_8D92A
test r11b, r11b
sets al
mov rdx, rbx
sub rdx, r12
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_8DB1F
mov rdi, [rbp+var_48]
add rdi, r12
mov esi, 20h ; ' '
call _memset
jmp short loc_8DB22
loc_8DB1F:
mov rbx, r12
loc_8DB22:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long my_strnxfrm_czech(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned __int8 *a5,
int a6,
int a7)
{
unsigned __int8 *v7; // r15
int v9; // r11d
long long v10; // rdx
int v11; // ecx
unsigned __int8 *v12; // r14
unsigned long long v13; // r12
int v14; // esi
long long v15; // r9
int v16; // eax
unsigned __int8 *v17; // r8
long long v18; // rax
unsigned __int8 *v19; // r10
unsigned __int8 *v20; // rdi
unsigned __int8 *v21; // rax
int v22; // r9d
unsigned __int8 *v23; // rax
long long v24; // rbx
char *v25; // r13
char v26; // al
char *v27; // r13
unsigned __int8 *v28; // r10
_BYTE *v29; // r12
long long v32; // [rsp+10h] [rbp-50h]
unsigned long long v34; // [rsp+20h] [rbp-40h]
unsigned long long v35; // [rsp+28h] [rbp-38h]
int v36; // [rsp+34h] [rbp-2Ch]
v7 = a5;
v9 = a7 | 0xF;
if ( (a7 & 0xF) != 0 )
v9 = a7;
v10 = a6;
v32 = 1LL - (_QWORD)a5;
v11 = 0;
v12 = a5;
v13 = 0LL;
v35 = a3;
v36 = v9;
do
{
v14 = 1 << v11;
if ( a5 - v7 >= v10 )
{
v19 = a5;
LABEL_21:
if ( v11 != 3 )
{
a5 = v7;
if ( !v11 )
a5 = v12;
++v11;
v22 = 1;
v23 = v12;
goto LABEL_45;
}
v22 = 0;
v11 = 3;
LABEL_23:
v23 = v12;
a5 = v19;
goto LABEL_45;
}
v15 = (long long)*(&CZ_SORT_TABLE + v11);
while ( 1 )
{
v16 = *(unsigned __int8 *)(v15 + *a5);
if ( !*(_BYTE *)(v15 + *a5) )
{
v21 = (unsigned __int8 *)(++a5 - v7);
v19 = a5;
goto LABEL_18;
}
if ( v16 != 2 )
break;
v17 = a5 + 1;
v18 = v17 - v7;
v19 = v17;
if ( v17 - v7 < v10 )
{
while ( *(_BYTE *)(v15 + *v19) == 2 )
{
++v19;
++v18;
v20 = v19;
if ( v18 >= v10 )
goto LABEL_14;
}
}
v20 = v17;
LABEL_14:
if ( v11 >= 3 )
v19 = v20;
v21 = (unsigned __int8 *)(v19 - v7);
if ( v19 - v7 < v10 )
{
v22 = 2;
if ( v11 <= 1 )
{
v23 = v19;
v11 = 1 - v11;
a5 = v12;
goto LABEL_45;
}
goto LABEL_23;
}
a5 = v19;
LABEL_18:
if ( (long long)v21 >= v10 )
goto LABEL_21;
}
if ( v16 != 255 )
goto LABEL_44;
v34 = v13;
v24 = 0LL;
while ( 2 )
{
v25 = (char *)*(&doubles + 2 * v24);
v26 = *v25;
if ( *v25 && a5 - v7 < v10 )
{
v27 = v25 + 1;
v28 = &a5[v32];
v29 = a5;
while ( *v29 == v26 )
{
++v29;
v26 = *v27;
if ( *v27 )
{
++v27;
if ( (long long)v28++ < v10 )
continue;
}
goto LABEL_37;
}
goto LABEL_38;
}
v29 = a5;
LABEL_37:
if ( v26 )
{
LABEL_38:
if ( ++v24 == 80 )
{
LOBYTE(v16) = -1;
goto LABEL_43;
}
continue;
}
break;
}
LOBYTE(v16) = *((_BYTE *)*(&doubles + 2 * v24 + 1) + v11);
a5 = v29 - 1;
LABEL_43:
a3 = v35;
v9 = v36;
v13 = v34;
LABEL_44:
v22 = (unsigned __int8)v16;
++a5;
v23 = v12;
LABEL_45:
if ( (v9 & v14) != 0 && v13 < a3 )
*(_BYTE *)(a2 + v13++) = v22;
v12 = v23;
}
while ( v22 );
if ( (v9 & 0x80u) == 0 || a3 <= v13 )
return v13;
memset(v13 + a2, 32LL, a3 - v13);
return a3;
}
|
my_strnxfrm_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,R8
MOV RBX,RDX
MOV qword ptr [RBP + -0x48],RSI
MOV EAX,dword ptr [RBP + 0x10]
MOV R11D,EAX
OR R11D,0xf
TEST AL,0xf
CMOVNZ R11D,EAX
MOVSXD RDX,R9D
MOV EAX,0x1
SUB RAX,R8
MOV qword ptr [RBP + -0x50],RAX
XOR ECX,ECX
LEA R13,[0x4641c0]
MOV R14,R8
XOR R12D,R12D
MOV qword ptr [RBP + -0x38],RBX
MOV dword ptr [RBP + -0x2c],R11D
LAB_0018d92a:
MOV ESI,0x1
SHL ESI,CL
MOV RAX,R8
SUB RAX,R15
CMP RAX,RDX
JGE 0x0018d9bb
MOVSXD RAX,ECX
MOV qword ptr [RBP + -0x58],RAX
MOV R9,qword ptr [R13 + RAX*0x8]
LAB_0018d948:
MOVZX EAX,byte ptr [R8]
MOVZX EAX,byte ptr [R9 + RAX*0x1]
TEST EAX,EAX
JZ 0x0018d98a
CMP EAX,0x2
JNZ 0x0018d9ef
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
CMP RAX,RDX
JGE 0x0018d998
LAB_0018d96f:
MOVZX EDI,byte ptr [R10]
CMP byte ptr [R9 + RDI*0x1],0x2
JNZ 0x0018d998
INC R10
INC RAX
MOV RDI,R10
CMP RAX,RDX
JL 0x0018d96f
JMP 0x0018d99b
LAB_0018d98a:
INC R8
MOV RAX,R8
SUB RAX,R15
MOV R10,R8
JMP 0x0018d9b4
LAB_0018d998:
MOV RDI,R8
LAB_0018d99b:
CMP ECX,0x3
CMOVGE R10,RDI
MOV RAX,R10
SUB RAX,R15
CMP RAX,RDX
JL 0x0018da70
MOV R8,R10
LAB_0018d9b4:
CMP RAX,RDX
JL 0x0018d948
JMP 0x0018d9be
LAB_0018d9bb:
MOV R10,R8
LAB_0018d9be:
CMP ECX,0x3
JNZ 0x0018d9d6
XOR R9D,R9D
MOV ECX,0x3
LAB_0018d9cb:
MOV RAX,R14
MOV R8,R10
JMP 0x0018dac8
LAB_0018d9d6:
TEST ECX,ECX
MOV R8,R15
CMOVZ R8,R14
INC ECX
MOV R9D,0x1
MOV RAX,R14
JMP 0x0018dac8
LAB_0018d9ef:
CMP EAX,0xff
JNZ 0x0018dabe
MOV qword ptr [RBP + -0x40],R12
MOV R9,R8
SUB R9,R15
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,R8
MOV qword ptr [RBP + -0x60],RAX
XOR EBX,EBX
LAB_0018da11:
MOV R11,RBX
SHL R11,0x4
LEA RAX,[0x4641e0]
MOV R13,qword ptr [R11 + RAX*0x1]
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x0018da5c
CMP R9,RDX
JGE 0x0018da5c
INC R13
MOV R10,qword ptr [RBP + -0x60]
MOV R12,R8
LAB_0018da3a:
CMP byte ptr [R12],AL
JNZ 0x0018da63
INC R12
MOV AL,byte ptr [R13]
TEST AL,AL
JZ 0x0018da5f
INC R13
LEA RDI,[R10 + 0x1]
CMP R10,RDX
MOV R10,RDI
JL 0x0018da3a
JMP 0x0018da5f
LAB_0018da5c:
MOV R12,R8
LAB_0018da5f:
TEST AL,AL
JZ 0x0018da90
LAB_0018da63:
INC RBX
CMP RBX,0x50
JNZ 0x0018da11
MOV AL,0xff
JMP 0x0018daab
LAB_0018da70:
MOV R9D,0x2
CMP ECX,0x1
JG 0x0018d9cb
MOV EDI,0x1
SUB EDI,ECX
MOV RAX,R10
MOV ECX,EDI
MOV R8,R14
JMP 0x0018dac8
LAB_0018da90:
LEA RAX,[0x4641e0]
ADD R11,RAX
MOV RAX,qword ptr [R11 + 0x8]
MOV RDI,qword ptr [RBP + -0x58]
MOV AL,byte ptr [RAX + RDI*0x1]
DEC R12
MOV R8,R12
LAB_0018daab:
MOV RBX,qword ptr [RBP + -0x38]
MOV R11D,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
LEA R13,[0x4641c0]
LAB_0018dabe:
MOVZX R9D,AL
INC R8
MOV RAX,R14
LAB_0018dac8:
TEST ESI,R11D
SETNZ R10B
CMP R12,RBX
SETC DIL
AND DIL,R10B
CMP DIL,0x1
JNZ 0x0018daea
MOV RSI,qword ptr [RBP + -0x48]
MOV byte ptr [RSI + R12*0x1],R9B
INC R12
LAB_0018daea:
MOV R14,RAX
TEST R9D,R9D
JNZ 0x0018d92a
TEST R11B,R11B
SETS AL
MOV RDX,RBX
SUB RDX,R12
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x0018db1f
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,R12
MOV ESI,0x20
CALL 0x0013a3a0
JMP 0x0018db22
LAB_0018db1f:
MOV RBX,R12
LAB_0018db22:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strnxfrm_czech(int8 param_1,long param_2,ulong param_3,int8 param_4,
byte *param_5,int param_6,uint param_7)
{
uint uVar1;
byte *pbVar2;
byte *pbVar3;
byte bVar4;
char cVar5;
long lVar6;
byte *pbVar7;
byte bVar8;
int iVar9;
long lVar10;
byte *pbVar11;
byte *pbVar12;
byte *pbVar13;
ulong uVar14;
byte *pbVar15;
uVar1 = param_7 | 0xf;
if ((param_7 & 0xf) != 0) {
uVar1 = param_7;
}
lVar10 = (long)param_6;
iVar9 = 0;
uVar14 = 0;
pbVar13 = param_5;
pbVar15 = param_5;
LAB_0018d92a:
bVar8 = (byte)iVar9;
pbVar7 = pbVar15;
if ((long)pbVar13 - (long)param_5 < lVar10) {
do {
cVar5 = (&CZ_SORT_TABLE)[iVar9][*pbVar13];
if (cVar5 == '\0') {
pbVar13 = pbVar13 + 1;
lVar6 = (long)pbVar13 - (long)param_5;
}
else {
if (cVar5 != '\x02') {
if (cVar5 != -1) goto LAB_0018dabe;
lVar6 = 0;
goto LAB_0018da11;
}
pbVar12 = pbVar13 + 1;
lVar6 = (long)pbVar12 - (long)param_5;
pbVar13 = pbVar12;
while ((pbVar11 = pbVar13, lVar6 < lVar10 &&
(pbVar11 = pbVar12, (&CZ_SORT_TABLE)[iVar9][*pbVar13] == '\x02'))) {
pbVar13 = pbVar13 + 1;
lVar6 = lVar6 + 1;
}
if (2 < iVar9) {
pbVar13 = pbVar11;
}
lVar6 = (long)pbVar13 - (long)param_5;
if (lVar6 < lVar10) {
cVar5 = '\x02';
if (iVar9 < 2) {
iVar9 = 1 - iVar9;
pbVar7 = pbVar13;
pbVar13 = pbVar15;
}
goto LAB_0018dac8;
}
}
} while (lVar6 < lVar10);
}
if (iVar9 == 3) {
cVar5 = '\0';
iVar9 = 3;
}
else {
pbVar13 = param_5;
if (iVar9 == 0) {
pbVar13 = pbVar15;
}
iVar9 = iVar9 + 1;
cVar5 = '\x01';
}
goto LAB_0018dac8;
LAB_0018da11:
do {
pbVar15 = (&doubles)[lVar6 * 2];
bVar4 = *pbVar15;
pbVar12 = pbVar13;
pbVar3 = pbVar13 + (1 - (long)param_5);
pbVar11 = pbVar13 + -(long)param_5;
if (bVar4 != 0) {
while (pbVar2 = pbVar3, (long)pbVar11 < lVar10) {
pbVar15 = pbVar15 + 1;
if (*pbVar12 != bVar4) goto LAB_0018da63;
pbVar12 = pbVar12 + 1;
bVar4 = *pbVar15;
if (bVar4 == 0) break;
pbVar3 = pbVar2 + 1;
pbVar11 = pbVar2;
}
}
if (bVar4 == 0) {
cVar5 = (&PTR_DAT_004641e8)[lVar6 * 2][iVar9];
pbVar13 = pbVar12 + -1;
goto LAB_0018dabe;
}
LAB_0018da63:
lVar6 = lVar6 + 1;
} while (lVar6 != 0x50);
cVar5 = -1;
LAB_0018dabe:
pbVar13 = pbVar13 + 1;
LAB_0018dac8:
if (uVar14 < param_3 && (1 << (bVar8 & 0x1f) & uVar1) != 0) {
*(char *)(param_2 + uVar14) = cVar5;
uVar14 = uVar14 + 1;
}
pbVar15 = pbVar7;
if (cVar5 == '\0') {
if ((uVar14 <= param_3 && param_3 - uVar14 != 0) && (char)uVar1 < '\0') {
memset((void *)(param_2 + uVar14),0x20,param_3 - uVar14);
uVar14 = param_3;
}
return uVar14;
}
goto LAB_0018d92a;
}
|
|
64,024 |
psi_prlock_wrlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_prlock_wrlock(mysql_prlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_pr_wrlock(&that->m_prlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_prlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1c8bfe(%rip), %rax # 0x2bf0b8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9c70
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xf6510
leaq 0x1c8bbb(%rip), %rax # 0x2bf0b8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
psi_prlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+68h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call rw_pr_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_F6510
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_F6510:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_prlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[54])(
v6,
*(_QWORD *)(a1 + 104),
1LL,
a2,
a3);
v4 = rw_pr_wrlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[55])(v5, v4);
return v4;
}
|
psi_prlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x3bf0b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001f9c70
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001f6510
LEA RAX,[0x3bf0b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001f6510:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_prlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x68),1,param_2,param_3);
uVar1 = rw_pr_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
|
|
64,025 |
SwayIdleManager::getConfigPath()
|
midoBB[P]pwrctl/swayidlemanager.cpp
|
QString SwayIdleManager::getConfigPath() {
return QDir::homePath() + "/.config/swayidle/config";
}
|
O3
|
cpp
|
SwayIdleManager::getConfigPath():
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x95a0
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
testq %rax, %rax
je 0x1cf15
lock
incl (%rax)
leaq 0x513a(%rip), %rdx # 0x22056
leaq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x95e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x9170
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1cf5b
lock
decl (%rax)
jne 0x1cf5b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1cf7e
lock
decl (%rax)
jne 0x1cf7e
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1cfb4
lock
decl (%rax)
jne 0x1cfb4
movq 0x8(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
jmp 0x1cfb4
movq %rax, %r14
movq %rbx, %rdi
callq 0x15760
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1cfdf
lock
decl (%rax)
jne 0x1cfdf
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x8, %edx
callq 0x9550
movq %r14, %rdi
callq 0x93d0
nop
|
_ZN15SwayIdleManager13getConfigPathEv:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
lea r14, [rsp+48h+var_28]
mov rdi, r14; this
call __ZN4QDir8homePathEv; QDir::homePath(void)
mov rax, [r14]
mov [rbx], rax
mov rcx, [r14+8]
mov [rbx+8], rcx
mov rcx, [r14+10h]
mov [rbx+10h], rcx
test rax, rax
jz short loc_1CF15
lock inc dword ptr [rax]
loc_1CF15:
lea rdx, aConfigSwayidle; "/.config/swayidle/config"
lea rdi, [rsp+48h+var_40]
mov esi, 18h
call __ZN7QString8fromUtf8E14QByteArrayView; QString::fromUtf8(QByteArrayView)
lea rsi, [rsp+48h+var_40]; QString *
mov rdi, rbx; this
call __ZN7QString6appendERKS_; QString::append(QString const&)
mov rax, [rsp+48h+var_40]
test rax, rax
jz short loc_1CF5B
lock dec dword ptr [rax]
jnz short loc_1CF5B
mov rdi, [rsp+48h+var_40]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1CF5B:
mov rax, [rsp+48h+var_28]
test rax, rax
jz short loc_1CF7E
lock dec dword ptr [rax]
jnz short loc_1CF7E
mov rdi, [rsp+48h+var_28]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1CF7E:
mov rax, rbx
add rsp, 38h
pop rbx
pop r14
retn
mov r14, rax
mov rax, [rsp+arg_0]
test rax, rax
jz short loc_1CFB4
lock dec dword ptr [rax]
jnz short loc_1CFB4
mov rdi, [rsp+arg_0]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
jmp short loc_1CFB4
mov r14, rax
loc_1CFB4:
mov rdi, rbx; void *
call _ZN7QStringD2Ev; QString::~QString()
mov rax, [rsp+arg_18]
test rax, rax
jz short loc_1CFDF
lock dec dword ptr [rax]
jnz short loc_1CFDF
mov rdi, [rsp+arg_18]
mov esi, 2
mov edx, 8
call __ZN10QArrayData10deallocateEPS_xx; QArrayData::deallocate(QArrayData*,long long,long long)
loc_1CFDF:
mov rdi, r14
call __Unwind_Resume
|
volatile signed __int32 ** SwayIdleManager::getConfigPath(volatile signed __int32 **this)
{
volatile signed __int32 *v1; // rax
volatile signed __int32 *v3[3]; // [rsp+8h] [rbp-40h] BYREF
volatile signed __int32 *v4[5]; // [rsp+20h] [rbp-28h] BYREF
QDir::homePath((QDir *)v4);
v1 = v4[0];
*this = v4[0];
this[1] = v4[1];
this[2] = v4[2];
if ( v1 )
_InterlockedIncrement(v1);
QString::fromUtf8(v3, 24LL, "/.config/swayidle/config");
QString::append((QString *)this, (const QString *)v3);
if ( v3[0] && !_InterlockedDecrement(v3[0]) )
QArrayData::deallocate(v3[0], 2LL, 8LL);
if ( v4[0] && !_InterlockedDecrement(v4[0]) )
QArrayData::deallocate(v4[0], 2LL, 8LL);
return this;
}
|
getConfigPath:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x001095a0
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x8],RCX
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RCX
TEST RAX,RAX
JZ 0x0011cf15
INC.LOCK dword ptr [RAX]
LAB_0011cf15:
LEA RDX,[0x122056]
LEA RDI,[RSP + 0x8]
MOV ESI,0x18
CALL 0x001095e0
LAB_0011cf2b:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00109170
LAB_0011cf38:
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x0011cf5b
DEC.LOCK dword ptr [RAX]
JNZ 0x0011cf5b
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x00109550
LAB_0011cf5b:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x0011cf7e
DEC.LOCK dword ptr [RAX]
JNZ 0x0011cf7e
MOV RDI,qword ptr [RSP + 0x20]
MOV ESI,0x2
MOV EDX,0x8
CALL 0x00109550
LAB_0011cf7e:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* SwayIdleManager::getConfigPath() */
SwayIdleManager * __thiscall SwayIdleManager::getConfigPath(SwayIdleManager *this)
{
QArrayData *local_40 [3];
QArrayData *local_28;
int8 local_20;
int8 local_18;
QDir::homePath();
*(QArrayData **)this = local_28;
*(int8 *)(this + 8) = local_20;
*(int8 *)(this + 0x10) = local_18;
if (local_28 != (QArrayData *)0x0) {
LOCK();
*(int *)local_28 = *(int *)local_28 + 1;
UNLOCK();
}
/* try { // try from 0011cf15 to 0011cf2a has its CatchHandler @ 0011cfb1 */
QString::fromUtf8(local_40,0x18,"/.config/swayidle/config");
/* try { // try from 0011cf2b to 0011cf37 has its CatchHandler @ 0011cf89 */
QString::append((QString *)this);
if (local_40[0] != (QArrayData *)0x0) {
LOCK();
*(int *)local_40[0] = *(int *)local_40[0] + -1;
UNLOCK();
if (*(int *)local_40[0] == 0) {
QArrayData::deallocate(local_40[0],2,8);
}
}
if (local_28 != (QArrayData *)0x0) {
LOCK();
*(int *)local_28 = *(int *)local_28 + -1;
UNLOCK();
if (*(int *)local_28 == 0) {
QArrayData::deallocate(local_28,2,8);
}
}
return this;
}
|
|
64,026 |
bitmap_union
|
eloqsql/mysys/my_bitmap.c
|
void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits == map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ |= *from++;
}
|
O3
|
c
|
bitmap_union:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
ja 0x9d8cc
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl (%rdx), %esi
orl %esi, (%rax)
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rcx, %rax
jbe 0x9d8ba
popq %rbp
retq
|
bitmap_union:
mov rax, [rdi]
mov rcx, [rdi+8]
cmp rax, rcx
ja short locret_9D8CC
push rbp
mov rbp, rsp
mov rdx, [rsi]
loc_9D8BA:
mov esi, [rdx]
or [rax], esi
add rdx, 4
add rax, 4
cmp rax, rcx
jbe short loc_9D8BA
pop rbp
locret_9D8CC:
retn
|
_DWORD * bitmap_union(long long a1, _DWORD **a2)
{
_DWORD *result; // rax
unsigned long long v3; // rcx
_DWORD *v4; // rdx
result = *(_DWORD **)a1;
v3 = *(_QWORD *)(a1 + 8);
if ( *(_QWORD *)a1 <= v3 )
{
v4 = *a2;
do
*result++ |= *v4++;
while ( (unsigned long long)result <= v3 );
}
return result;
}
|
bitmap_union:
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
CMP RAX,RCX
JA 0x0019d8cc
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RSI]
LAB_0019d8ba:
MOV ESI,dword ptr [RDX]
OR dword ptr [RAX],ESI
ADD RDX,0x4
ADD RAX,0x4
CMP RAX,RCX
JBE 0x0019d8ba
POP RBP
LAB_0019d8cc:
RET
|
void bitmap_union(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
puVar2 = (uint *)*param_1;
puVar1 = (uint *)param_1[1];
if (puVar2 <= puVar1) {
puVar3 = (uint *)*param_2;
do {
*puVar2 = *puVar2 | *puVar3;
puVar3 = puVar3 + 1;
puVar2 = puVar2 + 1;
} while (puVar2 <= puVar1);
}
return;
}
|
|
64,027 |
set_program_key(PFS_program_key*, enum_object_type, char const*, unsigned int, char const*, unsigned int)
|
eloqsql/storage/perfschema/pfs_program.cc
|
static void set_program_key(PFS_program_key *key,
enum_object_type object_type,
const char *object_name, uint object_name_length,
const char *schema_name, uint schema_name_length)
{
assert(object_name_length <= COL_OBJECT_NAME_SIZE);
assert(schema_name_length <= COL_OBJECT_SCHEMA_SIZE);
/*
To make sure generated key is case insensitive,
convert object_name/schema_name to lowercase.
*/
char *ptr= &key->m_hash_key[0];
ptr[0]= object_type;
ptr++;
if (object_name_length > 0)
{
char tmp_object_name[COL_OBJECT_NAME_SIZE + 1];
memcpy(tmp_object_name, object_name, object_name_length);
tmp_object_name[object_name_length]= '\0';
my_casedn_str(system_charset_info, tmp_object_name);
memcpy(ptr, tmp_object_name, object_name_length);
ptr+= object_name_length;
}
ptr[0]= 0;
ptr++;
if (schema_name_length > 0)
{
char tmp_schema_name[COL_OBJECT_SCHEMA_SIZE + 1];
memcpy(tmp_schema_name, schema_name, schema_name_length);
tmp_schema_name[schema_name_length]='\0';
my_casedn_str(system_charset_info, tmp_schema_name);
memcpy(ptr, tmp_schema_name, schema_name_length);
ptr+= schema_name_length;
}
ptr[0]= 0;
ptr++;
key->m_key_length= static_cast<uint>(ptr - &key->m_hash_key[0]);
}
|
O0
|
cpp
|
set_program_key(PFS_program_key*, enum_object_type, char const*, unsigned int, char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0xa8(%rbp)
movl %esi, -0xac(%rbp)
movq %rdx, -0xb8(%rbp)
movl %ecx, -0xbc(%rbp)
movq %r8, -0xc8(%rbp)
movl %r9d, -0xcc(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0xac(%rbp), %eax
movb %al, %cl
movq -0xd8(%rbp), %rax
movb %cl, (%rax)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
cmpl $0x0, -0xbc(%rbp)
jbe 0x32253
leaq -0x50(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl -0xbc(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0xbc(%rbp), %eax
movb $0x0, -0x50(%rbp,%rax)
leaq 0x3e6d3c(%rip), %rax # 0x418f40
movq (%rax), %rax
movq 0xb8(%rax), %rax
movq 0x48(%rax), %rax
leaq 0x3e6d27(%rip), %rcx # 0x418f40
movq (%rcx), %rdi
leaq -0x50(%rbp), %rsi
callq *%rax
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl -0xbc(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0xbc(%rbp), %ecx
movq -0xd8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
movb $0x0, (%rax)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
cmpl $0x0, -0xcc(%rbp)
jbe 0x32301
leaq -0xa0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movl -0xcc(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0xcc(%rbp), %eax
movb $0x0, -0xa0(%rbp,%rax)
leaq 0x3e6c94(%rip), %rax # 0x418f40
movq (%rax), %rax
movq 0xb8(%rax), %rax
movq 0x48(%rax), %rax
leaq 0x3e6c7f(%rip), %rcx # 0x418f40
movq (%rcx), %rdi
leaq -0xa0(%rbp), %rsi
callq *%rax
movq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl -0xcc(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0xcc(%rbp), %ecx
movq -0xd8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
movb $0x0, (%rax)
movq -0xd8(%rbp), %rax
incq %rax
movq %rax, -0xd8(%rbp)
movl -0xd8(%rbp), %ecx
movq -0xa8(%rbp), %rax
movl %eax, %edx
subl %edx, %ecx
movl %ecx, 0x88(%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x3234e
addq $0xe0, %rsp
popq %rbp
retq
callq 0x26360
nopw %cs:(%rax,%rax)
|
_ZL15set_program_keyP15PFS_program_key16enum_object_typePKcjS3_j:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_A8], rdi
mov [rbp+var_AC], esi
mov [rbp+var_B8], rdx
mov [rbp+var_BC], ecx
mov [rbp+var_C8], r8
mov [rbp+var_CC], r9d
mov rax, [rbp+var_A8]
mov [rbp+var_D8], rax
mov eax, [rbp+var_AC]
mov cl, al
mov rax, [rbp+var_D8]
mov [rax], cl
mov rax, [rbp+var_D8]
add rax, 1
mov [rbp+var_D8], rax
cmp [rbp+var_BC], 0
jbe short loc_32253
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_B8]
mov eax, [rbp+var_BC]
mov edx, eax
call _memcpy
mov eax, [rbp+var_BC]
mov [rbp+rax+var_50], 0
lea rax, system_charset_info
mov rax, [rax]
mov rax, [rax+0B8h]
mov rax, [rax+48h]
lea rcx, system_charset_info
mov rdi, [rcx]
lea rsi, [rbp+var_50]
call rax
mov rdi, [rbp+var_D8]
lea rsi, [rbp+var_50]
mov eax, [rbp+var_BC]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_BC]
mov rax, [rbp+var_D8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_D8], rax
loc_32253:
mov rax, [rbp+var_D8]
mov byte ptr [rax], 0
mov rax, [rbp+var_D8]
add rax, 1
mov [rbp+var_D8], rax
cmp [rbp+var_CC], 0
jbe loc_32301
lea rdi, [rbp+var_A0]
mov rsi, [rbp+var_C8]
mov eax, [rbp+var_CC]
mov edx, eax
call _memcpy
mov eax, [rbp+var_CC]
mov [rbp+rax+var_A0], 0
lea rax, system_charset_info
mov rax, [rax]
mov rax, [rax+0B8h]
mov rax, [rax+48h]
lea rcx, system_charset_info
mov rdi, [rcx]
lea rsi, [rbp+var_A0]
call rax
mov rdi, [rbp+var_D8]
lea rsi, [rbp+var_A0]
mov eax, [rbp+var_CC]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_CC]
mov rax, [rbp+var_D8]
mov ecx, ecx
add rax, rcx
mov [rbp+var_D8], rax
loc_32301:
mov rax, [rbp+var_D8]
mov byte ptr [rax], 0
mov rax, [rbp+var_D8]
inc rax
mov [rbp+var_D8], rax
mov ecx, dword ptr [rbp+var_D8]
mov rax, [rbp+var_A8]
mov edx, eax
sub ecx, edx
mov [rax+88h], ecx
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_3234E
add rsp, 0E0h
pop rbp
retn
loc_3234E:
call ___stack_chk_fail
|
unsigned long long set_program_key(
long long a1,
char a2,
long long a3,
unsigned int a4,
long long a5,
unsigned int a6)
{
_BYTE *v7; // [rsp+8h] [rbp-D8h]
_BYTE *v8; // [rsp+8h] [rbp-D8h]
_BYTE v12[80]; // [rsp+40h] [rbp-A0h] BYREF
_BYTE v13[72]; // [rsp+90h] [rbp-50h] BYREF
unsigned long long v14; // [rsp+D8h] [rbp-8h]
v14 = __readfsqword(0x28u);
*(_BYTE *)a1 = a2;
v7 = (_BYTE *)(a1 + 1);
if ( a4 )
{
memcpy(v13, a3, a4);
v13[a4] = 0;
(*(void ( **)(_QWORD, _BYTE *))(*(_QWORD *)(system_charset_info + 184LL) + 72LL))(
system_charset_info,
v13);
memcpy(v7, v13, a4);
v7 += a4;
}
*v7 = 0;
v8 = v7 + 1;
if ( a6 )
{
memcpy(v12, a5, a6);
v12[a6] = 0;
(*(void ( **)(_QWORD, _BYTE *))(*(_QWORD *)(system_charset_info + 184LL) + 72LL))(
system_charset_info,
v12);
memcpy(v8, v12, a6);
v8 += a6;
}
*v8 = 0;
*(_DWORD *)(a1 + 136) = (_DWORD)v8 + 1 - a1;
return __readfsqword(0x28u);
}
|
set_program_key:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0xa8],RDI
MOV dword ptr [RBP + -0xac],ESI
MOV qword ptr [RBP + -0xb8],RDX
MOV dword ptr [RBP + -0xbc],ECX
MOV qword ptr [RBP + -0xc8],R8
MOV dword ptr [RBP + -0xcc],R9D
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xd8],RAX
MOV EAX,dword ptr [RBP + -0xac]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xd8]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0xd8]
ADD RAX,0x1
MOV qword ptr [RBP + -0xd8],RAX
CMP dword ptr [RBP + -0xbc],0x0
JBE 0x00132253
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0xb8]
MOV EAX,dword ptr [RBP + -0xbc]
MOV EDX,EAX
CALL 0x00126280
MOV EAX,dword ptr [RBP + -0xbc]
MOV byte ptr [RBP + RAX*0x1 + -0x50],0x0
LEA RAX,[0x518f40]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x48]
LEA RCX,[0x518f40]
MOV RDI,qword ptr [RCX]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV RDI,qword ptr [RBP + -0xd8]
LEA RSI,[RBP + -0x50]
MOV EAX,dword ptr [RBP + -0xbc]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0xbc]
MOV RAX,qword ptr [RBP + -0xd8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0xd8],RAX
LAB_00132253:
MOV RAX,qword ptr [RBP + -0xd8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0xd8]
ADD RAX,0x1
MOV qword ptr [RBP + -0xd8],RAX
CMP dword ptr [RBP + -0xcc],0x0
JBE 0x00132301
LEA RDI,[RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0xc8]
MOV EAX,dword ptr [RBP + -0xcc]
MOV EDX,EAX
CALL 0x00126280
MOV EAX,dword ptr [RBP + -0xcc]
MOV byte ptr [RBP + RAX*0x1 + -0xa0],0x0
LEA RAX,[0x518f40]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x48]
LEA RCX,[0x518f40]
MOV RDI,qword ptr [RCX]
LEA RSI,[RBP + -0xa0]
CALL RAX
MOV RDI,qword ptr [RBP + -0xd8]
LEA RSI,[RBP + -0xa0]
MOV EAX,dword ptr [RBP + -0xcc]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0xcc]
MOV RAX,qword ptr [RBP + -0xd8]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0xd8],RAX
LAB_00132301:
MOV RAX,qword ptr [RBP + -0xd8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0xd8]
INC RAX
MOV qword ptr [RBP + -0xd8],RAX
MOV ECX,dword ptr [RBP + -0xd8]
MOV RAX,qword ptr [RBP + -0xa8]
MOV EDX,EAX
SUB ECX,EDX
MOV dword ptr [RAX + 0x88],ECX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0013234e
ADD RSP,0xe0
POP RBP
RET
LAB_0013234e:
CALL 0x00126360
|
/* set_program_key(PFS_program_key*, enum_object_type, char const*, unsigned int, char const*,
unsigned int) */
void set_program_key(int1 *param_1,int1 param_2,void *param_3,uint param_4,void *param_5
,uint param_6)
{
long in_FS_OFFSET;
int1 *local_e0;
int1 local_a8 [80];
int1 local_58 [72];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
*param_1 = param_2;
local_e0 = param_1 + 1;
if (param_4 != 0) {
memcpy(local_58,param_3,(ulong)param_4);
local_58[param_4] = 0;
(**(code **)(*(long *)(system_charset_info + 0xb8) + 0x48))(system_charset_info,local_58);
memcpy(local_e0,local_58,(ulong)param_4);
local_e0 = local_e0 + param_4;
}
*local_e0 = 0;
local_e0 = local_e0 + 1;
if (param_6 != 0) {
memcpy(local_a8,param_5,(ulong)param_6);
local_a8[param_6] = 0;
(**(code **)(*(long *)(system_charset_info + 0xb8) + 0x48))(system_charset_info,local_a8);
memcpy(local_e0,local_a8,(ulong)param_6);
local_e0 = local_e0 + param_6;
}
*local_e0 = 0;
local_e0._0_4_ = (int)local_e0 + 1;
*(int *)(param_1 + 0x88) = (int)local_e0 - (int)param_1;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
64,028 |
uf_blob
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((uchar*) to,(end-to));
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
uint pack_length=(uint) (end-to)-portable_sizeof_char_ptr;
if (bit_buff->blob_pos+length > bit_buff->blob_end)
{
bit_buff->error=1;
bzero((uchar*) to,(end-to));
return;
}
decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
_mi_store_blob_length((uchar*) to,pack_length,length);
memcpy(to+pack_length, &bit_buff->blob_pos, sizeof(char*));
bit_buff->blob_pos+=length;
}
}
|
O3
|
c
|
uf_blob:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x86677
movl (%r15), %r12d
decl %eax
movl %eax, 0x4(%r15)
btl %eax, %r12d
jae 0x86694
subq %r14, %rbx
jmp 0x86711
movq %r15, %rdi
callq 0x85129
movl $0x1f, 0x4(%r15)
movl (%r15), %r12d
movl $0x1f, %eax
testl %r12d, %r12d
js 0x8666f
movq %r13, %rdx
movl 0x1c(%r13), %r13d
movl %eax, %ecx
subl %r13d, %ecx
movq %rdx, -0x30(%rbp)
jae 0x866e0
subl %eax, %r13d
movl %eax, %eax
leaq 0x6368e(%rip), %rcx # 0xe9d40
andl (%rcx,%rax,4), %r12d
movl %r13d, %ecx
shll %cl, %r12d
movq %r15, %rdi
callq 0x85129
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %r12d
jmp 0x866f5
movl %ecx, 0x4(%r15)
shrl %cl, %r12d
movl 0x1c(%rdx), %eax
leaq 0x6364f(%rip), %rcx # 0xe9d40
andl (%rcx,%rax,4), %r12d
movl %r12d, %r13d
subq %r14, %rbx
movq 0x18(%r15), %rdx
leaq (%rdx,%r13), %rcx
cmpq 0x20(%r15), %rcx
jbe 0x8672c
movl $0x1, 0x28(%r15)
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a2c0
addl $-0x8, %ebx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x85a1a
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x7be07
movq 0x18(%r15), %rax
movq %rax, (%r14,%rbx)
addq %r13, 0x18(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
uf_blob_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r13, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_86677
mov r12d, [r15]
dec eax
mov [r15+4], eax
bt r12d, eax
jnb short loc_86694
loc_8666F:
sub rbx, r14
jmp loc_86711
loc_86677:
mov rdi, r15
call fill_buffer_0
mov dword ptr [r15+4], 1Fh
mov r12d, [r15]
mov eax, 1Fh
test r12d, r12d
js short loc_8666F
loc_86694:
mov rdx, r13
mov r13d, [r13+1Ch]
mov ecx, eax
sub ecx, r13d
mov [rbp+var_30], rdx
jnb short loc_866E0
sub r13d, eax
mov eax, eax
lea rcx, mask_0
and r12d, [rcx+rax*4]
mov ecx, r13d
shl r12d, cl
mov rdi, r15
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add r12d, eax
jmp short loc_866F5
loc_866E0:
mov [r15+4], ecx
shr r12d, cl
mov eax, [rdx+1Ch]
lea rcx, mask_0
and r12d, [rcx+rax*4]
loc_866F5:
mov r13d, r12d
sub rbx, r14
mov rdx, [r15+18h]
lea rcx, [rdx+r13]
cmp rcx, [r15+20h]
jbe short loc_8672C
mov dword ptr [r15+28h], 1
loc_86711:
mov rdi, r14
xor esi, esi
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
loc_8672C:
add ebx, 0FFFFFFF8h
mov rdi, [rbp+var_30]
mov rsi, r15
call decode_bytes_0
mov rdi, r14
mov esi, ebx
mov edx, r13d
call _mi_store_blob_length
mov rax, [r15+18h]
mov [r14+rbx], rax
add [r15+18h], r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long uf_blob_0(long long a1, long long a2, _BYTE *a3, long long a4)
{
int v6; // eax
unsigned int v7; // r12d
unsigned int v8; // eax
long long v9; // rbx
unsigned int v10; // r13d
int v11; // ecx
int v12; // r13d
int v13; // r12d
unsigned int v14; // r12d
_BYTE *v15; // rdx
_BYTE *v16; // rcx
long long result; // rax
long long v18; // rbx
v6 = *(_DWORD *)(a2 + 4);
if ( v6 )
{
v7 = *(_DWORD *)a2;
v8 = v6 - 1;
*(_DWORD *)(a2 + 4) = v8;
if ( _bittest((const int *)&v7, v8) )
{
LABEL_3:
v9 = a4 - (_QWORD)a3;
return memset(a3, 0LL, v9);
}
}
else
{
fill_buffer_0(a2);
*(_DWORD *)(a2 + 4) = 31;
v7 = *(_DWORD *)a2;
v8 = 31;
if ( *(int *)a2 < 0 )
goto LABEL_3;
}
v10 = *(_DWORD *)(a1 + 28);
v11 = v8 - v10;
if ( v8 >= v10 )
{
*(_DWORD *)(a2 + 4) = v11;
v14 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v11);
}
else
{
v12 = v10 - v8;
v13 = (mask_0[v8] & v7) << v12;
fill_buffer_0(a2);
*(_DWORD *)(a2 + 4) = 32 - v12;
v14 = (*(_DWORD *)a2 >> -(char)v12) + v13;
}
v9 = a4 - (_QWORD)a3;
v15 = *(_BYTE **)(a2 + 24);
v16 = &v15[v14];
if ( (unsigned long long)v16 > *(_QWORD *)(a2 + 32) )
{
*(_DWORD *)(a2 + 40) = 1;
return memset(a3, 0LL, v9);
}
v18 = (unsigned int)(v9 - 8);
decode_bytes_0(a1, a2, v15, v16);
mi_store_blob_length(a3, v18, v14);
result = *(_QWORD *)(a2 + 24);
*(_QWORD *)&a3[v18] = result;
*(_QWORD *)(a2 + 24) += v14;
return result;
}
|
uf_blob:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R13,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00186677
MOV R12D,dword ptr [R15]
DEC EAX
MOV dword ptr [R15 + 0x4],EAX
BT R12D,EAX
JNC 0x00186694
LAB_0018666f:
SUB RBX,R14
JMP 0x00186711
LAB_00186677:
MOV RDI,R15
CALL 0x00185129
MOV dword ptr [R15 + 0x4],0x1f
MOV R12D,dword ptr [R15]
MOV EAX,0x1f
TEST R12D,R12D
JS 0x0018666f
LAB_00186694:
MOV RDX,R13
MOV R13D,dword ptr [R13 + 0x1c]
MOV ECX,EAX
SUB ECX,R13D
MOV qword ptr [RBP + -0x30],RDX
JNC 0x001866e0
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e9d40]
AND R12D,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL R12D,CL
MOV RDI,R15
CALL 0x00185129
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD R12D,EAX
JMP 0x001866f5
LAB_001866e0:
MOV dword ptr [R15 + 0x4],ECX
SHR R12D,CL
MOV EAX,dword ptr [RDX + 0x1c]
LEA RCX,[0x1e9d40]
AND R12D,dword ptr [RCX + RAX*0x4]
LAB_001866f5:
MOV R13D,R12D
SUB RBX,R14
MOV RDX,qword ptr [R15 + 0x18]
LEA RCX,[RDX + R13*0x1]
CMP RCX,qword ptr [R15 + 0x20]
JBE 0x0018672c
MOV dword ptr [R15 + 0x28],0x1
LAB_00186711:
MOV RDI,R14
XOR ESI,ESI
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0012a2c0
LAB_0018672c:
ADD EBX,-0x8
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R15
CALL 0x00185a1a
MOV RDI,R14
MOV ESI,EBX
MOV EDX,R13D
CALL 0x0017be07
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [R14 + RBX*0x1],RAX
ADD qword ptr [R15 + 0x18],R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_blob(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
size_t __n;
uint uVar5;
ulong uVar6;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_00186694;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00186694:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar6 = (ulong)uVar5;
__n = param_4 - (long)param_3;
if (*(long *)(param_2 + 6) + uVar6 <= *(ulong *)(param_2 + 8)) {
uVar5 = (int)__n - 8;
decode_bytes(param_1,param_2);
_mi_store_blob_length(param_3,uVar5,uVar6);
*(int8 *)((long)param_3 + (ulong)uVar5) = *(int8 *)(param_2 + 6);
*(ulong *)(param_2 + 6) = *(long *)(param_2 + 6) + uVar6;
return;
}
param_2[10] = 1;
goto LAB_00186711;
}
}
__n = param_4 - (long)param_3;
LAB_00186711:
memset(param_3,0,__n);
return;
}
|
|
64,029 |
blst_scalar_from_uint64
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c
|
void blst_scalar_from_uint64(pow256 ret, const unsigned long long a[4])
{
const union {
long one;
char little;
} is_endian = { 1 };
size_t i;
if ((uptr_t)ret==(uptr_t)a && is_endian.little)
return;
for(i = 0; i < 4; i++) {
unsigned long long w = a[i];
*ret++ = (byte)w;
*ret++ = (byte)(w >> 8);
*ret++ = (byte)(w >> 16);
*ret++ = (byte)(w >> 24);
*ret++ = (byte)(w >> 32);
*ret++ = (byte)(w >> 40);
*ret++ = (byte)(w >> 48);
*ret++ = (byte)(w >> 56);
}
}
|
O3
|
c
|
blst_scalar_from_uint64:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
je 0x2508e
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x2507d
popq %rbp
retq
|
blst_scalar_from_uint64:
push rbp
mov rbp, rsp
cmp rdi, rsi
jz short loc_2508E
xor eax, eax
loc_2507D:
mov rcx, [rsi+rax*8]
mov [rdi+rax*8], rcx
inc rax
cmp rax, 4
jnz short loc_2507D
loc_2508E:
pop rbp
retn
|
void blst_scalar_from_uint64(long long a1, long long a2)
{
long long i; // rax
if ( a1 != a2 )
{
for ( i = 0LL; i != 4; ++i )
*(_QWORD *)(a1 + 8 * i) = *(_QWORD *)(a2 + 8 * i);
}
}
|
blst_scalar_from_uint64:
PUSH RBP
MOV RBP,RSP
CMP RDI,RSI
JZ 0x0012508e
XOR EAX,EAX
LAB_0012507d:
MOV RCX,qword ptr [RSI + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],RCX
INC RAX
CMP RAX,0x4
JNZ 0x0012507d
LAB_0012508e:
POP RBP
RET
|
void blst_scalar_from_uint64(long param_1,long param_2)
{
long lVar1;
if (param_1 != param_2) {
lVar1 = 0;
do {
*(int8 *)(param_1 + lVar1 * 8) = *(int8 *)(param_2 + lVar1 * 8);
lVar1 = lVar1 + 1;
} while (lVar1 != 4);
}
return;
}
|
|
64,030 |
my_strntoul_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static ulong
my_strntoul_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register unsigned int cutlim;
register uint32 cutoff;
register uint32 res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr + l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr= (char*)s;
err[0]= (cnv == MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+= cnv;
} while (1);
bs:
overflow= 0;
res= 0;
save= s;
cutoff= ((uint32)~0L) / (uint32) base;
cutlim= (uint) (((uint32)~0L) % (uint32) base);
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+= cnv;
if (wc >= '0' && wc <= '9')
wc-= '0';
else if (wc >= 'A' && wc <= 'Z')
wc= wc - 'A' + 10;
else if (wc >= 'a' && wc <= 'z')
wc= wc - 'a' + 10;
else
break;
if ((int) wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res*= (uint32) base;
res+= wc;
}
}
else if (cnv == MY_CS_ILSEQ)
{
if (endptr != NULL )
*endptr= (char*)s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr= (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (overflow)
{
err[0]= (ERANGE);
return (~(uint32) 0);
}
return (negative ? -((long) res) : (long) res);
}
|
O3
|
c
|
my_strntoul_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x457dd
movl $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0x457ad
cmpq $0x9, %rcx
je 0x457c5
cmpq $0x20, %rcx
je 0x457c5
jmp 0x4580f
cmpq $0x2b, %rcx
je 0x457c5
cmpq $0x2d, %rcx
jne 0x4580f
xorl %ecx, %ecx
cmpl $0x0, -0x38(%rbp)
sete %cl
movl %ecx, -0x38(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0x45795
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x457e9
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x34(%rbp)
movl %edx, %ebx
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x458d3
movq %r12, -0x68(%rbp)
movl %ebx, %ecx
movq %rcx, -0x60(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %edi, %edi
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0x45863
movq %rax, -0x30(%rbp)
jmp 0x45888
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0x45873
addq $-0x37, %rsi
jmp 0x45881
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0x458e4
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x34(%rbp), %eax
jge 0x458e4
movl $0x1, %esi
cmpl -0x44(%rbp), %ecx
ja 0x458ab
jne 0x458a3
movl -0x44(%rbp), %r12d
cmpq -0x60(%rbp), %rax
ja 0x458ae
imull -0x34(%rbp), %ecx
addl %eax, %ecx
movl %edi, %esi
movl %ecx, %r12d
movl %esi, -0x54(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *-0x68(%rbp)
movl -0x54(%rbp), %esi
movl %r12d, %ecx
movl %esi, %edi
testl %eax, %eax
jg 0x45847
jmp 0x458db
xorl %r12d, %r12d
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0x4591c
movl %esi, %edi
movl %r12d, %ecx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x458f0
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0x4590d
testl %edi, %edi
je 0x45937
movq -0x50(%rbp), %rax
movl $0x22, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x45800
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0x457fe
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x45928
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0x457fe
movl %ecx, %ecx
movq %rcx, %rax
negq %rax
cmpl $0x0, -0x38(%rbp)
cmoveq %rcx, %rax
jmp 0x45800
|
my_strntoul_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_40], r8
mov [rbp+var_34], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_457DD
mov [rbp+var_38], 0
lea rbx, [rbp+var_30]
loc_45795:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_457AD
cmp rcx, 9
jz short loc_457C5
cmp rcx, 20h ; ' '
jz short loc_457C5
jmp short loc_4580F
loc_457AD:
cmp rcx, 2Bh ; '+'
jz short loc_457C5
cmp rcx, 2Dh ; '-'
jnz short loc_4580F
xor ecx, ecx
cmp [rbp+var_38], 0
setz cl
mov [rbp+var_38], ecx
loc_457C5:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_45795
loc_457DD:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_457E9
mov [rcx], r15
loc_457E9:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_457FE:
xor eax, eax
loc_45800:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4580F:
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_34]
mov ebx, edx
mov [rbp+var_44], eax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_458D3
mov [rbp+var_68], r12
mov ecx, ebx
mov [rbp+var_60], rcx
xor ecx, ecx
mov rbx, r15
xor edi, edi
loc_45847:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_45863
mov [rbp+var_30], rax
jmp short loc_45888
loc_45863:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_45873
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_45881
loc_45873:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_458E4
add rsi, 0FFFFFFFFFFFFFFA9h
loc_45881:
mov [rbp+var_30], rsi
mov rax, rsi
loc_45888:
cmp eax, [rbp+var_34]
jge short loc_458E4
mov esi, 1
cmp ecx, [rbp+var_44]
ja short loc_458AB
jnz short loc_458A3
mov r12d, [rbp+var_44]
cmp rax, [rbp+var_60]
ja short loc_458AE
loc_458A3:
imul ecx, [rbp+var_34]
add ecx, eax
mov esi, edi
loc_458AB:
mov r12d, ecx
loc_458AE:
mov [rbp+var_54], esi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call [rbp+var_68]
mov esi, [rbp+var_54]
mov ecx, r12d
mov edi, esi
test eax, eax
jg loc_45847
jmp short loc_458DB
loc_458D3:
xor r12d, r12d
mov rbx, r15
xor esi, esi
loc_458DB:
test eax, eax
jz short loc_4591C
mov edi, esi
mov ecx, r12d
loc_458E4:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_458F0
mov [rax], rbx
loc_458F0:
cmp rbx, r15
jz short loc_4590D
test edi, edi
jz short loc_45937
mov rax, [rbp+var_50]
mov dword ptr [rax], 22h ; '"'
mov eax, 0FFFFFFFFh
jmp loc_45800
loc_4590D:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_457FE
loc_4591C:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_45928
mov [rax], rbx
loc_45928:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_457FE
loc_45937:
mov ecx, ecx
mov rax, rcx
neg rax
cmp [rbp+var_38], 0
cmovz rax, rcx
jmp loc_45800
|
long long my_strntoul_mb2_or_mb4(long long a1, long long a2, long long a3, unsigned int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
long long result; // rax
int v13; // eax
unsigned int v14; // ecx
long long v15; // rbx
int v16; // edi
unsigned long long v17; // rax
long long v18; // rsi
int v19; // esi
unsigned int v20; // r12d
long long ( *v21)(long long, _QWORD *, long long, long long); // [rsp+8h] [rbp-68h]
unsigned int v23; // [rsp+2Ch] [rbp-44h]
BOOL v25; // [rsp+38h] [rbp-38h]
_QWORD v27[6]; // [rsp+40h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v27, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v25 = 0;
while ( 1 )
{
if ( v27[0] > 42LL )
{
if ( v27[0] != 43LL )
{
if ( v27[0] != 45LL )
break;
v25 = !v25;
}
goto LABEL_10;
}
if ( v27[0] != 9LL && v27[0] != 32LL )
break;
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v27, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
v23 = 0xFFFFFFFF / a4;
v13 = v8(a1, v27, v6, v9);
if ( v13 > 0 )
{
v21 = v8;
v14 = 0;
v15 = v6;
v16 = 0;
while ( 1 )
{
v15 += (unsigned int)v13;
v17 = v27[0] - 48LL;
if ( (unsigned long long)(v27[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v27[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v27[0] - 97LL) > 0x19 )
goto LABEL_37;
v18 = v27[0] - 87LL;
}
else
{
v18 = v27[0] - 55LL;
}
v27[0] = v18;
v17 = v18;
}
else
{
v27[0] -= 48LL;
}
if ( (int)v17 >= (int)a4 )
goto LABEL_37;
v19 = 1;
if ( v14 <= v23 )
{
if ( v14 == v23 )
{
v20 = 0xFFFFFFFF / a4;
if ( v17 > 0xFFFFFFFF % a4 )
goto LABEL_32;
}
v14 = v17 + a4 * v14;
v19 = v16;
}
v20 = v14;
LABEL_32:
v13 = v21(a1, v27, v15, v9);
v14 = v20;
v16 = v19;
if ( v13 <= 0 )
goto LABEL_35;
}
}
v20 = 0;
v15 = v6;
v19 = 0;
LABEL_35:
if ( !v13 )
{
if ( a5 )
*a5 = v15;
*a6 = 84;
return 0LL;
}
v16 = v19;
v14 = v20;
LABEL_37:
if ( a5 )
*a5 = v15;
if ( v15 == v6 )
{
*a6 = 33;
return 0LL;
}
if ( v16 )
{
*a6 = 34;
return 0xFFFFFFFFLL;
}
else
{
result = -(long long)v14;
if ( !v25 )
return v14;
}
return result;
}
|
my_strntoul_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x34],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001457dd
MOV dword ptr [RBP + -0x38],0x0
LEA RBX,[RBP + -0x30]
LAB_00145795:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x001457ad
CMP RCX,0x9
JZ 0x001457c5
CMP RCX,0x20
JZ 0x001457c5
JMP 0x0014580f
LAB_001457ad:
CMP RCX,0x2b
JZ 0x001457c5
CMP RCX,0x2d
JNZ 0x0014580f
XOR ECX,ECX
CMP dword ptr [RBP + -0x38],0x0
SETZ CL
MOV dword ptr [RBP + -0x38],ECX
LAB_001457c5:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x00145795
LAB_001457dd:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x001457e9
MOV qword ptr [RCX],R15
LAB_001457e9:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_001457fe:
XOR EAX,EAX
LAB_00145800:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014580f:
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x34]
MOV EBX,EDX
MOV dword ptr [RBP + -0x44],EAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x001458d3
MOV qword ptr [RBP + -0x68],R12
MOV ECX,EBX
MOV qword ptr [RBP + -0x60],RCX
XOR ECX,ECX
MOV RBX,R15
XOR EDI,EDI
LAB_00145847:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x00145863
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00145888
LAB_00145863:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x00145873
ADD RSI,-0x37
JMP 0x00145881
LAB_00145873:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x001458e4
ADD RSI,-0x57
LAB_00145881:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_00145888:
CMP EAX,dword ptr [RBP + -0x34]
JGE 0x001458e4
MOV ESI,0x1
CMP ECX,dword ptr [RBP + -0x44]
JA 0x001458ab
JNZ 0x001458a3
MOV R12D,dword ptr [RBP + -0x44]
CMP RAX,qword ptr [RBP + -0x60]
JA 0x001458ae
LAB_001458a3:
IMUL ECX,dword ptr [RBP + -0x34]
ADD ECX,EAX
MOV ESI,EDI
LAB_001458ab:
MOV R12D,ECX
LAB_001458ae:
MOV dword ptr [RBP + -0x54],ESI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL qword ptr [RBP + -0x68]
MOV ESI,dword ptr [RBP + -0x54]
MOV ECX,R12D
MOV EDI,ESI
TEST EAX,EAX
JG 0x00145847
JMP 0x001458db
LAB_001458d3:
XOR R12D,R12D
MOV RBX,R15
XOR ESI,ESI
LAB_001458db:
TEST EAX,EAX
JZ 0x0014591c
MOV EDI,ESI
MOV ECX,R12D
LAB_001458e4:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001458f0
MOV qword ptr [RAX],RBX
LAB_001458f0:
CMP RBX,R15
JZ 0x0014590d
TEST EDI,EDI
JZ 0x00145937
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x22
MOV EAX,0xffffffff
JMP 0x00145800
LAB_0014590d:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x001457fe
LAB_0014591c:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x00145928
MOV qword ptr [RAX],RBX
LAB_00145928:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x001457fe
LAB_00145937:
MOV ECX,ECX
MOV RAX,RCX
NEG RAX
CMP dword ptr [RBP + -0x38],0x0
CMOVZ RAX,RCX
JMP 0x00145800
|
ulong my_strntoul_mb2_or_mb4
(long param_1,long param_2,long param_3,uint param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
bool bVar2;
bool bVar3;
bool bVar4;
uint uVar5;
uint uVar6;
int4 uVar7;
uint uVar8;
long lVar9;
ulong uVar10;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar5 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar5) {
bVar2 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_0014580f:
uVar5 = (uint)(0xffffffff / (ulong)param_4);
uVar6 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar9 = param_2;
if ((int)uVar6 < 1) {
uVar8 = 0;
bVar3 = false;
goto LAB_001458db;
}
uVar8 = 0;
bVar3 = false;
goto LAB_00145847;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_0014580f;
bVar2 = !bVar2;
}
param_2 = param_2 + (ulong)uVar5;
uVar5 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar5);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar7 = 0x21;
if (uVar5 == 0) {
uVar7 = 0x54;
}
*param_6 = uVar7;
return 0;
while( true ) {
if ((int)param_4 <= (int)uVar10) goto LAB_001458e4;
uVar6 = uVar8;
bVar4 = true;
if ((uVar8 <= uVar5) &&
((uVar8 != uVar5 || (uVar6 = uVar5, uVar10 <= 0xffffffffU % (ulong)param_4)))) {
uVar6 = uVar8 * param_4 + (int)uVar10;
bVar4 = bVar3;
}
bVar3 = bVar4;
uVar8 = uVar6;
local_38 = uVar10;
uVar6 = (*pcVar1)(param_1,&local_38,lVar9,param_3);
if ((int)uVar6 < 1) break;
LAB_00145847:
lVar9 = (ulong)uVar6 + lVar9;
uVar10 = local_38 - 0x30;
if (9 < uVar10) {
if (local_38 - 0x41 < 0x1a) {
uVar10 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_001458e4;
uVar10 = local_38 - 0x57;
}
}
}
LAB_001458db:
if (uVar6 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar9;
}
*param_6 = 0x54;
}
else {
LAB_001458e4:
if (param_5 != (long *)0x0) {
*param_5 = lVar9;
}
if (lVar9 != param_2) {
if (bVar3) {
*param_6 = 0x22;
return 0xffffffff;
}
if (!bVar2) {
return (ulong)uVar8;
}
return -(ulong)uVar8;
}
*param_6 = 0x21;
}
return 0;
}
|
|
64,031 |
mbedtls_pkcs5_pbes2_ext
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/pkcs5.c
|
int mbedtls_pkcs5_pbes2_ext(const mbedtls_asn1_buf *pbe_params, int mode,
const unsigned char *pwd, size_t pwdlen,
const unsigned char *data, size_t datalen,
unsigned char *output, size_t output_size,
size_t *output_len)
{
int ret, iterations = 0, keylen = 0;
unsigned char *p, *end;
mbedtls_asn1_buf kdf_alg_oid, enc_scheme_oid, kdf_alg_params, enc_scheme_params;
mbedtls_asn1_buf salt;
mbedtls_md_type_t md_type = MBEDTLS_MD_SHA1;
unsigned char key[32], iv[32];
const mbedtls_md_info_t *md_info;
const mbedtls_cipher_info_t *cipher_info;
mbedtls_md_context_t md_ctx;
mbedtls_cipher_type_t cipher_alg;
mbedtls_cipher_context_t cipher_ctx;
unsigned int padlen = 0;
p = pbe_params->p;
end = p + pbe_params->len;
/*
* PBES2-params ::= SEQUENCE {
* keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},
* encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}
* }
*/
if (pbe_params->tag != (MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) {
return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_PKCS5_INVALID_FORMAT,
MBEDTLS_ERR_ASN1_UNEXPECTED_TAG);
}
if ((ret = mbedtls_asn1_get_alg(&p, end, &kdf_alg_oid,
&kdf_alg_params)) != 0) {
return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_PKCS5_INVALID_FORMAT, ret);
}
// Only PBKDF2 supported at the moment
//
if (MBEDTLS_OID_CMP(MBEDTLS_OID_PKCS5_PBKDF2, &kdf_alg_oid) != 0) {
return MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE;
}
if ((ret = pkcs5_parse_pbkdf2_params(&kdf_alg_params,
&salt, &iterations, &keylen,
&md_type)) != 0) {
return ret;
}
md_info = mbedtls_md_info_from_type(md_type);
if (md_info == NULL) {
return MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE;
}
if ((ret = mbedtls_asn1_get_alg(&p, end, &enc_scheme_oid,
&enc_scheme_params)) != 0) {
return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_PKCS5_INVALID_FORMAT, ret);
}
if (mbedtls_oid_get_cipher_alg(&enc_scheme_oid, &cipher_alg) != 0) {
return MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE;
}
cipher_info = mbedtls_cipher_info_from_type(cipher_alg);
if (cipher_info == NULL) {
return MBEDTLS_ERR_PKCS5_FEATURE_UNAVAILABLE;
}
/*
* The value of keylen from pkcs5_parse_pbkdf2_params() is ignored
* since it is optional and we don't know if it was set or not
*/
keylen = cipher_info->key_bitlen / 8;
if (enc_scheme_params.tag != MBEDTLS_ASN1_OCTET_STRING ||
enc_scheme_params.len != cipher_info->iv_size) {
return MBEDTLS_ERR_PKCS5_INVALID_FORMAT;
}
if (mode == MBEDTLS_PKCS5_DECRYPT) {
if (output_size < datalen) {
return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
}
}
if (mode == MBEDTLS_PKCS5_ENCRYPT) {
padlen = cipher_info->block_size - (datalen % cipher_info->block_size);
if (output_size < (datalen + padlen)) {
return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
}
}
mbedtls_md_init(&md_ctx);
mbedtls_cipher_init(&cipher_ctx);
memcpy(iv, enc_scheme_params.p, enc_scheme_params.len);
if ((ret = mbedtls_md_setup(&md_ctx, md_info, 1)) != 0) {
goto exit;
}
if ((ret = mbedtls_pkcs5_pbkdf2_hmac(&md_ctx, pwd, pwdlen, salt.p, salt.len,
iterations, keylen, key)) != 0) {
goto exit;
}
if ((ret = mbedtls_cipher_setup(&cipher_ctx, cipher_info)) != 0) {
goto exit;
}
if ((ret = mbedtls_cipher_setkey(&cipher_ctx, key, 8 * keylen,
(mbedtls_operation_t) mode)) != 0) {
goto exit;
}
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
{
/* PKCS5 uses CBC with PKCS7 padding (which is the same as
* "PKCS5 padding" except that it's typically only called PKCS5
* with 64-bit-block ciphers).
*/
mbedtls_cipher_padding_t padding = MBEDTLS_PADDING_PKCS7;
#if !defined(MBEDTLS_CIPHER_PADDING_PKCS7)
/* For historical reasons, when decrypting, this function works when
* decrypting even when support for PKCS7 padding is disabled. In this
* case, it ignores the padding, and so will never report a
* password mismatch.
*/
if (mode == MBEDTLS_DECRYPT) {
padding = MBEDTLS_PADDING_NONE;
}
#endif
if ((ret = mbedtls_cipher_set_padding_mode(&cipher_ctx, padding)) != 0) {
goto exit;
}
}
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
if ((ret = mbedtls_cipher_crypt(&cipher_ctx, iv, enc_scheme_params.len,
data, datalen, output, output_len)) != 0) {
ret = MBEDTLS_ERR_PKCS5_PASSWORD_MISMATCH;
}
exit:
mbedtls_md_free(&md_ctx);
mbedtls_cipher_free(&cipher_ctx);
return ret;
}
|
O3
|
c
|
mbedtls_pkcs5_pbes2_ext:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
xorl %eax, %eax
movl %eax, 0x18(%rsp)
movl %eax, 0x4(%rsp)
movl $0x4, 0x14(%rsp)
movq 0x10(%rdi), %rbx
movq %rbx, 0x28(%rsp)
movl $0xffffd09e, %r13d # imm = 0xFFFFD09E
cmpl $0x30, (%rdi)
jne 0x99433
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %r9, 0x20(%rsp)
addq 0x8(%rdi), %rbx
leaq 0x28(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
leaq 0x88(%rsp), %rcx
movq %rbx, %rsi
callq 0x96df8
testl %eax, %eax
je 0x99400
movl %eax, %r13d
addl $0xffffd100, %r13d # imm = 0xFFFFD100
jmp 0x99433
cmpq $0x9, 0xc0(%rsp)
jne 0x9942d
movq 0xc8(%rsp), %rax
movabsq $0x5010df78648862a, %rcx # imm = 0x5010DF78648862A
xorq (%rax), %rcx
movzbl 0x8(%rax), %eax
xorq $0xc, %rax
orq %rcx, %rax
je 0x99448
movl $0xffffd180, %r13d # imm = 0xFFFFD180
movl %r13d, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0xffffd09e, %r13d # imm = 0xFFFFD09E
cmpl $0x30, 0x88(%rsp)
jne 0x99433
addq 0x90(%rsp), %rax
leaq 0x78(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movl $0x4, 0x10(%rsp)
movq %rax, %rsi
movq %rax, 0x8(%rsp)
movl $0x4, %ecx
callq 0x96961
testl %eax, %eax
jne 0x994c4
leaq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x80(%rsp)
addq 0x78(%rsp), %rax
movq %rax, (%rdi)
leaq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rsi
callq 0x969f2
testl %eax, %eax
je 0x996a2
movl %eax, %r13d
addl $0xffffd100, %r13d # imm = 0xFFFFD100
jne 0x99433
movl 0x10(%rsp), %edi
callq 0x8a34c
testq %rax, %rax
je 0x9942d
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x128(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movq %rbx, %rsi
callq 0x96df8
testl %eax, %eax
jne 0x993f4
leaq 0x128(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x97c5e
testl %eax, %eax
jne 0x9942d
movl 0x1c(%rsp), %edi
callq 0x9a1e7
movl $0xffffd180, %r13d # imm = 0xFFFFD180
testq %rax, %rax
movq 0x20(%rsp), %rdi
je 0x99433
movq %rax, %rbx
movl 0x8(%rax), %eax
shrl $0x3, %eax
movl %eax, 0x4(%rsp)
movl $0xffffd100, %r13d # imm = 0xFFFFD100
cmpl $0x4, 0x58(%rsp)
jne 0x99433
movl 0x18(%rbx), %eax
cmpq %rax, 0x60(%rsp)
jne 0x99433
movq 0x1a8(%rsp), %rcx
testl %ebp, %ebp
sete %al
cmpq %rdi, %rcx
setb %dl
movl $0xffffff94, %r13d # imm = 0xFFFFFF94
testb %dl, %al
jne 0x99433
cmpl $0x1, %ebp
jne 0x995af
movl 0x20(%rbx), %esi
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
subl %edx, %esi
addq %rdi, %rsi
cmpq %rcx, %rsi
ja 0x99433
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
callq 0x8a365
leaq 0xd0(%rsp), %rdi
callq 0x9a295
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rsi
leaq 0x140(%rsp), %rdi
callq 0xf3a0
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x8a4a1
testl %eax, %eax
jne 0x99680
movq 0x78(%rsp), %r8
movq 0x80(%rsp), %rcx
movl 0x18(%rsp), %r9d
movl 0x4(%rsp), %eax
leaq 0xa0(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x30(%rsp), %r10
pushq %r10
pushq %rax
callq 0x99791
addq $0x10, %rsp
testl %eax, %eax
jne 0x99680
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
callq 0x9a2df
testl %eax, %eax
jne 0x99680
movl 0x4(%rsp), %edx
shll $0x3, %edx
leaq 0xd0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %ecx
callq 0x9a393
testl %eax, %eax
jne 0x99680
leaq 0xd0(%rsp), %rdi
xorl %esi, %esi
callq 0x9a353
testl %eax, %eax
je 0x99747
movl %eax, %r13d
leaq 0xa0(%rsp), %rdi
callq 0x8a374
leaq 0xd0(%rsp), %rdi
callq 0x9a2b4
jmp 0x99433
movl $0x4, %ecx
movq 0x8(%rsp), %rsi
cmpq %rsi, 0x30(%rsp)
je 0x9973e
leaq 0x30(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x969f2
testl %eax, %eax
je 0x996d6
movl %eax, %r13d
cmpl $-0x62, %eax
jne 0x994c7
movq 0x8(%rsp), %rax
cmpq %rax, 0x30(%rsp)
movl $0x4, %ecx
je 0x9973e
leaq 0x30(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
movq %rax, %rsi
callq 0x96efe
testl %eax, %eax
jne 0x994c4
leaq 0xd0(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x97d6d
movl $0xffffd180, %r13d # imm = 0xFFFFD180
testl %eax, %eax
movq 0x8(%rsp), %rax
jne 0x99433
movl $0xffffd09a, %r13d # imm = 0xFFFFD09A
cmpq %rax, 0x30(%rsp)
jne 0x99433
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rsp)
jmp 0x994d4
movq 0x1a0(%rsp), %r9
movq 0x60(%rsp), %rdx
subq $0x8, %rsp
leaq 0xd8(%rsp), %rdi
leaq 0x148(%rsp), %rsi
movq %r14, %rcx
movq 0x28(%rsp), %r8
pushq 0x1b8(%rsp)
callq 0x9adbd
addq $0x10, %rsp
testl %eax, %eax
movl $0xffffd200, %r13d # imm = 0xFFFFD200
cmovel %eax, %r13d
jmp 0x99683
|
mbedtls_pkcs5_pbes2_ext:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 168h
xor eax, eax
mov [rsp+198h+var_180], eax
mov [rsp+198h+var_194], eax
mov [rsp+198h+var_184], 4
mov rbx, [rdi+10h]
mov [rsp+198h+var_170], rbx
mov r13d, 0FFFFD09Eh
cmp dword ptr [rdi], 30h ; '0'
jnz short loc_99433
mov r14, r8
mov r15, rcx
mov r12, rdx
mov ebp, esi
mov [rsp+198h+var_178], r9
add rbx, [rdi+8]
lea rdi, [rsp+198h+var_170]
lea rdx, [rsp+198h+var_E0]
lea rcx, [rsp+198h+var_110]
mov rsi, rbx
call mbedtls_asn1_get_alg
test eax, eax
jz short loc_99400
loc_993F4:
mov r13d, eax
add r13d, 0FFFFD100h
jmp short loc_99433
loc_99400:
cmp [rsp+198h+var_D8], 9
jnz short loc_9942D
mov rax, [rsp+198h+var_D0]
mov rcx, 5010DF78648862Ah
xor rcx, [rax]
movzx eax, byte ptr [rax+8]
xor rax, 0Ch
or rax, rcx
jz short loc_99448
loc_9942D:
mov r13d, 0FFFFD180h
loc_99433:
mov eax, r13d
add rsp, 168h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_99448:
mov rax, [rsp+198h+var_100]
mov [rsp+198h+var_168], rax
mov r13d, 0FFFFD09Eh
cmp [rsp+198h+var_110], 30h ; '0'
jnz short loc_99433
add rax, [rsp+198h+var_108]
lea rdx, [rsp+198h+var_120]
lea rdi, [rsp+198h+var_168]
mov [rsp+198h+var_188], 4
mov rsi, rax
mov [rsp+198h+var_190], rax
mov ecx, 4
call mbedtls_asn1_get_tag
test eax, eax
jnz short loc_994C4
lea rdi, [rsp+198h+var_168]
mov rax, [rdi]
mov [rsp+198h+var_118], rax
add rax, [rsp+198h+var_120]
mov [rdi], rax
lea rdx, [rsp+198h+var_180]
mov rsi, [rsp+198h+var_190]
call mbedtls_asn1_get_int
test eax, eax
jz loc_996A2
loc_994C4:
mov r13d, eax
loc_994C7:
add r13d, 0FFFFD100h
jnz loc_99433
loc_994D4:
mov edi, [rsp+198h+var_188]
call mbedtls_md_info_from_type
test rax, rax
jz loc_9942D
mov [rsp+198h+var_190], rax
lea rdi, [rsp+198h+var_170]
lea rdx, [rsp+198h+var_70]
lea rcx, [rsp+198h+var_140]
mov rsi, rbx
call mbedtls_asn1_get_alg
test eax, eax
jnz loc_993F4
lea rdi, [rsp+198h+var_70]
lea rsi, [rsp+198h+var_17C]
call mbedtls_oid_get_cipher_alg
test eax, eax
jnz loc_9942D
mov edi, [rsp+198h+var_17C]
call mbedtls_cipher_info_from_type
mov r13d, 0FFFFD180h
test rax, rax
mov rdi, [rsp+198h+var_178]
jz loc_99433
mov rbx, rax
mov eax, [rax+8]
shr eax, 3
mov [rsp+198h+var_194], eax
mov r13d, 0FFFFD100h
cmp [rsp+198h+var_140], 4
jnz loc_99433
mov eax, [rbx+18h]
cmp [rsp+198h+var_138], rax
jnz loc_99433
mov rcx, [rsp+198h+arg_8]
test ebp, ebp
setz al
cmp rcx, rdi
setb dl
mov r13d, 0FFFFFF94h
test al, dl
jnz loc_99433
cmp ebp, 1
jnz short loc_995AF
mov esi, [rbx+20h]
mov rax, rdi
xor edx, edx
div rsi
sub esi, edx
add rsi, rdi
cmp rsi, rcx
ja loc_99433
loc_995AF:
lea r13, [rsp+198h+var_F8]
mov rdi, r13
call mbedtls_md_init
lea rdi, [rsp+198h+var_C8]
call mbedtls_cipher_init
mov rdx, [rsp+198h+var_138]
mov rsi, [rsp+198h+var_130]
lea rdi, [rsp+198h+var_58]
call _memcpy
mov rdi, r13
mov rsi, [rsp+198h+var_190]
mov edx, 1
call mbedtls_md_setup
test eax, eax
jnz loc_99680
mov r8, [rsp+198h+var_120]
mov rcx, [rsp+198h+var_118]
mov r9d, [rsp+198h+var_180]
mov eax, [rsp+198h+var_194]
lea rdi, [rsp+198h+var_F8]
mov rsi, r12
mov rdx, r15
lea r10, [rsp+198h+var_168]
push r10
push rax
call mbedtls_pkcs5_pbkdf2_hmac
add rsp, 10h
test eax, eax
jnz short loc_99680
lea rdi, [rsp+198h+var_C8]
mov rsi, rbx
call mbedtls_cipher_setup
test eax, eax
jnz short loc_99680
mov edx, [rsp+198h+var_194]
shl edx, 3
lea rdi, [rsp+198h+var_C8]
lea rsi, [rsp+198h+var_168]
mov ecx, ebp
call mbedtls_cipher_setkey
test eax, eax
jnz short loc_99680
lea rdi, [rsp+198h+var_C8]
xor esi, esi
call mbedtls_cipher_set_padding_mode
test eax, eax
jz loc_99747
loc_99680:
mov r13d, eax
loc_99683:
lea rdi, [rsp+198h+var_F8]
call mbedtls_md_free
lea rdi, [rsp+198h+var_C8]
call mbedtls_cipher_free
jmp loc_99433
loc_996A2:
mov ecx, 4
mov rsi, [rsp+198h+var_190]
cmp [rsp+198h+var_168], rsi
jz loc_9973E
lea rdi, [rsp+198h+var_168]
lea rdx, [rsp+198h+var_194]
call mbedtls_asn1_get_int
test eax, eax
jz short loc_996D6
mov r13d, eax
cmp eax, 0FFFFFF9Eh
jnz loc_994C7
loc_996D6:
mov rax, [rsp+198h+var_190]
cmp [rsp+198h+var_168], rax
mov ecx, 4
jz short loc_9973E
lea rdi, [rsp+198h+var_168]
lea rdx, [rsp+198h+var_C8]
mov rsi, rax
call mbedtls_asn1_get_alg_null
test eax, eax
jnz loc_994C4
lea rdi, [rsp+198h+var_C8]
lea rsi, [rsp+198h+var_184]
call mbedtls_oid_get_md_hmac
mov r13d, 0FFFFD180h
test eax, eax
mov rax, [rsp+198h+var_190]
jnz loc_99433
mov r13d, 0FFFFD09Ah
cmp [rsp+198h+var_168], rax
jnz loc_99433
mov ecx, [rsp+198h+var_184]
loc_9973E:
mov [rsp+198h+var_188], ecx
jmp loc_994D4
loc_99747:
mov r9, [rsp+198h+arg_0]
mov rdx, [rsp+198h+var_138]
sub rsp, 8
lea rdi, [rsp+1A0h+var_C8]
lea rsi, [rsp+1A0h+var_58]
mov rcx, r14
mov r8, [rsp+1A0h+var_178]
push [rsp+1A0h+arg_10]
call mbedtls_cipher_crypt
add rsp, 10h
test eax, eax
mov r13d, 0FFFFD200h
cmovz r13d, eax
jmp loc_99683
|
long long mbedtls_pkcs5_pbes2_ext(
long long a1,
unsigned int a2,
int a3,
int a4,
int a5,
unsigned long long a6,
long long a7,
unsigned long long a8,
long long a9)
{
unsigned __int8 *v9; // rbx
unsigned int v10; // r13d
long long v14; // rbx
int alg; // eax
int tag; // eax
int v18; // r13d
unsigned __int8 *v19; // rax
_DWORD *v20; // rax
_DWORD *v21; // rbx
unsigned int v22; // eax
int v23; // ecx
int v24; // eax
int v25; // [rsp+4h] [rbp-194h] BYREF
unsigned __int8 *v26; // [rsp+8h] [rbp-190h]
int v27; // [rsp+10h] [rbp-188h]
int v28; // [rsp+14h] [rbp-184h] BYREF
int v29; // [rsp+18h] [rbp-180h] BYREF
unsigned int v30; // [rsp+1Ch] [rbp-17Ch] BYREF
unsigned long long v31; // [rsp+20h] [rbp-178h]
unsigned __int8 *v32; // [rsp+28h] [rbp-170h] BYREF
unsigned __int8 *v33[5]; // [rsp+30h] [rbp-168h] BYREF
int v34; // [rsp+58h] [rbp-140h] BYREF
long long v35; // [rsp+60h] [rbp-138h]
long long v36; // [rsp+68h] [rbp-130h]
unsigned long long v37; // [rsp+78h] [rbp-120h] BYREF
unsigned __int8 *v38; // [rsp+80h] [rbp-118h]
int v39; // [rsp+88h] [rbp-110h] BYREF
long long v40; // [rsp+90h] [rbp-108h]
unsigned __int8 *v41; // [rsp+98h] [rbp-100h]
_QWORD v42[3]; // [rsp+A0h] [rbp-F8h] BYREF
_BYTE v43[8]; // [rsp+B8h] [rbp-E0h] BYREF
long long v44; // [rsp+C0h] [rbp-D8h]
long long v45; // [rsp+C8h] [rbp-D0h]
_BYTE v46[88]; // [rsp+D0h] [rbp-C8h] BYREF
_BYTE v47[24]; // [rsp+128h] [rbp-70h] BYREF
_BYTE v48[88]; // [rsp+140h] [rbp-58h] BYREF
v29 = 0;
v25 = 0;
v28 = 4;
v9 = *(unsigned __int8 **)(a1 + 16);
v32 = v9;
v10 = -12130;
if ( *(_DWORD *)a1 != 48 )
return v10;
v31 = a6;
v14 = (long long)&v9[*(_QWORD *)(a1 + 8)];
alg = mbedtls_asn1_get_alg(&v32, v14, (long long)v43, (long long)&v39);
if ( alg )
return (unsigned int)(alg - 12032);
if ( v44 != 9 || *(_QWORD *)v45 ^ 0x5010DF78648862ALL | *(unsigned __int8 *)(v45 + 8) ^ 0xCLL )
return (unsigned int)-11904;
v33[0] = v41;
v10 = -12130;
if ( v39 != 48 )
return v10;
v27 = 4;
v26 = &v41[v40];
tag = mbedtls_asn1_get_tag(v33, (long long)&v41[v40], &v37, 4);
if ( tag )
goto LABEL_11;
v38 = v33[0];
v33[0] += v37;
tag = mbedtls_asn1_get_int((long long)v33, (long long)v26, (long long)&v29);
if ( tag )
goto LABEL_11;
v23 = 4;
if ( v33[0] == v26 )
goto LABEL_37;
v24 = mbedtls_asn1_get_int((long long)v33, (long long)v26, (long long)&v25);
if ( !v24 || (v18 = v24, v24 == -98) )
{
v23 = 4;
if ( v33[0] != v26 )
{
tag = mbedtls_asn1_get_alg_null(v33, (long long)v26, (long long)v46);
if ( tag )
{
LABEL_11:
v18 = tag;
goto LABEL_12;
}
v10 = -11904;
if ( (unsigned int)mbedtls_oid_get_md_hmac((long long)v46, &v28) )
return v10;
v10 = -12134;
if ( v33[0] != v26 )
return v10;
v23 = v28;
}
LABEL_37:
v27 = v23;
goto LABEL_13;
}
LABEL_12:
v10 = v18 - 12032;
if ( v10 )
return v10;
LABEL_13:
v19 = (unsigned __int8 *)mbedtls_md_info_from_type(v27);
if ( !v19 )
return (unsigned int)-11904;
v26 = v19;
alg = mbedtls_asn1_get_alg(&v32, v14, (long long)v47, (long long)&v34);
if ( alg )
return (unsigned int)(alg - 12032);
if ( (unsigned int)mbedtls_oid_get_cipher_alg((long long)v47, &v30) )
return (unsigned int)-11904;
v20 = (_DWORD *)mbedtls_cipher_info_from_type(v30);
v10 = -11904;
if ( v20 )
{
v21 = v20;
v25 = v20[2] >> 3;
v10 = -12032;
if ( v34 == 4 && v35 == v20[6] )
{
v10 = -108;
if ( (a8 >= v31 || a2 != 0) && (a2 != 1 || v31 + v20[8] - (unsigned int)(v31 % (unsigned int)v20[8]) <= a8) )
{
mbedtls_md_init((long long)v42);
mbedtls_cipher_init(v46);
memcpy(v48, v36, v35);
v22 = mbedtls_md_setup(v42, (long long)v26, 1);
if ( v22
|| (v22 = mbedtls_pkcs5_pbkdf2_hmac((unsigned int)v42, a3, a4, (_DWORD)v38, v37, v29, v25, (long long)v33)) != 0
|| (v22 = mbedtls_cipher_setup(v46, v21)) != 0
|| (v22 = mbedtls_cipher_setkey(v46, v33, (unsigned int)(8 * v25), a2)) != 0
|| (v22 = mbedtls_cipher_set_padding_mode(v46, 0LL)) != 0 )
{
v10 = v22;
}
else
{
v10 = -11776;
if ( !(unsigned int)mbedtls_cipher_crypt((unsigned int)v46, (unsigned int)v48, v35, a5, v31, a7, a9) )
v10 = 0;
}
mbedtls_md_free(v42);
mbedtls_cipher_free(v46);
}
}
}
return v10;
}
|
mbedtls_pkcs5_pbes2_ext:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x168
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],EAX
MOV dword ptr [RSP + 0x4],EAX
MOV dword ptr [RSP + 0x14],0x4
MOV RBX,qword ptr [RDI + 0x10]
MOV qword ptr [RSP + 0x28],RBX
MOV R13D,0xffffd09e
CMP dword ptr [RDI],0x30
JNZ 0x00199433
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOV EBP,ESI
MOV qword ptr [RSP + 0x20],R9
ADD RBX,qword ptr [RDI + 0x8]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0xb8]
LEA RCX,[RSP + 0x88]
MOV RSI,RBX
CALL 0x00196df8
TEST EAX,EAX
JZ 0x00199400
LAB_001993f4:
MOV R13D,EAX
ADD R13D,0xffffd100
JMP 0x00199433
LAB_00199400:
CMP qword ptr [RSP + 0xc0],0x9
JNZ 0x0019942d
MOV RAX,qword ptr [RSP + 0xc8]
MOV RCX,0x5010df78648862a
XOR RCX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX + 0x8]
XOR RAX,0xc
OR RAX,RCX
JZ 0x00199448
LAB_0019942d:
MOV R13D,0xffffd180
LAB_00199433:
MOV EAX,R13D
ADD RSP,0x168
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00199448:
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x30],RAX
MOV R13D,0xffffd09e
CMP dword ptr [RSP + 0x88],0x30
JNZ 0x00199433
ADD RAX,qword ptr [RSP + 0x90]
LEA RDX,[RSP + 0x78]
LEA RDI,[RSP + 0x30]
MOV dword ptr [RSP + 0x10],0x4
MOV RSI,RAX
MOV qword ptr [RSP + 0x8],RAX
MOV ECX,0x4
CALL 0x00196961
TEST EAX,EAX
JNZ 0x001994c4
LEA RDI,[RSP + 0x30]
MOV RAX,qword ptr [RDI]
MOV qword ptr [RSP + 0x80],RAX
ADD RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RDI],RAX
LEA RDX,[RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001969f2
TEST EAX,EAX
JZ 0x001996a2
LAB_001994c4:
MOV R13D,EAX
LAB_001994c7:
ADD R13D,0xffffd100
JNZ 0x00199433
LAB_001994d4:
MOV EDI,dword ptr [RSP + 0x10]
CALL 0x0018a34c
TEST RAX,RAX
JZ 0x0019942d
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x128]
LEA RCX,[RSP + 0x58]
MOV RSI,RBX
CALL 0x00196df8
TEST EAX,EAX
JNZ 0x001993f4
LEA RDI,[RSP + 0x128]
LEA RSI,[RSP + 0x1c]
CALL 0x00197c5e
TEST EAX,EAX
JNZ 0x0019942d
MOV EDI,dword ptr [RSP + 0x1c]
CALL 0x0019a1e7
MOV R13D,0xffffd180
TEST RAX,RAX
MOV RDI,qword ptr [RSP + 0x20]
JZ 0x00199433
MOV RBX,RAX
MOV EAX,dword ptr [RAX + 0x8]
SHR EAX,0x3
MOV dword ptr [RSP + 0x4],EAX
MOV R13D,0xffffd100
CMP dword ptr [RSP + 0x58],0x4
JNZ 0x00199433
MOV EAX,dword ptr [RBX + 0x18]
CMP qword ptr [RSP + 0x60],RAX
JNZ 0x00199433
MOV RCX,qword ptr [RSP + 0x1a8]
TEST EBP,EBP
SETZ AL
CMP RCX,RDI
SETC DL
MOV R13D,0xffffff94
TEST AL,DL
JNZ 0x00199433
CMP EBP,0x1
JNZ 0x001995af
MOV ESI,dword ptr [RBX + 0x20]
MOV RAX,RDI
XOR EDX,EDX
DIV RSI
SUB ESI,EDX
ADD RSI,RDI
CMP RSI,RCX
JA 0x00199433
LAB_001995af:
LEA R13,[RSP + 0xa0]
MOV RDI,R13
CALL 0x0018a365
LEA RDI,[RSP + 0xd0]
CALL 0x0019a295
MOV RDX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
LEA RDI,[RSP + 0x140]
CALL 0x0010f3a0
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,0x1
CALL 0x0018a4a1
TEST EAX,EAX
JNZ 0x00199680
MOV R8,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x80]
MOV R9D,dword ptr [RSP + 0x18]
MOV EAX,dword ptr [RSP + 0x4]
LEA RDI,[RSP + 0xa0]
MOV RSI,R12
MOV RDX,R15
LEA R10,[RSP + 0x30]
PUSH R10
PUSH RAX
CALL 0x00199791
ADD RSP,0x10
TEST EAX,EAX
JNZ 0x00199680
LEA RDI,[RSP + 0xd0]
MOV RSI,RBX
CALL 0x0019a2df
TEST EAX,EAX
JNZ 0x00199680
MOV EDX,dword ptr [RSP + 0x4]
SHL EDX,0x3
LEA RDI,[RSP + 0xd0]
LEA RSI,[RSP + 0x30]
MOV ECX,EBP
CALL 0x0019a393
TEST EAX,EAX
JNZ 0x00199680
LEA RDI,[RSP + 0xd0]
XOR ESI,ESI
CALL 0x0019a353
TEST EAX,EAX
JZ 0x00199747
LAB_00199680:
MOV R13D,EAX
LAB_00199683:
LEA RDI,[RSP + 0xa0]
CALL 0x0018a374
LEA RDI,[RSP + 0xd0]
CALL 0x0019a2b4
JMP 0x00199433
LAB_001996a2:
MOV ECX,0x4
MOV RSI,qword ptr [RSP + 0x8]
CMP qword ptr [RSP + 0x30],RSI
JZ 0x0019973e
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x4]
CALL 0x001969f2
TEST EAX,EAX
JZ 0x001996d6
MOV R13D,EAX
CMP EAX,-0x62
JNZ 0x001994c7
LAB_001996d6:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RSP + 0x30],RAX
MOV ECX,0x4
JZ 0x0019973e
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0xd0]
MOV RSI,RAX
CALL 0x00196efe
TEST EAX,EAX
JNZ 0x001994c4
LEA RDI,[RSP + 0xd0]
LEA RSI,[RSP + 0x14]
CALL 0x00197d6d
MOV R13D,0xffffd180
TEST EAX,EAX
MOV RAX,qword ptr [RSP + 0x8]
JNZ 0x00199433
MOV R13D,0xffffd09a
CMP qword ptr [RSP + 0x30],RAX
JNZ 0x00199433
MOV ECX,dword ptr [RSP + 0x14]
LAB_0019973e:
MOV dword ptr [RSP + 0x10],ECX
JMP 0x001994d4
LAB_00199747:
MOV R9,qword ptr [RSP + 0x1a0]
MOV RDX,qword ptr [RSP + 0x60]
SUB RSP,0x8
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0x148]
MOV RCX,R14
MOV R8,qword ptr [RSP + 0x28]
PUSH qword ptr [RSP + 0x1b8]
CALL 0x0019adbd
ADD RSP,0x10
TEST EAX,EAX
MOV R13D,0xffffd200
CMOVZ R13D,EAX
JMP 0x00199683
|
int mbedtls_pkcs5_pbes2_ext
(int *param_1,int param_2,int8 param_3,int8 param_4,int8 param_5,
ulong param_6,int8 param_7,ulong param_8,int8 param_9)
{
int4 uVar1;
int iVar2;
int iVar3;
long lVar4;
uint local_194;
long local_190;
int4 local_188;
int4 local_184;
int4 local_180;
int4 local_17c;
ulong local_178;
long local_170;
long local_168 [5];
int local_140 [2];
ulong local_138;
void *local_130;
long local_120;
long local_118;
int local_110 [2];
long local_108;
long local_100;
int1 local_f8 [24];
int1 local_e0 [8];
long local_d8;
long *local_d0;
int1 local_c8 [88];
int1 local_70 [24];
int1 local_58 [40];
local_180 = 0;
local_194 = 0;
local_184 = 4;
local_170 = *(long *)(param_1 + 4);
if (*param_1 != 0x30) {
return -0x2f62;
}
lVar4 = local_170 + *(long *)(param_1 + 2);
local_178 = param_6;
iVar2 = mbedtls_asn1_get_alg(&local_170,lVar4,local_e0,local_110);
if (iVar2 == 0) {
if ((local_d8 == 9) && ((char)local_d0[1] == '\f' && *local_d0 == 0x5010df78648862a)) {
local_168[0] = local_100;
if (local_110[0] != 0x30) {
return -0x2f62;
}
local_190 = local_100 + local_108;
local_188 = 4;
iVar2 = mbedtls_asn1_get_tag(local_168,local_190,&local_120,4);
if (iVar2 == 0) {
local_118 = local_168[0];
local_168[0] = local_168[0] + local_120;
iVar2 = mbedtls_asn1_get_int(local_168,local_190,&local_180);
if (iVar2 != 0) goto LAB_001994c7;
uVar1 = 4;
if (local_168[0] != local_190) {
iVar2 = mbedtls_asn1_get_int(local_168,local_190,&local_194);
if ((iVar2 != 0) && (iVar2 != -0x62)) goto LAB_001994c7;
uVar1 = 4;
if (local_168[0] != local_190) {
iVar2 = mbedtls_asn1_get_alg_null(local_168,local_190,local_c8);
if (iVar2 != 0) goto LAB_001994c7;
iVar2 = mbedtls_oid_get_md_hmac(local_c8,&local_184);
if (iVar2 != 0) {
return -0x2e80;
}
uVar1 = local_184;
if (local_168[0] != local_190) {
return -0x2f66;
}
}
}
}
else {
LAB_001994c7:
uVar1 = local_188;
if (iVar2 + -0x2f00 != 0) {
return iVar2 + -0x2f00;
}
}
local_188 = uVar1;
local_190 = mbedtls_md_info_from_type(local_188);
if (local_190 != 0) {
iVar2 = mbedtls_asn1_get_alg(&local_170,lVar4,local_70,local_140);
if (iVar2 != 0) goto LAB_001993f4;
iVar2 = mbedtls_oid_get_cipher_alg(local_70,&local_17c);
if (iVar2 == 0) {
lVar4 = mbedtls_cipher_info_from_type(local_17c);
if (lVar4 == 0) {
return -0x2e80;
}
local_194 = *(uint *)(lVar4 + 8) >> 3;
if (local_140[0] != 4) {
return -0x2f00;
}
if (local_138 != *(uint *)(lVar4 + 0x18)) {
return -0x2f00;
}
if (param_2 == 0 && param_8 < local_178) {
return -0x6c;
}
if ((param_2 == 1) &&
(param_8 < (*(uint *)(lVar4 + 0x20) - (int)(local_178 % (ulong)*(uint *)(lVar4 + 0x20))
) + local_178)) {
return -0x6c;
}
mbedtls_md_init(local_f8);
mbedtls_cipher_init(local_c8);
memcpy(local_58,local_130,local_138);
iVar2 = mbedtls_md_setup(local_f8,local_190,1);
if (((iVar2 == 0) &&
(((iVar2 = mbedtls_pkcs5_pbkdf2_hmac
(local_f8,param_3,param_4,local_118,local_120,local_180,local_194
,local_168), iVar2 == 0 &&
(iVar2 = mbedtls_cipher_setup(local_c8,lVar4), iVar2 == 0)) &&
(iVar2 = mbedtls_cipher_setkey(local_c8,local_168,local_194 << 3,param_2), iVar2 == 0
)))) && (iVar2 = mbedtls_cipher_set_padding_mode(local_c8,0), iVar2 == 0)) {
iVar3 = mbedtls_cipher_crypt
(local_c8,local_58,local_138,param_5,local_178,param_7,param_9);
iVar2 = -0x2e00;
if (iVar3 == 0) {
iVar2 = 0;
}
}
mbedtls_md_free(local_f8);
mbedtls_cipher_free(local_c8);
return iVar2;
}
}
}
iVar2 = -0x2e80;
}
else {
LAB_001993f4:
iVar2 = iVar2 + -0x2f00;
}
return iVar2;
}
|
|
64,032 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get()
|
monkey531[P]llama/common/json.hpp
|
char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x1c64c
movb $0x0, 0x18(%rbx)
jmp 0x1c661
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1c690
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
movl 0x14(%rbx), %eax
cmpl $-0x1, %eax
je 0x1c679
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x5cc86
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x1c68a
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x1c65e
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_1C64C
mov byte ptr [rbx+18h], 0
jmp short loc_1C661
loc_1C64C:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_1C690
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_1C65E:
mov [rbx+14h], eax
loc_1C661:
mov eax, [rbx+14h]
cmp eax, 0FFFFFFFFh
jz short loc_1C679
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
loc_1C679:
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_1C68A
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
loc_1C68A:
add rsp, 10h
pop rbx
retn
loc_1C690:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_1C65E
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(
__m128i *a1)
{
unsigned __int8 *v1; // rcx
int v2; // eax
long long result; // rax
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
}
else
{
v1 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v2 = -1;
}
else
{
v2 = *v1;
a1->m128i_i64[0] = (long long)(v1 + 1);
}
a1[1].m128i_i32[1] = v2;
}
if ( a1[1].m128i_i32[1] != -1 )
std::vector<char>::emplace_back<char>(&a1[3].m128i_u64[1]);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result == 10 )
{
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
}
return result;
}
|
get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x0011c64c
MOV byte ptr [RBX + 0x18],0x0
JMP 0x0011c661
LAB_0011c64c:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x0011c690
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_0011c65e:
MOV dword ptr [RBX + 0x14],EAX
LAB_0011c661:
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,-0x1
JZ 0x0011c679
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x0015cc86
LAB_0011c679:
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x0011c68a
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
LAB_0011c68a:
ADD RSP,0x10
POP RBX
RET
LAB_0011c690:
PUSH -0x1
POP RAX
JMP 0x0011c65e
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::get() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
byte *pbVar1;
uint uVar2;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (this[0x18] ==
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1) {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (*(int *)(this + 0x14) != -1) {
local_9 = (char)*(int *)(this + 0x14);
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
}
if (*(int *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
}
return;
}
|
|
64,033 |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get()
|
monkey531[P]llama/common/json.hpp
|
char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();
}
if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
{
token_string.push_back(char_traits<char_type>::to_char_type(current));
}
if (current == '\n')
{
++position.lines_read;
position.chars_read_current_line = 0;
}
return current;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::get():
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x1c667
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x1c67c
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x1c6af
movzbl (%rcx), %eax
incq %rcx
movq %rcx, (%rbx)
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x1c6ab
leaq 0x38(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x5d654
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x1c6a5
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
pushq $0xa
popq %rax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
jmp 0x1c6a4
pushq $-0x1
popq %rax
jmp 0x1c679
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv:
push rbx
sub rsp, 10h
mov rbx, rdi
movdqu xmm0, xmmword ptr [rdi+20h]
pcmpeqd xmm1, xmm1
psubq xmm0, xmm1
movdqu xmmword ptr [rdi+20h], xmm0
cmp byte ptr [rdi+18h], 1
jnz short loc_1C667
mov byte ptr [rbx+18h], 0
mov eax, [rbx+14h]
jmp short loc_1C67C
loc_1C667:
mov rcx, [rbx]
cmp rcx, [rbx+8]
jz short loc_1C6AF
movzx eax, byte ptr [rcx]
inc rcx
mov [rbx], rcx
loc_1C679:
mov [rbx+14h], eax
loc_1C67C:
cmp eax, 0FFFFFFFFh
jz short loc_1C6AB
lea rdi, [rbx+38h]
lea rsi, [rsp+18h+var_9]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
mov eax, [rbx+14h]
cmp eax, 0Ah
jnz short loc_1C6A5
inc qword ptr [rbx+30h]
and qword ptr [rbx+28h], 0
push 0Ah
loc_1C6A4:
pop rax
loc_1C6A5:
add rsp, 10h
pop rbx
retn
loc_1C6AB:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_1C6A4
loc_1C6AF:
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_1C679
|
long long nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(
__m128i *a1)
{
int v1; // eax
unsigned __int8 *v2; // rcx
long long result; // rax
a1[2] = _mm_sub_epi64(_mm_loadu_si128(a1 + 2), (__m128i)-1LL);
if ( a1[1].m128i_i8[8] == 1 )
{
a1[1].m128i_i8[8] = 0;
v1 = a1[1].m128i_i32[1];
}
else
{
v2 = (unsigned __int8 *)a1->m128i_i64[0];
if ( a1->m128i_i64[0] == a1->m128i_i64[1] )
{
v1 = -1;
}
else
{
v1 = *v2;
a1->m128i_i64[0] = (long long)(v2 + 1);
}
a1[1].m128i_i32[1] = v1;
}
if ( v1 == -1 )
return -1LL;
std::vector<char>::emplace_back<char>(&a1[3].m128i_u64[1]);
result = a1[1].m128i_u32[1];
if ( (_DWORD)result != 10 )
return result;
++a1[3].m128i_i64[0];
a1[2].m128i_i64[1] = 0LL;
return 10LL;
}
|
get:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVDQU XMM0,xmmword ptr [RDI + 0x20]
PCMPEQD XMM1,XMM1
PSUBQ XMM0,XMM1
MOVDQU xmmword ptr [RDI + 0x20],XMM0
CMP byte ptr [RDI + 0x18],0x1
JNZ 0x0011c667
MOV byte ptr [RBX + 0x18],0x0
MOV EAX,dword ptr [RBX + 0x14]
JMP 0x0011c67c
LAB_0011c667:
MOV RCX,qword ptr [RBX]
CMP RCX,qword ptr [RBX + 0x8]
JZ 0x0011c6af
MOVZX EAX,byte ptr [RCX]
INC RCX
MOV qword ptr [RBX],RCX
LAB_0011c679:
MOV dword ptr [RBX + 0x14],EAX
LAB_0011c67c:
CMP EAX,-0x1
JZ 0x0011c6ab
LEA RDI,[RBX + 0x38]
LEA RSI,[RSP + 0xf]
MOV byte ptr [RSI],AL
CALL 0x0015d654
MOV EAX,dword ptr [RBX + 0x14]
CMP EAX,0xa
JNZ 0x0011c6a5
INC qword ptr [RBX + 0x30]
AND qword ptr [RBX + 0x28],0x0
PUSH 0xa
LAB_0011c6a4:
POP RAX
LAB_0011c6a5:
ADD RSP,0x10
POP RBX
RET
LAB_0011c6ab:
PUSH -0x1
JMP 0x0011c6a4
LAB_0011c6af:
PUSH -0x1
POP RAX
JMP 0x0011c679
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::get() */
ulong __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
byte *pbVar1;
uint uVar2;
ulong uStack_20;
char local_9;
*(long *)(this + 0x20) = *(long *)(this + 0x20) + 1;
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
if (this[0x18] ==
(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x1) {
this[0x18] = (lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
)0x0;
uVar2 = *(uint *)(this + 0x14);
}
else {
pbVar1 = *(byte **)this;
if (pbVar1 == *(byte **)(this + 8)) {
uVar2 = 0xffffffff;
}
else {
uVar2 = (uint)*pbVar1;
*(byte **)this = pbVar1 + 1;
}
*(uint *)(this + 0x14) = uVar2;
}
if (uVar2 == 0xffffffff) {
uStack_20 = 0xffffffffffffffff;
}
else {
local_9 = (char)uVar2;
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),&local_9);
uStack_20 = (ulong)*(uint *)(this + 0x14);
if (*(uint *)(this + 0x14) == 10) {
*(long *)(this + 0x30) = *(long *)(this + 0x30) + 1;
*(int8 *)(this + 0x28) = 0;
uStack_20 = 10;
}
}
return uStack_20;
}
|
|
64,034 |
quantize_iq4_nl
|
monkey531[P]llama/ggml/src/ggml-quants.c
|
size_t quantize_iq4_nl(const float * restrict src, void * restrict dst, int64_t nrow, int64_t n_per_row, const float * quant_weights) {
GGML_ASSERT(n_per_row%QK4_NL == 0);
int64_t nblock = n_per_row/QK4_NL;
char * qrow = (char *)dst;
uint8_t L[QK4_NL];
float weight[QK4_NL];
uint16_t unused_h;
uint8_t * unused_l = NULL;
float scale;
for (int64_t row = 0; row < nrow; ++row) {
block_iq4_nl * iq4 = (block_iq4_nl *)qrow;
for (int ibl = 0; ibl < nblock; ++ibl) {
const float * qw = quant_weights ? quant_weights + QK4_NL*ibl : NULL;
quantize_row_iq4_nl_impl(QK4_NL, 32, src + QK4_NL*ibl, &iq4[ibl].d, iq4[ibl].qs, &unused_h, unused_l,
&scale, weight, L, kvalues_iq4nl, qw, 7);
}
src += n_per_row;
qrow += nblock*sizeof(block_iq4_nl);
}
return nrow * nblock * sizeof(block_iq4_nl);
}
|
O2
|
c
|
quantize_iq4_nl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
testb $0x1f, %cl
jne 0x3b6b3
movq %r8, %rbp
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rax
sarq $0x5, %rax
imulq $0x12, %rax, %r8
movq %r8, 0x18(%rsp)
xorl %r15d, %r15d
testq %rax, %rax
movl $0x0, %r9d
movq %rax, 0x8(%rsp)
cmovgq %rax, %r9
movq %r9, 0x30(%rsp)
testq %rdx, %rdx
movl $0x0, %eax
movq %rdx, 0x10(%rsp)
cmovgq %rdx, %rax
movq %rax, 0x28(%rsp)
shlq $0x2, %rcx
movq %rcx, 0x20(%rsp)
movq %r12, 0x40(%rsp)
movq %rbp, %r14
movq %r13, 0x38(%rsp)
movq 0x30(%rsp), %rbx
cmpq 0x28(%rsp), %r15
jne 0x3b670
jmp 0x3b692
testq %rbp, %rbp
movq %r14, %rax
cmoveq %rbp, %rax
leaq 0x2(%r12), %rcx
subq $0x8, %rsp
pushq $0x20
popq %rdi
movq %r13, %rsi
movq %r12, %rdx
leaq 0xe(%rsp), %r8
xorl %r9d, %r9d
pushq $0x7
pushq %rax
leaq 0x68(%rsp), %rax
pushq %rax
leaq 0x90(%rsp), %rax
pushq %rax
leaq 0x74(%rsp), %rax
pushq %rax
callq 0x3b6d4
addq $0x30, %rsp
movl $0x80, %eax
addq %rax, %r13
addq %rax, %r14
addq $0x12, %r12
subq $0x1, %rbx
jae 0x3b61c
movq 0x40(%rsp), %r12
addq 0x18(%rsp), %r12
incq %r15
movq 0x38(%rsp), %r13
addq 0x20(%rsp), %r13
jmp 0x3b601
movq 0x10(%rsp), %rax
imulq 0x8(%rsp), %rax
imulq $0x12, %rax, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e88e(%rip), %rdi # 0x59f48
leaq 0xff0c(%rip), %rdx # 0x4b5cd
leaq 0x1e991(%rip), %rcx # 0x5a059
movl $0x124d, %esi # imm = 0x124D
xorl %eax, %eax
callq 0x1e760
|
quantize_iq4_nl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
test cl, 1Fh
jnz loc_3B6B3
mov rbp, r8
mov r12, rsi
mov r13, rdi
mov rax, rcx
sar rax, 5
imul r8, rax, 12h
mov [rsp+128h+var_110], r8
xor r15d, r15d
test rax, rax
mov r9d, 0
mov [rsp+128h+var_120], rax
cmovg r9, rax
mov [rsp+128h+var_F8], r9
test rdx, rdx
mov eax, 0
mov [rsp+128h+var_118], rdx
cmovg rax, rdx
mov [rsp+128h+var_100], rax
shl rcx, 2
mov [rsp+128h+var_108], rcx
loc_3B601:
mov [rsp+128h+var_E8], r12
mov r14, rbp
mov [rsp+128h+var_F0], r13
mov rbx, [rsp+128h+var_F8]
cmp r15, [rsp+128h+var_100]
jnz short loc_3B670
jmp short loc_3B692
loc_3B61C:
test rbp, rbp
mov rax, r14
cmovz rax, rbp
lea rcx, [r12+2]
sub rsp, 8
push 20h ; ' '
pop rdi
mov rsi, r13
mov rdx, r12
lea r8, [rsp+130h+var_122]
xor r9d, r9d
push 7
push rax
lea rax, [rsp+140h+var_D8]
push rax
lea rax, [rsp+148h+var_B8]
push rax
lea rax, [rsp+150h+var_DC]
push rax
call quantize_row_iq4_nl_impl
add rsp, 30h
mov eax, 80h
add r13, rax
add r14, rax
add r12, 12h
loc_3B670:
sub rbx, 1
jnb short loc_3B61C
mov r12, [rsp+128h+var_E8]
add r12, [rsp+128h+var_110]
inc r15
mov r13, [rsp+128h+var_F0]
add r13, [rsp+128h+var_108]
jmp loc_3B601
loc_3B692:
mov rax, [rsp+128h+var_118]
imul rax, [rsp+128h+var_120]
imul rax, 12h
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3B6B3:
lea rdi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNPerRowQk4Nl0; "n_per_row%QK4_NL == 0"
mov esi, 124Dh
xor eax, eax
call _ggml_abort
|
long long quantize_iq4_nl(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v17; // r15
long long v18; // r9
long long v19; // rax
long long v20; // r14
long long v21; // rbx
long long v22; // rax
char v25; // [rsp+0h] [rbp-128h]
char v26; // [rsp+6h] [rbp-122h] BYREF
long long v27; // [rsp+8h] [rbp-120h]
long long v28; // [rsp+10h] [rbp-118h]
long long v29; // [rsp+18h] [rbp-110h]
long long i; // [rsp+20h] [rbp-108h]
long long v31; // [rsp+28h] [rbp-100h]
long long v32; // [rsp+30h] [rbp-F8h]
long long v33; // [rsp+38h] [rbp-F0h]
long long v34; // [rsp+40h] [rbp-E8h]
char v35[4]; // [rsp+4Ch] [rbp-DCh] BYREF
char v36[32]; // [rsp+50h] [rbp-D8h] BYREF
char v37[184]; // [rsp+70h] [rbp-B8h] BYREF
if ( (a4 & 0x1F) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
4685,
(long long)"GGML_ASSERT(%s) failed",
(long long)"n_per_row%QK4_NL == 0",
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v25);
v29 = 18 * (a4 >> 5);
v17 = 0LL;
v18 = 0LL;
v27 = a4 >> 5;
if ( a4 >> 5 > 0 )
v18 = a4 >> 5;
v32 = v18;
v19 = 0LL;
v28 = a3;
if ( a3 > 0 )
v19 = a3;
v31 = v19;
for ( i = 4 * a4; ; a1 = i + v33 )
{
v34 = a2;
v20 = a5;
v33 = a1;
v21 = v32;
if ( v17 == v31 )
break;
while ( v21-- != 0 )
{
v22 = v20;
if ( !a5 )
v22 = 0LL;
quantize_row_iq4_nl_impl(
32,
a1,
a2,
a2 + 2,
(unsigned int)&v26,
0,
(long long)v35,
(long long)v37,
(long long)v36,
v22,
7);
LODWORD(a1) = a1 + 128;
v20 += 128LL;
a2 += 18LL;
}
a2 = v29 + v34;
++v17;
}
return 18 * v27 * v28;
}
|
quantize_iq4_nl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
TEST CL,0x1f
JNZ 0x0013b6b3
MOV RBP,R8
MOV R12,RSI
MOV R13,RDI
MOV RAX,RCX
SAR RAX,0x5
IMUL R8,RAX,0x12
MOV qword ptr [RSP + 0x18],R8
XOR R15D,R15D
TEST RAX,RAX
MOV R9D,0x0
MOV qword ptr [RSP + 0x8],RAX
CMOVG R9,RAX
MOV qword ptr [RSP + 0x30],R9
TEST RDX,RDX
MOV EAX,0x0
MOV qword ptr [RSP + 0x10],RDX
CMOVG RAX,RDX
MOV qword ptr [RSP + 0x28],RAX
SHL RCX,0x2
MOV qword ptr [RSP + 0x20],RCX
LAB_0013b601:
MOV qword ptr [RSP + 0x40],R12
MOV R14,RBP
MOV qword ptr [RSP + 0x38],R13
MOV RBX,qword ptr [RSP + 0x30]
CMP R15,qword ptr [RSP + 0x28]
JNZ 0x0013b670
JMP 0x0013b692
LAB_0013b61c:
TEST RBP,RBP
MOV RAX,R14
CMOVZ RAX,RBP
LEA RCX,[R12 + 0x2]
SUB RSP,0x8
PUSH 0x20
POP RDI
MOV RSI,R13
MOV RDX,R12
LEA R8,[RSP + 0xe]
XOR R9D,R9D
PUSH 0x7
PUSH RAX
LEA RAX,[RSP + 0x68]
PUSH RAX
LEA RAX,[RSP + 0x90]
PUSH RAX
LEA RAX,[RSP + 0x74]
PUSH RAX
CALL 0x0013b6d4
ADD RSP,0x30
MOV EAX,0x80
ADD R13,RAX
ADD R14,RAX
ADD R12,0x12
LAB_0013b670:
SUB RBX,0x1
JNC 0x0013b61c
MOV R12,qword ptr [RSP + 0x40]
ADD R12,qword ptr [RSP + 0x18]
INC R15
MOV R13,qword ptr [RSP + 0x38]
ADD R13,qword ptr [RSP + 0x20]
JMP 0x0013b601
LAB_0013b692:
MOV RAX,qword ptr [RSP + 0x10]
IMUL RAX,qword ptr [RSP + 0x8]
IMUL RAX,RAX,0x12
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013b6b3:
LEA RDI,[0x159f48]
LEA RDX,[0x14b5cd]
LEA RCX,[0x15a059]
MOV ESI,0x124d
XOR EAX,EAX
CALL 0x0011e760
|
long quantize_iq4_nl(long param_1,long param_2,long param_3,ulong param_4,long param_5)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
bool bVar5;
int1 local_122 [2];
long local_120;
long local_118;
long local_110;
long local_108;
long local_100;
long local_f8;
long local_f0;
long local_e8;
int1 local_dc [4];
int1 local_d8 [32];
int1 local_b8 [136];
if ((param_4 & 0x1f) == 0) {
local_120 = (long)param_4 >> 5;
local_110 = local_120 * 0x12;
lVar4 = 0;
local_f8 = 0;
if (0 < local_120) {
local_f8 = local_120;
}
local_100 = 0;
if (0 < param_3) {
local_100 = param_3;
}
local_108 = param_4 << 2;
local_118 = param_3;
while( true ) {
lVar2 = local_f8;
lVar3 = param_5;
local_f0 = param_1;
local_e8 = param_2;
if (lVar4 == local_100) break;
while (bVar5 = lVar2 != 0, lVar2 = lVar2 + -1, bVar5) {
lVar1 = lVar3;
if (param_5 == 0) {
lVar1 = param_5;
}
quantize_row_iq4_nl_impl
(0x20,param_1,param_2,param_2 + 2,local_122,0,local_dc,local_b8,local_d8,lVar1,7);
param_1 = param_1 + 0x80;
lVar3 = lVar3 + 0x80;
param_2 = param_2 + 0x12;
}
param_2 = local_e8 + local_110;
lVar4 = lVar4 + 1;
param_1 = local_f0 + local_108;
}
return local_118 * local_120 * 0x12;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-quants.c",
0x124d,"GGML_ASSERT(%s) failed","n_per_row%QK4_NL == 0");
}
|
|
64,035 |
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<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>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>, 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&, 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>>>&)
|
monkey531[P]llama/common/json.hpp
|
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
}
from_json_array_impl(j, arr, priority_tag<3> {});
}
|
O1
|
cpp
|
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<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>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>, 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&, 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>>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0xc754d
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc766e
movl $0x20, %edi
callq 0x1b460
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f2f6
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x303f3(%rip), %rsi # 0xf7964
leaq 0x10(%rsp), %rdi
callq 0xc75e6
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x876b2
xorl %ebp, %ebp
leaq 0x6597c(%rip), %rsi # 0x12cf18
leaq -0x6c16b(%rip), %rdx # 0x5b438
movq %rbx, %rdi
callq 0x1bf30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc75d1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0xc75d1
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xc75de
movq %rbx, %rdi
callq 0x1b690
movq %r14, %rdi
callq 0x1bfd0
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_C754D
mov rax, [r14+8]
mov rdi, rsi
mov rsi, rax
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEaSERKSF_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator=(std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
loc_C754D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeArra; "type must be array, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA28_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(char const(&)[28],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C75D1
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C75D1
mov r14, rax
mov bpl, 1
loc_C75D1:
test bpl, bpl
jz short loc_C75DE
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C75DE:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(
v4,
"type must be array, but is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator=(
a2,
*(_QWORD *)(a1 + 8));
}
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x001c754d
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RSI
MOV RSI,RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001c766e
LAB_001c754d:
MOV EDI,0x20
CALL 0x0011b460
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f2f6
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001c756a:
LEA RSI,[0x1f7964]
LEA RDI,[RSP + 0x10]
CALL 0x001c75e6
MOV BPL,0x1
LAB_001c757e:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001876b2
XOR EBP,EBP
LEA RSI,[0x22cf18]
LEA RDX,[0x15b438]
MOV RDI,RBX
CALL 0x0011bf30
|
void _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,
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>>>
*param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 ==
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
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>>>
::operator=(param_2,*(vector **)(param_1 + 8));
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)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>
::type_name(param_1);
/* try { // try from 001c756a to 001c757a has its CatchHandler @ 001c75cb */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[28],char_const*>
(local_38,"type must be array, but is ",&local_40);
/* try { // try from 001c757e to 001c75aa has its CatchHandler @ 001c75ab */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
64,036 |
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<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>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>, 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&, 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>>>&)
|
monkey531[P]llama/common/json.hpp
|
auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
{
JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
}
from_json_array_impl(j, arr, priority_tag<3> {});
}
|
O3
|
cpp
|
decltype(from_json_array_impl(fp, fp0, nlohmann::json_abi_v3_11_3::detail::priority_tag<3u>{}), fp.get<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>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, 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>>>, 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&, 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>>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0xc5ac7
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc5be6
movl $0x20, %edi
callq 0x1a460
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e9cc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x2ee69(%rip), %rsi # 0xf4954
leaq 0x10(%rsp), %rdi
callq 0xc5b5d
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x861ba
xorl %ebp, %ebp
leaq 0x64442(%rip), %rsi # 0x129f58
leaq -0x6af1b(%rip), %rdx # 0x5ac02
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc5b43
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a8f0
testb %bpl, %bpl
jne 0xc5b4d
jmp 0xc5b55
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
movq %r14, %rdi
callq 0x1afd0
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_C5AC7
mov rax, [r14+8]
mov rdi, rsi
mov rsi, rax
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEaSERKSF_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator=(std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
loc_C5AC7:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeArra; "type must be array, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA28_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(char const(&)[28],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C5B43
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C5B43:
test bpl, bpl
jnz short loc_C5B4D
jmp short loc_C5B55
mov r14, rax
loc_C5B4D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C5B55:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[28],char const*>(
v4,
"type must be array, but is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator=(
a2,
*(_QWORD *)(a1 + 8));
}
|
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x001c5ac7
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RSI
MOV RSI,RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x001c5be6
LAB_001c5ac7:
MOV EDI,0x20
CALL 0x0011a460
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015e9cc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001c5ae4:
LEA RSI,[0x1f4954]
LEA RDI,[RSP + 0x10]
CALL 0x001c5b5d
MOV BPL,0x1
LAB_001c5af8:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001861ba
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15ac02]
MOV RDI,RBX
CALL 0x0011af30
|
void _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISF_SaISF_EETnNSt9enable_ifIXaaaaaaaasr27is_constructible_array_typeIT_T0_EE5valuentsr28is_constructible_object_typeISJ_SK_EE5valuentsr28is_constructible_string_typeISJ_SK_EE5valuentsr3std7is_sameISK_NSJ_8binary_tEEE5valuentsr13is_basic_jsonISK_EE5valueEiE4typeELi0EEEDTcmcmcl20from_json_array_implfp_fp0_tlNS1_12priority_tagILj3EEEEEcldtfp_3getINSK_10value_typeEEEcvv_EERKSJ_RSK_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,
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>>>
*param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 ==
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
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>>>
::operator=(param_2,*(vector **)(param_1 + 8));
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)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>
::type_name(param_1);
/* try { // try from 001c5ae4 to 001c5af4 has its CatchHandler @ 001c5b4a */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[28],char_const*>
(local_38,"type must be array, but is ",&local_40);
/* try { // try from 001c5af8 to 001c5b24 has its CatchHandler @ 001c5b25 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
|
|
64,037 |
my_init
|
eloqsql/mysys/my_init.c
|
my_bool my_init(void)
{
char *str;
if (my_init_done)
return 0;
my_init_done= 1;
mysys_usage_id++;
my_umask= 0660; /* Default umask for new files */
my_umask_dir= 0700; /* Default umask for new directories */
my_global_flags= 0;
/* Default creation of new files */
if ((str= getenv("UMASK")) != 0)
my_umask= (int) (atoi_octal(str) | 0600);
/* Default creation of new dir's */
if ((str= getenv("UMASK_DIR")) != 0)
my_umask_dir= (int) (atoi_octal(str) | 0700);
init_glob_errs();
instrumented_stdin.m_file= stdin;
instrumented_stdin.m_psi= NULL; /* not yet instrumented */
mysql_stdin= & instrumented_stdin;
my_progname_short= "unknown";
if (my_progname)
my_progname_short= my_progname + dirname_length(my_progname);
/* Initialize our mutex handling */
my_mutex_init();
if (my_thread_global_init())
return 1;
#if defined(SAFEMALLOC) && !defined(DBUG_OFF)
dbug_sanity= sf_sanity;
#endif
/* $HOME is needed early to parse configuration files located in ~/ */
if ((home_dir= getenv("HOME")) != 0)
home_dir= intern_filename(home_dir_buff, home_dir);
{
DBUG_ENTER("my_init");
DBUG_PROCESS((char*) (my_progname ? my_progname : "unknown"));
my_time_init();
my_win_init();
DBUG_PRINT("exit", ("home: '%s'", home_dir));
#ifdef _WIN32
if (win32_init_tcp_ip())
DBUG_RETURN(1);
#endif
#ifdef CHECK_UNLIKELY
init_my_likely();
#endif
DBUG_RETURN(0);
}
}
|
O0
|
c
|
my_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xb8e121(%rip), %rax # 0xc4b610
cmpb $0x0, (%rax)
je 0xbd4fd
movb $0x0, -0x1(%rbp)
jmp 0xbd686
leaq 0xb8e10c(%rip), %rax # 0xc4b610
movb $0x1, (%rax)
leaq 0xb8e106(%rip), %rax # 0xc4b614
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xb8e0fa(%rip), %rax # 0xc4b614
movl %ecx, (%rax)
leaq 0x1cb885(%rip), %rax # 0x288da8
movl $0x1b0, (%rax) # imm = 0x1B0
leaq 0x1cb87c(%rip), %rax # 0x288dac
movl $0x1c0, (%rax) # imm = 0x1C0
leaq 0xb8e5ab(%rip), %rax # 0xc4bae8
movq $0x0, (%rax)
leaq 0x63beb(%rip), %rdi # 0x121136
callq 0x276b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xbd574
movq -0x10(%rbp), %rdi
callq 0xbd690
orq $0x180, %rax # imm = 0x180
movl %eax, %ecx
leaq 0x1cb836(%rip), %rax # 0x288da8
movl %ecx, (%rax)
leaq 0x63bc1(%rip), %rdi # 0x12113c
callq 0x276b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xbd5a4
movq -0x10(%rbp), %rdi
callq 0xbd690
orq $0x1c0, %rax # imm = 0x1C0
movl %eax, %ecx
leaq 0x1cb80a(%rip), %rax # 0x288dac
movl %ecx, (%rax)
callq 0xcdac0
movq 0x1c9a38(%rip), %rax # 0x286fe8
movq (%rax), %rax
movq %rax, 0xb8e066(%rip) # 0xc4b620
movq $0x0, 0xb8e063(%rip) # 0xc4b628
leaq 0xb8e04c(%rip), %rax # 0xc4b618
leaq 0xb8e04d(%rip), %rcx # 0xc4b620
movq %rcx, (%rax)
leaq 0xb8e0eb(%rip), %rax # 0xc4b6c8
leaq 0x63b62(%rip), %rcx # 0x121146
movq %rcx, (%rax)
leaq 0xb8e0d2(%rip), %rax # 0xc4b6c0
cmpq $0x0, (%rax)
je 0xbd622
leaq 0xb8e0c5(%rip), %rax # 0xc4b6c0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0xb8e0b7(%rip), %rax # 0xc4b6c0
movq (%rax), %rdi
callq 0xae700
movq -0x18(%rbp), %rcx
addq %rax, %rcx
leaq 0xb8e0a9(%rip), %rax # 0xc4b6c8
movq %rcx, (%rax)
callq 0xc4350
callq 0xc0e20
cmpb $0x0, %al
je 0xbd636
movb $0x1, -0x1(%rbp)
jmp 0xbd686
leaq 0x63360(%rip), %rdi # 0x12099d
callq 0x276b0
leaq 0xb8e06f(%rip), %rcx # 0xc4b6b8
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0xbd675
leaq 0xb8e05f(%rip), %rax # 0xc4b6b8
movq (%rax), %rsi
leaq 0xb8e26d(%rip), %rdi # 0xc4b8d0
callq 0xb2780
movq %rax, %rcx
leaq 0xb8e046(%rip), %rax # 0xc4b6b8
movq %rcx, (%rax)
jmp 0xbd677
jmp 0xbd679
callq 0xbaec0
jmp 0xbd680
jmp 0xbd682
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
|
my_init:
push rbp
mov rbp, rsp
sub rsp, 20h
lea rax, my_init_done
cmp byte ptr [rax], 0
jz short loc_BD4FD
mov [rbp+var_1], 0
jmp loc_BD686
loc_BD4FD:
lea rax, my_init_done
mov byte ptr [rax], 1
lea rax, mysys_usage_id
mov ecx, [rax]
add ecx, 1
lea rax, mysys_usage_id
mov [rax], ecx
lea rax, my_umask
mov dword ptr [rax], 1B0h
lea rax, my_umask_dir
mov dword ptr [rax], 1C0h
lea rax, my_global_flags
mov qword ptr [rax], 0
lea rdi, aUmask; "UMASK"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_BD574
mov rdi, [rbp+var_10]
call atoi_octal
or rax, 180h
mov ecx, eax
lea rax, my_umask
mov [rax], ecx
loc_BD574:
lea rdi, aUmaskDir; "UMASK_DIR"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_BD5A4
mov rdi, [rbp+var_10]
call atoi_octal
or rax, 1C0h
mov ecx, eax
lea rax, my_umask_dir
mov [rax], ecx
loc_BD5A4:
call init_glob_errs
mov rax, cs:stdin_ptr
mov rax, [rax]
mov cs:instrumented_stdin, rax
mov cs:qword_C4B628, 0
lea rax, mysql_stdin
lea rcx, instrumented_stdin
mov [rax], rcx
lea rax, my_progname_short
lea rcx, aUnknown_1; "unknown"
mov [rax], rcx
lea rax, my_progname
cmp qword ptr [rax], 0
jz short loc_BD622
lea rax, my_progname
mov rax, [rax]
mov [rbp+var_18], rax
lea rax, my_progname
mov rdi, [rax]
call dirname_length
mov rcx, [rbp+var_18]
add rcx, rax
lea rax, my_progname_short
mov [rax], rcx
loc_BD622:
call my_mutex_init
call my_thread_global_init
cmp al, 0
jz short loc_BD636
mov [rbp+var_1], 1
jmp short loc_BD686
loc_BD636:
lea rdi, aMariadbHome+8; "HOME"
call _getenv
lea rcx, home_dir
mov [rcx], rax
cmp rax, 0
jz short loc_BD675
lea rax, home_dir
mov rsi, [rax]
lea rdi, home_dir_buff
call intern_filename
mov rcx, rax
lea rax, home_dir
mov [rax], rcx
loc_BD675:
jmp short $+2
loc_BD677:
jmp short $+2
loc_BD679:
call my_time_init
jmp short $+2
loc_BD680:
jmp short $+2
loc_BD682:
mov [rbp+var_1], 0
loc_BD686:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char my_init()
{
_BYTE *v1; // [rsp+8h] [rbp-18h]
long long v2; // [rsp+10h] [rbp-10h]
long long v3; // [rsp+10h] [rbp-10h]
if ( my_init_done )
return 0;
my_init_done = 1;
++mysys_usage_id;
my_umask = 432;
my_umask_dir = 448;
my_global_flags = 0LL;
v2 = getenv("UMASK");
if ( v2 )
my_umask = atoi_octal(v2) | 0x180;
v3 = getenv("UMASK_DIR");
if ( v3 )
my_umask_dir = atoi_octal(v3) | 0x1C0;
init_glob_errs();
instrumented_stdin = stdin;
qword_C4B628 = 0LL;
mysql_stdin = &instrumented_stdin;
my_progname_short = "unknown";
if ( my_progname )
{
v1 = my_progname;
my_progname_short = &v1[dirname_length(my_progname)];
}
my_mutex_init();
if ( (unsigned __int8)my_thread_global_init() )
return 1;
home_dir = (_BYTE *)getenv("HOME");
if ( home_dir )
home_dir = (_BYTE *)intern_filename((long long)&home_dir_buff, home_dir);
my_time_init();
return 0;
}
|
my_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
LEA RAX,[0xd4b610]
CMP byte ptr [RAX],0x0
JZ 0x001bd4fd
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001bd686
LAB_001bd4fd:
LEA RAX,[0xd4b610]
MOV byte ptr [RAX],0x1
LEA RAX,[0xd4b614]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0xd4b614]
MOV dword ptr [RAX],ECX
LEA RAX,[0x388da8]
MOV dword ptr [RAX],0x1b0
LEA RAX,[0x388dac]
MOV dword ptr [RAX],0x1c0
LEA RAX,[0xd4bae8]
MOV qword ptr [RAX],0x0
LEA RDI,[0x221136]
CALL 0x001276b0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x001bd574
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bd690
OR RAX,0x180
MOV ECX,EAX
LEA RAX,[0x388da8]
MOV dword ptr [RAX],ECX
LAB_001bd574:
LEA RDI,[0x22113c]
CALL 0x001276b0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x001bd5a4
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bd690
OR RAX,0x1c0
MOV ECX,EAX
LEA RAX,[0x388dac]
MOV dword ptr [RAX],ECX
LAB_001bd5a4:
CALL 0x001cdac0
MOV RAX,qword ptr [0x00386fe8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x00d4b620],RAX
MOV qword ptr [0x00d4b628],0x0
LEA RAX,[0xd4b618]
LEA RCX,[0xd4b620]
MOV qword ptr [RAX],RCX
LEA RAX,[0xd4b6c8]
LEA RCX,[0x221146]
MOV qword ptr [RAX],RCX
LEA RAX,[0xd4b6c0]
CMP qword ptr [RAX],0x0
JZ 0x001bd622
LEA RAX,[0xd4b6c0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0xd4b6c0]
MOV RDI,qword ptr [RAX]
CALL 0x001ae700
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,RAX
LEA RAX,[0xd4b6c8]
MOV qword ptr [RAX],RCX
LAB_001bd622:
CALL 0x001c4350
CALL 0x001c0e20
CMP AL,0x0
JZ 0x001bd636
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001bd686
LAB_001bd636:
LEA RDI,[0x22099d]
CALL 0x001276b0
LEA RCX,[0xd4b6b8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x001bd675
LEA RAX,[0xd4b6b8]
MOV RSI,qword ptr [RAX]
LEA RDI,[0xd4b8d0]
CALL 0x001b2780
MOV RCX,RAX
LEA RAX,[0xd4b6b8]
MOV qword ptr [RAX],RCX
LAB_001bd675:
JMP 0x001bd677
LAB_001bd677:
JMP 0x001bd679
LAB_001bd679:
CALL 0x001baec0
JMP 0x001bd680
LAB_001bd680:
JMP 0x001bd682
LAB_001bd682:
MOV byte ptr [RBP + -0x1],0x0
LAB_001bd686:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_init(void)
{
long lVar1;
char cVar2;
uint uVar3;
char *pcVar4;
long lVar5;
int1 local_9;
if (my_init_done == '\0') {
my_init_done = '\x01';
mysys_usage_id = mysys_usage_id + 1;
my_umask = 0x1b0;
my_umask_dir = 0x1c0;
my_global_flags = 0;
pcVar4 = getenv("UMASK");
if (pcVar4 != (char *)0x0) {
uVar3 = atoi_octal(pcVar4);
my_umask = uVar3 | 0x180;
}
pcVar4 = getenv("UMASK_DIR");
if (pcVar4 != (char *)0x0) {
uVar3 = atoi_octal(pcVar4);
my_umask_dir = uVar3 | 0x1c0;
}
init_glob_errs();
lVar1 = my_progname;
instrumented_stdin._0_8_ = *(int8 *)PTR_stdin_00386fe8;
instrumented_stdin._8_8_ = 0;
mysql_stdin = instrumented_stdin;
my_progname_short = "unknown";
if (my_progname != 0) {
lVar5 = dirname_length(my_progname);
my_progname_short = (char *)(lVar1 + lVar5);
}
my_mutex_init();
cVar2 = my_thread_global_init();
if (cVar2 == '\0') {
home_dir = getenv("HOME");
if (home_dir != (char *)0x0) {
home_dir = (char *)intern_filename(home_dir_buff,home_dir);
}
my_time_init();
local_9 = 0;
}
else {
local_9 = 1;
}
}
else {
local_9 = 0;
}
return local_9;
}
|
|
64,038 |
getopt_ull
|
eloqsql/mysys/my_getopt.c
|
static ulonglong getopt_ull(char *arg, const struct my_option *optp, int *err)
{
ulonglong num= eval_num_suffix_ull(arg, err, (char*) optp->name);
return getopt_ull_limit_value(num, optp, NULL);
}
|
O3
|
c
|
getopt_ull:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rcx
cmpb $0x2d, (%rdi)
jne 0x839af
leaq 0x2ebdc2(%rip), %r8 # 0x36f760
leaq 0x3d3c2(%rip), %rsi # 0xc0d67
xorl %r13d, %r13d
xorl %edi, %edi
movq %r15, %rdx
jmp 0x839f7
movq %rcx, -0x30(%rbp)
xorl %r14d, %r14d
movl %r14d, (%r12)
callq 0x3ab70
movq %rax, %r13
movl %r14d, (%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
movl $0xa, %edx
callq 0x3a0b0
cmpl $0x22, (%r13)
jne 0x83a20
leaq 0x2ebd7c(%rip), %r8 # 0x36f760
leaq 0x3d3a2(%rip), %rsi # 0xc0d8d
xorl %r13d, %r13d
xorl %edi, %edi
movq %r15, %rdx
movq -0x30(%rbp), %rcx
xorl %eax, %eax
callq *(%r8)
movl $0x1, (%r12)
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x82cc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rdx
movb (%rdx), %cl
movzbl %cl, %esi
cmpl $0x53, %esi
jle 0x83a46
leal -0x65(%rsi), %edi
cmpl $0xb, %edi
ja 0x83a6a
leaq 0x40f9b(%rip), %rsi # 0xc49d8
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
leal -0x45(%rsi), %edi
cmpl $0xb, %edi
ja 0x83aa4
leaq 0x40f53(%rip), %rsi # 0xc49a8
movslq (%rsi,%rdi,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
movabsq $0x1000000000000000, %r13 # imm = 0x1000000000000000
jmp 0x83aae
cmpl $0x54, %esi
je 0x83a74
cmpl $0x74, %esi
jne 0x83ae1
movabsq $0x10000000000, %r13 # imm = 0x10000000000
jmp 0x83aae
movabsq $0x4000000000000, %r13 # imm = 0x4000000000000
jmp 0x83aae
movl $0x400, %r13d # imm = 0x400
jmp 0x83aae
movl $0x40000000, %r13d # imm = 0x40000000
jmp 0x83aae
movl $0x100000, %r13d # imm = 0x100000
jmp 0x83aae
movl $0x1, %r13d
testl %esi, %esi
jne 0x83ae1
imulq %rax, %r13
cmpl $0x0, (%r12)
je 0x83a04
leaq 0x2ebc9c(%rip), %r9 # 0x36f760
movsbl %cl, %edx
leaq 0x3d2e4(%rip), %rsi # 0xc0db2
xorl %edi, %edi
movq -0x30(%rbp), %rcx
movq %r15, %r8
xorl %eax, %eax
callq *(%r9)
jmp 0x83a04
movl $0x1, (%r12)
movb (%rdx), %cl
xorl %r13d, %r13d
jmp 0x83abd
|
getopt_ull:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov rbx, rsi
mov r15, rdi
mov rcx, [rsi]
cmp byte ptr [rdi], 2Dh ; '-'
jnz short loc_839AF
lea r8, my_getopt_error_reporter
lea rsi, aIncorrectUnsig; "Incorrect unsigned value: '%s' for %s"
xor r13d, r13d
xor edi, edi
mov rdx, r15
jmp short loc_839F7
loc_839AF:
mov [rbp+var_30], rcx
xor r14d, r14d
mov [r12], r14d
call ___errno_location
mov r13, rax
mov [rax], r14d
lea rsi, [rbp+var_38]
mov rdi, r15
mov edx, 0Ah
call ___isoc23_strtoul
cmp dword ptr [r13+0], 22h ; '"'
jnz short loc_83A20
lea r8, my_getopt_error_reporter
lea rsi, aIncorrectInteg_0; "Incorrect integer value: '%s' for %s"
xor r13d, r13d
xor edi, edi
mov rdx, r15
mov rcx, [rbp+var_30]
loc_839F7:
xor eax, eax
call qword ptr [r8]
mov dword ptr [r12], 1
loc_83A04:
mov rdi, r13
mov rsi, rbx
xor edx, edx
call getopt_ull_limit_value
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83A20:
mov rdx, [rbp+var_38]
mov cl, [rdx]
movzx esi, cl
cmp esi, 53h ; 'S'
jle short loc_83A46
lea edi, [rsi-65h]; switch 12 cases
cmp edi, 0Bh
ja short def_83A44; jumptable 0000000000083A44 default case
lea rsi, jpt_83A44
movsxd rdi, ds:(jpt_83A44 - 0C49D8h)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_83A46:
lea edi, [rsi-45h]; switch 12 cases
cmp edi, 0Bh
ja short def_83A5C; jumptable 0000000000083A5C default case
lea rsi, jpt_83A5C
movsxd rdi, ds:(jpt_83A5C - 0C49A8h)[rsi+rdi*4]
add rdi, rsi
jmp rdi; switch jump
loc_83A5E:
mov r13, 1000000000000000h; jumptable 0000000000083A44 case 101
jmp short loc_83AAE
def_83A44:
cmp esi, 54h ; 'T'; jumptable 0000000000083A44 default case
jz short loc_83A74
cmp esi, 74h ; 't'
jnz short loc_83AE1; jumptable 0000000000083A44 cases 102,104-106,108,110,111
loc_83A74:
mov r13, 10000000000h
jmp short loc_83AAE
loc_83A80:
mov r13, 4000000000000h; jumptable 0000000000083A44 case 112
jmp short loc_83AAE
loc_83A8C:
mov r13d, 400h; jumptable 0000000000083A44 case 107
jmp short loc_83AAE
loc_83A94:
mov r13d, 40000000h; jumptable 0000000000083A44 case 103
jmp short loc_83AAE
loc_83A9C:
mov r13d, offset unk_100000; jumptable 0000000000083A44 case 109
jmp short loc_83AAE
def_83A5C:
mov r13d, 1; jumptable 0000000000083A5C default case
test esi, esi
jnz short loc_83AE1; jumptable 0000000000083A44 cases 102,104-106,108,110,111
loc_83AAE:
imul r13, rax
cmp dword ptr [r12], 0
jz loc_83A04
loc_83ABD:
lea r9, my_getopt_error_reporter
movsx edx, cl
lea rsi, aUnknownSuffixC_0; "Unknown suffix '%c' used for variable '"...
xor edi, edi
mov rcx, [rbp+var_30]
mov r8, r15
xor eax, eax
call qword ptr [r9]
jmp loc_83A04
loc_83AE1:
mov dword ptr [r12], 1; jumptable 0000000000083A44 cases 102,104-106,108,110,111
mov cl, [rdx]
xor r13d, r13d
jmp short loc_83ABD
|
unsigned long long getopt_ull(const char *a1, _QWORD *a2, _DWORD *a3)
{
unsigned long long v5; // r13
_DWORD *v6; // r13
long long v7; // rax
char *v9; // rdx
char v10; // cl
unsigned int v11; // esi
long long v12; // r13
char *v13; // [rsp+8h] [rbp-38h] BYREF
const char *v14; // [rsp+10h] [rbp-30h]
if ( *a1 == 45 )
{
v5 = 0LL;
my_getopt_error_reporter(0, "Incorrect unsigned value: '%s' for %s", a1, *a2);
LABEL_5:
*a3 = 1;
return getopt_ull_limit_value(v5, (long long)a2, 0LL);
}
v14 = (const char *)*a2;
*a3 = 0;
v6 = (_DWORD *)__errno_location(a1);
*v6 = 0;
v7 = __isoc23_strtoul(a1, &v13, 10LL);
if ( *v6 == 34 )
{
v5 = 0LL;
my_getopt_error_reporter(0, "Incorrect integer value: '%s' for %s", a1, v14);
goto LABEL_5;
}
v9 = v13;
v10 = *v13;
v11 = (unsigned __int8)*v13;
if ( v11 <= 0x53 )
{
switch ( *v13 )
{
case 'E':
LABEL_10:
v12 = 0x1000000000000000LL;
goto LABEL_19;
case 'F':
case 'H':
case 'I':
case 'J':
case 'L':
case 'N':
case 'O':
break;
case 'G':
LABEL_16:
v12 = 0x40000000LL;
goto LABEL_19;
case 'K':
LABEL_15:
v12 = 1024LL;
goto LABEL_19;
case 'M':
LABEL_17:
v12 = (long long)&unk_100000;
goto LABEL_19;
case 'P':
LABEL_14:
v12 = 0x4000000000000LL;
goto LABEL_19;
default:
v12 = 1LL;
if ( !*v13 )
goto LABEL_19;
break;
}
LABEL_21:
*a3 = 1;
v10 = *v9;
v5 = 0LL;
goto LABEL_20;
}
switch ( *v13 )
{
case 'e':
goto LABEL_10;
case 'f':
case 'h':
case 'i':
case 'j':
case 'l':
case 'n':
case 'o':
goto LABEL_21;
case 'g':
goto LABEL_16;
case 'k':
goto LABEL_15;
case 'm':
goto LABEL_17;
case 'p':
goto LABEL_14;
default:
if ( v11 != 84 && v11 != 116 )
goto LABEL_21;
v12 = 0x10000000000LL;
break;
}
LABEL_19:
v5 = v7 * v12;
if ( *a3 )
LABEL_20:
my_getopt_error_reporter(0, "Unknown suffix '%c' used for variable '%s' (value '%s')", (unsigned int)v10, v14, a1);
return getopt_ull_limit_value(v5, (long long)a2, 0LL);
}
|
getopt_ull:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RCX,qword ptr [RSI]
CMP byte ptr [RDI],0x2d
JNZ 0x001839af
LEA R8,[0x46f760]
LEA RSI,[0x1c0d67]
XOR R13D,R13D
XOR EDI,EDI
MOV RDX,R15
JMP 0x001839f7
LAB_001839af:
MOV qword ptr [RBP + -0x30],RCX
XOR R14D,R14D
MOV dword ptr [R12],R14D
CALL 0x0013ab70
MOV R13,RAX
MOV dword ptr [RAX],R14D
LEA RSI,[RBP + -0x38]
MOV RDI,R15
MOV EDX,0xa
CALL 0x0013a0b0
CMP dword ptr [R13],0x22
JNZ 0x00183a20
LEA R8,[0x46f760]
LEA RSI,[0x1c0d8d]
XOR R13D,R13D
XOR EDI,EDI
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x30]
LAB_001839f7:
XOR EAX,EAX
CALL qword ptr [R8]
MOV dword ptr [R12],0x1
LAB_00183a04:
MOV RDI,R13
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00182cc0
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183a20:
MOV RDX,qword ptr [RBP + -0x38]
MOV CL,byte ptr [RDX]
MOVZX ESI,CL
CMP ESI,0x53
JLE 0x00183a46
LEA EDI,[RSI + -0x65]
CMP EDI,0xb
JA 0x00183a6a
LEA RSI,[0x1c49d8]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
LAB_00183a46:
LEA EDI,[RSI + -0x45]
CMP EDI,0xb
JA 0x00183aa4
LEA RSI,[0x1c49a8]
MOVSXD RDI,dword ptr [RSI + RDI*0x4]
ADD RDI,RSI
switchD:
JMP RDI
caseD_65:
MOV R13,0x1000000000000000
JMP 0x00183aae
default:
CMP ESI,0x54
JZ 0x00183a74
CMP ESI,0x74
JNZ 0x00183ae1
LAB_00183a74:
MOV R13,0x10000000000
JMP 0x00183aae
caseD_70:
MOV R13,0x4000000000000
JMP 0x00183aae
caseD_6b:
MOV R13D,0x400
JMP 0x00183aae
caseD_67:
MOV R13D,0x40000000
JMP 0x00183aae
caseD_6d:
MOV R13D,0x100000
JMP 0x00183aae
default:
MOV R13D,0x1
TEST ESI,ESI
JNZ 0x00183ae1
LAB_00183aae:
IMUL R13,RAX
CMP dword ptr [R12],0x0
JZ 0x00183a04
LAB_00183abd:
LEA R9,[0x46f760]
MOVSX EDX,CL
LEA RSI,[0x1c0db2]
XOR EDI,EDI
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,R15
XOR EAX,EAX
CALL qword ptr [R9]
JMP 0x00183a04
caseD_66:
MOV dword ptr [R12],0x1
MOV CL,byte ptr [RDX]
XOR R13D,R13D
JMP 0x00183abd
|
void getopt_ull(char *param_1,int8 *param_2,int *param_3)
{
int *piVar1;
long lVar2;
byte bVar3;
int8 uVar4;
char *pcVar5;
long lVar6;
byte *local_40;
int8 local_38;
uVar4 = *param_2;
if (*param_1 == '-') {
pcVar5 = "Incorrect unsigned value: \'%s\' for %s";
}
else {
*param_3 = 0;
local_38 = uVar4;
piVar1 = __errno_location();
*piVar1 = 0;
lVar2 = __isoc23_strtoul(param_1,&local_40,10);
if (*piVar1 != 0x22) {
bVar3 = *local_40;
if (bVar3 < 0x54) {
switch(bVar3) {
case 0x45:
goto switchD_00183a44_caseD_65;
case 0x46:
case 0x48:
case 0x49:
case 0x4a:
case 0x4c:
case 0x4e:
case 0x4f:
break;
case 0x47:
goto switchD_00183a44_caseD_67;
case 0x4b:
goto switchD_00183a44_caseD_6b;
case 0x4d:
goto switchD_00183a44_caseD_6d;
case 0x50:
goto switchD_00183a44_caseD_70;
default:
lVar6 = 1;
if (bVar3 == 0) goto LAB_00183aae;
}
switchD_00183a44_caseD_66:
*param_3 = 1;
bVar3 = *local_40;
lVar6 = 0;
}
else {
switch(bVar3) {
case 0x65:
switchD_00183a44_caseD_65:
lVar6 = 0x1000000000000000;
break;
case 0x66:
case 0x68:
case 0x69:
case 0x6a:
case 0x6c:
case 0x6e:
case 0x6f:
goto switchD_00183a44_caseD_66;
case 0x67:
switchD_00183a44_caseD_67:
lVar6 = 0x40000000;
break;
case 0x6b:
switchD_00183a44_caseD_6b:
lVar6 = 0x400;
break;
case 0x6d:
switchD_00183a44_caseD_6d:
lVar6 = 0x100000;
break;
case 0x70:
switchD_00183a44_caseD_70:
lVar6 = 0x4000000000000;
break;
default:
if ((bVar3 != 0x54) && (bVar3 != 0x74)) goto switchD_00183a44_caseD_66;
lVar6 = 0x10000000000;
}
LAB_00183aae:
lVar6 = lVar6 * lVar2;
if (*param_3 == 0) goto LAB_00183a04;
}
(*(code *)my_getopt_error_reporter)
(0,"Unknown suffix \'%c\' used for variable \'%s\' (value \'%s\')",(int)(char)bVar3,
local_38,param_1);
goto LAB_00183a04;
}
pcVar5 = "Incorrect integer value: \'%s\' for %s";
uVar4 = local_38;
}
lVar6 = 0;
(*(code *)my_getopt_error_reporter)(0,pcVar5,param_1,uVar4);
*param_3 = 1;
LAB_00183a04:
getopt_ull_limit_value(lVar6,param_2,0);
return;
}
|
|
64,039 |
minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&)
|
monkey531[P]llama/common/minja.hpp
|
CallExpr(const Location & location, std::shared_ptr<Expression> && obj, ArgumentsExpression && a)
: Expression(location), object(std::move(obj)), args(std::move(a)) {}
|
O2
|
cpp
|
minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x60e0a
leaq 0x6ff2a(%rip), %rax # 0xd8cf0
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6689a
|
_ZN5minja8CallExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEEONS_19ArgumentsExpressionE:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
mov r15, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja8CallExprE; `vtable for'minja::CallExpr
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
add r15, 30h ; '0'
mov rdi, r15
mov rsi, rbx
pop rbx
pop r14
pop r15
jmp _ZN5minja19ArgumentsExpressionC2EOS0_; minja::ArgumentsExpression::ArgumentsExpression(minja::ArgumentsExpression&&)
|
long long minja::CallExpr::CallExpr(long long a1, _QWORD *a2, __int128 *a3, long long a4)
{
__int128 v6; // xmm0
minja::Expression::Expression((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::CallExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
return minja::ArgumentsExpression::ArgumentsExpression(a1 + 48, a4);
}
|
CallExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
CALL 0x00160e0a
LEA RAX,[0x1d8cf0]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
ADD R15,0x30
MOV RDI,R15
MOV RSI,RBX
POP RBX
POP R14
POP R15
JMP 0x0016689a
|
/* minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::ArgumentsExpression&&) */
void __thiscall
minja::CallExpr::CallExpr
(CallExpr *this,Location *param_1,shared_ptr *param_2,ArgumentsExpression *param_3)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_001d8d00;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
ArgumentsExpression::ArgumentsExpression((ArgumentsExpression *)(this + 0x30),param_3);
return;
}
|
|
64,040 |
rw_pr_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
}
|
O3
|
c
|
rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x264d0
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x26250
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
|
rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x001264d0
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x00126250
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
64,041 |
my_mb_wc_cp932
|
eloqsql/strings/ctype-cp932.c
|
static int
my_mb_wc_cp932(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= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
}
|
O0
|
c
|
my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x10df8a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x10e0e8
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x80, %eax
jge 0x10dfb2
movslq -0x2c(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x10e0e8
cmpl $0xa1, -0x2c(%rbp)
jl 0x10dfe8
cmpl $0xdf, -0x2c(%rbp)
jg 0x10dfe8
movslq -0x2c(%rbp), %rcx
leaq 0x64381(%rip), %rax # 0x172350
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x10e0e8
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x10e002
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x10e0e8
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x64334(%rip), %rax # 0x172350
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x10e0e1
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
movl $0x81, %eax
cmpl %ecx, %eax
jg 0x10e04d
movl -0x2c(%rbp), %eax
movzbl %al, %eax
cmpl $0x9f, %eax
jle 0x10e074
movl -0x2c(%rbp), %eax
movzbl %al, %edx
xorl %eax, %eax
movl $0xe0, %ecx
cmpl %edx, %ecx
movb %al, -0x2d(%rbp)
jg 0x10e0cc
movl -0x2c(%rbp), %eax
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0xfc, %ecx
movb %al, -0x2d(%rbp)
jg 0x10e0cc
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movl $0x40, %eax
cmpl %ecx, %eax
jg 0x10e097
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x7e, %ecx
movb %al, -0x2e(%rbp)
jle 0x10e0c6
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, -0x2f(%rbp)
jg 0x10e0c0
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xfc, %eax
setle %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x10e0e8
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_10DF8A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_10E0E8
loc_10DF8A:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov [rbp+var_2C], eax
cmp eax, 80h
jge short loc_10DFB2
movsxd rcx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_10E0E8
loc_10DFB2:
cmp [rbp+var_2C], 0A1h
jl short loc_10DFE8
cmp [rbp+var_2C], 0DFh
jg short loc_10DFE8
movsxd rcx, [rbp+var_2C]
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_10E0E8
loc_10DFE8:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_10E002
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_10E0E8
loc_10E002:
mov eax, [rbp+var_2C]
shl eax, 8
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rcx*2]
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz loc_10E0E1
mov eax, [rbp+var_2C]
movzx ecx, al
mov eax, 81h
cmp eax, ecx
jg short loc_10E04D
mov eax, [rbp+var_2C]
movzx eax, al
cmp eax, 9Fh
jle short loc_10E074
loc_10E04D:
mov eax, [rbp+var_2C]
movzx edx, al
xor eax, eax
mov ecx, 0E0h
cmp ecx, edx
mov [rbp+var_2D], al
jg short loc_10E0CC
mov eax, [rbp+var_2C]
movzx ecx, al
xor eax, eax
cmp ecx, 0FCh
mov [rbp+var_2D], al
jg short loc_10E0CC
loc_10E074:
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov eax, 40h ; '@'
cmp eax, ecx
jg short loc_10E097
mov rax, [rbp+var_20]
movzx ecx, byte ptr [rax+1]
mov al, 1
cmp ecx, 7Eh ; '~'
mov [rbp+var_2E], al
jle short loc_10E0C6
loc_10E097:
mov rax, [rbp+var_20]
movzx edx, byte ptr [rax+1]
xor eax, eax
mov ecx, 80h
cmp ecx, edx
mov [rbp+var_2F], al
jg short loc_10E0C0
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+1]
cmp eax, 0FCh
setle al
mov [rbp+var_2F], al
loc_10E0C0:
mov al, [rbp+var_2F]
mov [rbp+var_2E], al
loc_10E0C6:
mov al, [rbp+var_2E]
mov [rbp+var_2D], al
loc_10E0CC:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 0FFFFFFFEh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_10E0E8
loc_10E0E1:
mov [rbp+var_4], 2
loc_10E0E8:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long v4; // rax
unsigned int v5; // eax
bool v7; // [rsp+1h] [rbp-2Fh]
char v8; // [rsp+2h] [rbp-2Eh]
char v9; // [rsp+3h] [rbp-2Dh]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
v10 = *a3;
if ( v10 >= 0x80 )
{
if ( *a3 < 0xA1u || *a3 > 0xDFu )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v4 = cp932_to_unicode[a3[1] + (v10 << 8)];
*a2 = v4;
if ( v4 )
{
return 2;
}
else
{
if ( (unsigned __int8)v10 >= 0x81u && (unsigned __int8)v10 <= 0x9Fu
|| (v9 = 0, (unsigned __int8)v10 >= 0xE0u) && (v9 = 0, (unsigned __int8)v10 <= 0xFCu) )
{
if ( a3[1] < 0x40u || (v8 = 1, a3[1] > 0x7Eu) )
{
v7 = 0;
if ( a3[1] >= 0x80u )
v7 = a3[1] <= 0xFCu;
v8 = v7;
}
v9 = v8;
}
v5 = 0;
if ( (v9 & 1) != 0 )
return (unsigned int)-2;
return v5;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
*a2 = cp932_to_unicode[*a3];
return 1;
}
}
else
{
*a2 = *a3;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| |||
64,042 |
my_mb_wc_cp932
|
eloqsql/strings/ctype-cp932.c
|
static int
my_mb_wc_cp932(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= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
}
|
O3
|
c
|
my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xacc13
movzbl (%rdx), %edi
testb %dil, %dil
js 0xacbf9
movq %rdi, (%rsi)
jmp 0xacc0e
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0xacc15
leaq 0x4dc29(%rip), %rax # 0xfa830
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 0xacc13
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x4dbfa(%rip), %rcx # 0xfa830
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0xacc13
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 0xacc13
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0xacc13
movl $0x0, %eax
testb %cl, %cl
jns 0xacc13
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0xacc13
|
my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_ACC13
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_ACBF9
mov [rsi], rdi
jmp short loc_ACC0E
loc_ACBF9:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_ACC15
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_ACC0E:
mov eax, 1
loc_ACC13:
pop rbp
retn
loc_ACC15:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_ACC13
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, cp932_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_ACC13
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_ACC13
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_ACC13
mov eax, 0
test cl, cl
jns short loc_ACC13
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_ACC13
|
long long my_mb_wc_cp932(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 = cp932_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = cp932_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_cp932:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001acc13
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x001acbf9
MOV qword ptr [RSI],RDI
JMP 0x001acc0e
LAB_001acbf9:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x001acc15
LEA RAX,[0x1fa830]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_001acc0e:
MOV EAX,0x1
LAB_001acc13:
POP RBP
RET
LAB_001acc15:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001acc13
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x1fa830]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x001acc13
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 0x001acc13
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x001acc13
MOV EAX,0x0
TEST CL,CL
JNS 0x001acc13
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x001acc13
|
int my_mb_wc_cp932(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 *)(cp932_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 *)(cp932_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
|
|
64,043 |
Json::Reader::decodeNumber(Json::Reader::Token&)
|
aimrt_mujoco_sim/_deps/jsoncpp-src/src/lib_json/json_reader.cpp
|
bool Reader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
|
O3
|
cpp
|
Json::Reader::decodeNumber(Json::Reader::Token&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x76670
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6eb66
movl %eax, %ebx
testb %al, %al
je 0x6e09d
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x6e039
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x76d9a
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x6e05e
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
movq 0x8(%r15), %rsi
subq 0xc0(%r14), %rsi
callq 0x79aba
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
jne 0x6e089
movq 0x48(%r14), %rcx
movl $0x200, %eax # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rdi
movq 0x10(%r15), %rsi
subq 0xc0(%r14), %rsi
callq 0x79ac0
leaq 0x8(%rsp), %rdi
callq 0x76cde
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76cde
movq %rbx, %rdi
callq 0x1ffd0
|
_ZN4Json6Reader12decodeNumberERNS0_5TokenE:
push r15
push r14
push rbx
sub rsp, 30h
mov r15, rsi
mov r14, rdi
lea rbx, [rsp+48h+var_40]
mov rdi, rbx
xor esi, esi
call _ZN4Json5ValueC2ENS_9ValueTypeE; Json::Value::Value(Json::ValueType)
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call _ZN4Json6Reader12decodeNumberERNS0_5TokenERNS_5ValueE; Json::Reader::decodeNumber(Json::Reader::Token &,Json::Value &)
mov ebx, eax
test al, al
jz short loc_6E09D
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_6E039
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_6E039:
mov rdi, [rax-8]; this
lea rsi, [rsp+48h+var_40]; Json::Value *
call _ZN4Json5Value11swapPayloadERS0_; Json::Value::swapPayload(Json::Value&)
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_6E05E
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_6E05E:
mov rdi, [rax-8]; this
mov rsi, [r15+8]
sub rsi, [r14+0C0h]; __int64
call _ZN4Json5Value14setOffsetStartEl; Json::Value::setOffsetStart(long)
mov rax, [r14+30h]
cmp rax, [r14+38h]
jnz short loc_6E089
mov rcx, [r14+48h]
mov eax, 200h
add rax, [rcx-8]
loc_6E089:
mov rdi, [rax-8]; this
mov rsi, [r15+10h]
sub rsi, [r14+0C0h]; __int64
call _ZN4Json5Value14setOffsetLimitEl; Json::Value::setOffsetLimit(long)
loc_6E09D:
lea rdi, [rsp+48h+var_40]; void *
call _ZN4Json5ValueD2Ev; Json::Value::~Value()
mov eax, ebx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZN4Json5ValueD2Ev; Json::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long Json::Reader::decodeNumber(_QWORD *a1, long long a2)
{
unsigned int v2; // ebx
long long v3; // rax
long long v4; // rax
long long v5; // rax
_BYTE v7[64]; // [rsp+8h] [rbp-40h] BYREF
Json::Value::Value(v7, 0LL);
v2 = Json::Reader::decodeNumber(a1, a2, v7);
if ( (_BYTE)v2 )
{
v3 = a1[6];
if ( v3 == a1[7] )
v3 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::swapPayload(*(Json::Value **)(v3 - 8), (Json::Value *)v7);
v4 = a1[6];
if ( v4 == a1[7] )
v4 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::setOffsetStart(*(Json::Value **)(v4 - 8), *(_QWORD *)(a2 + 8) - a1[24]);
v5 = a1[6];
if ( v5 == a1[7] )
v5 = *(_QWORD *)(a1[9] - 8LL) + 512LL;
Json::Value::setOffsetLimit(*(Json::Value **)(v5 - 8), *(_QWORD *)(a2 + 16) - a1[24]);
}
Json::Value::~Value(v7);
return v2;
}
|
decodeNumber:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R15,RSI
MOV R14,RDI
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00176670
LAB_0016e00e:
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x0016eb66
MOV EBX,EAX
TEST AL,AL
JZ 0x0016e09d
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x0016e039
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_0016e039:
MOV RDI,qword ptr [RAX + -0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00176d9a
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x0016e05e
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_0016e05e:
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [R15 + 0x8]
SUB RSI,qword ptr [R14 + 0xc0]
CALL 0x00179aba
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x0016e089
MOV RCX,qword ptr [R14 + 0x48]
MOV EAX,0x200
ADD RAX,qword ptr [RCX + -0x8]
LAB_0016e089:
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,qword ptr [R15 + 0x10]
SUB RSI,qword ptr [R14 + 0xc0]
CALL 0x00179ac0
LAB_0016e09d:
LEA RDI,[RSP + 0x8]
CALL 0x00176cde
MOV EAX,EBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* Json::Reader::decodeNumber(Json::Reader::Token&) */
int4 __thiscall Json::Reader::decodeNumber(Reader *this,Token *param_1)
{
int4 uVar1;
long lVar2;
Value local_40 [40];
Value::Value(local_40,0);
/* try { // try from 0016e00e to 0016e09c has its CatchHandler @ 0016e0b3 */
uVar1 = decodeNumber(this,param_1,local_40);
if ((char)uVar1 != '\0') {
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::swapPayload(*(Value **)(lVar2 + -8),local_40);
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::setOffsetStart(*(Value **)(lVar2 + -8),*(long *)(param_1 + 8) - *(long *)(this + 0xc0));
lVar2 = *(long *)(this + 0x30);
if (lVar2 == *(long *)(this + 0x38)) {
lVar2 = *(long *)(*(long *)(this + 0x48) + -8) + 0x200;
}
Value::setOffsetLimit
(*(Value **)(lVar2 + -8),*(long *)(param_1 + 0x10) - *(long *)(this + 0xc0));
}
Value::~Value(local_40);
return uVar1;
}
|
|
64,044 |
add_var
|
bluesky950520[P]quickjs/quickjs.c
|
static int add_var(JSContext *ctx, JSFunctionDef *fd, JSAtom name)
{
JSVarDef *vd;
/* the local variable indexes are currently stored on 16 bits */
if (fd->var_count >= JS_MAX_LOCAL_VARS) {
// XXX: add_var() should take JSParseState *s and use js_parse_error
JS_ThrowSyntaxError(ctx, "too many variables declared (only %d allowed)",
JS_MAX_LOCAL_VARS - 1);
return -1;
}
if (js_resize_array(ctx, (void **)&fd->vars, sizeof(fd->vars[0]),
&fd->var_size, fd->var_count + 1))
return -1;
vd = &fd->vars[fd->var_count++];
memset(vd, 0, sizeof(*vd));
vd->var_name = JS_DupAtom(ctx, name);
vd->func_pool_idx = -1;
if (update_var_htab(ctx, fd))
return -1;
return fd->var_count - 1;
}
|
O3
|
c
|
add_var:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl 0xa4(%rsi), %r8d
cmpl $0xffff, %r8d # imm = 0xFFFF
jl 0x60d72
leaq 0x42b43(%rip), %rsi # 0xa389c
movq %r12, %rdi
movl $0xfffe, %edx # imm = 0xFFFE
xorl %eax, %eax
callq 0x22cf5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x60ec5
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
cmpl %r8d, 0xa0(%rsi)
jle 0x60ed4
movq 0x90(%rbx), %rcx
leal 0x1(%r8), %eax
movl %eax, 0xa4(%rbx)
movslq %r8d, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rcx,%rdx)
movl $0xffffff00, %ecx # imm = 0xFFFFFF00
cmpl $0xe0, %ebp
jl 0x60dd4
movq 0x18(%r12), %rcx
movq 0x68(%rcx), %rcx
movl %ebp, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
movl $0xffffff00, %ecx # imm = 0xFFFFFF00
orl 0xc(%rax), %ecx
movl %ebp, (%rax)
movl %ecx, 0xc(%rax)
movl 0xa4(%rbx), %eax
cmpl $0x1b, %eax
jl 0x60ec3
movl %eax, %ecx
movl $0xcccccccd, %ebp # imm = 0xCCCCCCCD
imulq %rcx, %rbp
shrq $0x22, %rbp
leal (%rax,%rbp), %ecx
decl %ecx
addl %eax, %ebp
movq 0x98(%rbx), %r15
testl %ecx, %ebp
jne 0x60e4a
addl %ebp, %ebp
leaq (,%rbp,4), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1d4c0
testq %rax, %rax
je 0x60d68
movq %rax, %r15
movq %rax, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0xe350
movq %r15, 0x98(%rbx)
decl %ebp
xorl %edx, %edx
jmp 0x60e4e
decl %eax
movl %eax, %edx
bsrl %ebp, %ecx
notl %ecx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
shrl %cl, %esi
movq (%r14), %rcx
movl %edx, %eax
shlq $0x4, %rax
movl (%rcx,%rax), %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
xorl %edi, %edi
movl %edi, %r8d
shll $0x5, %r8d
addl %edi, %r8d
movzbl 0x4(%rsp,%rax), %edi
addl %r8d, %edi
incq %rax
cmpq $0x4, %rax
jne 0x60e6e
movl %edi, %eax
shrl $0x5, %eax
addl %edi, %eax
movl %eax, %r8d
andl %esi, %r8d
cmpl $-0x1, (%r15,%r8,4)
je 0x60eb3
movl $0x1, %edi
addl %edi, %eax
incl %edi
movl %eax, %r8d
andl %esi, %r8d
cmpl $-0x1, (%r15,%r8,4)
jne 0x60ea2
movl %edx, (%r15,%r8,4)
incl %edx
movl 0xa4(%rbx), %eax
cmpl %eax, %edx
jb 0x60e5d
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa0(%rbx), %rcx
incl %r8d
movq %r12, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x4512a
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x60ec5
movl 0xa4(%rbx), %r8d
jmp 0x60d8b
|
add_var:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rdi
mov r8d, [rsi+0A4h]
cmp r8d, 0FFFFh
jl short loc_60D72
lea rsi, aTooManyVariabl; "too many variables declared (only %d al"...
mov rdi, r12
mov edx, 0FFFEh
xor eax, eax
call JS_ThrowSyntaxError
loc_60D68:
mov eax, 0FFFFFFFFh
jmp loc_60EC5
loc_60D72:
mov ebp, edx
mov rbx, rsi
lea r14, [rsi+90h]
cmp [rsi+0A0h], r8d
jle loc_60ED4
loc_60D8B:
mov rcx, [rbx+90h]
lea eax, [r8+1]
mov [rbx+0A4h], eax
movsxd rdx, r8d
shl rdx, 4
lea rax, [rcx+rdx]
xorps xmm0, xmm0
movups xmmword ptr [rcx+rdx], xmm0
mov ecx, 0FFFFFF00h
cmp ebp, 0E0h
jl short loc_60DD4
mov rcx, [r12+18h]
mov rcx, [rcx+68h]
mov edx, ebp
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
mov ecx, 0FFFFFF00h
or ecx, [rax+0Ch]
loc_60DD4:
mov [rax], ebp
mov [rax+0Ch], ecx
mov eax, [rbx+0A4h]
cmp eax, 1Bh
jl loc_60EC3
mov ecx, eax
mov ebp, 0CCCCCCCDh
imul rbp, rcx
shr rbp, 22h
lea ecx, [rax+rbp]
dec ecx
add ebp, eax
mov r15, [rbx+98h]
test ebp, ecx
jnz short loc_60E4A
add ebp, ebp
lea r13, ds:0[rbp*4]
mov rdi, r12
mov rsi, r15
mov rdx, r13
call js_realloc
test rax, rax
jz loc_60D68
mov r15, rax
mov rdi, rax
mov esi, 0FFh
mov rdx, r13
call _memset
mov [rbx+98h], r15
dec ebp
xor edx, edx
jmp short loc_60E4E
loc_60E4A:
dec eax
mov edx, eax
loc_60E4E:
bsr ecx, ebp
not ecx
mov esi, 0FFFFFFFFh
shr esi, cl
mov rcx, [r14]
loc_60E5D:
mov eax, edx
shl rax, 4
mov eax, [rcx+rax]
mov [rsp+38h+var_34], eax
xor eax, eax
xor edi, edi
loc_60E6E:
mov r8d, edi
shl r8d, 5
add r8d, edi
movzx edi, byte ptr [rsp+rax+38h+var_34]
add edi, r8d
inc rax
cmp rax, 4
jnz short loc_60E6E
mov eax, edi
shr eax, 5
add eax, edi
mov r8d, eax
and r8d, esi
cmp dword ptr [r15+r8*4], 0FFFFFFFFh
jz short loc_60EB3
mov edi, 1
loc_60EA2:
add eax, edi
inc edi
mov r8d, eax
and r8d, esi
cmp dword ptr [r15+r8*4], 0FFFFFFFFh
jnz short loc_60EA2
loc_60EB3:
mov [r15+r8*4], edx
inc edx
mov eax, [rbx+0A4h]
cmp edx, eax
jb short loc_60E5D
loc_60EC3:
dec eax
loc_60EC5:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60ED4:
lea rcx, [rbx+0A0h]
inc r8d
mov rdi, r12
mov rsi, r14
mov edx, 10h
call js_realloc_array
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_60EC5
mov r8d, [rbx+0A4h]
jmp loc_60D8B
|
long long add_var(
long long a1,
long long a2,
int a3,
long long a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
long long a13,
long long a14)
{
long long v14; // rax
long long v15; // r8
long long result; // rax
long long *v19; // r14
long long v20; // rcx
long long v21; // rax
unsigned int v22; // ecx
_DWORD *v23; // rcx
int v24; // eax
unsigned int v25; // ebp
long long v26; // r15
long long v27; // rbp
long long v28; // rax
unsigned int v29; // edx
unsigned int v30; // ecx
unsigned int v31; // esi
long long v32; // rcx
long long v33; // rax
unsigned int v34; // edi
unsigned int v35; // eax
long long v36; // r8
int v37; // edi
int v38; // ecx
_QWORD v39[7]; // [rsp-4h] [rbp-38h]
v39[0] = v14;
v15 = *(unsigned int *)(a2 + 164);
if ( (int)v15 >= 0xFFFF )
{
JS_ThrowSyntaxError(
a1,
(long long)"too many variables declared (only %d allowed)",
65534LL,
a4,
v15,
a14,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
v39[0]);
return 0xFFFFFFFFLL;
}
v19 = (long long *)(a2 + 144);
if ( *(_DWORD *)(a2 + 160) <= (int)v15 )
{
v38 = js_realloc_array(a1, (long long *)(a2 + 144), 0x10u, (_DWORD *)(a2 + 160), (int)v15 + 1);
result = 0xFFFFFFFFLL;
if ( v38 )
return result;
LODWORD(v15) = *(_DWORD *)(a2 + 164);
}
v20 = *(_QWORD *)(a2 + 144);
*(_DWORD *)(a2 + 164) = v15 + 1;
v21 = v20 + 16LL * (int)v15;
*(_OWORD *)v21 = 0LL;
v22 = -256;
if ( a3 >= 224 )
{
v23 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v23;
v22 = *(_DWORD *)(v21 + 12) | 0xFFFFFF00;
}
*(_DWORD *)v21 = a3;
*(_DWORD *)(v21 + 12) = v22;
v24 = *(_DWORD *)(a2 + 164);
if ( v24 >= 27 )
{
v25 = v24 + v24 / 5u;
v26 = *(_QWORD *)(a2 + 152);
if ( ((v25 - 1) & v25) != 0 )
{
v29 = v24 - 1;
}
else
{
v27 = 2 * v25;
v28 = js_realloc(a1, *(_QWORD *)(a2 + 152), 4 * v27);
if ( !v28 )
return 0xFFFFFFFFLL;
v26 = v28;
memset(v28, 255LL, 4 * v27);
*(_QWORD *)(a2 + 152) = v26;
v25 = v27 - 1;
v29 = 0;
}
_BitScanReverse(&v30, v25);
v31 = 0xFFFFFFFF >> ~(_BYTE)v30;
v32 = *v19;
do
{
HIDWORD(v39[0]) = *(_DWORD *)(v32 + 16LL * v29);
v33 = 0LL;
v34 = 0;
do
v34 = 33 * v34 + *((unsigned __int8 *)v39 + v33++ + 4);
while ( v33 != 4 );
v35 = v34 + (v34 >> 5);
v36 = v31 & v35;
if ( *(_DWORD *)(v26 + 4 * v36) != -1 )
{
v37 = 1;
do
{
v35 += v37++;
v36 = v31 & v35;
}
while ( *(_DWORD *)(v26 + 4 * v36) != -1 );
}
*(_DWORD *)(v26 + 4 * v36) = v29++;
v24 = *(_DWORD *)(a2 + 164);
}
while ( v29 < v24 );
}
return (unsigned int)(v24 - 1);
}
|
add_var:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RDI
MOV R8D,dword ptr [RSI + 0xa4]
CMP R8D,0xffff
JL 0x00160d72
LEA RSI,[0x1a389c]
MOV RDI,R12
MOV EDX,0xfffe
XOR EAX,EAX
CALL 0x00122cf5
LAB_00160d68:
MOV EAX,0xffffffff
JMP 0x00160ec5
LAB_00160d72:
MOV EBP,EDX
MOV RBX,RSI
LEA R14,[RSI + 0x90]
CMP dword ptr [RSI + 0xa0],R8D
JLE 0x00160ed4
LAB_00160d8b:
MOV RCX,qword ptr [RBX + 0x90]
LEA EAX,[R8 + 0x1]
MOV dword ptr [RBX + 0xa4],EAX
MOVSXD RDX,R8D
SHL RDX,0x4
LEA RAX,[RCX + RDX*0x1]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX + RDX*0x1],XMM0
MOV ECX,0xffffff00
CMP EBP,0xe0
JL 0x00160dd4
MOV RCX,qword ptr [R12 + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EBP
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
MOV ECX,0xffffff00
OR ECX,dword ptr [RAX + 0xc]
LAB_00160dd4:
MOV dword ptr [RAX],EBP
MOV dword ptr [RAX + 0xc],ECX
MOV EAX,dword ptr [RBX + 0xa4]
CMP EAX,0x1b
JL 0x00160ec3
MOV ECX,EAX
MOV EBP,0xcccccccd
IMUL RBP,RCX
SHR RBP,0x22
LEA ECX,[RAX + RBP*0x1]
DEC ECX
ADD EBP,EAX
MOV R15,qword ptr [RBX + 0x98]
TEST EBP,ECX
JNZ 0x00160e4a
ADD EBP,EBP
LEA R13,[RBP*0x4]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R13
CALL 0x0011d4c0
TEST RAX,RAX
JZ 0x00160d68
MOV R15,RAX
MOV RDI,RAX
MOV ESI,0xff
MOV RDX,R13
CALL 0x0010e350
MOV qword ptr [RBX + 0x98],R15
DEC EBP
XOR EDX,EDX
JMP 0x00160e4e
LAB_00160e4a:
DEC EAX
MOV EDX,EAX
LAB_00160e4e:
BSR ECX,EBP
NOT ECX
MOV ESI,0xffffffff
SHR ESI,CL
MOV RCX,qword ptr [R14]
LAB_00160e5d:
MOV EAX,EDX
SHL RAX,0x4
MOV EAX,dword ptr [RCX + RAX*0x1]
MOV dword ptr [RSP + 0x4],EAX
XOR EAX,EAX
XOR EDI,EDI
LAB_00160e6e:
MOV R8D,EDI
SHL R8D,0x5
ADD R8D,EDI
MOVZX EDI,byte ptr [RSP + RAX*0x1 + 0x4]
ADD EDI,R8D
INC RAX
CMP RAX,0x4
JNZ 0x00160e6e
MOV EAX,EDI
SHR EAX,0x5
ADD EAX,EDI
MOV R8D,EAX
AND R8D,ESI
CMP dword ptr [R15 + R8*0x4],-0x1
JZ 0x00160eb3
MOV EDI,0x1
LAB_00160ea2:
ADD EAX,EDI
INC EDI
MOV R8D,EAX
AND R8D,ESI
CMP dword ptr [R15 + R8*0x4],-0x1
JNZ 0x00160ea2
LAB_00160eb3:
MOV dword ptr [R15 + R8*0x4],EDX
INC EDX
MOV EAX,dword ptr [RBX + 0xa4]
CMP EDX,EAX
JC 0x00160e5d
LAB_00160ec3:
DEC EAX
LAB_00160ec5:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160ed4:
LEA RCX,[RBX + 0xa0]
INC R8D
MOV RDI,R12
MOV RSI,R14
MOV EDX,0x10
CALL 0x0014512a
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x00160ec5
MOV R8D,dword ptr [RBX + 0xa4]
JMP 0x00160d8b
|
int add_var(long param_1,long param_2,uint param_3)
{
uint *puVar1;
int8 *puVar2;
size_t __n;
int *piVar3;
void *__s;
long lVar4;
uint uVar5;
uint uVar6;
uint uVar7;
int iVar8;
ulong uVar9;
byte abStack_34 [4];
iVar8 = *(int *)(param_2 + 0xa4);
if (iVar8 < 0xffff) {
if (*(int *)(param_2 + 0xa0) <= iVar8) {
iVar8 = js_realloc_array(param_1,param_2 + 0x90,0x10,param_2 + 0xa0,iVar8 + 1);
if (iVar8 != 0) {
return -1;
}
iVar8 = *(int *)(param_2 + 0xa4);
}
*(int *)(param_2 + 0xa4) = iVar8 + 1;
puVar1 = (uint *)(*(long *)(param_2 + 0x90) + (long)iVar8 * 0x10);
puVar2 = (int8 *)(*(long *)(param_2 + 0x90) + (long)iVar8 * 0x10);
*puVar2 = 0;
puVar2[1] = 0;
uVar5 = 0xffffff00;
if (0xdf < (int)param_3) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_3 * 8);
*piVar3 = *piVar3 + 1;
uVar5 = puVar1[3] | 0xffffff00;
}
*puVar1 = param_3;
puVar1[3] = uVar5;
uVar5 = *(uint *)(param_2 + 0xa4);
if (0x1a < (int)uVar5) {
uVar7 = (uint)((ulong)uVar5 * 0x4cccccccd >> 0x22);
__s = *(void **)(param_2 + 0x98);
if ((uVar7 & (uint)((ulong)uVar5 * 0x4cccccccd >> 0x22) - 1) == 0) {
__n = (ulong)(uVar7 * 2) * 4;
__s = (void *)js_realloc(param_1,__s,__n);
if (__s == (void *)0x0) goto LAB_00160d68;
memset(__s,0xff,__n);
*(void **)(param_2 + 0x98) = __s;
uVar7 = uVar7 * 2 - 1;
uVar6 = 0;
}
else {
uVar6 = uVar5 - 1;
}
iVar8 = 0x1f;
if (uVar7 != 0) {
for (; uVar7 >> iVar8 == 0; iVar8 = iVar8 + -1) {
}
}
uVar7 = 0xffffffff >> (~(byte)iVar8 & 0x1f);
do {
lVar4 = 0;
uVar5 = 0;
do {
uVar5 = (uint)abStack_34[lVar4] + uVar5 * 0x21;
lVar4 = lVar4 + 1;
} while (lVar4 != 4);
uVar5 = (uVar5 >> 5) + uVar5;
uVar9 = (ulong)(uVar5 & uVar7);
if (*(int *)((long)__s + uVar9 * 4) != -1) {
iVar8 = 1;
do {
uVar5 = uVar5 + iVar8;
iVar8 = iVar8 + 1;
uVar9 = (ulong)(uVar5 & uVar7);
} while (*(int *)((long)__s + uVar9 * 4) != -1);
}
*(uint *)((long)__s + uVar9 * 4) = uVar6;
uVar6 = uVar6 + 1;
uVar5 = *(uint *)(param_2 + 0xa4);
} while (uVar6 < uVar5);
}
iVar8 = uVar5 - 1;
}
else {
JS_ThrowSyntaxError(param_1,"too many variables declared (only %d allowed)",0xfffe);
LAB_00160d68:
iVar8 = -1;
}
return iVar8;
}
|
|
64,045 |
gindex_indexOf
|
corpus-core[P]colibri-stateless/src/util/ssz_merkle.c
|
static int gindex_indexOf(buffer_t* index_list, gindex_t index) {
int len = index_list->data.len / sizeof(gindex_t);
gindex_t* index_list_array = (gindex_t*) index_list->data.data;
for (int i = 0; i < len; i++) {
if (index_list_array[i] == index) return i;
}
return -1;
}
|
O0
|
c
|
gindex_indexOf:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrq $0x3, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa32db
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0xa32ce
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa32e2
jmp 0xa32d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa32ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
gindex_indexOf:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax]
shr rax, 3
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_28], rax
mov [rbp+var_2C], 0
loc_A32AC:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_1C]
jge short loc_A32DB
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_2C]
mov rax, [rax+rcx*8]
cmp rax, [rbp+var_18]
jnz short loc_A32CE
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_A32E2
loc_A32CE:
jmp short $+2
loc_A32D0:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_A32AC
loc_A32DB:
mov [rbp+var_4], 0FFFFFFFFh
loc_A32E2:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long gindex_indexOf(long long a1, long long a2)
{
unsigned int i; // [rsp+0h] [rbp-2Ch]
for ( i = 0; (signed int)i < *(_DWORD *)a1 >> 3; ++i )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * (int)i) == a2 )
return i;
}
return (unsigned int)-1;
}
|
gindex_indexOf:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
SHR RAX,0x3
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x2c],0x0
LAB_001a32ac:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001a32db
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001a32ce
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001a32e2
LAB_001a32ce:
JMP 0x001a32d0
LAB_001a32d0:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001a32ac
LAB_001a32db:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001a32e2:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int gindex_indexOf(uint *param_1,long param_2)
{
int local_34;
local_34 = 0;
while( true ) {
if ((int)(*param_1 >> 3) <= local_34) {
return -1;
}
if (*(long *)(*(long *)(param_1 + 2) + (long)local_34 * 8) == param_2) break;
local_34 = local_34 + 1;
}
return local_34;
}
|
|
64,046 |
purge_bin_logs_to
|
eloqsql/client/mysqldump.c
|
static int purge_bin_logs_to(MYSQL *mysql_con, char* log_name)
{
DYNAMIC_STRING str;
int err;
init_dynamic_string_checked(&str, "PURGE BINARY LOGS TO '", 1024, 1024);
dynstr_append_checked(&str, log_name);
dynstr_append_checked(&str, "'");
err = mysql_query_with_error_report(mysql_con, 0, str.str);
dynstr_free(&str);
return err;
}
|
O0
|
c
|
purge_bin_logs_to:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0xa2baf(%rip), %rsi # 0xdf31a
movl $0x400, %ecx # imm = 0x400
movq %rcx, %rdx
callq 0x3ba90
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3e190
leaq -0x30(%rbp), %rdi
leaq 0x9f4d1(%rip), %rsi # 0xdbc61
callq 0x3e190
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x39350
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8deb0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
purge_bin_logs_to:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_30]
lea rsi, aPurgeBinaryLog; "PURGE BINARY LOGS TO '"
mov ecx, 400h
mov rdx, rcx
call init_dynamic_string_checked
mov rsi, [rbp+var_10]
lea rdi, [rbp+var_30]
call dynstr_append_checked
lea rdi, [rbp+var_30]
lea rsi, asc_DBC5E+3; "'"
call dynstr_append_checked
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_30]
xor eax, eax
mov esi, eax
call mysql_query_with_error_report
mov [rbp+var_34], eax
lea rdi, [rbp+var_30]
call dynstr_free
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
|
long long purge_bin_logs_to(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
unsigned int v7; // [rsp+Ch] [rbp-34h]
long long v8[4]; // [rsp+10h] [rbp-30h] BYREF
long long v9; // [rsp+30h] [rbp-10h]
long long v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v9 = a2;
init_dynamic_string_checked((long long)v8, (long long)"PURGE BINARY LOGS TO '", 1024LL, 1024LL, a5, a6);
dynstr_append_checked(v8, v9);
dynstr_append_checked(v8, "'");
v7 = mysql_query_with_error_report(v10, 0LL, v8[0]);
dynstr_free(v8);
return v7;
}
|
purge_bin_logs_to:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x30]
LEA RSI,[0x1df31a]
MOV ECX,0x400
MOV RDX,RCX
CALL 0x0013ba90
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[RBP + -0x30]
CALL 0x0013e190
LEA RDI,[RBP + -0x30]
LEA RSI,[0x1dbc61]
CALL 0x0013e190
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x30]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00139350
MOV dword ptr [RBP + -0x34],EAX
LEA RDI,[RBP + -0x30]
CALL 0x0018deb0
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 purge_bin_logs_to(int8 param_1,int8 param_2)
{
int4 uVar1;
int8 local_38 [4];
int8 local_18;
int8 local_10;
local_18 = param_2;
local_10 = param_1;
init_dynamic_string_checked(local_38,"PURGE BINARY LOGS TO \'",0x400);
dynstr_append_checked(local_38,local_18);
dynstr_append_checked(local_38,&DAT_001dbc61);
uVar1 = mysql_query_with_error_report(local_10,0,local_38[0]);
dynstr_free(local_38);
return uVar1;
}
|
|
64,047 |
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
}
|
O1
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0x6aba4
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x44665
testb %al, %al
je 0x69df8
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq -0x48(%rcx), %rsi
cmpq $0x48, %rdx
movq %rax, %rdi
cmoveq %rsi, %rdi
movq %rcx, %rdx
subq %rax, %rdx
cmoveq %rsi, %rdi
movq (%rdi), %rdi
cmpq 0x18(%rsp), %rdi
je 0x69e3a
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4be32(%rip), %rdx # 0xb5c3c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x32ea4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x69e2b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x48, %rdx
movq %rax, %rdx
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
xorl %ecx, %ecx
cmpb $0x0, 0x10(%rdx)
cmovneq %rax, %rcx
addq %rcx, 0x20(%r14)
cmpb $0x1, 0x10(%rdx)
jne 0x69e7f
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4d9d4
jmp 0x69e15
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x69e15
jmp 0x69e96
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x69eaf
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196b0
movq %rbx, %rdi
callq 0x19be0
nop
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
mov rdx, rsp
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov rcx, r15
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_69DF8
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_40]
mov rdx, rcx
sub rdx, rax
lea rsi, [rcx-48h]
cmp rdx, 48h ; 'H'
mov rdi, rax
cmovz rdi, rsi
mov rdx, rcx
sub rdx, rax
cmovz rdi, rsi
mov rdi, [rdi]
cmp rdi, [rsp+48h+var_30]
jz short loc_69E3A
loc_69DF8:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aNoteDebugGramm+0CAh; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_69E15:
mov rdi, [rsp+48h+var_48]; void *
test rdi, rdi
jz short loc_69E2B
mov rsi, [rsp+48h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_69E2B:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_69E3A:
cmp rdx, 48h ; 'H'
mov rdx, rax
cmovz rdx, rsi
cmp rax, rcx
cmovz rdx, rsi
mov rax, [rdx+8]
sub rax, [rdx]
xor ecx, ecx
cmp byte ptr [rdx+10h], 0
cmovnz rcx, rax
add [r14+20h], rcx
cmp byte ptr [rdx+10h], 1
jnz short loc_69E7F
mov rsi, [rdx]
mov rdx, [rdx+8]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
jmp short loc_69E15
loc_69E7F:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
jmp short loc_69E15
jmp short $+2
loc_69E96:
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_69EAF
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_69EAF:
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Parser::consumeToken(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v6; // r12
_QWORD *v7; // rdi
long long v9; // rdx
long long v10; // rcx
_BYTE *v11; // rsi
long long v12; // rdx
__int128 v13; // [rsp+0h] [rbp-48h] BYREF
__int128 v14; // [rsp+10h] [rbp-38h]
v6 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v14 = 0LL;
v13 = 0LL;
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
*(long long **)(a2 + 32),
*(_QWORD *)(a2 + 24),
(long long **)&v13,
a3,
0) )
goto LABEL_7;
v7 = (_QWORD *)v13;
if ( *((_QWORD *)&v13 + 1) - (_QWORD)v13 == 72LL )
v7 = (_QWORD *)(*((_QWORD *)&v13 + 1) - 72LL);
if ( *((_QWORD *)&v13 + 1) == (_QWORD)v13 )
v7 = (_QWORD *)(*((_QWORD *)&v13 + 1) - 72LL);
if ( *v7 == *((_QWORD *)&v14 + 1) )
{
v9 = v13;
if ( *((_QWORD *)&v13 + 1) - (_QWORD)v13 == 72LL )
v9 = *((_QWORD *)&v13 + 1) - 72LL;
if ( (_QWORD)v13 == *((_QWORD *)&v13 + 1) )
v9 = *((_QWORD *)&v13 + 1) - 72LL;
v10 = 0LL;
if ( *(_BYTE *)(v9 + 16) )
v10 = *(_QWORD *)(v9 + 8) - *(_QWORD *)v9;
*(_QWORD *)(a2 + 32) += v10;
if ( *(_BYTE *)(v9 + 16) == 1 )
{
v11 = *(_BYTE **)v9;
v12 = *(_QWORD *)(v9 + 8);
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((_QWORD *)a1, v11, v12);
}
else
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
}
else
{
LABEL_7:
*(_QWORD *)(a2 + 32) = v6;
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>((_QWORD *)a1, "", (long long)"");
}
if ( (_QWORD)v13 )
operator delete((void *)v13, v14 - v13);
return a1;
}
|
consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x0016aba4
XORPS XMM0,XMM0
MOV RDX,RSP
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_00169db7:
MOV RCX,R15
XOR R8D,R8D
CALL 0x00144665
TEST AL,AL
JZ 0x00169df8
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RCX
SUB RDX,RAX
LEA RSI,[RCX + -0x48]
CMP RDX,0x48
MOV RDI,RAX
CMOVZ RDI,RSI
MOV RDX,RCX
SUB RDX,RAX
CMOVZ RDI,RSI
MOV RDI,qword ptr [RDI]
CMP RDI,qword ptr [RSP + 0x18]
JZ 0x00169e3a
LAB_00169df8:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_00169e03:
LEA RDX,[0x1b5c3c]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00132ea4
LAB_00169e15:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x00169e2b
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x001196b0
LAB_00169e2b:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00169e3a:
CMP RDX,0x48
MOV RDX,RAX
CMOVZ RDX,RSI
CMP RAX,RCX
CMOVZ RDX,RSI
MOV RAX,qword ptr [RDX + 0x8]
SUB RAX,qword ptr [RDX]
XOR ECX,ECX
CMP byte ptr [RDX + 0x10],0x0
CMOVNZ RCX,RAX
ADD qword ptr [R14 + 0x20],RCX
CMP byte ptr [RDX + 0x10],0x1
JNZ 0x00169e7f
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_00169e75:
MOV RDI,RBX
CALL 0x0014d9d4
LAB_00169e7d:
JMP 0x00169e15
LAB_00169e7f:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
JMP 0x00169e15
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
long *plVar1;
int8 uVar2;
long lVar3;
bool bVar4;
long lVar5;
long *plVar6;
long *local_48;
long *plStack_40;
long local_38;
long lStack_30;
uVar2 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
plStack_40 = (long *)0x0;
/* try { // try from 00169db7 to 00169dc1 has its CatchHandler @ 00169e96 */
bVar4 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0);
if (bVar4) {
plVar1 = plStack_40 + -9;
plVar6 = local_48;
if ((long)plStack_40 - (long)local_48 == 0x48) {
plVar6 = plVar1;
}
if (plStack_40 == local_48) {
plVar6 = plVar1;
}
if (*plVar6 == lStack_30) {
plVar6 = local_48;
if ((long)plStack_40 - (long)local_48 == 0x48) {
plVar6 = plVar1;
}
if (local_48 == plStack_40) {
plVar6 = plVar1;
}
lVar5 = 0;
if ((char)plVar6[2] != '\0') {
lVar5 = plVar6[1] - *plVar6;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar5;
if ((char)plVar6[2] == '\x01') {
lVar5 = *plVar6;
lVar3 = plVar6[1];
*param_1 = (long)(param_1 + 2);
/* try { // try from 00169e75 to 00169e7c has its CatchHandler @ 00169e96 */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar5,lVar3);
}
else {
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int1 *)(param_1 + 2) = 0;
}
goto LAB_00169e15;
}
}
*(int8 *)(param_2 + 0x20) = uVar2;
*param_1 = (long)(param_1 + 2);
/* try { // try from 00169e03 to 00169e14 has its CatchHandler @ 00169e94 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
LAB_00169e15:
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
|
|
64,048 |
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling)
|
monkey531[P]llama/common/minja.hpp
|
std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
}
|
O3
|
cpp
|
minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0x68eb4
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x43899
testb %al, %al
je 0x68129
movq 0x18(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x68110
movq (%rax), %r8
cmpq $0x48, %rdx
jne 0x68121
cmpq %rsi, %r8
jne 0x68129
jmp 0x68117
cmpq %rsi, -0x48(%rax,%rdx)
jne 0x68129
leaq (%rax,%rdx), %rdi
addq $-0x48, %rdi
jmp 0x6816b
movq %rax, %rdi
cmpq %rsi, %r8
je 0x6816b
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4ab11(%rip), %rdx # 0xb2c4c
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x320e8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6815c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %r8
subq %rsi, %r8
xorl %esi, %esi
cmpb $0x0, 0x10(%rdi)
cmovneq %r8, %rsi
addq %rsi, 0x20(%r14)
cmpq $0x48, %rdx
leaq -0x48(%rax,%rdx), %rsi
movq %rax, %rdx
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x681b5
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x4cb3c
jmp 0x68146
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x68146
jmp 0x681cf
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x681e8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x196b0
movq %rbx, %rdi
callq 0x19be0
|
_ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
mov rdx, rsp
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov rcx, r15
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_68129
mov rsi, [rsp+48h+var_30]
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_40]
mov rdx, rcx
sub rdx, rax
jz short loc_68110
mov r8, [rax]
cmp rdx, 48h ; 'H'
jnz short loc_68121
cmp r8, rsi
jnz short loc_68129
jmp short loc_68117
loc_68110:
cmp [rax+rdx-48h], rsi
jnz short loc_68129
loc_68117:
lea rdi, [rax+rdx]
add rdi, 0FFFFFFFFFFFFFFB8h
jmp short loc_6816B
loc_68121:
mov rdi, rax
cmp r8, rsi
jz short loc_6816B
loc_68129:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aNoteDebugGramm+0CAh; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_68146:
mov rdi, [rsp+48h+var_48]; void *
test rdi, rdi
jz short loc_6815C
mov rsi, [rsp+48h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6815C:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_6816B:
mov r8, [rdi+8]
sub r8, rsi
xor esi, esi
cmp byte ptr [rdi+10h], 0
cmovnz rsi, r8
add [r14+20h], rsi
cmp rdx, 48h ; 'H'
lea rsi, [rax+rdx-48h]
mov rdx, rax
cmovz rdx, rsi
cmp rax, rcx
cmovz rdx, rsi
cmp byte ptr [rdx+10h], 1
jnz short loc_681B5
mov rsi, [rdx]
mov rdx, [rdx+8]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
jmp short loc_68146
loc_681B5:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
jmp loc_68146
jmp short $+2
loc_681CF:
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_681E8
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_681E8:
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Parser::consumeToken(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v7; // r12
__int128 v8; // kr00_16
long long v9; // rdx
long long v10; // r8
long long v11; // rdi
long long v13; // rsi
bool v14; // zf
long long v15; // rsi
long long v16; // rdx
_BYTE *v17; // rsi
long long v18; // rdx
__int128 v19; // [rsp+0h] [rbp-48h] BYREF
__int128 v20; // [rsp+10h] [rbp-38h]
v7 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v20 = 0LL;
v19 = 0LL;
if ( !std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
*(long long **)(a2 + 32),
*(_QWORD *)(a2 + 24),
(long long **)&v19,
a3,
0) )
goto LABEL_9;
v8 = v19;
v9 = *((_QWORD *)&v19 + 1) - v19;
if ( *((_QWORD *)&v19 + 1) != (_QWORD)v19 )
{
v10 = *(_QWORD *)v19;
if ( v9 == 72 )
{
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_7;
}
else
{
v11 = v19;
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_13;
}
LABEL_9:
*(_QWORD *)(a2 + 32) = v7;
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "", (long long)"");
goto LABEL_10;
}
if ( *(_QWORD *)(*((_QWORD *)&v19 + 1) - 72LL) != *((_QWORD *)&v20 + 1) )
goto LABEL_9;
LABEL_7:
v11 = *((_QWORD *)&v19 + 1) - 72LL;
LABEL_13:
v13 = 0LL;
if ( *(_BYTE *)(v11 + 16) )
v13 = *(_QWORD *)(v11 + 8) - *((_QWORD *)&v20 + 1);
*(_QWORD *)(a2 + 32) += v13;
v14 = v9 == 72;
v15 = v8 + v9 - 72;
v16 = v8;
if ( v14 )
v16 = v15;
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
v16 = v15;
if ( *(_BYTE *)(v16 + 16) == 1 )
{
v17 = *(_BYTE **)v16;
v18 = *(_QWORD *)(v16 + 8);
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(a1, v17, v18);
}
else
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
LABEL_10:
if ( (_QWORD)v19 )
operator delete((void *)v19, v20 - v19);
return a1;
}
|
consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x00168eb4
XORPS XMM0,XMM0
MOV RDX,RSP
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_001680db:
MOV RCX,R15
XOR R8D,R8D
CALL 0x00143899
TEST AL,AL
JZ 0x00168129
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RCX
SUB RDX,RAX
JZ 0x00168110
MOV R8,qword ptr [RAX]
CMP RDX,0x48
JNZ 0x00168121
CMP R8,RSI
JNZ 0x00168129
JMP 0x00168117
LAB_00168110:
CMP qword ptr [RAX + RDX*0x1 + -0x48],RSI
JNZ 0x00168129
LAB_00168117:
LEA RDI,[RAX + RDX*0x1]
ADD RDI,-0x48
JMP 0x0016816b
LAB_00168121:
MOV RDI,RAX
CMP R8,RSI
JZ 0x0016816b
LAB_00168129:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_00168134:
LEA RDX,[0x1b2c4c]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x001320e8
LAB_00168146:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0016815c
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x001196b0
LAB_0016815c:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0016816b:
MOV R8,qword ptr [RDI + 0x8]
SUB R8,RSI
XOR ESI,ESI
CMP byte ptr [RDI + 0x10],0x0
CMOVNZ RSI,R8
ADD qword ptr [R14 + 0x20],RSI
CMP RDX,0x48
LEA RSI,[RAX + RDX*0x1 + -0x48]
MOV RDX,RAX
CMOVZ RDX,RSI
CMP RAX,RCX
CMOVZ RDX,RSI
CMP byte ptr [RDX + 0x10],0x1
JNZ 0x001681b5
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_001681ab:
MOV RDI,RBX
CALL 0x0014cb3c
LAB_001681b3:
JMP 0x00168146
LAB_001681b5:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
JMP 0x00168146
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
bool bVar2;
long lVar3;
long *plVar4;
long lVar5;
long *plVar6;
long *local_48;
long *plStack_40;
long local_38;
long lStack_30;
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
plStack_40 = (long *)0x0;
/* try { // try from 001680db to 001680e5 has its CatchHandler @ 001681cf */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0);
if (bVar2) {
lVar3 = (long)plStack_40 - (long)local_48;
if (lVar3 == 0) {
lVar5 = local_48[-9];
joined_r0x00168115:
if (lVar5 != lStack_30) goto LAB_00168129;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
}
else {
lVar5 = *local_48;
if (lVar3 == 0x48) goto joined_r0x00168115;
plVar6 = local_48;
if (lVar5 != lStack_30) goto LAB_00168129;
}
lVar5 = 0;
if ((char)plVar6[2] != '\0') {
lVar5 = plVar6[1] - lStack_30;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar5;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
plVar4 = local_48;
if (lVar3 == 0x48) {
plVar4 = plVar6;
}
if (local_48 == plStack_40) {
plVar4 = plVar6;
}
if ((char)plVar4[2] == '\x01') {
lVar3 = *plVar4;
lVar5 = plVar4[1];
*param_1 = (long)(param_1 + 2);
/* try { // try from 001681ab to 001681b2 has its CatchHandler @ 001681cf */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar3,lVar5);
}
else {
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int1 *)(param_1 + 2) = 0;
}
}
else {
LAB_00168129:
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
/* try { // try from 00168134 to 00168145 has its CatchHandler @ 001681cd */
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
|
|
64,049 |
my_fwrite
|
eloqsql/mysys/my_fstream.c
|
size_t my_fwrite(FILE *stream, const uchar *Buffer, size_t Count, myf MyFlags)
{
size_t writtenbytes =0;
my_off_t seekptr;
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
uint errors;
#endif
DBUG_ENTER("my_fwrite");
DBUG_PRINT("my",("stream:%p Buffer:%p Count: %u MyFlags: %lu",
stream, Buffer, (uint) Count, MyFlags));
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
errors=0;
#endif
seekptr= ftell(stream);
for (;;)
{
size_t written;
if ((written = (size_t) fwrite((char*) Buffer,sizeof(char),
Count, stream)) != Count)
{
DBUG_PRINT("error",("Write only %d bytes", (int) writtenbytes));
my_errno=errno;
if (written != (size_t) -1)
{
seekptr+=written;
Buffer+=written;
writtenbytes+=written;
Count-=written;
}
#ifdef EINTR
if (errno == EINTR)
{
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif
#if !defined(NO_BACKGROUND) && defined(USE_MY_STREAM)
if (my_thread_var->abort)
MyFlags&= ~ MY_WAIT_IF_FULL; /* End if aborted by user */
if ((errno == ENOSPC || errno == EDQUOT) &&
(MyFlags & MY_WAIT_IF_FULL))
{
wait_for_free_space("[stream]", errors);
errors++;
(void) my_fseek(stream,seekptr,MY_SEEK_SET,MYF(0));
continue;
}
#endif
if (ferror(stream) || (MyFlags & (MY_NABP | MY_FNABP)))
{
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
my_error(EE_WRITE, MYF(ME_BELL),
my_filename(my_fileno(stream)), errno);
}
writtenbytes= (size_t) -1; /* Return that we got error */
break;
}
}
if (MyFlags & (MY_NABP | MY_FNABP))
writtenbytes= 0; /* Everything OK */
else
writtenbytes+= written;
break;
}
DBUG_RETURN(writtenbytes);
}
|
O3
|
c
|
my_fwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2aa40
movq %rax, %r13
movl $0x1, %esi
movq %rbx, -0x48(%rbp)
movq %rbx, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2a8c0
cmpq %r12, %rax
jne 0xa6467
movq $0x0, -0x38(%rbp)
jmp 0xa64ff
movq %rax, %r15
movq $0x0, -0x38(%rbp)
callq 0x2a7f0
movq %rax, -0x40(%rbp)
movq %r14, %rbx
movq -0x40(%rbp), %rax
movl (%rax), %r14d
callq 0xac2be
movl %r14d, (%rax)
movq %r13, %rsi
cmpq $-0x1, %r15
je 0xa64a4
addq %r15, %rsi
addq %r15, -0x48(%rbp)
addq %r15, -0x38(%rbp)
subq %r15, %r12
movq -0x40(%rbp), %rax
cmpl $0x4, (%rax)
movq %rbx, %r14
movq %rbx, %rdi
jne 0xa64e7
movq %rsi, %r13
xorl %edx, %edx
callq 0x2a040
testl %eax, %eax
jne 0xa64c9
movq %r14, %rdi
callq 0x2aa40
movl $0x1, %esi
movq -0x48(%rbp), %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2a8c0
movq %rax, %r15
cmpq %r12, %rax
jne 0xa647b
jmp 0xa64ff
callq 0x2a660
testl %eax, %eax
sete %al
testb $0x6, -0x30(%rbp)
sete %cl
movq %r15, %r12
testb %al, %cl
je 0xa651f
addq -0x38(%rbp), %r12
xorl %ebx, %ebx
testb $0x6, -0x30(%rbp)
cmoveq %r12, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x1, %rbx
testb $0x1a, -0x30(%rbp)
je 0xa650d
movq %r14, %rdi
callq 0x2a9a0
movl %eax, %edi
callq 0xb3eb8
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
movl $0x4, %esi
movl $0x3, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0xa5c33
jmp 0xa650d
|
my_fwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_30], rcx
mov r12, rdx
mov rbx, rsi
mov r14, rdi
call _ftello64
mov r13, rax
mov esi, 1
mov [rbp+var_48], rbx
mov rdi, rbx
mov rdx, r12
mov rcx, r14
call _fwrite
cmp rax, r12
jnz short loc_A6467
mov [rbp+var_38], 0
jmp loc_A64FF
loc_A6467:
mov r15, rax
mov [rbp+var_38], 0
call ___errno_location
mov [rbp+var_40], rax
loc_A647B:
mov rbx, r14
mov rax, [rbp+var_40]
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
mov rsi, r13
cmp r15, 0FFFFFFFFFFFFFFFFh
jz short loc_A64A4
add rsi, r15
add [rbp+var_48], r15
add [rbp+var_38], r15
sub r12, r15
loc_A64A4:
mov rax, [rbp+var_40]
cmp dword ptr [rax], 4
mov r14, rbx
mov rdi, rbx
jnz short loc_A64E7
mov r13, rsi
xor edx, edx
call _fseeko64
test eax, eax
jnz short loc_A64C9
mov rdi, r14
call _ftello64
loc_A64C9:
mov esi, 1
mov rdi, [rbp+var_48]
mov rdx, r12
mov rcx, r14
call _fwrite
mov r15, rax
cmp rax, r12
jnz short loc_A647B
jmp short loc_A64FF
loc_A64E7:
call _ferror
test eax, eax
setz al
test byte ptr [rbp+var_30], 6
setz cl
mov r12, r15
test cl, al
jz short loc_A651F
loc_A64FF:
add r12, [rbp+var_38]
xor ebx, ebx
test byte ptr [rbp+var_30], 6
cmovz rbx, r12
loc_A650D:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A651F:
mov rbx, 0FFFFFFFFFFFFFFFFh
test byte ptr [rbp+var_30], 1Ah
jz short loc_A650D
mov rdi, r14
call _fileno
mov edi, eax
call my_filename
mov rcx, [rbp+var_40]
mov ecx, [rcx]
mov esi, 4
mov edi, 3
mov rdx, rax
xor eax, eax
call my_error
jmp short loc_A650D
|
long long my_fwrite(long long a1, long long a2, long long a3, char a4)
{
long long v6; // r13
long long v7; // rdi
long long v8; // rax
long long v9; // r15
long long v10; // rbx
unsigned int v11; // r14d
long long v12; // rsi
long long v13; // r12
long long v14; // rbx
unsigned int v16; // eax
long long v17; // rax
long long v18; // [rsp+8h] [rbp-48h]
unsigned int *v19; // [rsp+10h] [rbp-40h]
long long v20; // [rsp+18h] [rbp-38h]
v6 = ((long long (*)(void))ftello64)();
v18 = a2;
v7 = a2;
v8 = fwrite(a2, 1LL, a3, a1);
if ( v8 == a3 )
{
v20 = 0LL;
LABEL_12:
v13 = v20 + a3;
v14 = 0LL;
if ( (a4 & 6) == 0 )
return v13;
return v14;
}
v9 = v8;
v20 = 0LL;
v19 = (unsigned int *)__errno_location(a2);
while ( 1 )
{
v10 = a1;
v11 = *v19;
*(_DWORD *)my_thread_var(v7) = v11;
v12 = v6;
if ( v9 != -1 )
{
v12 = v9 + v6;
v18 += v9;
v20 += v9;
a3 -= v9;
}
a1 = v10;
if ( *v19 != 4 )
break;
v6 = v12;
if ( !(unsigned int)fseeko64(v10, v12, 0LL) )
ftello64(v10);
v7 = v18;
v9 = fwrite(v18, 1LL, a3, v10);
if ( v9 == a3 )
goto LABEL_12;
}
a3 = v9;
if ( (unsigned int)ferror(v10) == 0 && (a4 & 6) == 0 )
goto LABEL_12;
v14 = -1LL;
if ( (a4 & 0x1A) != 0 )
{
v16 = fileno(a1);
v17 = my_filename(v16);
my_error(3u, 4LL, v17, *v19);
}
return v14;
}
|
my_fwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x30],RCX
MOV R12,RDX
MOV RBX,RSI
MOV R14,RDI
CALL 0x0012aa40
MOV R13,RAX
MOV ESI,0x1
MOV qword ptr [RBP + -0x48],RBX
MOV RDI,RBX
MOV RDX,R12
MOV RCX,R14
CALL 0x0012a8c0
CMP RAX,R12
JNZ 0x001a6467
MOV qword ptr [RBP + -0x38],0x0
JMP 0x001a64ff
LAB_001a6467:
MOV R15,RAX
MOV qword ptr [RBP + -0x38],0x0
CALL 0x0012a7f0
MOV qword ptr [RBP + -0x40],RAX
LAB_001a647b:
MOV RBX,R14
MOV RAX,qword ptr [RBP + -0x40]
MOV R14D,dword ptr [RAX]
CALL 0x001ac2be
MOV dword ptr [RAX],R14D
MOV RSI,R13
CMP R15,-0x1
JZ 0x001a64a4
ADD RSI,R15
ADD qword ptr [RBP + -0x48],R15
ADD qword ptr [RBP + -0x38],R15
SUB R12,R15
LAB_001a64a4:
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX],0x4
MOV R14,RBX
MOV RDI,RBX
JNZ 0x001a64e7
MOV R13,RSI
XOR EDX,EDX
CALL 0x0012a040
TEST EAX,EAX
JNZ 0x001a64c9
MOV RDI,R14
CALL 0x0012aa40
LAB_001a64c9:
MOV ESI,0x1
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,R12
MOV RCX,R14
CALL 0x0012a8c0
MOV R15,RAX
CMP RAX,R12
JNZ 0x001a647b
JMP 0x001a64ff
LAB_001a64e7:
CALL 0x0012a660
TEST EAX,EAX
SETZ AL
TEST byte ptr [RBP + -0x30],0x6
SETZ CL
MOV R12,R15
TEST CL,AL
JZ 0x001a651f
LAB_001a64ff:
ADD R12,qword ptr [RBP + -0x38]
XOR EBX,EBX
TEST byte ptr [RBP + -0x30],0x6
CMOVZ RBX,R12
LAB_001a650d:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a651f:
MOV RBX,-0x1
TEST byte ptr [RBP + -0x30],0x1a
JZ 0x001a650d
MOV RDI,R14
CALL 0x0012a9a0
MOV EDI,EAX
CALL 0x001b3eb8
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX]
MOV ESI,0x4
MOV EDI,0x3
MOV RDX,RAX
XOR EAX,EAX
CALL 0x001a5c33
JMP 0x001a650d
|
long my_fwrite(FILE *param_1,void *param_2,size_t param_3,ulong param_4)
{
int iVar1;
__off64_t __off;
size_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
long lVar6;
void *local_50;
long local_40;
__off = ftello64(param_1);
sVar2 = fwrite(param_2,1,param_3,param_1);
if (sVar2 == param_3) {
local_40 = 0;
}
else {
local_40 = 0;
piVar3 = __errno_location();
local_50 = param_2;
do {
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (sVar2 != 0xffffffffffffffff) {
__off = __off + sVar2;
local_50 = (void *)((long)local_50 + sVar2);
local_40 = local_40 + sVar2;
param_3 = param_3 - sVar2;
}
if (*piVar3 != 4) {
iVar1 = ferror(param_1);
param_3 = sVar2;
if ((param_4 & 6) != 0 || iVar1 != 0) {
if ((param_4 & 0x1a) == 0) {
return -1;
}
iVar1 = fileno(param_1);
uVar5 = my_filename(iVar1);
my_error(3,4,uVar5,*piVar3);
return -1;
}
break;
}
iVar1 = fseeko64(param_1,__off,0);
if (iVar1 == 0) {
ftello64(param_1);
}
sVar2 = fwrite(local_50,1,param_3,param_1);
} while (sVar2 != param_3);
}
lVar6 = 0;
if ((param_4 & 6) == 0) {
lVar6 = param_3 + local_40;
}
return lVar6;
}
|
|
64,050 |
hashcmp
|
eloqsql/mysys/hash.c
|
static int hashcmp(const HASH *hash, HASH_LINK *pos, const uchar *key,
size_t length)
{
size_t rec_keylength;
uchar *rec_key= (uchar*) my_hash_key(hash, pos->data, &rec_keylength, 1);
return ((length && length != rec_keylength) ||
my_strnncoll(hash->charset, (uchar*) rec_key, rec_keylength,
(uchar*) key, rec_keylength));
}
|
O3
|
c
|
hashcmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rdi, %r14
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x4a198
leaq -0x28(%rbp), %r12
movq %rsi, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *%rax
movq %rax, %rsi
movq (%r12), %rdx
jmp 0x4a1a3
movq 0x8(%r14), %rdx
movq %rdx, -0x28(%rbp)
addq (%r14), %rsi
testq %r15, %r15
sete %al
cmpq %r15, %rdx
sete %cl
orb %al, %cl
movl $0x1, %eax
cmpb $0x1, %cl
jne 0x4a1db
movq 0x68(%r14), %rdi
movq 0xc0(%rdi), %rax
movq %rbx, %rcx
movq %rdx, %r8
xorl %r9d, %r9d
callq *0x8(%rax)
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
hashcmp:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15, rcx
mov rbx, rdx
mov r14, rdi
mov rax, [rdi+50h]
test rax, rax
jz short loc_4A198
lea r12, [rbp+var_28]
mov rdi, rsi
mov rsi, r12
mov edx, 1
call rax
mov rsi, rax
mov rdx, [r12]
jmp short loc_4A1A3
loc_4A198:
mov rdx, [r14+8]
mov [rbp+var_28], rdx
add rsi, [r14]
loc_4A1A3:
test r15, r15
setz al
cmp rdx, r15
setz cl
or cl, al
mov eax, 1
cmp cl, 1
jnz short loc_4A1DB
mov rdi, [r14+68h]
mov rax, [rdi+0C0h]
mov rcx, rbx
mov r8, rdx
xor r9d, r9d
call qword ptr [rax+8]
mov ecx, eax
xor eax, eax
test ecx, ecx
setnz al
loc_4A1DB:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
_BOOL8 hashcmp(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long ( *v6)(long long, _QWORD *, long long); // rax
long long v7; // rsi
long long v8; // rdx
_BOOL8 result; // rax
_QWORD v10[5]; // [rsp+8h] [rbp-28h] BYREF
v6 = (long long ( *)(long long, _QWORD *, long long))a1[10];
if ( v6 )
{
v7 = v6(a2, v10, 1LL);
v8 = v10[0];
}
else
{
v8 = a1[1];
v10[0] = v8;
v7 = *a1 + a2;
}
result = 1LL;
if ( a4 == 0 || v8 == a4 )
return (*(unsigned int ( **)(_QWORD, long long, long long, long long, long long, _QWORD))(*(_QWORD *)(a1[13] + 192LL)
+ 8LL))(
a1[13],
v7,
v8,
a3,
v8,
0LL) != 0;
return result;
}
|
hashcmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RCX
MOV RBX,RDX
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
JZ 0x0014a198
LEA R12,[RBP + -0x28]
MOV RDI,RSI
MOV RSI,R12
MOV EDX,0x1
CALL RAX
MOV RSI,RAX
MOV RDX,qword ptr [R12]
JMP 0x0014a1a3
LAB_0014a198:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x28],RDX
ADD RSI,qword ptr [R14]
LAB_0014a1a3:
TEST R15,R15
SETZ AL
CMP RDX,R15
SETZ CL
OR CL,AL
MOV EAX,0x1
CMP CL,0x1
JNZ 0x0014a1db
MOV RDI,qword ptr [R14 + 0x68]
MOV RAX,qword ptr [RDI + 0xc0]
MOV RCX,RBX
MOV R8,RDX
XOR R9D,R9D
CALL qword ptr [RAX + 0x8]
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
SETNZ AL
LAB_0014a1db:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
bool hashcmp(long *param_1,long param_2,int8 param_3,long param_4)
{
int iVar1;
bool bVar2;
long local_30;
if ((code *)param_1[10] == (code *)0x0) {
local_30 = param_1[1];
param_2 = param_2 + *param_1;
}
else {
param_2 = (*(code *)param_1[10])(param_2,&local_30,1);
}
bVar2 = true;
if (local_30 == param_4 || param_4 == 0) {
iVar1 = (**(code **)(*(long *)(param_1[0xd] + 0xc0) + 8))
(param_1[0xd],param_2,local_30,param_3,local_30,0);
bVar2 = iVar1 != 0;
}
return bVar2;
}
|
|
64,051 |
bitmap_set_next
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_set_next(MY_BITMAP *map)
{
uint bit_found;
DBUG_ASSERT(map->bitmap);
if ((bit_found= bitmap_get_first(map)) != MY_BIT_NONE)
bitmap_set_bit(map, bit_found);
return bit_found;
}
|
O3
|
c
|
bitmap_set_next:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9d488
cmpl $-0x1, %eax
je 0x9d481
movq (%rbx), %rdx
movl %eax, %esi
movl %eax, %ecx
andb $0x7, %cl
movl $0x1, %edi
shll %cl, %edi
shrl $0x3, %esi
orb %dil, (%rdx,%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
bitmap_set_next:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call bitmap_get_first
cmp eax, 0FFFFFFFFh
jz short loc_9D481
mov rdx, [rbx]
mov esi, eax
mov ecx, eax
and cl, 7
mov edi, 1
shl edi, cl
shr esi, 3
or [rdx+rsi], dil
loc_9D481:
add rsp, 8
pop rbx
pop rbp
retn
|
long long bitmap_set_next(_QWORD *a1)
{
long long result; // rax
result = bitmap_get_first(a1);
if ( (_DWORD)result != -1 )
*(_BYTE *)(*a1 + ((unsigned int)result >> 3)) |= 1 << (result & 7);
return result;
}
|
bitmap_set_next:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0019d488
CMP EAX,-0x1
JZ 0x0019d481
MOV RDX,qword ptr [RBX]
MOV ESI,EAX
MOV ECX,EAX
AND CL,0x7
MOV EDI,0x1
SHL EDI,CL
SHR ESI,0x3
OR byte ptr [RDX + RSI*0x1],DIL
LAB_0019d481:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void bitmap_set_next(long *param_1)
{
byte *pbVar1;
uint uVar2;
uVar2 = bitmap_get_first();
if (uVar2 != 0xffffffff) {
pbVar1 = (byte *)(*param_1 + (ulong)(uVar2 >> 3));
*pbVar1 = *pbVar1 | (byte)(1 << ((byte)uVar2 & 7));
}
return;
}
|
|
64,052 |
my_string_metadata_get
|
eloqsql/strings/ctype.c
|
void
my_string_metadata_get(MY_STRING_METADATA *metadata,
CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbmaxlen == 1 && !(cs->state & MY_CS_NONASCII))
{
metadata->char_length= length;
metadata->repertoire= my_string_repertoire_8bit(cs, str, (ulong)length);
}
else
{
my_string_metadata_get_mb(metadata, cs, str, (ulong)length);
}
}
|
O3
|
c
|
my_string_metadata_get:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x1, 0x9c(%rsi)
jne 0xd13f9
testb $0x20, 0xd(%r12)
jne 0xd13f9
movq %r14, (%rbx)
movl $0x3, %eax
testq %r14, %r14
je 0xd13d9
movl $0x2000, %ecx # imm = 0x2000
andl 0xc(%r12), %ecx
jne 0xd13f4
testq %r14, %r14
jle 0xd13ef
addq %r15, %r14
cmpb $0x0, (%r15)
js 0xd13f4
incq %r15
cmpq %r14, %r15
jb 0xd13e1
movl $0x1, %eax
movl %eax, 0x8(%rbx)
jmp 0xd1463
movl $0x1, 0x8(%rbx)
movq $0x0, (%rbx)
testq %r14, %r14
jle 0xd1463
addq %r15, %r14
leaq -0x30(%rbp), %r13
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x28(%rax)
testl %eax, %eax
jle 0xd143e
cmpq $0x80, -0x30(%rbp)
jb 0xd1456
orb $0x2, 0x8(%rbx)
jmp 0xd1456
je 0xd144d
orb $0x2, 0x8(%rbx)
cmpl $-0x64, %eax
jb 0xd1463
negl %eax
jmp 0xd1456
orb $0x2, 0x8(%rbx)
movl $0x1, %eax
movl %eax, %eax
addq %rax, %r15
incq (%rbx)
cmpq %r14, %r15
jb 0xd1413
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_string_metadata_get:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
cmp dword ptr [rsi+9Ch], 1
jnz short loc_D13F9
test byte ptr [r12+0Dh], 20h
jnz short loc_D13F9
mov [rbx], r14
mov eax, 3
test r14, r14
jz short loc_D13D9
mov ecx, 2000h
and ecx, [r12+0Ch]
jnz short loc_D13F4
loc_D13D9:
test r14, r14
jle short loc_D13EF
add r14, r15
loc_D13E1:
cmp byte ptr [r15], 0
js short loc_D13F4
inc r15
cmp r15, r14
jb short loc_D13E1
loc_D13EF:
mov eax, 1
loc_D13F4:
mov [rbx+8], eax
jmp short loc_D1463
loc_D13F9:
mov dword ptr [rbx+8], 1
mov qword ptr [rbx], 0
test r14, r14
jle short loc_D1463
add r14, r15
lea r13, [rbp+var_30]
loc_D1413:
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r13
mov rdx, r15
mov rcx, r14
call qword ptr [rax+28h]
test eax, eax
jle short loc_D143E
cmp [rbp+var_30], 80h
jb short loc_D1456
or byte ptr [rbx+8], 2
jmp short loc_D1456
loc_D143E:
jz short loc_D144D
or byte ptr [rbx+8], 2
cmp eax, 0FFFFFF9Ch
jb short loc_D1463
neg eax
jmp short loc_D1456
loc_D144D:
or byte ptr [rbx+8], 2
mov eax, 1
loc_D1456:
mov eax, eax
add r15, rax
inc qword ptr [rbx]
cmp r15, r14
jb short loc_D1413
loc_D1463:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_string_metadata_get(long long a1, long long a2, char *a3, long long a4)
{
long long result; // rax
char *v5; // r15
unsigned long long v6; // r14
unsigned long long v7[6]; // [rsp+0h] [rbp-30h] BYREF
v7[0] = result;
v5 = a3;
if ( *(_DWORD *)(a2 + 156) != 1 || (*(_BYTE *)(a2 + 13) & 0x20) != 0 )
{
*(_DWORD *)(a1 + 8) = 1;
*(_QWORD *)a1 = 0LL;
if ( a4 > 0 )
{
v6 = (unsigned long long)&a3[a4];
do
{
result = (*(long long ( **)(long long, unsigned long long *, char *, unsigned long long))(*(_QWORD *)(a2 + 184)
+ 40LL))(
a2,
v7,
v5,
v6);
if ( (int)result <= 0 )
{
if ( (_DWORD)result )
{
*(_BYTE *)(a1 + 8) |= 2u;
if ( (unsigned int)result < 0xFFFFFF9C )
return result;
LODWORD(result) = -(int)result;
}
else
{
*(_BYTE *)(a1 + 8) |= 2u;
LODWORD(result) = 1;
}
}
else if ( v7[0] >= 0x80 )
{
*(_BYTE *)(a1 + 8) |= 2u;
}
result = (unsigned int)result;
v5 += (unsigned int)result;
++*(_QWORD *)a1;
}
while ( (unsigned long long)v5 < v6 );
}
}
else
{
*(_QWORD *)a1 = a4;
result = 3LL;
if ( !a4 || (*(_DWORD *)(a2 + 12) & 0x2000) == 0 )
{
if ( a4 <= 0 )
{
LABEL_8:
result = 1LL;
}
else
{
while ( *v5 >= 0 )
{
if ( ++v5 >= &a3[a4] )
goto LABEL_8;
}
}
}
*(_DWORD *)(a1 + 8) = result;
}
return result;
}
|
my_string_metadata_get:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
CMP dword ptr [RSI + 0x9c],0x1
JNZ 0x001d13f9
TEST byte ptr [R12 + 0xd],0x20
JNZ 0x001d13f9
MOV qword ptr [RBX],R14
MOV EAX,0x3
TEST R14,R14
JZ 0x001d13d9
MOV ECX,0x2000
AND ECX,dword ptr [R12 + 0xc]
JNZ 0x001d13f4
LAB_001d13d9:
TEST R14,R14
JLE 0x001d13ef
ADD R14,R15
LAB_001d13e1:
CMP byte ptr [R15],0x0
JS 0x001d13f4
INC R15
CMP R15,R14
JC 0x001d13e1
LAB_001d13ef:
MOV EAX,0x1
LAB_001d13f4:
MOV dword ptr [RBX + 0x8],EAX
JMP 0x001d1463
LAB_001d13f9:
MOV dword ptr [RBX + 0x8],0x1
MOV qword ptr [RBX],0x0
TEST R14,R14
JLE 0x001d1463
ADD R14,R15
LEA R13,[RBP + -0x30]
LAB_001d1413:
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R13
MOV RDX,R15
MOV RCX,R14
CALL qword ptr [RAX + 0x28]
TEST EAX,EAX
JLE 0x001d143e
CMP qword ptr [RBP + -0x30],0x80
JC 0x001d1456
OR byte ptr [RBX + 0x8],0x2
JMP 0x001d1456
LAB_001d143e:
JZ 0x001d144d
OR byte ptr [RBX + 0x8],0x2
CMP EAX,-0x64
JC 0x001d1463
NEG EAX
JMP 0x001d1456
LAB_001d144d:
OR byte ptr [RBX + 0x8],0x2
MOV EAX,0x1
LAB_001d1456:
MOV EAX,EAX
ADD R15,RAX
INC qword ptr [RBX]
CMP R15,R14
JC 0x001d1413
LAB_001d1463:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_string_metadata_get(long *param_1,long param_2,char *param_3,long param_4)
{
int4 uVar1;
uint uVar2;
ulong in_RAX;
char *pcVar3;
ulong local_38;
if ((*(int *)(param_2 + 0x9c) == 1) && ((*(byte *)(param_2 + 0xd) & 0x20) == 0)) {
*param_1 = param_4;
uVar1 = 3;
if ((param_4 == 0) || ((*(uint *)(param_2 + 0xc) & 0x2000) == 0)) {
if (0 < param_4) {
pcVar3 = param_3 + param_4;
do {
if (*param_3 < '\0') goto LAB_001d13f4;
param_3 = param_3 + 1;
} while (param_3 < pcVar3);
}
uVar1 = 1;
}
LAB_001d13f4:
*(int4 *)(param_1 + 1) = uVar1;
}
else {
*(int4 *)(param_1 + 1) = 1;
*param_1 = 0;
if (0 < param_4) {
pcVar3 = param_3 + param_4;
local_38 = in_RAX;
do {
uVar2 = (**(code **)(*(long *)(param_2 + 0xb8) + 0x28))(param_2,&local_38,param_3,pcVar3);
if ((int)uVar2 < 1) {
if (uVar2 == 0) {
*(byte *)(param_1 + 1) = *(byte *)(param_1 + 1) | 2;
uVar2 = 1;
}
else {
*(byte *)(param_1 + 1) = *(byte *)(param_1 + 1) | 2;
if (uVar2 < 0xffffff9c) {
return;
}
uVar2 = -uVar2;
}
}
else if (0x7f < local_38) {
*(byte *)(param_1 + 1) = *(byte *)(param_1 + 1) | 2;
}
param_3 = param_3 + uVar2;
*param_1 = *param_1 + 1;
} while (param_3 < pcVar3);
}
}
return;
}
|
|
64,053 |
maria_ftparser_call_deinitializer
|
eloqsql/storage/maria/ma_ft_parser.c
|
void maria_ftparser_call_deinitializer(MARIA_HA *info)
{
uint i, j, keys= info->s->state.header.keys;
free_root(&info->ft_memroot, MYF(0));
if (! info->ftparser_param)
return;
for (i= 0; i < keys; i++)
{
MARIA_KEYDEF *keyinfo= &info->s->keyinfo[i];
for (j=0; j < MAX_PARAM_NR; j++)
{
MYSQL_FTPARSER_PARAM *ftparser_param=
&info->ftparser_param[keyinfo->ftkey_nr*MAX_PARAM_NR + j];
if (keyinfo->flag & HA_FULLTEXT && ftparser_param->mysql_add_word)
{
if (keyinfo->parser->deinit)
keyinfo->parser->deinit(ftparser_param);
ftparser_param->mysql_add_word= 0;
}
else
break;
}
}
}
|
O0
|
c
|
maria_ftparser_call_deinitializer:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x12(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x328, %rdi # imm = 0x328
xorl %eax, %eax
movl %eax, %esi
callq 0xeed90
movq -0x8(%rbp), %rax
cmpq $0x0, 0x368(%rax)
jne 0x4d521
jmp 0x4d602
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x4d602
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jae 0x4d5f2
movq -0x8(%rbp), %rax
movq 0x368(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0xbc(%rcx), %ecx
shll %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4d5e0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d5e0
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x4d5d2
movq -0x20(%rbp), %rax
movq 0xd0(%rax), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x4d5e2
jmp 0x4d5f2
jmp 0x4d5e4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d55a
jmp 0x4d5f4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d528
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
maria_ftparser_call_deinitializer:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
movzx eax, byte ptr [rax+12h]
mov [rbp+var_14], eax
mov rdi, [rbp+var_8]
add rdi, 328h
xor eax, eax
mov esi, eax
call free_root
mov rax, [rbp+var_8]
cmp qword ptr [rax+368h], 0
jnz short loc_4D521
jmp loc_4D602
loc_4D521:
mov [rbp+var_C], 0
loc_4D528:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jnb loc_4D602
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
mov [rbp+var_20], rax
mov [rbp+var_10], 0
loc_4D55A:
cmp [rbp+var_10], 2
jnb loc_4D5F2
mov rax, [rbp+var_8]
mov rax, [rax+368h]
mov rcx, [rbp+var_20]
mov ecx, [rcx+0BCh]
shl ecx, 1
add ecx, [rbp+var_10]
mov ecx, ecx
shl rcx, 6
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+0A2h]
and eax, 80h
cmp eax, 0
jz short loc_4D5E0
mov rax, [rbp+var_28]
cmp qword ptr [rax+8], 0
jz short loc_4D5E0
mov rax, [rbp+var_20]
mov rax, [rax+0D0h]
cmp qword ptr [rax+18h], 0
jz short loc_4D5D2
mov rax, [rbp+var_20]
mov rax, [rax+0D0h]
mov rax, [rax+18h]
mov rdi, [rbp+var_28]
call rax
loc_4D5D2:
mov rax, [rbp+var_28]
mov qword ptr [rax+8], 0
jmp short loc_4D5E2
loc_4D5E0:
jmp short loc_4D5F2
loc_4D5E2:
jmp short $+2
loc_4D5E4:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp loc_4D55A
loc_4D5F2:
jmp short $+2
loc_4D5F4:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
jmp loc_4D528
loc_4D602:
add rsp, 30h
pop rbp
retn
|
unsigned long long maria_ftparser_call_deinitializer(_QWORD *a1)
{
unsigned long long result; // rax
unsigned long long v2; // [rsp+8h] [rbp-28h]
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
unsigned int j; // [rsp+20h] [rbp-10h]
unsigned int i; // [rsp+24h] [rbp-Ch]
v4 = *(unsigned __int8 *)(*a1 + 18LL);
free_root(a1 + 101, 0LL);
result = (unsigned long long)a1;
if ( a1[109] )
{
for ( i = 0; ; ++i )
{
result = i;
if ( i >= v4 )
break;
v3 = 280LL * i + *(_QWORD *)(*a1 + 1392LL);
for ( j = 0; j < 2; ++j )
{
v2 = ((unsigned long long)(j + 2 * *(_DWORD *)(v3 + 188)) << 6) + a1[109];
if ( (*(_WORD *)(v3 + 162) & 0x80) == 0 || !*(_QWORD *)(v2 + 8) )
break;
if ( *(_QWORD *)(*(_QWORD *)(v3 + 208) + 24LL) )
(*(void ( **)(unsigned long long))(*(_QWORD *)(v3 + 208) + 24LL))(v2);
*(_QWORD *)(v2 + 8) = 0LL;
}
}
}
return result;
}
|
maria_ftparser_call_deinitializer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX + 0x12]
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x328
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001eed90
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x368],0x0
JNZ 0x0014d521
JMP 0x0014d602
LAB_0014d521:
MOV dword ptr [RBP + -0xc],0x0
LAB_0014d528:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x0014d602
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x10],0x0
LAB_0014d55a:
CMP dword ptr [RBP + -0x10],0x2
JNC 0x0014d5f2
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x368]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0xbc]
SHL ECX,0x1
ADD ECX,dword ptr [RBP + -0x10]
MOV ECX,ECX
SHL RCX,0x6
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x80
CMP EAX,0x0
JZ 0x0014d5e0
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0014d5e0
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xd0]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0014d5d2
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0xd0]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
LAB_0014d5d2:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],0x0
JMP 0x0014d5e2
LAB_0014d5e0:
JMP 0x0014d5f2
LAB_0014d5e2:
JMP 0x0014d5e4
LAB_0014d5e4:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014d55a
LAB_0014d5f2:
JMP 0x0014d5f4
LAB_0014d5f4:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x0014d528
LAB_0014d602:
ADD RSP,0x30
POP RBP
RET
|
void maria_ftparser_call_deinitializer(long *param_1)
{
byte bVar1;
long lVar2;
long lVar3;
uint local_18;
uint local_14;
bVar1 = *(byte *)(*param_1 + 0x12);
free_root(param_1 + 0x65,0);
if (param_1[0x6d] != 0) {
for (local_14 = 0; local_14 < bVar1; local_14 = local_14 + 1) {
lVar2 = *(long *)(*param_1 + 0x570) + (ulong)local_14 * 0x118;
local_18 = 0;
while (((local_18 < 2 &&
(lVar3 = param_1[0x6d] + (ulong)(*(int *)(lVar2 + 0xbc) * 2 + local_18) * 0x40,
(*(ushort *)(lVar2 + 0xa2) & 0x80) != 0)) && (*(long *)(lVar3 + 8) != 0))) {
if (*(long *)(*(long *)(lVar2 + 0xd0) + 0x18) != 0) {
(**(code **)(*(long *)(lVar2 + 0xd0) + 0x18))(lVar3);
}
*(int8 *)(lVar3 + 8) = 0;
local_18 = local_18 + 1;
}
}
}
return;
}
|
|
64,054 |
bf_atan
|
bluesky950520[P]quickjs/libbf.c
|
int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
bf_context_t *s = r->ctx;
bf_t T_s, *T = &T_s;
int res;
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF) {
/* -PI/2 or PI/2 */
bf_const_pi_signed(r, a->sign, prec, flags);
bf_mul_2exp(r, -1, BF_PREC_INF, BF_RNDZ);
return BF_ST_INEXACT;
} else {
bf_set_zero(r, a->sign);
return 0;
}
}
bf_init(s, T);
bf_set_ui(T, 1);
res = bf_cmpu(a, T);
bf_delete(T);
if (res == 0) {
/* short cut: abs(a) == 1 -> +/-pi/4 */
bf_const_pi_signed(r, a->sign, prec, flags);
bf_mul_2exp(r, -2, BF_PREC_INF, BF_RNDZ);
return BF_ST_INEXACT;
}
/* small argument case: result = x+r(x) with r(x) = -x^3/3 +
O(X^5). We assume r(x) < 2^(3*EXP(x) - 1). */
if (a->expn < 0) {
slimb_t e;
e = sat_add(2 * a->expn, a->expn - 1);
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
bf_set(r, a);
return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
}
}
return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
}
|
O1
|
c
|
bf_atan:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rcx
cmpq $0x0, 0x18(%rsi)
je 0x8c015
movq %rsp, %r13
movq %rcx, (%r13)
movl $0x0, 0x8(%r13)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r13)
movl $0x1, %esi
movq %r13, %rdi
callq 0x83ea7
movq %r15, %rdi
movq %r13, %rsi
callq 0x84816
movl %eax, %r12d
movq (%r13), %rax
testq %rax, %rax
je 0x8bf77
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x8bf77
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
testl %r12d, %r12d
je 0x8c07b
movq 0x10(%r15), %r13
testq %r13, %r13
jns 0x8bfed
leaq -0x1(,%r13,2), %rdx
addq %r13, %rdx
leaq 0x2(%r14), %rax
movq 0x18(%r15), %rcx
shlq $0x6, %rcx
orq $0x2, %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
subq %rcx, %r13
cmpq %r13, %rdx
jge 0x8bfe4
movq %rbx, %rdi
movq %r15, %rsi
movq %rdx, %r12
callq 0x84079
movl $0x1, %ecx
subl 0x8(%r15), %ecx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %r8
movl %ebp, %r9d
callq 0x8a036
movq %r12, %rdx
movl %eax, %r12d
cmpq %r13, %rdx
jl 0x8c136
leaq 0x154(%rip), %r8 # 0x8c148
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
xorl %r9d, %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a0d8
movq 0x10(%r15), %rax
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rdx, %rax
je 0x8c0b4
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rdx, %rax
jne 0x8c0ff
cmpq $0x0, 0x18(%rbx)
je 0x8c05e
movq 0x20(%rbx), %rsi
movq (%rcx), %rdi
xorl %edx, %edx
callq *0x8(%rcx)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
decq %rax
movq %rax, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x8c133
movl 0x8(%r15), %r9d
movq (%rbx), %rcx
addq $0x40, %rcx
leaq 0x52c8(%rip), %r8 # 0x91355
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x89a2c
movq 0x18(%rbx), %rcx
movl $0x10, %r12d
testq %rcx, %rcx
je 0x8c136
addq $-0x2, 0x10(%rbx)
jmp 0x8c0e3
movl 0x8(%r15), %r9d
addq $0x40, %rcx
leaq 0x5292(%rip), %r8 # 0x91355
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x89a2c
movq 0x18(%rbx), %rcx
movl $0x10, %r12d
testq %rcx, %rcx
je 0x8c136
decq 0x10(%rbx)
movabsq $0x3fffffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFFFF
movq %rbx, %rdi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x84212
jmp 0x8c136
movl 0x8(%r15), %ebp
cmpq $0x0, 0x18(%rbx)
je 0x8c122
movq 0x20(%rbx), %rsi
movq (%rcx), %rdi
xorl %edx, %edx
callq *0x8(%rcx)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
bf_atan:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rcx, [rdi]
cmp qword ptr [rsi+18h], 0
jz loc_8C015
mov r13, rsp
mov [r13+0], rcx
mov dword ptr [r13+8], 0
mov rax, 8000000000000000h
mov [r13+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [r13+18h], xmm0
mov esi, 1
mov rdi, r13
call bf_set_ui
mov rdi, r15
mov rsi, r13
call bf_cmpu
mov r12d, eax
mov rax, [r13+0]
test rax, rax
jz short loc_8BF77
mov rsi, [rsp+58h+var_38]
test rsi, rsi
jz short loc_8BF77
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_8BF77:
test r12d, r12d
jz loc_8C07B
mov r13, [r15+10h]
test r13, r13
jns short loc_8BFED
lea rdx, ds:0FFFFFFFFFFFFFFFFh[r13*2]
add rdx, r13
lea rax, [r14+2]
mov rcx, [r15+18h]
shl rcx, 6
or rcx, 2
cmp rax, rcx
cmovg rcx, rax
sub r13, rcx
cmp rdx, r13
jge short loc_8BFE4
mov rdi, rbx
mov rsi, r15
mov r12, rdx
call bf_set
mov ecx, 1
sub ecx, [r15+8]
mov rdi, rbx
mov rsi, rbx
mov rdx, r12
mov r8, r14
mov r9d, ebp
call bf_add_epsilon
mov rdx, r12
mov r12d, eax
loc_8BFE4:
cmp rdx, r13
jl loc_8C136
loc_8BFED:
lea r8, bf_atan_internal
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov ecx, ebp
xor r9d, r9d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_ziv_rounding
loc_8C015:
mov rax, [r15+10h]
mov rdx, 7FFFFFFFFFFFFFFEh
cmp rax, rdx
jz loc_8C0B4
mov rdx, 7FFFFFFFFFFFFFFFh
cmp rax, rdx
jnz loc_8C0FF
cmp qword ptr [rbx+18h], 0
jz short loc_8C05E
mov rsi, [rbx+20h]
mov rdi, [rcx]
xor edx, edx
call qword ptr [rcx+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8C05E:
mov rax, 8000000000000000h
dec rax
mov [rbx+10h], rax
mov dword ptr [rbx+8], 0
jmp loc_8C133
loc_8C07B:
mov r9d, [r15+8]
mov rcx, [rbx]
add rcx, 40h ; '@'
lea r8, bf_const_pi_internal
mov rdi, rbx
mov rsi, r14
mov edx, ebp
call bf_const_get
mov rcx, [rbx+18h]
mov r12d, 10h
test rcx, rcx
jz loc_8C136
add qword ptr [rbx+10h], 0FFFFFFFFFFFFFFFEh
jmp short loc_8C0E3
loc_8C0B4:
mov r9d, [r15+8]
add rcx, 40h ; '@'
lea r8, bf_const_pi_internal
mov rdi, rbx
mov rsi, r14
mov edx, ebp
call bf_const_get
mov rcx, [rbx+18h]
mov r12d, 10h
test rcx, rcx
jz short loc_8C136
dec qword ptr [rbx+10h]
loc_8C0E3:
mov rsi, 3FFFFFFFFFFFFFFFh
mov rdi, rbx
mov edx, 1
xor r8d, r8d
call __bf_round
jmp short loc_8C136
loc_8C0FF:
mov ebp, [r15+8]
cmp qword ptr [rbx+18h], 0
jz short loc_8C122
mov rsi, [rbx+20h]
mov rdi, [rcx]
xor edx, edx
call qword ptr [rcx+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8C122:
mov rax, 8000000000000000h
mov [rbx+10h], rax
mov [rbx+8], ebp
loc_8C133:
xor r12d, r12d
loc_8C136:
mov eax, r12d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long bf_atan(long long a1, long long a2, long long a3, unsigned int a4)
{
_QWORD *v6; // rcx
unsigned int v7; // r12d
long long v8; // r13
long long v9; // rdx
long long v10; // rcx
long long v11; // r13
long long v12; // r12
unsigned int v13; // eax
long long v15; // rax
unsigned long long v16; // rcx
int v17; // ebp
_QWORD *v18; // [rsp+0h] [rbp-58h] BYREF
int v19; // [rsp+8h] [rbp-50h]
unsigned long long v20; // [rsp+10h] [rbp-48h]
__int128 v21; // [rsp+18h] [rbp-40h]
v6 = *(_QWORD **)a1;
if ( *(_QWORD *)(a2 + 24) )
{
v18 = *(_QWORD **)a1;
v19 = 0;
v20 = 0x8000000000000000LL;
v21 = 0LL;
bf_set_ui(&v18, 1uLL);
v7 = bf_cmpu((_QWORD *)a2, &v18);
if ( v18 && *((_QWORD *)&v21 + 1) )
((void ( *)(_QWORD, _QWORD, _QWORD))v18[1])(*v18, *((_QWORD *)&v21 + 1), 0LL);
if ( v7 )
{
v8 = *(_QWORD *)(a2 + 16);
if ( v8 >= 0 )
return bf_ziv_rounding(
(_QWORD *)a1,
a2,
a3,
a4,
(void ( *)(_QWORD *, long long, long long, long long))bf_atan_internal,
0LL);
v9 = v8 + 2 * v8 - 1;
v10 = (*(_QWORD *)(a2 + 24) << 6) | 2LL;
if ( a3 + 2 > v10 )
v10 = a3 + 2;
v11 = v8 - v10;
if ( v9 < v11 )
{
v12 = v9;
bf_set((_QWORD *)a1, a2);
v13 = bf_add_epsilon((__int128 *)a1, (_QWORD *)a1, v12, 1 - *(_DWORD *)(a2 + 8), a3, a4);
v9 = v12;
v7 = v13;
}
if ( v9 >= v11 )
return bf_ziv_rounding(
(_QWORD *)a1,
a2,
a3,
a4,
(void ( *)(_QWORD *, long long, long long, long long))bf_atan_internal,
0LL);
return v7;
}
bf_const_get(
a1,
a3,
a4,
*(_QWORD *)a1 + 64LL,
(void ( *)(long long, unsigned long long))bf_const_pi_internal,
*(_DWORD *)(a2 + 8));
v16 = *(_QWORD *)(a1 + 24);
v7 = 16;
if ( !v16 )
return v7;
*(_QWORD *)(a1 + 16) -= 2LL;
LABEL_22:
_bf_round(a1, 0x3FFFFFFFFFFFFFFFLL, 1LL, v16, 0);
return v7;
}
v15 = *(_QWORD *)(a2 + 16);
if ( v15 != 0x7FFFFFFFFFFFFFFELL )
{
if ( v15 == 0x7FFFFFFFFFFFFFFFLL )
{
if ( *(_QWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 32) = ((long long ( *)(_QWORD, _QWORD, _QWORD))v6[1])(*v6, *(_QWORD *)(a1 + 32), 0LL);
*(_QWORD *)(a1 + 24) = 0LL;
}
*(_QWORD *)(a1 + 16) = 0x7FFFFFFFFFFFFFFFLL;
*(_DWORD *)(a1 + 8) = 0;
}
else
{
v17 = *(_DWORD *)(a2 + 8);
if ( *(_QWORD *)(a1 + 24) )
{
*(_QWORD *)(a1 + 32) = ((long long ( *)(_QWORD, _QWORD, _QWORD))v6[1])(*v6, *(_QWORD *)(a1 + 32), 0LL);
*(_QWORD *)(a1 + 24) = 0LL;
}
*(_QWORD *)(a1 + 16) = 0x8000000000000000LL;
*(_DWORD *)(a1 + 8) = v17;
}
return 0;
}
bf_const_get(
a1,
a3,
a4,
(long long)(v6 + 8),
(void ( *)(long long, unsigned long long))bf_const_pi_internal,
*(_DWORD *)(a2 + 8));
v16 = *(_QWORD *)(a1 + 24);
v7 = 16;
if ( v16 )
{
--*(_QWORD *)(a1 + 16);
goto LABEL_22;
}
return v7;
}
|
bf_atan:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RCX,qword ptr [RDI]
CMP qword ptr [RSI + 0x18],0x0
JZ 0x0018c015
MOV R13,RSP
MOV qword ptr [R13],RCX
MOV dword ptr [R13 + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [R13 + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x18],XMM0
MOV ESI,0x1
MOV RDI,R13
CALL 0x00183ea7
MOV RDI,R15
MOV RSI,R13
CALL 0x00184816
MOV R12D,EAX
MOV RAX,qword ptr [R13]
TEST RAX,RAX
JZ 0x0018bf77
MOV RSI,qword ptr [RSP + 0x20]
TEST RSI,RSI
JZ 0x0018bf77
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_0018bf77:
TEST R12D,R12D
JZ 0x0018c07b
MOV R13,qword ptr [R15 + 0x10]
TEST R13,R13
JNS 0x0018bfed
LEA RDX,[-0x1 + R13*0x2]
ADD RDX,R13
LEA RAX,[R14 + 0x2]
MOV RCX,qword ptr [R15 + 0x18]
SHL RCX,0x6
OR RCX,0x2
CMP RAX,RCX
CMOVG RCX,RAX
SUB R13,RCX
CMP RDX,R13
JGE 0x0018bfe4
MOV RDI,RBX
MOV RSI,R15
MOV R12,RDX
CALL 0x00184079
MOV ECX,0x1
SUB ECX,dword ptr [R15 + 0x8]
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R12
MOV R8,R14
MOV R9D,EBP
CALL 0x0018a036
MOV RDX,R12
MOV R12D,EAX
LAB_0018bfe4:
CMP RDX,R13
JL 0x0018c136
LAB_0018bfed:
LEA R8,[0x18c148]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV ECX,EBP
XOR R9D,R9D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018a0d8
LAB_0018c015:
MOV RAX,qword ptr [R15 + 0x10]
MOV RDX,0x7ffffffffffffffe
CMP RAX,RDX
JZ 0x0018c0b4
MOV RDX,0x7fffffffffffffff
CMP RAX,RDX
JNZ 0x0018c0ff
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018c05e
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RCX]
XOR EDX,EDX
CALL qword ptr [RCX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018c05e:
MOV RAX,-0x8000000000000000
DEC RAX
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],0x0
JMP 0x0018c133
LAB_0018c07b:
MOV R9D,dword ptr [R15 + 0x8]
MOV RCX,qword ptr [RBX]
ADD RCX,0x40
LEA R8,[0x191355]
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EBP
CALL 0x00189a2c
MOV RCX,qword ptr [RBX + 0x18]
MOV R12D,0x10
TEST RCX,RCX
JZ 0x0018c136
ADD qword ptr [RBX + 0x10],-0x2
JMP 0x0018c0e3
LAB_0018c0b4:
MOV R9D,dword ptr [R15 + 0x8]
ADD RCX,0x40
LEA R8,[0x191355]
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EBP
CALL 0x00189a2c
MOV RCX,qword ptr [RBX + 0x18]
MOV R12D,0x10
TEST RCX,RCX
JZ 0x0018c136
DEC qword ptr [RBX + 0x10]
LAB_0018c0e3:
MOV RSI,0x3fffffffffffffff
MOV RDI,RBX
MOV EDX,0x1
XOR R8D,R8D
CALL 0x00184212
JMP 0x0018c136
LAB_0018c0ff:
MOV EBP,dword ptr [R15 + 0x8]
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018c122
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RCX]
XOR EDX,EDX
CALL qword ptr [RCX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018c122:
MOV RAX,-0x8000000000000000
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],EBP
LAB_0018c133:
XOR R12D,R12D
LAB_0018c136:
MOV EAX,R12D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_atan(long *param_1,long param_2,long param_3,int4 param_4)
{
long lVar1;
int4 uVar2;
int8 *puVar3;
uint uVar4;
long lVar5;
ulong uVar6;
int8 *local_58;
int4 local_50;
int8 local_48;
int8 local_40;
long lStack_38;
puVar3 = (int8 *)*param_1;
if (*(long *)(param_2 + 0x18) == 0) {
if (*(long *)(param_2 + 0x10) != 0x7ffffffffffffffe) {
if (*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) {
if (param_1[3] != 0) {
lVar5 = (*(code *)puVar3[1])(*puVar3,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
}
else {
uVar2 = *(int4 *)(param_2 + 8);
if (param_1[3] != 0) {
lVar5 = (*(code *)puVar3[1])(*puVar3,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = -0x8000000000000000;
*(int4 *)(param_1 + 1) = uVar2;
}
return 0;
}
bf_const_get(param_1,param_3,param_4,puVar3 + 8,bf_const_pi_internal,
*(int4 *)(param_2 + 8));
lVar5 = param_1[3];
if (lVar5 == 0) {
return 0x10;
}
param_1[2] = param_1[2] + -1;
}
else {
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
lStack_38 = 0;
local_58 = puVar3;
bf_set_ui(&local_58,1);
uVar4 = bf_cmpu(param_2,&local_58);
if ((local_58 != (int8 *)0x0) && (lStack_38 != 0)) {
(*(code *)local_58[1])(*local_58,lStack_38,0);
}
if (uVar4 != 0) {
lVar5 = *(long *)(param_2 + 0x10);
if (lVar5 < 0) {
lVar1 = lVar5 * 3 + -1;
uVar6 = *(long *)(param_2 + 0x18) << 6 | 2;
if ((long)uVar6 < (long)(param_3 + 2U)) {
uVar6 = param_3 + 2U;
}
if (lVar1 < (long)(lVar5 - uVar6)) {
bf_set(param_1,param_2);
uVar4 = bf_add_epsilon(param_1,param_1,lVar1,1 - *(int *)(param_2 + 8),param_3,param_4);
}
if (lVar1 < (long)(lVar5 - uVar6)) {
return (ulong)uVar4;
}
}
uVar6 = bf_ziv_rounding(param_1,param_2,param_3,param_4,bf_atan_internal,0);
return uVar6;
}
bf_const_get(param_1,param_3,param_4,*param_1 + 0x40,bf_const_pi_internal,
*(int4 *)(param_2 + 8));
lVar5 = param_1[3];
if (lVar5 == 0) {
return 0x10;
}
param_1[2] = param_1[2] + -2;
}
__bf_round(param_1,0x3fffffffffffffff,1,lVar5,0);
return 0x10;
}
|
|
64,055 |
gguf_writer::write_tensor_data(gguf_tensor_info const&, unsigned long, unsigned long) const
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void write_tensor_data(const struct gguf_tensor_info & info, const size_t offset_data, const size_t alignment) const {
GGML_ASSERT(buf.size() - offset_data == info.offset);
GGML_ASSERT(ggml_is_contiguous(&info.t));
const size_t offset = buf.size();
const size_t nbytes = ggml_nbytes(&info.t);
buf.resize(offset + nbytes);
if (info.t.buffer) {
ggml_backend_tensor_get(&info.t, buf.data() + offset, 0, nbytes);
} else {
GGML_ASSERT(info.t.data);
memcpy(buf.data() + offset, info.t.data, nbytes);
}
pad(alignment);
}
|
O2
|
cpp
|
gguf_writer::write_tensor_data(gguf_tensor_info const&, unsigned long, unsigned long) const:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
addq (%rax), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
cmpq 0x150(%rsi), %rax
jne 0x42e81
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1c630
testb %al, %al
je 0x42e9d
movq (%r14), %rax
movq 0x8(%rax), %r12
subq (%rax), %r12
movq %r15, %rdi
callq 0x1c2d0
movq %rax, %r13
movq (%r14), %rdi
leaq (%rax,%r12), %rsi
callq 0x1c200
cmpq $0x0, 0x8(%r15)
je 0x42e50
movq (%r14), %rax
addq (%rax), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x1d9b0
jmp 0x42e6d
movq 0xf8(%r15), %rsi
testq %rsi, %rsi
je 0x42eb9
movq (%r14), %rax
addq (%rax), %r12
movq %r12, %rdi
movq %r13, %rdx
callq 0x1d280
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1da40
leaq 0x17a8d(%rip), %rdi # 0x5a915
leaq 0x873f(%rip), %rdx # 0x4b5ce
leaq 0x18145(%rip), %rcx # 0x5afdb
movl $0x4de, %esi # imm = 0x4DE
jmp 0x42ed3
leaq 0x17a71(%rip), %rdi # 0x5a915
leaq 0x8723(%rip), %rdx # 0x4b5ce
leaq 0x18151(%rip), %rcx # 0x5b003
movl $0x4e0, %esi # imm = 0x4E0
jmp 0x42ed3
leaq 0x17a55(%rip), %rdi # 0x5a915
leaq 0x8707(%rip), %rdx # 0x4b5ce
leaq 0x18151(%rip), %rcx # 0x5b01f
movl $0x4e8, %esi # imm = 0x4E8
xorl %eax, %eax
callq 0x1e770
|
_ZNK11gguf_writer17write_tensor_dataERK16gguf_tensor_infomm:
push r15
push r14
push r13
push r12
push rbx
mov rax, [rdi]
add rdx, [rax]
mov rax, [rax+8]
sub rax, rdx
cmp rax, [rsi+150h]
jnz loc_42E81
mov rbx, rcx
mov r15, rsi
mov r14, rdi
mov rdi, rsi
call _ggml_is_contiguous
test al, al
jz loc_42E9D
mov rax, [r14]
mov r12, [rax+8]
sub r12, [rax]
mov rdi, r15
call _ggml_nbytes
mov r13, rax
mov rdi, [r14]
lea rsi, [rax+r12]
call __ZNSt6vectorIaSaIaEE6resizeEm; std::vector<signed char>::resize(ulong)
cmp qword ptr [r15+8], 0
jz short loc_42E50
mov rax, [r14]
add r12, [rax]
mov rdi, r15
mov rsi, r12
xor edx, edx
mov rcx, r13
call _ggml_backend_tensor_get
jmp short loc_42E6D
loc_42E50:
mov rsi, [r15+0F8h]
test rsi, rsi
jz short loc_42EB9
mov rax, [r14]
add r12, [rax]
mov rdi, r12
mov rdx, r13
call _memcpy
loc_42E6D:
mov rdi, r14; this
mov rsi, rbx; unsigned __int64
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp __ZNK11gguf_writer3padEm; gguf_writer::pad(ulong)
loc_42E81:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBufSizeOffsetD; "buf.size() - offset_data == info.offset"
mov esi, 4DEh
jmp short loc_42ED3
loc_42E9D:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_24; "ggml_is_contiguous(&info.t)"
mov esi, 4E0h
jmp short loc_42ED3
loc_42EB9:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aInfoTData; "info.t.data"
mov esi, 4E8h
loc_42ED3:
xor eax, eax
call _ggml_abort
|
long long gguf_writer::write_tensor_data(
gguf_writer *this,
long long a2,
long long a3,
unsigned long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v15; // r12
unsigned long long v16; // r13
long long v17; // rsi
const char *v19; // rcx
int v20; // esi
char v21; // [rsp+0h] [rbp-28h]
if ( *(_QWORD *)(*(_QWORD *)this + 8LL) - (**(_QWORD **)this + a3) != *(_QWORD *)(a2 + 336) )
{
v19 = "buf.size() - offset_data == info.offset";
v20 = 1246;
goto LABEL_11;
}
if ( !(unsigned __int8)ggml_is_contiguous(a2) )
{
v19 = "ggml_is_contiguous(&info.t)";
v20 = 1248;
goto LABEL_11;
}
v15 = *(_QWORD *)(*(_QWORD *)this + 8LL) - **(_QWORD **)this;
v16 = ggml_nbytes((unsigned int *)a2);
std::vector<signed char>::resize(*(_QWORD *)this, v16 + v15);
if ( !*(_QWORD *)(a2 + 8) )
{
v17 = *(_QWORD *)(a2 + 248);
if ( v17 )
{
memcpy(**(_QWORD **)this + v15, v17, v16);
return gguf_writer::pad(this, a4);
}
v19 = "info.t.data";
v20 = 1256;
LABEL_11:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
v20,
(long long)"GGML_ASSERT(%s) failed",
(long long)v19,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v21);
}
ggml_backend_tensor_get(a2, **(_QWORD **)this + v15, 0LL, v16);
return gguf_writer::pad(this, a4);
}
|
write_tensor_data:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RAX,qword ptr [RDI]
ADD RDX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,RDX
CMP RAX,qword ptr [RSI + 0x150]
JNZ 0x00142e81
MOV RBX,RCX
MOV R15,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x0011c630
TEST AL,AL
JZ 0x00142e9d
MOV RAX,qword ptr [R14]
MOV R12,qword ptr [RAX + 0x8]
SUB R12,qword ptr [RAX]
MOV RDI,R15
CALL 0x0011c2d0
MOV R13,RAX
MOV RDI,qword ptr [R14]
LEA RSI,[RAX + R12*0x1]
CALL 0x0011c200
CMP qword ptr [R15 + 0x8],0x0
JZ 0x00142e50
MOV RAX,qword ptr [R14]
ADD R12,qword ptr [RAX]
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV RCX,R13
CALL 0x0011d9b0
JMP 0x00142e6d
LAB_00142e50:
MOV RSI,qword ptr [R15 + 0xf8]
TEST RSI,RSI
JZ 0x00142eb9
MOV RAX,qword ptr [R14]
ADD R12,qword ptr [RAX]
MOV RDI,R12
MOV RDX,R13
CALL 0x0011d280
LAB_00142e6d:
MOV RDI,R14
MOV RSI,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x0011da40
LAB_00142e81:
LEA RDI,[0x15a915]
LEA RDX,[0x14b5ce]
LEA RCX,[0x15afdb]
MOV ESI,0x4de
JMP 0x00142ed3
LAB_00142e9d:
LEA RDI,[0x15a915]
LEA RDX,[0x14b5ce]
LEA RCX,[0x15b003]
MOV ESI,0x4e0
JMP 0x00142ed3
LAB_00142eb9:
LEA RDI,[0x15a915]
LEA RDX,[0x14b5ce]
LEA RCX,[0x15b01f]
MOV ESI,0x4e8
LAB_00142ed3:
XOR EAX,EAX
CALL 0x0011e770
|
/* gguf_writer::write_tensor_data(gguf_tensor_info const&, unsigned long, unsigned long) const */
void __thiscall
gguf_writer::write_tensor_data
(gguf_writer *this,gguf_tensor_info *param_1,ulong param_2,ulong param_3)
{
char cVar1;
size_t __n;
char *pcVar2;
int8 uVar3;
long lVar4;
if ((*(long **)this)[1] - (param_2 + **(long **)this) == *(long *)(param_1 + 0x150)) {
cVar1 = ggml_is_contiguous(param_1);
if (cVar1 != '\0') {
lVar4 = (*(long **)this)[1] - **(long **)this;
__n = ggml_nbytes(param_1);
std::vector<signed_char,std::allocator<signed_char>>::resize
(*(vector<signed_char,std::allocator<signed_char>> **)this,__n + lVar4);
if (*(long *)(param_1 + 8) == 0) {
if (*(void **)(param_1 + 0xf8) == (void *)0x0) {
pcVar2 = "info.t.data";
uVar3 = 0x4e8;
goto LAB_00142ed3;
}
memcpy((void *)(lVar4 + **(long **)this),*(void **)(param_1 + 0xf8),__n);
}
else {
ggml_backend_tensor_get(param_1,lVar4 + **(long **)this,0,__n);
}
pad(this,param_3);
return;
}
pcVar2 = "ggml_is_contiguous(&info.t)";
uVar3 = 0x4e0;
}
else {
pcVar2 = "buf.size() - offset_data == info.offset";
uVar3 = 0x4de;
}
LAB_00142ed3:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
64,056 |
clip_log_internal(ggml_log_level, char const*, ...)
|
llama.cpp/examples/llava/clip-impl.h
|
static void clip_log_internal(enum ggml_log_level level, const char * format, ...) {
va_list args;
va_start(args, format);
clip_log_internal_v(level, format, args);
va_end(args);
}
|
O3
|
c
|
clip_log_internal(ggml_log_level, char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movq %rsi, %r14
leaq 0xc0(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1f24c
movaps %xmm0, 0xf0(%rsp)
movaps %xmm1, 0x100(%rsp)
movaps %xmm2, 0x110(%rsp)
movaps %xmm3, 0x120(%rsp)
movaps %xmm4, 0x130(%rsp)
movaps %xmm5, 0x140(%rsp)
movaps %xmm6, 0x150(%rsp)
movaps %xmm7, 0x160(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x1a0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rsp)
testq %r14, %r14
je 0x1f307
movl %edi, %ebx
movq %rsp, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x30(%rsp)
movaps (%rcx), %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x80, %esi
movq %r14, %rdx
callq 0x1cc50
cmpl $0x7f, %eax
jg 0x1f2b9
movq 0x3ece7(%rip), %rax # 0x5df90
movq 0x10(%rax), %rdx
leaq 0x40(%rsp), %rsi
movl %ebx, %edi
callq *0x8(%rax)
jmp 0x1f307
movl %eax, %r15d
leal 0x1(%r15), %r12d
movl $0x1, %esi
movq %r12, %rdi
callq 0x1cce0
movq %rax, %r13
leaq 0x20(%rsp), %rcx
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1cc50
movl %r15d, %eax
movb $0x0, (%r13,%rax)
movq 0x3ec9d(%rip), %rax # 0x5df90
movq 0x10(%rax), %rdx
movl %ebx, %edi
movq %r13, %rsi
callq *0x8(%rax)
movq %r13, %rdi
callq 0x1d810
addq $0x170, %rsp # imm = 0x170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZL17clip_log_internal14ggml_log_levelPKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 170h
mov r14, rsi
lea rsi, [rsp+198h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_1F24C
movaps [rsp+198h+var_A8], xmm0
movaps [rsp+198h+var_98], xmm1
movaps [rsp+198h+var_88], xmm2
movaps [rsp+198h+var_78], xmm3
movaps [rsp+198h+var_68], xmm4
movaps [rsp+198h+var_58], xmm5
movaps [rsp+198h+var_48], xmm6
movaps [rsp+198h+var_38], xmm7
loc_1F24C:
mov [rsp+198h+var_188], rsi
lea rax, [rsp+198h+arg_0]
mov [rsp+198h+var_190], rax
mov rax, 3000000010h
mov [rsp+198h+var_198], rax
test r14, r14
jz loc_1F307
mov ebx, edi
mov rcx, rsp
mov rax, [rcx+10h]
mov [rsp+198h+var_168], rax
movaps xmm0, xmmword ptr [rcx]
movaps [rsp+198h+var_178], xmm0
lea rdi, [rsp+198h+var_158]
mov esi, 80h
mov rdx, r14
call _vsnprintf
cmp eax, 7Fh
jg short loc_1F2B9
mov rax, cs:g_logger_state_ptr
mov rdx, [rax+10h]
lea rsi, [rsp+198h+var_158]
mov edi, ebx
call qword ptr [rax+8]
jmp short loc_1F307
loc_1F2B9:
mov r15d, eax
lea r12d, [r15+1]
mov esi, 1
mov rdi, r12
call _calloc
mov r13, rax
lea rcx, [rsp+198h+var_178]
mov rdi, rax
mov rsi, r12
mov rdx, r14
call _vsnprintf
mov eax, r15d
mov byte ptr [r13+rax+0], 0
mov rax, cs:g_logger_state_ptr
mov rdx, [rax+10h]
mov edi, ebx
mov rsi, r13
call qword ptr [rax+8]
mov rdi, r13
call _free
loc_1F307:
add rsp, 170h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long clip_log_internal(
unsigned int a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long result; // rax
int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
long long v18; // r13
_BYTE v19[128]; // [rsp+40h] [rbp-158h] BYREF
long long v20; // [rsp+D0h] [rbp-C8h]
long long v21; // [rsp+D8h] [rbp-C0h]
long long v22; // [rsp+E0h] [rbp-B8h]
long long v23; // [rsp+E8h] [rbp-B0h]
__m128 v24; // [rsp+F0h] [rbp-A8h]
__m128 v25; // [rsp+100h] [rbp-98h]
__m128 v26; // [rsp+110h] [rbp-88h]
__m128 v27; // [rsp+120h] [rbp-78h]
__m128 v28; // [rsp+130h] [rbp-68h]
__m128 v29; // [rsp+140h] [rbp-58h]
__m128 v30; // [rsp+150h] [rbp-48h]
__m128 v31; // [rsp+160h] [rbp-38h]
v24 = a7;
v25 = a8;
v26 = a9;
v27 = a10;
v28 = a11;
v29 = a12;
v30 = a13;
v31 = a14;
v20 = a3;
v21 = a4;
v22 = a5;
v23 = a6;
result = 0x3000000010LL;
if ( a2 )
{
v15 = vsnprintf(v19, 128LL, a2);
if ( v15 > 127 )
{
v16 = v15;
v17 = (unsigned int)(v15 + 1);
v18 = calloc(v17, 1LL);
vsnprintf(v18, v17, a2);
*(_BYTE *)(v18 + v16) = 0;
(*((void ( **)(_QWORD, long long, _QWORD))&g_logger_state + 1))(a1, v18, *((_QWORD *)&g_logger_state + 2));
return free(v18);
}
else
{
return (*((long long ( **)(_QWORD, _BYTE *, _QWORD))&g_logger_state + 1))(
a1,
v19,
*((_QWORD *)&g_logger_state + 2));
}
}
return result;
}
|
clip_log_internal:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x170
MOV R14,RSI
LEA RSI,[RSP + 0xc0]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x0011f24c
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVAPS xmmword ptr [RSP + 0x100],XMM1
MOVAPS xmmword ptr [RSP + 0x110],XMM2
MOVAPS xmmword ptr [RSP + 0x120],XMM3
MOVAPS xmmword ptr [RSP + 0x130],XMM4
MOVAPS xmmword ptr [RSP + 0x140],XMM5
MOVAPS xmmword ptr [RSP + 0x150],XMM6
MOVAPS xmmword ptr [RSP + 0x160],XMM7
LAB_0011f24c:
MOV qword ptr [RSP + 0x10],RSI
LEA RAX,[RSP + 0x1a0]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RSP],RAX
TEST R14,R14
JZ 0x0011f307
MOV EBX,EDI
MOV RCX,RSP
MOV RAX,qword ptr [RCX + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOVAPS XMM0,xmmword ptr [RCX]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LEA RDI,[RSP + 0x40]
MOV ESI,0x80
MOV RDX,R14
CALL 0x0011cc50
CMP EAX,0x7f
JG 0x0011f2b9
MOV RAX,qword ptr [0x0015df90]
MOV RDX,qword ptr [RAX + 0x10]
LEA RSI,[RSP + 0x40]
MOV EDI,EBX
CALL qword ptr [RAX + 0x8]
JMP 0x0011f307
LAB_0011f2b9:
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
MOV ESI,0x1
MOV RDI,R12
CALL 0x0011cce0
MOV R13,RAX
LEA RCX,[RSP + 0x20]
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R14
CALL 0x0011cc50
MOV EAX,R15D
MOV byte ptr [R13 + RAX*0x1],0x0
MOV RAX,qword ptr [0x0015df90]
MOV RDX,qword ptr [RAX + 0x10]
MOV EDI,EBX
MOV RSI,R13
CALL qword ptr [RAX + 0x8]
MOV RDI,R13
CALL 0x0011d810
LAB_0011f307:
ADD RSP,0x170
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* clip_log_internal(ggml_log_level, char const*, ...) */
void clip_log_internal(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,char *param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14,...)
{
char in_AL;
uint uVar1;
char *__s;
int8 local_198;
int1 *puStack_190;
int1 *local_188;
int8 local_178;
int1 *puStack_170;
int1 *local_168;
char local_158 [128];
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int4 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_188 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
puStack_190 = &stack0x00000008;
local_198 = 0x3000000010;
if (param_10 != (char *)0x0) {
local_178 = 0x3000000010;
puStack_170 = puStack_190;
local_168 = local_188;
local_c8 = param_11;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
uVar1 = vsnprintf(local_158,0x80,param_10,&local_198);
if ((int)uVar1 < 0x80) {
(**(code **)(PTR_g_logger_state_0015df90 + 8))
(param_9,local_158,*(int8 *)(PTR_g_logger_state_0015df90 + 0x10));
}
else {
__s = (char *)calloc((ulong)(uVar1 + 1),1);
vsnprintf(__s,(ulong)(uVar1 + 1),param_10,&local_178);
__s[uVar1] = '\0';
(**(code **)(PTR_g_logger_state_0015df90 + 8))
(param_9,__s,*(int8 *)(PTR_g_logger_state_0015df90 + 0x10));
free(__s);
}
}
return;
}
|
|
64,057 |
fill_buffer
|
eloqsql/storage/myisam/mi_packrec.c
|
static void fill_buffer(MI_BIT_BUFF *bit_buff)
{
if (bit_buff->pos >= bit_buff->end)
{
bit_buff->error= 1;
bit_buff->current_byte=0;
return;
}
#if BITS_SAVED == 64
bit_buff->current_byte= ((((uint) ((uchar) bit_buff->pos[7]))) |
(((uint) ((uchar) bit_buff->pos[6])) << 8) |
(((uint) ((uchar) bit_buff->pos[5])) << 16) |
(((uint) ((uchar) bit_buff->pos[4])) << 24) |
((ulonglong)
((((uint) ((uchar) bit_buff->pos[3]))) |
(((uint) ((uchar) bit_buff->pos[2])) << 8) |
(((uint) ((uchar) bit_buff->pos[1])) << 16) |
(((uint) ((uchar) bit_buff->pos[0])) << 24)) << 32));
bit_buff->pos+=8;
#else
#if BITS_SAVED == 32
bit_buff->current_byte= (((uint) ((uchar) bit_buff->pos[3])) |
(((uint) ((uchar) bit_buff->pos[2])) << 8) |
(((uint) ((uchar) bit_buff->pos[1])) << 16) |
(((uint) ((uchar) bit_buff->pos[0])) << 24));
bit_buff->pos+=4;
#else
bit_buff->current_byte= (uint) (((uint) ((uchar) bit_buff->pos[1])) |
(((uint) ((uchar) bit_buff->pos[0])) << 8));
bit_buff->pos+=2;
#endif
#endif
}
|
O3
|
c
|
fill_buffer:
movq 0x8(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x82356
pushq %rbp
movq %rsp, %rbp
movl (%rcx), %eax
bswapl %eax
addq $0x4, %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
jmp 0x8235f
movl $0x1, 0x28(%rdi)
xorl %eax, %eax
movl %eax, (%rdi)
retq
|
fill_buffer_0:
mov rcx, [rdi+8]
cmp rcx, [rdi+10h]
jnb short loc_82356
push rbp
mov rbp, rsp
mov eax, [rcx]
bswap eax
add rcx, 4
mov [rdi+8], rcx
pop rbp
jmp short loc_8235F
loc_82356:
mov dword ptr [rdi+28h], 1
xor eax, eax
loc_8235F:
mov [rdi], eax
retn
|
long long fill_buffer_0(long long a1)
{
unsigned int *v1; // rcx
long long result; // rax
v1 = *(unsigned int **)(a1 + 8);
if ( (unsigned long long)v1 >= *(_QWORD *)(a1 + 16) )
{
*(_DWORD *)(a1 + 40) = 1;
result = 0LL;
}
else
{
result = _byteswap_ulong(*v1);
*(_QWORD *)(a1 + 8) = v1 + 1;
}
*(_DWORD *)a1 = result;
return result;
}
|
fill_buffer:
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,qword ptr [RDI + 0x10]
JNC 0x00182356
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RCX]
BSWAP EAX
ADD RCX,0x4
MOV qword ptr [RDI + 0x8],RCX
POP RBP
JMP 0x0018235f
LAB_00182356:
MOV dword ptr [RDI + 0x28],0x1
XOR EAX,EAX
LAB_0018235f:
MOV dword ptr [RDI],EAX
RET
|
void fill_buffer(uint *param_1)
{
uint *puVar1;
uint uVar2;
puVar1 = *(uint **)(param_1 + 2);
if (puVar1 < *(uint **)(param_1 + 4)) {
uVar2 = *puVar1;
uVar2 = uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18;
*(uint **)(param_1 + 2) = puVar1 + 1;
}
else {
param_1[10] = 1;
uVar2 = 0;
}
*param_1 = uVar2;
return;
}
|
|
64,058 |
Cache::getId(unsigned int)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
}
|
O1
|
cpp
|
Cache::getId(unsigned int):
movl 0x34(%rdi), %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x316a
xorl %r8d, %r8d
cmpl $0x1, %eax
je 0x316a
cmpl $0x2, %eax
jb 0x316a
xorl %r8d, %r8d
movl %eax, %edx
shrl %edx
incl %r8d
cmpl $0x3, %eax
movl %edx, %eax
ja 0x315e
movl 0x38(%rdi), %eax
xorl %edx, %edx
divl 0x3c(%rdi)
testl %eax, %eax
je 0x3191
xorl %ecx, %ecx
cmpl $0x1, %eax
je 0x3191
cmpl $0x2, %eax
jb 0x3191
xorl %ecx, %ecx
movl %eax, %edx
shrl %edx
incl %ecx
cmpl $0x3, %eax
movl %edx, %eax
ja 0x3186
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movl %r8d, %ecx
shrl %cl, %esi
notl %eax
andl %eax, %esi
movl %esi, %eax
retq
|
_ZN5Cache5getIdEj:
mov eax, [rdi+34h]
mov ecx, 0FFFFFFFFh
mov r8d, 0FFFFFFFFh
test eax, eax
jz short loc_316A
xor r8d, r8d
cmp eax, 1
jz short loc_316A
cmp eax, 2
jb short loc_316A
xor r8d, r8d
mov edx, eax
loc_315E:
shr edx, 1
inc r8d
cmp eax, 3
mov eax, edx
ja short loc_315E
loc_316A:
mov eax, [rdi+38h]
xor edx, edx
div dword ptr [rdi+3Ch]
test eax, eax
jz short loc_3191
xor ecx, ecx
cmp eax, 1
jz short loc_3191
cmp eax, 2
jb short loc_3191
xor ecx, ecx
mov edx, eax
loc_3186:
shr edx, 1
inc ecx
cmp eax, 3
mov eax, edx
ja short loc_3186
loc_3191:
mov eax, 0FFFFFFFFh
shl eax, cl
mov ecx, r8d
shr esi, cl
not eax
and esi, eax
mov eax, esi
retn
|
long long Cache::getId(Cache *this, unsigned int a2)
{
unsigned int v2; // eax
char v3; // cl
char v4; // r8
unsigned int v5; // edx
bool v6; // cc
unsigned int v7; // eax
unsigned int v8; // edx
v2 = *((_DWORD *)this + 13);
v3 = -1;
v4 = -1;
if ( v2 )
{
v4 = 0;
if ( v2 != 1 )
{
v4 = 0;
v5 = *((_DWORD *)this + 13);
do
{
v5 >>= 1;
++v4;
v6 = v2 <= 3;
v2 = v5;
}
while ( !v6 );
}
}
v7 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
if ( v7 )
{
v3 = 0;
if ( v7 != 1 )
{
v3 = 0;
v8 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
do
{
v8 >>= 1;
++v3;
v6 = v7 <= 3;
v7 = v8;
}
while ( !v6 );
}
}
return ~(-1 << v3) & (a2 >> v4);
}
|
getId:
MOV EAX,dword ptr [RDI + 0x34]
MOV ECX,0xffffffff
MOV R8D,0xffffffff
TEST EAX,EAX
JZ 0x0010316a
XOR R8D,R8D
CMP EAX,0x1
JZ 0x0010316a
CMP EAX,0x2
JC 0x0010316a
XOR R8D,R8D
MOV EDX,EAX
LAB_0010315e:
SHR EDX,0x1
INC R8D
CMP EAX,0x3
MOV EAX,EDX
JA 0x0010315e
LAB_0010316a:
MOV EAX,dword ptr [RDI + 0x38]
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
TEST EAX,EAX
JZ 0x00103191
XOR ECX,ECX
CMP EAX,0x1
JZ 0x00103191
CMP EAX,0x2
JC 0x00103191
XOR ECX,ECX
MOV EDX,EAX
LAB_00103186:
SHR EDX,0x1
INC ECX
CMP EAX,0x3
MOV EAX,EDX
JA 0x00103186
LAB_00103191:
MOV EAX,0xffffffff
SHL EAX,CL
MOV ECX,R8D
SHR ESI,CL
NOT EAX
AND ESI,EAX
MOV EAX,ESI
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
bool bVar1;
uint uVar2;
byte bVar3;
ulong uVar4;
byte bVar5;
uVar2 = *(uint *)(this + 0x34);
bVar5 = 0xff;
if (uVar2 != 0) {
bVar5 = 0;
if ((uVar2 != 1) && (bVar5 = 0, 1 < uVar2)) {
bVar5 = 0;
do {
bVar5 = bVar5 + 1;
bVar1 = 3 < uVar2;
uVar2 = uVar2 >> 1;
} while (bVar1);
}
}
uVar2 = (uint)((ulong)*(uint *)(this + 0x38) / (ulong)*(uint *)(this + 0x3c));
bVar3 = 0xff;
if (uVar2 != 0) {
bVar3 = 0;
if ((uVar2 != 1) && (bVar3 = 0, 1 < uVar2)) {
bVar3 = 0;
uVar4 = (ulong)*(uint *)(this + 0x38) / (ulong)*(uint *)(this + 0x3c);
do {
bVar3 = bVar3 + 1;
uVar2 = (uint)uVar4;
uVar4 = uVar4 >> 1;
} while (3 < uVar2);
}
}
return param_1 >> (bVar5 & 0x1f) & ~(-1 << (bVar3 & 0x1f));
}
|
|
64,059 |
Cache::getId(unsigned int)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
}
|
O2
|
cpp
|
Cache::getId(unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x34(%rdi), %esi
callq 0x4618
movl %eax, %ebp
movl 0x38(%r14), %eax
xorl %edx, %edx
divl 0x3c(%r14)
movl %eax, %esi
callq 0x4618
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
movl %ebp, %ecx
shrl %cl, %ebx
notl %edx
andl %edx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN5Cache5getIdEj:
push rbp
push r14
push rbx
mov ebx, esi
mov r14, rdi
mov esi, [rdi+34h]; unsigned int
call _ZN5Cache5log2iEj; Cache::log2i(uint)
mov ebp, eax
mov eax, [r14+38h]
xor edx, edx
div dword ptr [r14+3Ch]
mov esi, eax; unsigned int
call _ZN5Cache5log2iEj; Cache::log2i(uint)
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov ecx, eax
shl edx, cl
mov ecx, ebp
shr ebx, cl
not edx
and ebx, edx
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
|
long long Cache::getId(Cache *this, unsigned int a2)
{
char v2; // bp
v2 = Cache::log2i(this, *((_DWORD *)this + 13));
return ~(-1 << Cache::log2i(this, *((_DWORD *)this + 14) / *((_DWORD *)this + 15))) & (a2 >> v2);
}
|
getId:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x34]
CALL 0x00104618
MOV EBP,EAX
MOV EAX,dword ptr [R14 + 0x38]
XOR EDX,EDX
DIV dword ptr [R14 + 0x3c]
MOV ESI,EAX
CALL 0x00104618
PUSH -0x1
POP RDX
MOV ECX,EAX
SHL EDX,CL
MOV ECX,EBP
SHR EBX,CL
NOT EDX
AND EBX,EDX
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
byte bVar1;
byte bVar2;
Cache *this_00;
this_00 = this;
bVar1 = log2i(this,*(uint *)(this + 0x34));
bVar2 = log2i(this_00,*(uint *)(this + 0x38) / *(uint *)(this + 0x3c));
return param_1 >> (bVar1 & 0x1f) & ~(-1 << (bVar2 & 0x1f));
}
|
|
64,060 |
Cache::getId(unsigned int)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
uint32_t Cache::getId(uint32_t addr) {
uint32_t offsetBits = log2i(policy.blockSize);
uint32_t idBits = log2i(policy.blockNum / policy.associativity);
uint32_t mask = (1 << idBits) - 1;
return (addr >> offsetBits) & mask;
}
|
O3
|
cpp
|
Cache::getId(unsigned int):
movl 0x34(%rdi), %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x314a
xorl %r8d, %r8d
cmpl $0x1, %eax
je 0x314a
movl %eax, %edx
shrl %edx
incl %r8d
cmpl $0x3, %eax
movl %edx, %eax
ja 0x313e
movl 0x38(%rdi), %eax
xorl %edx, %edx
divl 0x3c(%rdi)
testl %eax, %eax
je 0x316a
xorl %ecx, %ecx
cmpl $0x1, %eax
je 0x316a
movl %eax, %edx
shrl %edx
incl %ecx
cmpl $0x3, %eax
movl %edx, %eax
ja 0x315f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
shll %cl, %eax
movl %r8d, %ecx
shrl %cl, %esi
notl %eax
andl %eax, %esi
movl %esi, %eax
retq
nop
|
_ZN5Cache5getIdEj:
mov eax, [rdi+34h]
mov ecx, 0FFFFFFFFh
mov r8d, 0FFFFFFFFh
test eax, eax
jz short loc_314A
xor r8d, r8d
cmp eax, 1
jz short loc_314A
mov edx, eax
loc_313E:
shr edx, 1
inc r8d
cmp eax, 3
mov eax, edx
ja short loc_313E
loc_314A:
mov eax, [rdi+38h]
xor edx, edx
div dword ptr [rdi+3Ch]
test eax, eax
jz short loc_316A
xor ecx, ecx
cmp eax, 1
jz short loc_316A
mov edx, eax
loc_315F:
shr edx, 1
inc ecx
cmp eax, 3
mov eax, edx
ja short loc_315F
loc_316A:
mov eax, 0FFFFFFFFh
shl eax, cl
mov ecx, r8d
shr esi, cl
not eax
and esi, eax
mov eax, esi
retn
|
long long Cache::getId(Cache *this, unsigned int a2)
{
unsigned int v2; // eax
char v3; // cl
char v4; // r8
unsigned int v5; // edx
bool v6; // cc
unsigned int v7; // eax
unsigned int v8; // edx
v2 = *((_DWORD *)this + 13);
v3 = -1;
v4 = -1;
if ( v2 )
{
v4 = 0;
if ( v2 != 1 )
{
v5 = *((_DWORD *)this + 13);
do
{
v5 >>= 1;
++v4;
v6 = v2 <= 3;
v2 = v5;
}
while ( !v6 );
}
}
v7 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
if ( v7 )
{
v3 = 0;
if ( v7 != 1 )
{
v8 = *((_DWORD *)this + 14) / *((_DWORD *)this + 15);
do
{
v8 >>= 1;
++v3;
v6 = v7 <= 3;
v7 = v8;
}
while ( !v6 );
}
}
return ~(-1 << v3) & (a2 >> v4);
}
|
getId:
MOV EAX,dword ptr [RDI + 0x34]
MOV ECX,0xffffffff
MOV R8D,0xffffffff
TEST EAX,EAX
JZ 0x0010314a
XOR R8D,R8D
CMP EAX,0x1
JZ 0x0010314a
MOV EDX,EAX
LAB_0010313e:
SHR EDX,0x1
INC R8D
CMP EAX,0x3
MOV EAX,EDX
JA 0x0010313e
LAB_0010314a:
MOV EAX,dword ptr [RDI + 0x38]
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
TEST EAX,EAX
JZ 0x0010316a
XOR ECX,ECX
CMP EAX,0x1
JZ 0x0010316a
MOV EDX,EAX
LAB_0010315f:
SHR EDX,0x1
INC ECX
CMP EAX,0x3
MOV EAX,EDX
JA 0x0010315f
LAB_0010316a:
MOV EAX,0xffffffff
SHL EAX,CL
MOV ECX,R8D
SHR ESI,CL
NOT EAX
AND ESI,EAX
MOV EAX,ESI
RET
|
/* Cache::getId(unsigned int) */
uint __thiscall Cache::getId(Cache *this,uint param_1)
{
bool bVar1;
uint uVar2;
byte bVar3;
ulong uVar4;
byte bVar5;
byte bVar6;
uVar2 = *(uint *)(this + 0x34);
bVar3 = 0xff;
bVar5 = 0xff;
if (uVar2 != 0) {
bVar6 = 0;
bVar5 = 0;
if (uVar2 != 1) {
do {
bVar5 = bVar6 + 1;
bVar1 = 3 < uVar2;
uVar2 = uVar2 >> 1;
bVar6 = bVar5;
} while (bVar1);
}
}
uVar4 = (ulong)*(uint *)(this + 0x38) / (ulong)*(uint *)(this + 0x3c);
if ((int)uVar4 != 0) {
bVar6 = 0;
bVar3 = 0;
if ((int)uVar4 != 1) {
do {
bVar3 = bVar6 + 1;
uVar2 = (uint)uVar4;
uVar4 = uVar4 >> 1;
bVar6 = bVar3;
} while (3 < uVar2);
}
}
return param_1 >> (bVar5 & 0x1f) & ~(-1 << (bVar3 & 0x1f));
}
|
|
64,061 |
ImageDrawTriangle
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color)
{
// Calculate the 2D bounding box of the triangle
// Determine the minimum and maximum x and y coordinates of the triangle vertices
int xMin = (int)((v1.x < v2.x)? ((v1.x < v3.x)? v1.x : v3.x) : ((v2.x < v3.x)? v2.x : v3.x));
int yMin = (int)((v1.y < v2.y)? ((v1.y < v3.y)? v1.y : v3.y) : ((v2.y < v3.y)? v2.y : v3.y));
int xMax = (int)((v1.x > v2.x)? ((v1.x > v3.x)? v1.x : v3.x) : ((v2.x > v3.x)? v2.x : v3.x));
int yMax = (int)((v1.y > v2.y)? ((v1.y > v3.y)? v1.y : v3.y) : ((v2.y > v3.y)? v2.y : v3.y));
// Clamp the bounding box to the image dimensions
if (xMin < 0) xMin = 0;
if (yMin < 0) yMin = 0;
if (xMax > dst->width) xMax = dst->width;
if (yMax > dst->height) yMax = dst->height;
// Check the order of the vertices to determine if it's a front or back face
// NOTE: if signedArea is equal to 0, the face is degenerate
float signedArea = (v2.x - v1.x)*(v3.y - v1.y) - (v3.x - v1.x)*(v2.y - v1.y);
bool isBackFace = (signedArea > 0);
// Barycentric interpolation setup
// Calculate the step increments for the barycentric coordinates
int w1XStep = (int)(v3.y - v2.y), w1YStep = (int)(v2.x - v3.x);
int w2XStep = (int)(v1.y - v3.y), w2YStep = (int)(v3.x - v1.x);
int w3XStep = (int)(v2.y - v1.y), w3YStep = (int)(v1.x - v2.x);
// If the triangle is a back face, invert the steps
if (isBackFace)
{
w1XStep = -w1XStep, w1YStep = -w1YStep;
w2XStep = -w2XStep, w2YStep = -w2YStep;
w3XStep = -w3XStep, w3YStep = -w3YStep;
}
// Calculate the initial barycentric coordinates for the top-left point of the bounding box
int w1Row = (int)((xMin - v2.x)*w1XStep + w1YStep*(yMin - v2.y));
int w2Row = (int)((xMin - v3.x)*w2XStep + w2YStep*(yMin - v3.y));
int w3Row = (int)((xMin - v1.x)*w3XStep + w3YStep*(yMin - v1.y));
// Rasterization loop
// Iterate through each pixel in the bounding box
for (int y = yMin; y <= yMax; y++)
{
int w1 = w1Row;
int w2 = w2Row;
int w3 = w3Row;
for (int x = xMin; x <= xMax; x++)
{
// Check if the pixel is inside the triangle using barycentric coordinates
// If it is then we can draw the pixel with the given color
if ((w1 | w2 | w3) >= 0) ImageDrawPixel(dst, x, y, color);
// Increment the barycentric coordinates for the next pixel
w1 += w1XStep;
w2 += w2XStep;
w3 += w3XStep;
}
// Move to the next row in the bounding box
w1Row += w1YStep;
w2Row += w2YStep;
w3Row += w3YStep;
}
}
|
O2
|
c
|
ImageDrawTriangle:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, 0x1c(%rsp)
movq %rdi, %r14
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm4 # xmm4 = xmm4[1,1],xmm0[1,1]
movaps %xmm0, %xmm5
maxss %xmm1, %xmm5
maxss %xmm2, %xmm5
cvttss2si %xmm5, %r12d
movaps %xmm4, %xmm6
maxss %xmm3, %xmm6
movaps %xmm2, %xmm5
shufps $0x55, %xmm2, %xmm5 # xmm5 = xmm5[1,1],xmm2[1,1]
maxss %xmm5, %xmm6
cvttss2si %xmm6, %edx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %ecx
cmpl %r12d, %eax
cmovll %eax, %r12d
cmpl %edx, %ecx
cmovll %ecx, %edx
movl %edx, 0x14(%rsp)
movaps %xmm1, %xmm3
subss %xmm0, %xmm3
subss %xmm4, %xmm5
mulss %xmm3, %xmm5
movaps %xmm0, %xmm3
minps %xmm1, %xmm3
minps %xmm2, %xmm3
cvttps2dq %xmm3, %xmm4
pxor %xmm7, %xmm7
movdqa %xmm4, %xmm3
pcmpgtd %xmm7, %xmm3
pand %xmm4, %xmm3
movaps %xmm1, %xmm4
shufps $0x10, %xmm2, %xmm4 # xmm4 = xmm4[0,0],xmm2[1,0]
shufps $0xe2, %xmm2, %xmm4 # xmm4 = xmm4[2,0],xmm2[2,3]
movaps %xmm2, %xmm6
shufps $0x10, %xmm1, %xmm6 # xmm6 = xmm6[0,0],xmm1[1,0]
shufps $0xe2, %xmm1, %xmm6 # xmm6 = xmm6[2,0],xmm1[2,3]
subps %xmm6, %xmm4
cvttps2dq %xmm4, %xmm4
movaps %xmm1, %xmm8
shufps $0x11, %xmm0, %xmm8 # xmm8 = xmm8[1,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm8 # xmm8 = xmm8[2,0],xmm0[2,3]
movaps %xmm0, %xmm6
shufps $0x11, %xmm2, %xmm6 # xmm6 = xmm6[1,0],xmm2[1,0]
shufps $0xe2, %xmm2, %xmm6 # xmm6 = xmm6[2,0],xmm2[2,3]
subps %xmm6, %xmm8
unpcklps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movaps %xmm2, %xmm9
subps %xmm0, %xmm9
cvttps2dq %xmm8, %xmm10
shufps $0x55, %xmm8, %xmm8 # xmm8 = xmm8[1,1,1,1]
mulss %xmm9, %xmm8
ucomiss %xmm8, %xmm5
cvttps2dq %xmm9, %xmm8
jbe 0x85def
xorps %xmm0, %xmm0
psubd %xmm4, %xmm0
pxor %xmm4, %xmm4
psubd %xmm10, %xmm4
psubd %xmm8, %xmm7
movdqa %xmm4, %xmm10
movdqa %xmm7, %xmm8
movdqa %xmm0, %xmm4
cvtdq2ps %xmm3, %xmm0
cvtdq2ps %xmm4, %xmm5
movaps %xmm0, %xmm7
subps %xmm1, %xmm7
mulps %xmm5, %xmm7
movaps %xmm7, %xmm1
shufps $0x55, %xmm7, %xmm1 # xmm1 = xmm1[1,1],xmm7[1,1]
addss %xmm7, %xmm1
cvttss2si %xmm1, %ebx
cvtdq2ps %xmm10, %xmm1
cvtdq2ps %xmm8, %xmm5
movaps %xmm0, %xmm7
shufps $0x0, %xmm0, %xmm7 # xmm7 = xmm7[0,0],xmm0[0,0]
subps %xmm2, %xmm7
mulps %xmm1, %xmm7
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
subps %xmm6, %xmm0
mulps %xmm5, %xmm0
addps %xmm7, %xmm0
cvttps2dq %xmm0, %xmm1
pshufd $0x55, %xmm3, %xmm0 # xmm0 = xmm3[1,1,1,1]
movd %xmm0, %ebp
movd %xmm3, 0x10(%rsp)
pshufd $0x55, %xmm4, %xmm0 # xmm0 = xmm4[1,1,1,1]
movd %xmm0, 0xc(%rsp)
movd %xmm4, %r13d
movaps %xmm10, 0x30(%rsp)
movaps %xmm8, 0x20(%rsp)
movl %ebx, 0x18(%rsp)
movl 0x10(%rsp), %r15d
movdqa %xmm1, %xmm2
cmpl 0x14(%rsp), %ebp
movdqa %xmm1, 0x40(%rsp)
jg 0x85edc
cmpl %r12d, %r15d
jg 0x85ecb
movd %xmm2, %eax
pshufd $0x55, %xmm2, %xmm0 # xmm0 = xmm2[1,1,1,1]
movd %xmm0, %ecx
orl %eax, %ecx
orl %ebx, %ecx
js 0x85ebe
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl 0x1c(%rsp), %ecx
movdqa %xmm2, 0x50(%rsp)
callq 0x84b48
movdqa 0x50(%rsp), %xmm2
movdqa 0x40(%rsp), %xmm1
movaps 0x20(%rsp), %xmm8
movaps 0x30(%rsp), %xmm10
addl %r13d, %ebx
paddd %xmm10, %xmm2
incl %r15d
jmp 0x85e77
movl 0x18(%rsp), %ebx
addl 0xc(%rsp), %ebx
paddd %xmm8, %xmm1
incl %ebp
jmp 0x85e5e
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ImageDrawTriangle:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_7C], esi
mov r14, rdi
movaps xmm3, xmm1
shufps xmm3, xmm1, 55h ; 'U'
movaps xmm4, xmm0
shufps xmm4, xmm0, 55h ; 'U'
movaps xmm5, xmm0
maxss xmm5, xmm1
maxss xmm5, xmm2
cvttss2si r12d, xmm5
movaps xmm6, xmm4
maxss xmm6, xmm3
movaps xmm5, xmm2
shufps xmm5, xmm2, 55h ; 'U'
maxss xmm6, xmm5
cvttss2si edx, xmm6
mov eax, [rdi+8]
mov ecx, [rdi+0Ch]
cmp eax, r12d
cmovl r12d, eax
cmp ecx, edx
cmovl edx, ecx
mov [rsp+98h+var_84], edx
movaps xmm3, xmm1
subss xmm3, xmm0
subss xmm5, xmm4
mulss xmm5, xmm3
movaps xmm3, xmm0
minps xmm3, xmm1
minps xmm3, xmm2
cvttps2dq xmm4, xmm3
pxor xmm7, xmm7
movdqa xmm3, xmm4
pcmpgtd xmm3, xmm7
pand xmm3, xmm4
movaps xmm4, xmm1
shufps xmm4, xmm2, 10h
shufps xmm4, xmm2, 0E2h
movaps xmm6, xmm2
shufps xmm6, xmm1, 10h
shufps xmm6, xmm1, 0E2h
subps xmm4, xmm6
cvttps2dq xmm4, xmm4
movaps xmm8, xmm1
shufps xmm8, xmm0, 11h
shufps xmm8, xmm0, 0E2h
movaps xmm6, xmm0
shufps xmm6, xmm2, 11h
shufps xmm6, xmm2, 0E2h
subps xmm8, xmm6
unpcklps xmm2, xmm0
unpcklps xmm0, xmm1
movaps xmm9, xmm2
subps xmm9, xmm0
cvttps2dq xmm10, xmm8
shufps xmm8, xmm8, 55h ; 'U'
mulss xmm8, xmm9
ucomiss xmm5, xmm8
cvttps2dq xmm8, xmm9
jbe short loc_85DEF
xorps xmm0, xmm0
psubd xmm0, xmm4
pxor xmm4, xmm4
psubd xmm4, xmm10
psubd xmm7, xmm8
movdqa xmm10, xmm4
movdqa xmm8, xmm7
movdqa xmm4, xmm0
loc_85DEF:
cvtdq2ps xmm0, xmm3
cvtdq2ps xmm5, xmm4
movaps xmm7, xmm0
subps xmm7, xmm1
mulps xmm7, xmm5
movaps xmm1, xmm7
shufps xmm1, xmm7, 55h ; 'U'
addss xmm1, xmm7
cvttss2si ebx, xmm1
cvtdq2ps xmm1, xmm10
cvtdq2ps xmm5, xmm8
movaps xmm7, xmm0
shufps xmm7, xmm0, 0
subps xmm7, xmm2
mulps xmm7, xmm1
shufps xmm0, xmm0, 55h ; 'U'
subps xmm0, xmm6
mulps xmm0, xmm5
addps xmm0, xmm7
cvttps2dq xmm1, xmm0
pshufd xmm0, xmm3, 55h ; 'U'
movd ebp, xmm0
movd [rsp+98h+var_88], xmm3
pshufd xmm0, xmm4, 55h ; 'U'
movd [rsp+98h+var_8C], xmm0
movd r13d, xmm4
movaps [rsp+98h+var_68], xmm10
movaps [rsp+98h+var_78], xmm8
loc_85E5E:
mov [rsp+98h+var_80], ebx
mov r15d, [rsp+98h+var_88]
movdqa xmm2, xmm1
cmp ebp, [rsp+98h+var_84]
movdqa [rsp+98h+var_58], xmm1
jg short loc_85EDC
loc_85E77:
cmp r15d, r12d
jg short loc_85ECB
movd eax, xmm2
pshufd xmm0, xmm2, 55h ; 'U'
movd ecx, xmm0
or ecx, eax
or ecx, ebx
js short loc_85EBE
mov rdi, r14
mov esi, r15d
mov edx, ebp
mov ecx, [rsp+98h+var_7C]
movdqa [rsp+98h+var_48], xmm2
call ImageDrawPixel
movdqa xmm2, [rsp+98h+var_48]
movdqa xmm1, [rsp+98h+var_58]
movaps xmm8, [rsp+98h+var_78]
movaps xmm10, [rsp+98h+var_68]
loc_85EBE:
add ebx, r13d
paddd xmm2, xmm10
inc r15d
jmp short loc_85E77
loc_85ECB:
mov ebx, [rsp+98h+var_80]
add ebx, [rsp+98h+var_8C]
paddd xmm1, xmm8
inc ebp
jmp short loc_85E5E
loc_85EDC:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char ImageDrawTriangle(long long a1, unsigned int a2, __m128 a3, __m128 a4, __m128 a5)
{
float v5; // xmm4_4
int v6; // r12d
float v7; // xmm5_4
int v8; // edx
int v9; // eax
float v10; // xmm5_4
__m128i v11; // xmm4
__m128i v12; // xmm3
__m128i v13; // xmm4
__m128 v14; // xmm6
__m128 v15; // xmm8
__m128 v16; // xmm2
__m128 v17; // xmm9
__m128i v18; // xmm10
bool v19; // cc
__m128i v20; // xmm8
__m128 v21; // xmm0
__m128 v22; // xmm7
int v23; // ebx
__m128i v24; // xmm1
int v25; // ebp
int v26; // r13d
int v27; // r15d
__m128i si128; // xmm2
int v30; // [rsp+Ch] [rbp-8Ch]
int v31; // [rsp+10h] [rbp-88h]
int v32; // [rsp+14h] [rbp-84h]
int v33; // [rsp+18h] [rbp-80h]
__m128i v34; // [rsp+20h] [rbp-78h]
__m128i v35; // [rsp+30h] [rbp-68h]
__m128i v36; // [rsp+40h] [rbp-58h] BYREF
__m128i v37[4]; // [rsp+50h] [rbp-48h] BYREF
LODWORD(v5) = _mm_shuffle_ps(a3, a3, 85).m128_u32[0];
v6 = (int)fmaxf(fmaxf(a3.m128_f32[0], a4.m128_f32[0]), a5.m128_f32[0]);
LODWORD(v7) = _mm_shuffle_ps(a5, a5, 85).m128_u32[0];
v8 = (int)fmaxf(fmaxf(v5, _mm_shuffle_ps(a4, a4, 85).m128_f32[0]), v7);
v9 = *(_DWORD *)(a1 + 8);
if ( v9 < v6 )
v6 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)(a1 + 12) < v8 )
v8 = *(_DWORD *)(a1 + 12);
v32 = v8;
v10 = (float)(v7 - v5) * (float)(a4.m128_f32[0] - a3.m128_f32[0]);
v11 = _mm_cvttps_epi32(_mm_min_ps(_mm_min_ps(a3, a4), a5));
v12 = _mm_and_si128(_mm_cmpgt_epi32(v11, (__m128i)0LL), v11);
v13 = _mm_cvttps_epi32(
_mm_sub_ps(
_mm_shuffle_ps(_mm_shuffle_ps(a4, a5, 16), a5, 226),
_mm_shuffle_ps(_mm_shuffle_ps(a5, a4, 16), a4, 226)));
v14 = _mm_shuffle_ps(_mm_shuffle_ps(a3, a5, 17), a5, 226);
v15 = _mm_sub_ps(_mm_shuffle_ps(_mm_shuffle_ps(a4, a3, 17), a3, 226), v14);
v16 = _mm_unpacklo_ps(a5, a3);
v17 = _mm_sub_ps(v16, _mm_unpacklo_ps(a3, a4));
v18 = _mm_cvttps_epi32(v15);
v19 = v10 <= (float)(_mm_shuffle_ps(v15, v15, 85).m128_f32[0] * v17.m128_f32[0]);
v20 = _mm_cvttps_epi32(v17);
if ( !v19 )
{
v18 = _mm_sub_epi32((__m128i)0LL, v18);
v20 = _mm_sub_epi32((__m128i)0LL, v20);
v13 = _mm_sub_epi32((__m128i)0LL, v13);
}
v21 = _mm_cvtepi32_ps(v12);
v22 = _mm_mul_ps(_mm_sub_ps(v21, a4), _mm_cvtepi32_ps(v13));
v23 = (int)(float)(_mm_shuffle_ps(v22, v22, 85).m128_f32[0] + v22.m128_f32[0]);
v24 = _mm_cvttps_epi32(
_mm_add_ps(
_mm_mul_ps(_mm_sub_ps(_mm_shuffle_ps(v21, v21, 85), v14), _mm_cvtepi32_ps(v20)),
_mm_mul_ps(_mm_sub_ps(_mm_shuffle_ps(v21, v21, 0), v16), _mm_cvtepi32_ps(v18))));
v25 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v12, 85));
v31 = _mm_cvtsi128_si32(v12);
v30 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v13, 85));
v26 = _mm_cvtsi128_si32(v13);
v35 = v18;
v34 = v20;
while ( 1 )
{
v33 = v23;
v27 = v31;
si128 = v24;
v36 = v24;
if ( v25 > v32 )
break;
while ( v27 <= v6 )
{
v9 = _mm_cvtsi128_si32(si128);
if ( (v23 | v9 | _mm_cvtsi128_si32(_mm_shuffle_epi32(si128, 85))) >= 0 )
{
v37[0] = si128;
LOBYTE(v9) = ImageDrawPixel((long long *)a1, v27, v25, a2);
si128 = _mm_load_si128(v37);
v24 = _mm_load_si128(&v36);
v20 = v34;
v18 = v35;
}
v23 += v26;
si128 = _mm_add_epi32(si128, v18);
++v27;
}
v23 = v30 + v33;
v24 = _mm_add_epi32(v24, v20);
++v25;
}
return v9;
}
|
ImageDrawTriangle:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RSP + 0x1c],ESI
MOV R14,RDI
MOVAPS XMM3,XMM1
SHUFPS XMM3,XMM1,0x55
MOVAPS XMM4,XMM0
SHUFPS XMM4,XMM0,0x55
MOVAPS XMM5,XMM0
MAXSS XMM5,XMM1
MAXSS XMM5,XMM2
CVTTSS2SI R12D,XMM5
MOVAPS XMM6,XMM4
MAXSS XMM6,XMM3
MOVAPS XMM5,XMM2
SHUFPS XMM5,XMM2,0x55
MAXSS XMM6,XMM5
CVTTSS2SI EDX,XMM6
MOV EAX,dword ptr [RDI + 0x8]
MOV ECX,dword ptr [RDI + 0xc]
CMP EAX,R12D
CMOVL R12D,EAX
CMP ECX,EDX
CMOVL EDX,ECX
MOV dword ptr [RSP + 0x14],EDX
MOVAPS XMM3,XMM1
SUBSS XMM3,XMM0
SUBSS XMM5,XMM4
MULSS XMM5,XMM3
MOVAPS XMM3,XMM0
MINPS XMM3,XMM1
MINPS XMM3,XMM2
CVTTPS2DQ XMM4,XMM3
PXOR XMM7,XMM7
MOVDQA XMM3,XMM4
PCMPGTD XMM3,XMM7
PAND XMM3,XMM4
MOVAPS XMM4,XMM1
SHUFPS XMM4,XMM2,0x10
SHUFPS XMM4,XMM2,0xe2
MOVAPS XMM6,XMM2
SHUFPS XMM6,XMM1,0x10
SHUFPS XMM6,XMM1,0xe2
SUBPS XMM4,XMM6
CVTTPS2DQ XMM4,XMM4
MOVAPS XMM8,XMM1
SHUFPS XMM8,XMM0,0x11
SHUFPS XMM8,XMM0,0xe2
MOVAPS XMM6,XMM0
SHUFPS XMM6,XMM2,0x11
SHUFPS XMM6,XMM2,0xe2
SUBPS XMM8,XMM6
UNPCKLPS XMM2,XMM0
UNPCKLPS XMM0,XMM1
MOVAPS XMM9,XMM2
SUBPS XMM9,XMM0
CVTTPS2DQ XMM10,XMM8
SHUFPS XMM8,XMM8,0x55
MULSS XMM8,XMM9
UCOMISS XMM5,XMM8
CVTTPS2DQ XMM8,XMM9
JBE 0x00185def
XORPS XMM0,XMM0
PSUBD XMM0,XMM4
PXOR XMM4,XMM4
PSUBD XMM4,XMM10
PSUBD XMM7,XMM8
MOVDQA XMM10,XMM4
MOVDQA XMM8,XMM7
MOVDQA XMM4,XMM0
LAB_00185def:
CVTDQ2PS XMM0,XMM3
CVTDQ2PS XMM5,XMM4
MOVAPS XMM7,XMM0
SUBPS XMM7,XMM1
MULPS XMM7,XMM5
MOVAPS XMM1,XMM7
SHUFPS XMM1,XMM7,0x55
ADDSS XMM1,XMM7
CVTTSS2SI EBX,XMM1
CVTDQ2PS XMM1,XMM10
CVTDQ2PS XMM5,XMM8
MOVAPS XMM7,XMM0
SHUFPS XMM7,XMM0,0x0
SUBPS XMM7,XMM2
MULPS XMM7,XMM1
SHUFPS XMM0,XMM0,0x55
SUBPS XMM0,XMM6
MULPS XMM0,XMM5
ADDPS XMM0,XMM7
CVTTPS2DQ XMM1,XMM0
PSHUFD XMM0,XMM3,0x55
MOVD EBP,XMM0
MOVD dword ptr [RSP + 0x10],XMM3
PSHUFD XMM0,XMM4,0x55
MOVD dword ptr [RSP + 0xc],XMM0
MOVD R13D,XMM4
MOVAPS xmmword ptr [RSP + 0x30],XMM10
MOVAPS xmmword ptr [RSP + 0x20],XMM8
LAB_00185e5e:
MOV dword ptr [RSP + 0x18],EBX
MOV R15D,dword ptr [RSP + 0x10]
MOVDQA XMM2,XMM1
CMP EBP,dword ptr [RSP + 0x14]
MOVDQA xmmword ptr [RSP + 0x40],XMM1
JG 0x00185edc
LAB_00185e77:
CMP R15D,R12D
JG 0x00185ecb
MOVD EAX,XMM2
PSHUFD XMM0,XMM2,0x55
MOVD ECX,XMM0
OR ECX,EAX
OR ECX,EBX
JS 0x00185ebe
MOV RDI,R14
MOV ESI,R15D
MOV EDX,EBP
MOV ECX,dword ptr [RSP + 0x1c]
MOVDQA xmmword ptr [RSP + 0x50],XMM2
CALL 0x00184b48
MOVDQA XMM2,xmmword ptr [RSP + 0x50]
MOVDQA XMM1,xmmword ptr [RSP + 0x40]
MOVAPS XMM8,xmmword ptr [RSP + 0x20]
MOVAPS XMM10,xmmword ptr [RSP + 0x30]
LAB_00185ebe:
ADD EBX,R13D
PADDD XMM2,XMM10
INC R15D
JMP 0x00185e77
LAB_00185ecb:
MOV EBX,dword ptr [RSP + 0x18]
ADD EBX,dword ptr [RSP + 0xc]
PADDD XMM1,XMM8
INC EBP
JMP 0x00185e5e
LAB_00185edc:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void ImageDrawTriangle(int8 param_1,long param_2,int4 param_3)
{
int iVar1;
int iVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
float fVar7;
float fVar8;
float fVar9;
float fVar10;
int4 in_XMM0_Dc;
int4 in_XMM0_Dd;
float fVar11;
uint uVar12;
float fVar13;
uint uVar14;
int1 in_XMM1 [16];
float fVar15;
uint uVar16;
float fVar17;
uint uVar18;
int1 in_XMM2 [16];
uint uVar19;
int1 auVar20 [16];
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int iVar25;
int iVar26;
fVar9 = (float)((ulong)param_1 >> 0x20);
fVar7 = (float)param_1;
fVar11 = in_XMM1._0_4_;
fVar13 = in_XMM1._4_4_;
fVar8 = fVar7;
if (fVar7 <= fVar11) {
fVar8 = fVar11;
}
fVar15 = in_XMM2._0_4_;
if (fVar8 <= fVar15) {
fVar8 = fVar15;
}
fVar10 = fVar9;
if (fVar9 <= fVar13) {
fVar10 = fVar13;
}
fVar17 = in_XMM2._4_4_;
if (fVar10 <= fVar17) {
fVar10 = fVar17;
}
iVar1 = (int)fVar8;
if (*(int *)(param_2 + 8) < (int)fVar8) {
iVar1 = *(int *)(param_2 + 8);
}
iVar2 = (int)fVar10;
if (*(int *)(param_2 + 0xc) < (int)fVar10) {
iVar2 = *(int *)(param_2 + 0xc);
}
auVar20._8_4_ = in_XMM0_Dc;
auVar20._0_8_ = param_1;
auVar20._12_4_ = in_XMM0_Dd;
auVar20 = minps(auVar20,in_XMM1);
auVar20 = minps(auVar20,in_XMM2);
uVar19 = -(uint)(0 < (int)auVar20._0_4_) & (int)auVar20._0_4_;
uVar5 = -(uint)(0 < (int)auVar20._4_4_) & (int)auVar20._4_4_;
iVar21 = (int)(fVar17 - fVar13);
iVar22 = (int)(fVar11 - fVar15);
iVar25 = (int)(fVar9 - fVar17);
iVar26 = (int)(fVar13 - fVar9);
iVar23 = (int)(fVar15 - fVar7);
iVar24 = (int)(fVar7 - fVar11);
if ((fVar13 - fVar9) * (fVar15 - fVar7) < (fVar17 - fVar9) * (fVar11 - fVar7)) {
iVar21 = -iVar21;
iVar22 = -iVar22;
iVar25 = -iVar25;
iVar26 = -iVar26;
iVar23 = -iVar23;
iVar24 = -iVar24;
}
fVar8 = (float)(int)uVar19;
fVar10 = (float)(int)uVar5;
uVar3 = (uint)((fVar10 - fVar13) * (float)iVar22 + (fVar8 - fVar11) * (float)iVar21);
uVar12 = (uint)((fVar10 - fVar17) * (float)iVar23 + (fVar8 - fVar15) * (float)iVar25);
uVar14 = (uint)((fVar10 - fVar9) * (float)iVar24 + (fVar8 - fVar7) * (float)iVar26);
while( true ) {
uVar4 = uVar3;
uVar6 = uVar19;
uVar16 = uVar12;
uVar18 = uVar14;
if (iVar2 < (int)uVar5) break;
for (; (int)uVar6 <= iVar1; uVar6 = uVar6 + 1) {
if (-1 < (int)(uVar18 | uVar16 | uVar4)) {
ImageDrawPixel(param_2,uVar6,uVar5,param_3);
}
uVar4 = uVar4 + iVar21;
uVar16 = uVar16 + iVar25;
uVar18 = uVar18 + iVar26;
}
uVar3 = uVar3 + iVar22;
uVar12 = uVar12 + iVar23;
uVar14 = uVar14 + iVar24;
uVar5 = uVar5 + 1;
}
return;
}
|
|
64,062 |
ImageDrawTriangle
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color)
{
// Calculate the 2D bounding box of the triangle
// Determine the minimum and maximum x and y coordinates of the triangle vertices
int xMin = (int)((v1.x < v2.x)? ((v1.x < v3.x)? v1.x : v3.x) : ((v2.x < v3.x)? v2.x : v3.x));
int yMin = (int)((v1.y < v2.y)? ((v1.y < v3.y)? v1.y : v3.y) : ((v2.y < v3.y)? v2.y : v3.y));
int xMax = (int)((v1.x > v2.x)? ((v1.x > v3.x)? v1.x : v3.x) : ((v2.x > v3.x)? v2.x : v3.x));
int yMax = (int)((v1.y > v2.y)? ((v1.y > v3.y)? v1.y : v3.y) : ((v2.y > v3.y)? v2.y : v3.y));
// Clamp the bounding box to the image dimensions
if (xMin < 0) xMin = 0;
if (yMin < 0) yMin = 0;
if (xMax > dst->width) xMax = dst->width;
if (yMax > dst->height) yMax = dst->height;
// Check the order of the vertices to determine if it's a front or back face
// NOTE: if signedArea is equal to 0, the face is degenerate
float signedArea = (v2.x - v1.x)*(v3.y - v1.y) - (v3.x - v1.x)*(v2.y - v1.y);
bool isBackFace = (signedArea > 0);
// Barycentric interpolation setup
// Calculate the step increments for the barycentric coordinates
int w1XStep = (int)(v3.y - v2.y), w1YStep = (int)(v2.x - v3.x);
int w2XStep = (int)(v1.y - v3.y), w2YStep = (int)(v3.x - v1.x);
int w3XStep = (int)(v2.y - v1.y), w3YStep = (int)(v1.x - v2.x);
// If the triangle is a back face, invert the steps
if (isBackFace)
{
w1XStep = -w1XStep, w1YStep = -w1YStep;
w2XStep = -w2XStep, w2YStep = -w2YStep;
w3XStep = -w3XStep, w3YStep = -w3YStep;
}
// Calculate the initial barycentric coordinates for the top-left point of the bounding box
int w1Row = (int)((xMin - v2.x)*w1XStep + w1YStep*(yMin - v2.y));
int w2Row = (int)((xMin - v3.x)*w2XStep + w2YStep*(yMin - v3.y));
int w3Row = (int)((xMin - v1.x)*w3XStep + w3YStep*(yMin - v1.y));
// Rasterization loop
// Iterate through each pixel in the bounding box
for (int y = yMin; y <= yMax; y++)
{
int w1 = w1Row;
int w2 = w2Row;
int w3 = w3Row;
for (int x = xMin; x <= xMax; x++)
{
// Check if the pixel is inside the triangle using barycentric coordinates
// If it is then we can draw the pixel with the given color
if ((w1 | w2 | w3) >= 0) ImageDrawPixel(dst, x, y, color);
// Increment the barycentric coordinates for the next pixel
w1 += w1XStep;
w2 += w2XStep;
w3 += w3XStep;
}
// Move to the next row in the bounding box
w1Row += w1YStep;
w2Row += w2YStep;
w3Row += w3YStep;
}
}
|
O3
|
c
|
ImageDrawTriangle:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, 0xc(%rsp)
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm0, %xmm4
maxss %xmm1, %xmm4
maxss %xmm2, %xmm4
cvttss2si %xmm4, %edx
movaps %xmm5, %xmm6
maxss %xmm3, %xmm6
movaps %xmm2, %xmm3
movaps %xmm0, %xmm8
unpcklps %xmm2, %xmm8 # xmm8 = xmm8[0],xmm2[0],xmm8[1],xmm2[1]
movaps %xmm2, %xmm9
movaps %xmm1, %xmm4
shufps $0x11, %xmm2, %xmm4 # xmm4 = xmm4[1,0],xmm2[1,0]
shufps $0xe2, %xmm2, %xmm4 # xmm4 = xmm4[2,0],xmm2[2,3]
movaps %xmm0, %xmm10
minps %xmm1, %xmm10
minps %xmm2, %xmm10
movaps %xmm2, %xmm7
shufps $0x55, %xmm2, %xmm7 # xmm7 = xmm7[1,1],xmm2[1,1]
maxss %xmm7, %xmm6
cvttss2si %xmm6, %esi
movl 0x8(%rdi), %eax
movq %rdi, 0x18(%rsp)
movl 0xc(%rdi), %ecx
cmpl %edx, %eax
cmovll %eax, %edx
movq %rdx, 0x10(%rsp)
cmpl %esi, %ecx
cmovll %ecx, %esi
movl %esi, (%rsp)
movaps %xmm1, %xmm2
subss %xmm0, %xmm2
subss %xmm5, %xmm7
mulss %xmm2, %xmm7
unpcklps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movaps %xmm3, %xmm6
subps %xmm8, %xmm6
shufps $0x11, %xmm0, %xmm9 # xmm9 = xmm9[1,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm9 # xmm9 = xmm9[2,0],xmm0[2,3]
subps %xmm4, %xmm9
cvttps2dq %xmm9, %xmm9
cvttps2dq %xmm6, %xmm11
cvttps2dq %xmm10, %xmm8
xorps %xmm5, %xmm5
movdqa %xmm8, %xmm2
pcmpgtd %xmm5, %xmm2
pand %xmm8, %xmm2
pshufd $0x55, %xmm2, %xmm8 # xmm8 = xmm2[1,1,1,1]
movd %xmm8, %r15d
movaps %xmm0, %xmm8
shufps $0x10, %xmm1, %xmm8 # xmm8 = xmm8[0,0],xmm1[1,0]
shufps $0xe2, %xmm1, %xmm8 # xmm8 = xmm8[2,0],xmm1[2,3]
shufps $0x10, %xmm0, %xmm1 # xmm1 = xmm1[0,0],xmm0[1,0]
shufps $0xe2, %xmm0, %xmm1 # xmm1 = xmm1[2,0],xmm0[2,3]
subps %xmm1, %xmm8
mulss %xmm8, %xmm6
ucomiss %xmm6, %xmm7
cvttps2dq %xmm8, %xmm1
jbe 0x9a73e
xorps %xmm6, %xmm6
psubd %xmm9, %xmm6
xorps %xmm7, %xmm7
psubd %xmm11, %xmm7
psubd %xmm1, %xmm5
movdqa %xmm6, %xmm9
movdqa %xmm7, %xmm11
movdqa %xmm5, %xmm1
cmpl (%rsp), %r15d
jg 0x9a840
cvtdq2ps %xmm2, %xmm5
cvtdq2ps %xmm1, %xmm6
movaps %xmm5, %xmm7
subps %xmm0, %xmm7
mulps %xmm6, %xmm7
movaps %xmm7, %xmm0
shufps $0x55, %xmm7, %xmm0 # xmm0 = xmm0[1,1],xmm7[1,1]
addss %xmm7, %xmm0
cvttss2si %xmm0, %r14d
cvtdq2ps %xmm9, %xmm0
cvtdq2ps %xmm11, %xmm6
movaps %xmm5, %xmm7
shufps $0x0, %xmm5, %xmm7 # xmm7 = xmm7[0,0],xmm5[0,0]
subps %xmm3, %xmm7
mulps %xmm0, %xmm7
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
subps %xmm4, %xmm5
mulps %xmm6, %xmm5
addps %xmm7, %xmm5
cvttps2dq %xmm5, %xmm3
movd %xmm2, 0x8(%rsp)
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
movd %xmm0, 0x4(%rsp)
movdqa %xmm3, %xmm0
movd %xmm1, %r13d
movq 0x10(%rsp), %rax
leal 0x1(%rax), %ebx
movaps %xmm9, 0x40(%rsp)
movaps %xmm11, 0x30(%rsp)
movl 0x8(%rsp), %eax
movl %eax, %ebp
movl %r14d, %r12d
movdqa %xmm0, 0x20(%rsp)
movdqa %xmm0, %xmm1
cmpl 0x10(%rsp), %eax
jg 0x9a81f
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
por %xmm1, %xmm0
movd %xmm0, %eax
orl %r12d, %eax
js 0x9a811
movq 0x18(%rsp), %rdi
movl %ebp, %esi
movl %r15d, %edx
movl 0xc(%rsp), %ecx
movdqa %xmm1, 0x50(%rsp)
callq 0x99487
movdqa 0x50(%rsp), %xmm1
movaps 0x30(%rsp), %xmm11
movaps 0x40(%rsp), %xmm9
paddd %xmm9, %xmm1
addl %r13d, %r12d
incl %ebp
cmpl %ebp, %ebx
jne 0x9a7d4
movdqa 0x20(%rsp), %xmm0
paddd %xmm11, %xmm0
addl 0x4(%rsp), %r14d
leal 0x1(%r15), %eax
cmpl (%rsp), %r15d
movl %eax, %r15d
jne 0x9a7bb
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ImageDrawTriangle:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_8C], esi
movaps xmm5, xmm0
shufps xmm5, xmm0, 55h ; 'U'
movaps xmm3, xmm1
shufps xmm3, xmm1, 55h ; 'U'
movaps xmm4, xmm0
maxss xmm4, xmm1
maxss xmm4, xmm2
cvttss2si edx, xmm4
movaps xmm6, xmm5
maxss xmm6, xmm3
movaps xmm3, xmm2
movaps xmm8, xmm0
unpcklps xmm8, xmm2
movaps xmm9, xmm2
movaps xmm4, xmm1
shufps xmm4, xmm2, 11h
shufps xmm4, xmm2, 0E2h
movaps xmm10, xmm0
minps xmm10, xmm1
minps xmm10, xmm2
movaps xmm7, xmm2
shufps xmm7, xmm2, 55h ; 'U'
maxss xmm6, xmm7
cvttss2si esi, xmm6
mov eax, [rdi+8]
mov [rsp+98h+var_80], rdi
mov ecx, [rdi+0Ch]
cmp eax, edx
cmovl edx, eax
mov [rsp+98h+var_88], rdx
cmp ecx, esi
cmovl esi, ecx
mov [rsp+98h+var_98], esi
movaps xmm2, xmm1
subss xmm2, xmm0
subss xmm7, xmm5
mulss xmm7, xmm2
unpcklps xmm3, xmm1
movaps xmm6, xmm3
subps xmm6, xmm8
shufps xmm9, xmm0, 11h
shufps xmm9, xmm0, 0E2h
subps xmm9, xmm4
cvttps2dq xmm9, xmm9
cvttps2dq xmm11, xmm6
cvttps2dq xmm8, xmm10
xorps xmm5, xmm5
movdqa xmm2, xmm8
pcmpgtd xmm2, xmm5
pand xmm2, xmm8
pshufd xmm8, xmm2, 55h ; 'U'
movd r15d, xmm8
movaps xmm8, xmm0
shufps xmm8, xmm1, 10h
shufps xmm8, xmm1, 0E2h
shufps xmm1, xmm0, 10h
shufps xmm1, xmm0, 0E2h
subps xmm8, xmm1
mulss xmm6, xmm8
ucomiss xmm7, xmm6
cvttps2dq xmm1, xmm8
jbe short loc_9A73E
xorps xmm6, xmm6
psubd xmm6, xmm9
xorps xmm7, xmm7
psubd xmm7, xmm11
psubd xmm5, xmm1
movdqa xmm9, xmm6
movdqa xmm11, xmm7
movdqa xmm1, xmm5
loc_9A73E:
cmp r15d, [rsp+98h+var_98]
jg loc_9A840
cvtdq2ps xmm5, xmm2
cvtdq2ps xmm6, xmm1
movaps xmm7, xmm5
subps xmm7, xmm0
mulps xmm7, xmm6
movaps xmm0, xmm7
shufps xmm0, xmm7, 55h ; 'U'
addss xmm0, xmm7
cvttss2si r14d, xmm0
cvtdq2ps xmm0, xmm9
cvtdq2ps xmm6, xmm11
movaps xmm7, xmm5
shufps xmm7, xmm5, 0
subps xmm7, xmm3
mulps xmm7, xmm0
shufps xmm5, xmm5, 55h ; 'U'
subps xmm5, xmm4
mulps xmm5, xmm6
addps xmm5, xmm7
cvttps2dq xmm3, xmm5
movd [rsp+98h+var_90], xmm2
pshufd xmm0, xmm1, 55h ; 'U'
movd [rsp+98h+var_94], xmm0
movdqa xmm0, xmm3
movd r13d, xmm1
mov rax, [rsp+98h+var_88]
lea ebx, [rax+1]
movaps [rsp+98h+var_58], xmm9
movaps [rsp+98h+var_68], xmm11
loc_9A7BB:
mov eax, [rsp+98h+var_90]
mov ebp, eax
mov r12d, r14d
movdqa [rsp+98h+var_78], xmm0
movdqa xmm1, xmm0
cmp eax, dword ptr [rsp+98h+var_88]
jg short loc_9A81F
loc_9A7D4:
pshufd xmm0, xmm1, 55h ; 'U'
por xmm0, xmm1
movd eax, xmm0
or eax, r12d
js short loc_9A811
mov rdi, [rsp+98h+var_80]
mov esi, ebp
mov edx, r15d
mov ecx, [rsp+98h+var_8C]
movdqa [rsp+98h+var_48], xmm1
call ImageDrawPixel
movdqa xmm1, [rsp+98h+var_48]
movaps xmm11, [rsp+98h+var_68]
movaps xmm9, [rsp+98h+var_58]
loc_9A811:
paddd xmm1, xmm9
add r12d, r13d
inc ebp
cmp ebx, ebp
jnz short loc_9A7D4
loc_9A81F:
movdqa xmm0, [rsp+98h+var_78]
paddd xmm0, xmm11
add r14d, [rsp+98h+var_94]
lea eax, [r15+1]
cmp r15d, [rsp+98h+var_98]
mov r15d, eax
jnz loc_9A7BB
loc_9A840:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ImageDrawTriangle(long long a1, unsigned int a2, __m128 a3, __m128 a4, __m128 a5)
{
float v5; // xmm5_4
int v6; // edx
__m128 v7; // xmm8
__m128 v8; // xmm4
__m128 v9; // xmm10
float v10; // xmm7_4
int v11; // esi
long long result; // rax
float v13; // xmm7_4
__m128 v14; // xmm3
__m128 v15; // xmm6
__m128i v16; // xmm9
__m128i v17; // xmm11
__m128i v18; // xmm8
__m128i v19; // xmm2
int v20; // r15d
__m128 v21; // xmm8
__m128i v22; // xmm1
__m128 v23; // xmm5
__m128 v24; // xmm7
int v25; // r14d
__m128i v26; // xmm0
int v27; // r13d
int v28; // ebp
int v29; // r12d
__m128i si128; // xmm1
int v32; // [rsp+4h] [rbp-94h]
int v33; // [rsp+8h] [rbp-90h]
int v35; // [rsp+10h] [rbp-88h]
__m128i v36; // [rsp+20h] [rbp-78h] BYREF
__m128i v37; // [rsp+30h] [rbp-68h]
__m128i v38; // [rsp+40h] [rbp-58h]
__m128i v39[4]; // [rsp+50h] [rbp-48h] BYREF
LODWORD(v5) = _mm_shuffle_ps(a3, a3, 85).m128_u32[0];
v6 = (int)fmaxf(fmaxf(a3.m128_f32[0], a4.m128_f32[0]), a5.m128_f32[0]);
v7 = _mm_unpacklo_ps(a3, a5);
v8 = _mm_shuffle_ps(_mm_shuffle_ps(a4, a5, 17), a5, 226);
v9 = _mm_min_ps(_mm_min_ps(a3, a4), a5);
LODWORD(v10) = _mm_shuffle_ps(a5, a5, 85).m128_u32[0];
v11 = (int)fmaxf(fmaxf(v5, _mm_shuffle_ps(a4, a4, 85).m128_f32[0]), v10);
result = *(unsigned int *)(a1 + 8);
if ( (int)result < v6 )
v6 = *(_DWORD *)(a1 + 8);
v35 = v6;
if ( *(_DWORD *)(a1 + 12) < v11 )
v11 = *(_DWORD *)(a1 + 12);
v13 = (float)(v10 - v5) * (float)(a4.m128_f32[0] - a3.m128_f32[0]);
v14 = _mm_unpacklo_ps(a5, a4);
v15 = _mm_sub_ps(v14, v7);
v16 = _mm_cvttps_epi32(_mm_sub_ps(_mm_shuffle_ps(_mm_shuffle_ps(a5, a3, 17), a3, 226), v8));
v17 = _mm_cvttps_epi32(v15);
v18 = _mm_cvttps_epi32(v9);
v19 = _mm_and_si128(_mm_cmpgt_epi32(v18, (__m128i)0LL), v18);
v20 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v19, 85));
v21 = _mm_sub_ps(
_mm_shuffle_ps(_mm_shuffle_ps(a3, a4, 16), a4, 226),
_mm_shuffle_ps(_mm_shuffle_ps(a4, a3, 16), a3, 226));
v22 = _mm_cvttps_epi32(v21);
if ( v13 > (float)(v15.m128_f32[0] * v21.m128_f32[0]) )
{
v16 = _mm_sub_epi32((__m128i)0LL, v16);
v17 = _mm_sub_epi32((__m128i)0LL, v17);
v22 = _mm_sub_epi32((__m128i)0LL, v22);
}
if ( v20 <= v11 )
{
v23 = _mm_cvtepi32_ps(v19);
v24 = _mm_mul_ps(_mm_sub_ps(v23, a3), _mm_cvtepi32_ps(v22));
v25 = (int)(float)(_mm_shuffle_ps(v24, v24, 85).m128_f32[0] + v24.m128_f32[0]);
v33 = _mm_cvtsi128_si32(v19);
v32 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v22, 85));
v26 = _mm_cvttps_epi32(
_mm_add_ps(
_mm_mul_ps(_mm_sub_ps(_mm_shuffle_ps(v23, v23, 85), v8), _mm_cvtepi32_ps(v17)),
_mm_mul_ps(_mm_sub_ps(_mm_shuffle_ps(v23, v23, 0), v14), _mm_cvtepi32_ps(v16))));
v27 = _mm_cvtsi128_si32(v22);
v38 = v16;
v37 = v17;
do
{
v28 = v33;
v29 = v25;
v36 = v26;
si128 = v26;
if ( v33 <= v35 )
{
do
{
if ( (v29 | _mm_cvtsi128_si32(_mm_or_si128(_mm_shuffle_epi32(si128, 85), si128))) >= 0 )
{
v39[0] = si128;
ImageDrawPixel((long long *)a1, v28, v20, a2);
si128 = _mm_load_si128(v39);
v17 = v37;
v16 = v38;
}
si128 = _mm_add_epi32(si128, v16);
v29 += v27;
++v28;
}
while ( v35 + 1 != v28 );
}
v26 = _mm_add_epi32(_mm_load_si128(&v36), v17);
v25 += v32;
result = (unsigned int)(v20 + 1);
}
while ( v20++ != v11 );
}
return result;
}
|
ImageDrawTriangle:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RSP + 0xc],ESI
MOVAPS XMM5,XMM0
SHUFPS XMM5,XMM0,0x55
MOVAPS XMM3,XMM1
SHUFPS XMM3,XMM1,0x55
MOVAPS XMM4,XMM0
MAXSS XMM4,XMM1
MAXSS XMM4,XMM2
CVTTSS2SI EDX,XMM4
MOVAPS XMM6,XMM5
MAXSS XMM6,XMM3
MOVAPS XMM3,XMM2
MOVAPS XMM8,XMM0
UNPCKLPS XMM8,XMM2
MOVAPS XMM9,XMM2
MOVAPS XMM4,XMM1
SHUFPS XMM4,XMM2,0x11
SHUFPS XMM4,XMM2,0xe2
MOVAPS XMM10,XMM0
MINPS XMM10,XMM1
MINPS XMM10,XMM2
MOVAPS XMM7,XMM2
SHUFPS XMM7,XMM2,0x55
MAXSS XMM6,XMM7
CVTTSS2SI ESI,XMM6
MOV EAX,dword ptr [RDI + 0x8]
MOV qword ptr [RSP + 0x18],RDI
MOV ECX,dword ptr [RDI + 0xc]
CMP EAX,EDX
CMOVL EDX,EAX
MOV qword ptr [RSP + 0x10],RDX
CMP ECX,ESI
CMOVL ESI,ECX
MOV dword ptr [RSP],ESI
MOVAPS XMM2,XMM1
SUBSS XMM2,XMM0
SUBSS XMM7,XMM5
MULSS XMM7,XMM2
UNPCKLPS XMM3,XMM1
MOVAPS XMM6,XMM3
SUBPS XMM6,XMM8
SHUFPS XMM9,XMM0,0x11
SHUFPS XMM9,XMM0,0xe2
SUBPS XMM9,XMM4
CVTTPS2DQ XMM9,XMM9
CVTTPS2DQ XMM11,XMM6
CVTTPS2DQ XMM8,XMM10
XORPS XMM5,XMM5
MOVDQA XMM2,XMM8
PCMPGTD XMM2,XMM5
PAND XMM2,XMM8
PSHUFD XMM8,XMM2,0x55
MOVD R15D,XMM8
MOVAPS XMM8,XMM0
SHUFPS XMM8,XMM1,0x10
SHUFPS XMM8,XMM1,0xe2
SHUFPS XMM1,XMM0,0x10
SHUFPS XMM1,XMM0,0xe2
SUBPS XMM8,XMM1
MULSS XMM6,XMM8
UCOMISS XMM7,XMM6
CVTTPS2DQ XMM1,XMM8
JBE 0x0019a73e
XORPS XMM6,XMM6
PSUBD XMM6,XMM9
XORPS XMM7,XMM7
PSUBD XMM7,XMM11
PSUBD XMM5,XMM1
MOVDQA XMM9,XMM6
MOVDQA XMM11,XMM7
MOVDQA XMM1,XMM5
LAB_0019a73e:
CMP R15D,dword ptr [RSP]
JG 0x0019a840
CVTDQ2PS XMM5,XMM2
CVTDQ2PS XMM6,XMM1
MOVAPS XMM7,XMM5
SUBPS XMM7,XMM0
MULPS XMM7,XMM6
MOVAPS XMM0,XMM7
SHUFPS XMM0,XMM7,0x55
ADDSS XMM0,XMM7
CVTTSS2SI R14D,XMM0
CVTDQ2PS XMM0,XMM9
CVTDQ2PS XMM6,XMM11
MOVAPS XMM7,XMM5
SHUFPS XMM7,XMM5,0x0
SUBPS XMM7,XMM3
MULPS XMM7,XMM0
SHUFPS XMM5,XMM5,0x55
SUBPS XMM5,XMM4
MULPS XMM5,XMM6
ADDPS XMM5,XMM7
CVTTPS2DQ XMM3,XMM5
MOVD dword ptr [RSP + 0x8],XMM2
PSHUFD XMM0,XMM1,0x55
MOVD dword ptr [RSP + 0x4],XMM0
MOVDQA XMM0,XMM3
MOVD R13D,XMM1
MOV RAX,qword ptr [RSP + 0x10]
LEA EBX,[RAX + 0x1]
MOVAPS xmmword ptr [RSP + 0x40],XMM9
MOVAPS xmmword ptr [RSP + 0x30],XMM11
LAB_0019a7bb:
MOV EAX,dword ptr [RSP + 0x8]
MOV EBP,EAX
MOV R12D,R14D
MOVDQA xmmword ptr [RSP + 0x20],XMM0
MOVDQA XMM1,XMM0
CMP EAX,dword ptr [RSP + 0x10]
JG 0x0019a81f
LAB_0019a7d4:
PSHUFD XMM0,XMM1,0x55
POR XMM0,XMM1
MOVD EAX,XMM0
OR EAX,R12D
JS 0x0019a811
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,EBP
MOV EDX,R15D
MOV ECX,dword ptr [RSP + 0xc]
MOVDQA xmmword ptr [RSP + 0x50],XMM1
CALL 0x00199487
MOVDQA XMM1,xmmword ptr [RSP + 0x50]
MOVAPS XMM11,xmmword ptr [RSP + 0x30]
MOVAPS XMM9,xmmword ptr [RSP + 0x40]
LAB_0019a811:
PADDD XMM1,XMM9
ADD R12D,R13D
INC EBP
CMP EBX,EBP
JNZ 0x0019a7d4
LAB_0019a81f:
MOVDQA XMM0,xmmword ptr [RSP + 0x20]
PADDD XMM0,XMM11
ADD R14D,dword ptr [RSP + 0x4]
LEA EAX,[R15 + 0x1]
CMP R15D,dword ptr [RSP]
MOV R15D,EAX
JNZ 0x0019a7bb
LAB_0019a840:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void ImageDrawTriangle(long param_1,int4 param_2)
{
int iVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
bool bVar7;
float fVar8;
float fVar9;
int1 in_XMM0 [16];
float fVar10;
int iVar11;
float fVar14;
int1 in_XMM1 [16];
int iVar15;
int1 auVar12 [16];
int1 auVar13 [16];
float fVar16;
uint uVar17;
float fVar18;
int1 in_XMM2 [16];
float fVar19;
float fVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int1 auVar25 [16];
int iVar26;
int iVar27;
int iVar28;
int iVar29;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
fVar8 = in_XMM0._0_4_;
fVar9 = in_XMM0._4_4_;
fVar10 = in_XMM1._0_4_;
fVar14 = in_XMM1._4_4_;
fVar19 = fVar8;
if (fVar8 <= fVar10) {
fVar19 = fVar10;
}
fVar16 = in_XMM2._0_4_;
if (fVar19 <= fVar16) {
fVar19 = fVar16;
}
fVar20 = fVar9;
if (fVar9 <= fVar14) {
fVar20 = fVar14;
}
fVar18 = in_XMM2._4_4_;
auVar25 = minps(in_XMM0,in_XMM1);
auVar25 = minps(auVar25,in_XMM2);
if (fVar20 <= fVar18) {
fVar20 = fVar18;
}
iVar1 = (int)fVar19;
if (*(int *)(param_1 + 8) < (int)fVar19) {
iVar1 = *(int *)(param_1 + 8);
}
uVar3 = (int)fVar20;
if ((int)*(uint *)(param_1 + 0xc) < (int)fVar20) {
uVar3 = *(uint *)(param_1 + 0xc);
}
iVar21 = (int)(fVar9 - fVar18);
iVar22 = (int)(fVar18 - fVar14);
iVar23 = (int)(in_XMM0._8_4_ - in_XMM2._8_4_);
iVar24 = (int)(in_XMM0._12_4_ - in_XMM2._12_4_);
iVar26 = (int)(fVar16 - fVar8);
iVar27 = (int)(fVar10 - fVar16);
iVar28 = (int)(fVar18 - fVar9);
iVar29 = (int)(fVar14 - fVar18);
uVar17 = -(uint)(0 < (int)auVar25._0_4_) & (int)auVar25._0_4_;
uVar6 = -(uint)(0 < (int)auVar25._4_4_) & (int)auVar25._4_4_;
iVar11 = (int)(fVar14 - fVar9);
iVar15 = (int)(fVar8 - fVar10);
if ((fVar16 - fVar8) * (fVar14 - fVar9) < (fVar18 - fVar9) * (fVar10 - fVar8)) {
iVar21 = -iVar21;
iVar22 = -iVar22;
iVar23 = -iVar23;
iVar24 = -iVar24;
iVar26 = -iVar26;
iVar27 = -iVar27;
iVar28 = -iVar28;
iVar29 = -iVar29;
iVar11 = -iVar11;
iVar15 = -iVar15;
}
if ((int)uVar6 <= (int)uVar3) {
fVar19 = (float)(int)uVar17;
fVar20 = (float)(int)uVar6;
uVar5 = (uint)((fVar20 - fVar9) * (float)iVar15 + (fVar19 - fVar8) * (float)iVar11);
auVar25._4_4_ = (int)((fVar20 - fVar14) * (float)iVar27 + (fVar19 - fVar10) * (float)iVar22);
auVar25._0_4_ = (int)((fVar20 - fVar18) * (float)iVar26 + (fVar19 - fVar16) * (float)iVar21);
auVar25._8_4_ =
(int)((fVar20 - in_XMM2._8_4_) * (float)iVar28 + (fVar19 - fVar18) * (float)iVar23);
auVar25._12_4_ =
(int)((fVar20 - in_XMM2._12_4_) * (float)iVar29 + (fVar19 - fVar14) * (float)iVar24);
do {
auVar12 = auVar25;
uVar2 = uVar17;
uVar4 = uVar5;
if ((int)uVar17 <= iVar1) {
do {
if (-1 < (int)(auVar12._4_4_ | auVar12._0_4_ | uVar4)) {
ImageDrawPixel(param_1,uVar2,uVar6,param_2);
}
auVar13._0_4_ = auVar12._0_4_ + iVar21;
auVar13._4_4_ = auVar12._4_4_ + iVar22;
auVar13._8_4_ = auVar12._8_4_ + iVar23;
auVar13._12_4_ = auVar12._12_4_ + iVar24;
uVar4 = uVar4 + iVar11;
uVar2 = uVar2 + 1;
auVar12 = auVar13;
} while (iVar1 + 1U != uVar2);
}
local_78 = auVar25._0_4_;
uStack_74 = auVar25._4_4_;
uStack_70 = auVar25._8_4_;
uStack_6c = auVar25._12_4_;
auVar25._0_4_ = local_78 + iVar26;
auVar25._4_4_ = uStack_74 + iVar27;
auVar25._8_4_ = uStack_70 + iVar28;
auVar25._12_4_ = uStack_6c + iVar29;
uVar5 = uVar5 + iVar15;
bVar7 = uVar6 != uVar3;
uVar6 = uVar6 + 1;
} while (bVar7);
}
return;
}
|
|
64,063 |
my_numchars_mb
|
eloqsql/strings/ctype-mb.c
|
size_t my_numchars_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end)
{
register size_t count= 0;
while (pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs,pos,end)) ? mb_len : 1;
count++;
}
return count;
}
|
O0
|
c
|
my_numchars_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xf4a5f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf3f20
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xf4a37
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xf4a41
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xf4a41
movl -0x28(%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 0xf4a0c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
my_numchars_mb:
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], 0
loc_F4A0C:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_F4A5F
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_0
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_F4A37
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
jmp short loc_F4A41
loc_F4A37:
mov eax, 1
mov [rbp+var_28], eax
jmp short $+2
loc_F4A41:
mov ecx, [rbp+var_28]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_F4A0C
loc_F4A5F:
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
|
long long my_numchars_mb(long long a1, unsigned long long a2, unsigned long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
v6 = 0LL;
while ( a2 < a3 )
{
v5 = my_ismbchar_0(a1, a2, a3);
if ( v5 )
v4 = v5;
else
v4 = 1;
a2 += v4;
++v6;
}
return v6;
}
|
my_numchars_mb:
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],0x0
LAB_001f4a0c:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001f4a5f
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001f3f20
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x001f4a37
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001f4a41
LAB_001f4a37:
MOV EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001f4a41
LAB_001f4a41:
MOV ECX,dword ptr [RBP + -0x28]
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 0x001f4a0c
LAB_001f4a5f:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
long my_numchars_mb(int8 param_1,ulong param_2,ulong param_3)
{
int4 local_30;
int8 local_28;
int8 local_18;
local_28 = 0;
for (local_18 = param_2; local_18 < param_3; local_18 = local_18 + local_30) {
local_30 = my_ismbchar(param_1,local_18,param_3);
if (local_30 == 0) {
local_30 = 1;
}
local_28 = local_28 + 1;
}
return local_28;
}
|
|
64,064 |
inline_mysql_mutex_init
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
}
|
O0
|
c
|
inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1c880e(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_mutex_init_11:
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+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
|
long long inline_mysql_mutex_init_11(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
|
inline_mysql_mutex_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,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
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 + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a340
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
|
|
64,065 |
json_validate
|
corpus-core[P]colibri-stateless/src/util/json_validate.c
|
const char* json_validate(json_t val, const char* def, const char* error_prefix) {
if (*def == '[') return check_array(val, def, error_prefix ? error_prefix : "");
if (*def == '{') return check_object(val, def, error_prefix ? error_prefix : "");
if (strncmp(def, "bytes32", 7) == 0) return check_hex(val, 32, false, error_prefix ? error_prefix : "");
if (strncmp(def, "address", 7) == 0) return check_hex(val, 20, false, error_prefix);
if (strncmp(def, "hexuint", 7) == 0) return check_hex(val, 0, true, error_prefix);
if (strncmp(def, "hex32", 5) == 0) return check_hex(val, -32, false, error_prefix);
if (strncmp(def, "bytes", 5) == 0) return check_hex(val, 0, false, error_prefix);
if (strncmp(def, "uint", 4) == 0) return val.type == JSON_TYPE_NUMBER ? NULL : strdup("Expected uint");
if (strncmp(def, "bool", 4) == 0) return val.type == JSON_TYPE_BOOLEAN ? NULL : strdup("Expected boolean");
if (strncmp(def, "block", 5) == 0) return check_block(val, error_prefix);
ERROR("%sUnknown type %s", error_prefix ? error_prefix : "", def);
}
|
O0
|
c
|
json_validate:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0xa4c50
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa4c10
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xa4c1d
leaq 0x35503(%rip), %rax # 0xda11a
movq %rax, -0x30(%rbp)
jmp 0xa4c1d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa4f90
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0xa4cb5
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa4c75
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xa4c82
leaq 0x3549e(%rip), %rax # 0xda11a
movq %rax, -0x40(%rbp)
jmp 0xa4c82
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x40(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5200
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x407d4(%rip), %rsi # 0xe5494
movl $0x7, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4d23
cmpq $0x0, -0x18(%rbp)
je 0xa4ce0
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xa4ced
leaq 0x35433(%rip), %rax # 0xda11a
movq %rax, -0x48(%rbp)
jmp 0xa4ced
movq -0x20(%rbp), %rax
movq -0x48(%rbp), %rdx
movl $0x20, %edi
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5920
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x365fd(%rip), %rsi # 0xdb32b
movl $0x7, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4d73
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movl $0x14, %edi
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5920
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x40cfd(%rip), %rsi # 0xe5a7b
movl $0x7, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4dc3
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
xorl %edi, %edi
movl $0x1, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5920
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x40cb5(%rip), %rsi # 0xe5a83
movl $0x5, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4e13
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movl $0xffffffe0, %edi # imm = 0xFFFFFFE0
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5920
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x3633c(%rip), %rsi # 0xdb15a
movl $0x5, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4e60
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movl %esi, %edi
callq 0xa5920
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x40c27(%rip), %rsi # 0xe5a92
movl $0x4, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4ea9
movq -0x20(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0xa4e8c
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xa4e9c
leaq 0x40bf6(%rip), %rdi # 0xe5a89
callq 0x23450
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x40be3(%rip), %rsi # 0xe5a97
movl $0x4, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4ef2
movq -0x20(%rbp), %rax
cmpl $0x5, 0x10(%rax)
jne 0xa4ed5
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xa4ee5
leaq 0x40bc0(%rip), %rdi # 0xe5a9c
callq 0x23450
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa4f74
movq -0x10(%rbp), %rdi
leaq 0x3510d(%rip), %rsi # 0xda00a
movl $0x5, %edx
callq 0x23110
cmpl $0x0, %eax
jne 0xa4f38
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xa5b70
movq %rax, -0x8(%rbp)
jmp 0xa4f74
cmpq $0x0, -0x18(%rbp)
je 0xa4f49
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0xa4f56
leaq 0x351ca(%rip), %rax # 0xda11a
movq %rax, -0x60(%rbp)
jmp 0xa4f56
movq -0x60(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
leaq 0x40b44(%rip), %rsi # 0xe5aad
movb $0x0, %al
callq 0x9d5a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
json_validate:
push rbp
mov rbp, rsp
sub rsp, 80h
lea rax, [rbp+arg_0]
mov [rbp+var_20], rax
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Bh ; '['
jnz short loc_A4C50
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
cmp [rbp+var_18], 0
jz short loc_A4C10
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
jmp short loc_A4C1D
loc_A4C10:
lea rax, aUsageSTTypenam+0ECh; ""
mov [rbp+var_30], rax
jmp short $+2
loc_A4C1D:
mov rdi, [rbp+var_28]
mov rax, [rbp+var_20]
mov rsi, [rbp+var_30]
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_array
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4C50:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Bh ; '{'
jnz short loc_A4CB5
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
cmp [rbp+var_18], 0
jz short loc_A4C75
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
jmp short loc_A4C82
loc_A4C75:
lea rax, aUsageSTTypenam+0ECh; ""
mov [rbp+var_40], rax
jmp short $+2
loc_A4C82:
mov rdi, [rbp+var_38]
mov rax, [rbp+var_20]
mov rsi, [rbp+var_40]
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_object
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4CB5:
mov rdi, [rbp+var_10]
lea rsi, aBytes32; "bytes32"
mov edx, 7
call _strncmp
cmp eax, 0
jnz short loc_A4D23
cmp [rbp+var_18], 0
jz short loc_A4CE0
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
jmp short loc_A4CED
loc_A4CE0:
lea rax, aUsageSTTypenam+0ECh; ""
mov [rbp+var_48], rax
jmp short $+2
loc_A4CED:
mov rax, [rbp+var_20]
mov rdx, [rbp+var_48]
mov edi, 20h ; ' '
xor esi, esi
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_hex
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4D23:
mov rdi, [rbp+var_10]
lea rsi, aCodeAddress+7; "address"
mov edx, 7
call _strncmp
cmp eax, 0
jnz short loc_A4D73
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov edi, 14h
xor esi, esi
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_hex
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4D73:
mov rdi, [rbp+var_10]
lea rsi, aHexuint; "hexuint"
mov edx, 7
call _strncmp
cmp eax, 0
jnz short loc_A4DC3
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
xor edi, edi
mov esi, 1
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_hex
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4DC3:
mov rdi, [rbp+var_10]
lea rsi, aHex32; "hex32"
mov edx, 5
call _strncmp
cmp eax, 0
jnz short loc_A4E13
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
mov edi, 0FFFFFFE0h
xor esi, esi
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_hex
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4E13:
mov rdi, [rbp+var_10]
lea rsi, aInvalidTransac_0+2Ah; "bytes"
mov edx, 5
call _strncmp
cmp eax, 0
jnz short loc_A4E60
mov rax, [rbp+var_20]
mov rdx, [rbp+var_18]
xor esi, esi
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
mov edi, esi
call check_hex
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4E60:
mov rdi, [rbp+var_10]
lea rsi, aExpectedUint+9; "uint"
mov edx, 4
call _strncmp
cmp eax, 0
jnz short loc_A4EA9
mov rax, [rbp+var_20]
cmp dword ptr [rax+10h], 2
jnz short loc_A4E8C
xor eax, eax
mov [rbp+var_50], rax
jmp short loc_A4E9C
loc_A4E8C:
lea rdi, aExpectedUint; "Expected uint"
call _strdup
mov [rbp+var_50], rax
loc_A4E9C:
mov rax, [rbp+var_50]
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4EA9:
mov rdi, [rbp+var_10]
lea rsi, aBool; "bool"
mov edx, 4
call _strncmp
cmp eax, 0
jnz short loc_A4EF2
mov rax, [rbp+var_20]
cmp dword ptr [rax+10h], 5
jnz short loc_A4ED5
xor eax, eax
mov [rbp+var_58], rax
jmp short loc_A4EE5
loc_A4ED5:
lea rdi, aExpectedBoolea; "Expected boolean"
call _strdup
mov [rbp+var_58], rax
loc_A4EE5:
mov rax, [rbp+var_58]
mov [rbp+var_8], rax
jmp loc_A4F74
loc_A4EF2:
mov rdi, [rbp+var_10]
lea rsi, aSignedblock+6; "block"
mov edx, 5
call _strncmp
cmp eax, 0
jnz short loc_A4F38
mov rax, [rbp+var_20]
mov rdi, [rbp+var_18]
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call check_block
mov [rbp+var_8], rax
jmp short loc_A4F74
loc_A4F38:
cmp [rbp+var_18], 0
jz short loc_A4F49
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
jmp short loc_A4F56
loc_A4F49:
lea rax, aUsageSTTypenam+0ECh; ""
mov [rbp+var_60], rax
jmp short $+2
loc_A4F56:
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_10]
xor eax, eax
mov edi, eax
lea rsi, aSunknownTypeS; "%sUnknown type %s"
mov al, 0
call bprintf
mov [rbp+var_8], rax
loc_A4F74:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
long long json_validate(
_BYTE *a1,
long long a2,
int a3,
_DWORD a4,
int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
long long a16,
long long a17)
{
int v19; // r8d
int v20; // r9d
int v22; // r8d
int v23; // r9d
int v24; // r8d
int v25; // r9d
int v26; // r8d
int v27; // r9d
int v28; // r8d
int v29; // r9d
int v30; // edx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
char v37; // [rsp+0h] [rbp-80h]
if ( *a1 == 91 )
{
if ( a2 )
return check_array((_DWORD)a1, a2, a3, a16, a5, a6, a15, a16, a17);
else
return check_array((_DWORD)a1, (unsigned int)"", a3, a16, a5, a6, a15, a16, a17);
}
else if ( *a1 == 123 )
{
if ( a2 )
return check_object((_DWORD)a1, a2, a3, a16, a5, a6, a15, a16, a17);
else
return check_object((_DWORD)a1, (unsigned int)"", a3, a16, a5, a6, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "bytes32", 7LL) )
{
if ( a2 )
return check_hex(32, 0, a2, a16, v19, v20, a15, a16, a17);
else
return check_hex(32, 0, (unsigned int)"", a16, v19, v20, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "address", 7LL) )
{
return check_hex(20, 0, a2, a16, v22, v23, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "hexuint", 7LL) )
{
return check_hex(0, 1, a2, a16, v24, v25, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "hex32", 5LL) )
{
return check_hex(-32, 0, a2, a16, v26, v27, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "bytes", 5LL) )
{
return check_hex(0, 0, a2, a16, v28, v29, a15, a16, a17);
}
else if ( !(unsigned int)strncmp(a1, "uint", 4LL) )
{
if ( (_DWORD)a17 == 2 )
return 0LL;
else
return strdup("Expected uint");
}
else if ( !(unsigned int)strncmp(a1, "bool", 4LL) )
{
if ( (_DWORD)a17 == 5 )
return 0LL;
else
return strdup("Expected boolean");
}
else if ( !(unsigned int)strncmp(a1, "block", 5LL) )
{
return check_block(a2, (unsigned int)"block", v30, a16, v31, v32, a15, a16, a17);
}
else if ( a2 )
{
return bprintf(
0LL,
(long long)"%sUnknown type %s",
a2,
(long long)a1,
v31,
v32,
a7,
a8,
a9,
a10,
v33,
v34,
a13,
a14,
v37);
}
else
{
return bprintf(
0LL,
(long long)"%sUnknown type %s",
(long long)"",
(long long)a1,
v31,
v32,
a7,
a8,
a9,
a10,
v33,
v34,
a13,
a14,
v37);
}
}
|
json_validate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5b
JNZ 0x001a4c50
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001a4c10
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001a4c1d
LAB_001a4c10:
LEA RAX,[0x1da11a]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001a4c1d
LAB_001a4c1d:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -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 0x001a4f90
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4c50:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7b
JNZ 0x001a4cb5
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001a4c75
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001a4c82
LAB_001a4c75:
LEA RAX,[0x1da11a]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001a4c82
LAB_001a4c82:
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x40]
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 0x001a5200
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4cb5:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1e5494]
MOV EDX,0x7
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4d23
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001a4ce0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001a4ced
LAB_001a4ce0:
LEA RAX,[0x1da11a]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001a4ced
LAB_001a4ced:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x48]
MOV EDI,0x20
XOR ESI,ESI
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 0x001a5920
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4d23:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1db32b]
MOV EDX,0x7
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4d73
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV EDI,0x14
XOR ESI,ESI
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 0x001a5920
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4d73:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1e5a7b]
MOV EDX,0x7
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4dc3
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
XOR EDI,EDI
MOV ESI,0x1
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 0x001a5920
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4dc3:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1e5a83]
MOV EDX,0x5
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4e13
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV EDI,0xffffffe0
XOR ESI,ESI
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 0x001a5920
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4e13:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1db15a]
MOV EDX,0x5
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4e60
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
XOR ESI,ESI
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
MOV EDI,ESI
CALL 0x001a5920
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4e60:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1e5a92]
MOV EDX,0x4
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4ea9
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x10],0x2
JNZ 0x001a4e8c
XOR EAX,EAX
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001a4e9c
LAB_001a4e8c:
LEA RDI,[0x1e5a89]
CALL 0x00123450
MOV qword ptr [RBP + -0x50],RAX
LAB_001a4e9c:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4ea9:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1e5a97]
MOV EDX,0x4
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4ef2
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x10],0x5
JNZ 0x001a4ed5
XOR EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001a4ee5
LAB_001a4ed5:
LEA RDI,[0x1e5a9c]
CALL 0x00123450
MOV qword ptr [RBP + -0x58],RAX
LAB_001a4ee5:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4ef2:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1da00a]
MOV EDX,0x5
CALL 0x00123110
CMP EAX,0x0
JNZ 0x001a4f38
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
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 0x001a5b70
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a4f74
LAB_001a4f38:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001a4f49
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001a4f56
LAB_001a4f49:
LEA RAX,[0x1da11a]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001a4f56
LAB_001a4f56:
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV EDI,EAX
LEA RSI,[0x1e5aad]
MOV AL,0x0
CALL 0x0019d5a0
MOV qword ptr [RBP + -0x8],RAX
LAB_001a4f74:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
char * json_validate(char *param_1,char *param_2)
{
int iVar1;
int in_stack_00000018;
char *local_68;
char *local_60;
char *local_58;
char *local_50;
char *local_48;
char *local_38;
char *local_10;
if (*param_1 == '[') {
local_38 = param_2;
if (param_2 == (char *)0x0) {
local_38 = "";
}
local_10 = (char *)check_array(param_1,local_38);
}
else if (*param_1 == '{') {
local_48 = param_2;
if (param_2 == (char *)0x0) {
local_48 = "";
}
local_10 = (char *)check_object(param_1,local_48);
}
else {
iVar1 = strncmp(param_1,"bytes32",7);
if (iVar1 == 0) {
local_50 = param_2;
if (param_2 == (char *)0x0) {
local_50 = "";
}
local_10 = (char *)check_hex(0x20,0,local_50);
}
else {
iVar1 = strncmp(param_1,"address",7);
if (iVar1 == 0) {
local_10 = (char *)check_hex(0x14,0,param_2);
}
else {
iVar1 = strncmp(param_1,"hexuint",7);
if (iVar1 == 0) {
local_10 = (char *)check_hex(0,1,param_2);
}
else {
iVar1 = strncmp(param_1,"hex32",5);
if (iVar1 == 0) {
local_10 = (char *)check_hex(0xffffffe0,0,param_2);
}
else {
iVar1 = strncmp(param_1,"bytes",5);
if (iVar1 == 0) {
local_10 = (char *)check_hex(0,0,param_2);
}
else {
iVar1 = strncmp(param_1,"uint",4);
if (iVar1 == 0) {
if (in_stack_00000018 == 2) {
local_58 = (char *)0x0;
}
else {
local_58 = strdup("Expected uint");
}
local_10 = local_58;
}
else {
iVar1 = strncmp(param_1,"bool",4);
if (iVar1 == 0) {
if (in_stack_00000018 == 5) {
local_60 = (char *)0x0;
}
else {
local_60 = strdup("Expected boolean");
}
local_10 = local_60;
}
else {
iVar1 = strncmp(param_1,"block",5);
if (iVar1 == 0) {
local_10 = (char *)check_block(param_2);
}
else {
local_68 = param_2;
if (param_2 == (char *)0x0) {
local_68 = "";
}
local_10 = (char *)bprintf(0,"%sUnknown type %s",local_68,param_1);
}
}
}
}
}
}
}
}
}
return local_10;
}
|
|
64,066 |
trnman_free_trn
|
eloqsql/storage/maria/trnman.c
|
static void trnman_free_trn(TRN *trn)
{
/*
union is to solve strict aliasing issue.
without it gcc 3.4.3 doesn't notice that updating *(void **)&tmp
modifies the value of tmp.
*/
union { TRN *trn; void *v; } tmp;
DBUG_ASSERT(trn != &dummy_transaction_object);
mysql_mutex_lock(&trn->state_lock);
trn->short_id= 0;
mysql_mutex_unlock(&trn->state_lock);
tmp.trn= pool;
do
{
/*
without this volatile cast gcc-3.4.4 moves the assignment
down after the loop at -O2
*/
*(TRN * volatile *)&(trn->next)= tmp.trn;
} while (!my_atomic_casptr((void **)(char*)&pool, &tmp.v, trn));
}
|
O3
|
c
|
trnman_free_trn:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x50(%rdi)
jne 0x46c96
movq %r14, %rdi
callq 0x29220
movw $0x0, 0xac(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
jne 0x46cac
movq %r14, %rdi
callq 0x291e0
movq 0x3b67c6(%rip), %rax # 0x3fd448
movq %rax, 0x68(%rbx)
lock
cmpxchgq %rbx, 0x3b67b9(%rip) # 0x3fd448
jne 0x46c82
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x92cf8(%rip), %rsi # 0xd9995
movq %r14, %rdi
movl $0x22d, %edx # imm = 0x22D
callq 0x2eb8f
jmp 0x46c61
leaq 0x33f35d(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x46c73
|
trnman_free_trn:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+10h]
cmp qword ptr [rdi+50h], 0
jnz short loc_46C96
mov rdi, r14
call _pthread_mutex_lock
loc_46C61:
mov word ptr [rbx+0ACh], 0
mov rdi, [rbx+50h]
test rdi, rdi
jnz short loc_46CAC
loc_46C73:
mov rdi, r14
call _pthread_mutex_unlock
mov rax, cs:pool
loc_46C82:
mov [rbx+68h], rax
lock cmpxchg cs:pool, rbx
jnz short loc_46C82
pop rbx
pop r14
pop rbp
retn
loc_46C96:
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 22Dh
call psi_mutex_lock
jmp short loc_46C61
loc_46CAC:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_46C73
|
signed long long trnman_free_trn(signed long long a1)
{
signed long long result; // rax
signed long long v2; // rtt
if ( *(_QWORD *)(a1 + 80) )
psi_mutex_lock(a1 + 16, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 0x22Du);
else
pthread_mutex_lock(a1 + 16);
*(_WORD *)(a1 + 172) = 0;
if ( *(_QWORD *)(a1 + 80) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 16);
result = pool;
do
{
*(_QWORD *)(a1 + 104) = result;
v2 = result;
result = _InterlockedCompareExchange64(&pool, a1, result);
}
while ( v2 != result );
return result;
}
|
trnman_free_trn:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x10]
CMP qword ptr [RDI + 0x50],0x0
JNZ 0x00146c96
MOV RDI,R14
CALL 0x00129220
LAB_00146c61:
MOV word ptr [RBX + 0xac],0x0
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JNZ 0x00146cac
LAB_00146c73:
MOV RDI,R14
CALL 0x001291e0
MOV RAX,qword ptr [0x004fd448]
LAB_00146c82:
MOV qword ptr [RBX + 0x68],RAX
CMPXCHG.LOCK qword ptr [0x004fd448],RBX
JNZ 0x00146c82
POP RBX
POP R14
POP RBP
RET
LAB_00146c96:
LEA RSI,[0x1d9995]
MOV RDI,R14
MOV EDX,0x22d
CALL 0x0012eb8f
JMP 0x00146c61
LAB_00146cac:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00146c73
|
void trnman_free_trn(long param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
bool bVar3;
__mutex = (pthread_mutex_t *)(param_1 + 0x10);
if (*(long *)(param_1 + 0x50) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x22d);
}
*(int2 *)(param_1 + 0xac) = 0;
if (*(long *)(param_1 + 0x50) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar2 = pool;
do {
*(long *)(param_1 + 0x68) = lVar2;
LOCK();
bVar3 = lVar2 != pool;
lVar1 = param_1;
if (bVar3) {
lVar2 = pool;
lVar1 = pool;
}
pool = lVar1;
UNLOCK();
} while (bVar3);
return;
}
|
|
64,067 |
my_hash_first
|
eloqsql/mysys/hash.c
|
uchar* my_hash_first(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
uchar *res;
DBUG_ASSERT(my_hash_inited(hash));
res= my_hash_first_from_hash_value(hash,
hash->hash_function(hash->charset, key,
length ? length :
hash->key_length),
key, length, current_record);
return res;
}
|
O3
|
c
|
my_hash_first:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x58(%rdi), %rax
movq 0x68(%rdi), %rdi
movq %rdx, %r12
testq %rdx, %rdx
jne 0x94438
movq 0x8(%r15), %rdx
xorl %r12d, %r12d
movq %r14, %rsi
callq *%rax
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9446f
|
my_hash_first:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rcx
mov r14, rsi
mov r15, rdi
mov rax, [rdi+58h]
mov rdi, [rdi+68h]
mov r12, rdx
test rdx, rdx
jnz short loc_94438
mov rdx, [r15+8]
xor r12d, r12d
loc_94438:
mov rsi, r14
call rax
mov rdi, r15
mov esi, eax
mov rdx, r14
mov rcx, r12
mov r8, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp my_hash_first_from_hash_value
|
long long my_hash_first(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long ( *v6)(long long, long long, long long); // rax
long long v7; // rdi
long long v8; // r12
unsigned int v9; // eax
v6 = (long long ( *)(long long, long long, long long))a1[11];
v7 = a1[13];
v8 = a3;
if ( !a3 )
{
a3 = a1[1];
v8 = 0LL;
}
v9 = v6(v7, a2, a3);
return my_hash_first_from_hash_value(a1, v9, a2, v8, a4);
}
|
my_hash_first:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x58]
MOV RDI,qword ptr [RDI + 0x68]
MOV R12,RDX
TEST RDX,RDX
JNZ 0x00194438
MOV RDX,qword ptr [R15 + 0x8]
XOR R12D,R12D
LAB_00194438:
MOV RSI,R14
CALL RAX
MOV RDI,R15
MOV ESI,EAX
MOV RDX,R14
MOV RCX,R12
MOV R8,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0019446f
|
void my_hash_first(long param_1,int8 param_2,long param_3,int8 param_4)
{
int4 uVar1;
long lVar2;
lVar2 = param_3;
if (param_3 == 0) {
param_3 = *(long *)(param_1 + 8);
lVar2 = 0;
}
uVar1 = (**(code **)(param_1 + 0x58))(*(int8 *)(param_1 + 0x68),param_2,param_3);
my_hash_first_from_hash_value(param_1,uVar1,param_2,lVar2,param_4);
return;
}
|
|
64,068 |
ftxui::StackedContainer::ActiveChild()
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/container.cpp
|
Component ActiveChild() final {
if (children_.empty()) {
return nullptr;
}
return children_[0];
}
|
O1
|
cpp
|
ftxui::StackedContainer::ActiveChild():
movq %rdi, %rax
movq 0x8(%rsi), %rcx
cmpq 0x10(%rsi), %rcx
je 0x295b2
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x295bd
movq 0x30a07(%rip), %rdx # 0x59fb0
cmpb $0x0, (%rdx)
je 0x295b9
incl 0x8(%rcx)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
lock
incl 0x8(%rcx)
retq
|
_ZN5ftxui16StackedContainer11ActiveChildEv:
mov rax, rdi
mov rcx, [rsi+8]
cmp rcx, [rsi+10h]
jz short loc_295B2
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
test rcx, rcx
jz short locret_295BD
mov rdx, cs:__libc_single_threaded_ptr
cmp byte ptr [rdx], 0
jz short loc_295B9
inc dword ptr [rcx+8]
retn
loc_295B2:
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
retn
loc_295B9:
lock inc dword ptr [rcx+8]
locret_295BD:
retn
|
ftxui::StackedContainer * ftxui::StackedContainer::ActiveChild(ftxui::StackedContainer *this, long long a2)
{
ftxui::StackedContainer *result; // rax
_QWORD *v3; // rcx
long long v4; // rcx
result = this;
v3 = *(_QWORD **)(a2 + 8);
if ( v3 == *(_QWORD **)(a2 + 16) )
{
*(_OWORD *)this = 0LL;
}
else
{
*(_QWORD *)this = *v3;
v4 = v3[1];
*((_QWORD *)this + 1) = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v4 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v4 + 8));
}
}
return result;
}
|
ActiveChild:
MOV RAX,RDI
MOV RCX,qword ptr [RSI + 0x8]
CMP RCX,qword ptr [RSI + 0x10]
JZ 0x001295b2
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
TEST RCX,RCX
JZ 0x001295bd
MOV RDX,qword ptr [0x00159fb0]
CMP byte ptr [RDX],0x0
JZ 0x001295b9
INC dword ptr [RCX + 0x8]
RET
LAB_001295b2:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
RET
LAB_001295b9:
INC.LOCK dword ptr [RCX + 0x8]
LAB_001295bd:
RET
|
/* ftxui::StackedContainer::ActiveChild() */
void ftxui::StackedContainer::ActiveChild(void)
{
int8 *puVar1;
long lVar2;
long in_RSI;
int8 *in_RDI;
puVar1 = *(int8 **)(in_RSI + 8);
if (puVar1 == *(int8 **)(in_RSI + 0x10)) {
*in_RDI = 0;
in_RDI[1] = 0;
return;
}
*in_RDI = *puVar1;
lVar2 = puVar1[1];
in_RDI[1] = lVar2;
if (lVar2 != 0) {
if (*PTR___libc_single_threaded_00159fb0 != '\0') {
*(int *)(lVar2 + 8) = *(int *)(lVar2 + 8) + 1;
return;
}
LOCK();
*(int *)(lVar2 + 8) = *(int *)(lVar2 + 8) + 1;
UNLOCK();
}
return;
}
|
|
64,069 |
js_proxy_constructor
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_proxy_constructor(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue target, handler;
JSValue obj;
JSProxyData *s;
target = argv[0];
handler = argv[1];
if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
if (JS_IsException(obj))
return obj;
s = js_malloc(ctx, sizeof(JSProxyData));
if (!s) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
s->target = js_dup(target);
s->handler = js_dup(handler);
s->is_func = JS_IsFunction(ctx, target);
s->is_revoked = FALSE;
JS_SetOpaqueInternal(obj, s);
JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
return obj;
}
|
O1
|
c
|
js_proxy_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq 0x8(%r8), %r12
movq 0x18(%r8), %r13
movl %r13d, %eax
notl %eax
movl %r12d, %ebp
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorq %rbp, %rcx
orq %rcx, %rax
je 0x39a5f
leaq 0x69854(%rip), %rsi # 0xa329d
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x265c3
movl $0x6, %r14d
xorl %ecx, %ecx
jmp 0x39aa3
movq (%r8), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%r8), %rax
movq %rax, 0x18(%rsp)
movl $0x2, %edx
movq %r15, %rdi
xorl %esi, %esi
movl $0x30, %ecx
callq 0x24f61
movq %rax, %rbx
movq %rdx, %r14
movl %r14d, %eax
cmpq $0x6, %rax
jne 0x39aba
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x10(%rsp)
movl $0x28, %esi
movq %r15, %rdi
callq 0xf082
testq %rax, %rax
je 0x39b25
movq 0x20(%rsp), %rsi
incl (%rsi)
movq %rsi, (%rax)
movq %r12, 0x8(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
incl (%rax)
movq %rax, 0x10(%rcx)
movq %r13, 0x18(%rcx)
movq %rcx, %r13
movq %r15, %rdi
movq %rsi, %r15
movq %r12, %rdx
callq 0x26e1a
movb %al, 0x20(%r13)
movb $0x0, 0x21(%r13)
movq %r13, 0x30(%rbx)
movq %r15, 0x8(%rsp)
cmpl $-0x1, %ebp
jne 0x39b41
movq 0x8(%rsp), %rax
movb 0x5(%rax), %al
andb $0x10, %al
jmp 0x39b43
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21922
movl $0x6, %r14d
xorl %ebx, %ebx
jmp 0x39a5b
xorl %eax, %eax
movq %rbx, 0x8(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x39a93
movq 0x8(%rsp), %rcx
movb 0x5(%rcx), %dl
andb $-0x11, %dl
orb %al, %dl
movb %dl, 0x5(%rcx)
jmp 0x39a93
|
js_proxy_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
mov r12, [r8+8]
mov r13, [r8+18h]
mov eax, r13d
not eax
mov ebp, r12d
mov ecx, 0FFFFFFFFh
xor rcx, rbp
or rax, rcx
jz short loc_39A5F
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14d, 6
loc_39A5B:
xor ecx, ecx
jmp short loc_39AA3
loc_39A5F:
mov rax, [r8]
mov [rsp+58h+var_38], rax
mov rax, [r8+10h]
mov [rsp+58h+var_40], rax
mov edx, 2
mov rdi, r15
xor esi, esi
mov ecx, 30h ; '0'
call JS_NewObjectProtoClass
mov rbx, rax
mov r14, rdx
mov eax, r14d
cmp rax, 6
jnz short loc_39ABA
loc_39A93:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
loc_39AA3:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_39ABA:
mov [rsp+58h+var_48], rax
mov esi, 28h ; '('
mov rdi, r15
call js_malloc
test rax, rax
jz short loc_39B25
mov rsi, [rsp+58h+var_38]
inc dword ptr [rsi]
mov [rax], rsi
mov [rax+8], r12
mov rcx, rax
mov rax, [rsp+58h+var_40]
inc dword ptr [rax]
mov [rcx+10h], rax
mov [rcx+18h], r13
mov r13, rcx
mov rdi, r15
mov r15, rsi
mov rdx, r12
call JS_IsFunction
mov [r13+20h], al
mov byte ptr [r13+21h], 0
mov [rbx+30h], r13
mov [rsp+58h+var_50], r15
cmp ebp, 0FFFFFFFFh
jnz short loc_39B41
mov rax, [rsp+58h+var_50]
mov al, [rax+5]
and al, 10h
jmp short loc_39B43
loc_39B25:
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
xor ebx, ebx
jmp loc_39A5B
loc_39B41:
xor eax, eax
loc_39B43:
mov [rsp+58h+var_50], rbx
cmp dword ptr [rsp+58h+var_48], 0FFFFFFFFh
jnz loc_39A93
mov rcx, [rsp+58h+var_50]
mov dl, [rcx+5]
and dl, 0EFh
or dl, al
mov [rcx+5], dl
jmp loc_39A93
|
unsigned long long js_proxy_constructor(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
long long v14; // r12
long long v15; // r13
long long v16; // rbx
unsigned long long v17; // rcx
long long v18; // rdx
long long v19; // r14
long long v21; // rax
long long v22; // r13
char v23; // al
char v24; // [rsp+0h] [rbp-58h]
int v25; // [rsp+10h] [rbp-48h]
_DWORD *v26; // [rsp+18h] [rbp-40h]
long long v27; // [rsp+20h] [rbp-38h]
v14 = a13[1];
v15 = a13[3];
if ( !((unsigned int)v14 ^ 0xFFFFFFFFLL | (unsigned int)~*((_DWORD *)a13 + 6)) )
{
v27 = *a13;
v26 = (_DWORD *)a13[2];
v16 = JS_NewObjectProtoClass(a1, 0LL, 2, 0x30u);
v19 = v18;
if ( (unsigned int)v18 != 6LL )
{
v25 = v18;
v21 = js_malloc(a1, 40LL);
if ( !v21 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v16, v19);
LODWORD(v16) = 0;
goto LABEL_3;
}
++*(_DWORD *)v27;
*(_QWORD *)v21 = v27;
*(_QWORD *)(v21 + 8) = v14;
++*v26;
*(_QWORD *)(v21 + 16) = v26;
*(_QWORD *)(v21 + 24) = v15;
v22 = v21;
*(_BYTE *)(v21 + 32) = JS_IsFunction(a1, v27, v14);
*(_BYTE *)(v22 + 33) = 0;
*(_QWORD *)(v16 + 48) = v22;
if ( (_DWORD)v14 == -1 )
v23 = *(_BYTE *)(v27 + 5) & 0x10;
else
v23 = 0;
if ( v25 == -1 )
*(_BYTE *)(v16 + 5) = v23 | *(_BYTE *)(v16 + 5) & 0xEF;
}
v17 = v16 & 0xFFFFFFFF00000000LL;
return v17 | (unsigned int)v16;
}
LODWORD(v16) = 0;
JS_ThrowTypeError(
a1,
(long long)"not an object",
a11,
(unsigned int)v14 ^ 0xFFFFFFFFLL,
(long long)a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v24);
LABEL_3:
v17 = 0LL;
return v17 | (unsigned int)v16;
}
|
js_proxy_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDI
MOV R12,qword ptr [R8 + 0x8]
MOV R13,qword ptr [R8 + 0x18]
MOV EAX,R13D
NOT EAX
MOV EBP,R12D
MOV ECX,0xffffffff
XOR RCX,RBP
OR RAX,RCX
JZ 0x00139a5f
LEA RSI,[0x1a329d]
XOR EBX,EBX
MOV RDI,R15
XOR EAX,EAX
CALL 0x001265c3
MOV R14D,0x6
LAB_00139a5b:
XOR ECX,ECX
JMP 0x00139aa3
LAB_00139a5f:
MOV RAX,qword ptr [R8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [R8 + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV EDX,0x2
MOV RDI,R15
XOR ESI,ESI
MOV ECX,0x30
CALL 0x00124f61
MOV RBX,RAX
MOV R14,RDX
MOV EAX,R14D
CMP RAX,0x6
JNZ 0x00139aba
LAB_00139a93:
MOV RAX,-0x100000000
MOV RCX,RBX
AND RCX,RAX
LAB_00139aa3:
MOV EAX,EBX
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00139aba:
MOV qword ptr [RSP + 0x10],RAX
MOV ESI,0x28
MOV RDI,R15
CALL 0x0010f082
TEST RAX,RAX
JZ 0x00139b25
MOV RSI,qword ptr [RSP + 0x20]
INC dword ptr [RSI]
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],R12
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
INC dword ptr [RAX]
MOV qword ptr [RCX + 0x10],RAX
MOV qword ptr [RCX + 0x18],R13
MOV R13,RCX
MOV RDI,R15
MOV R15,RSI
MOV RDX,R12
CALL 0x00126e1a
MOV byte ptr [R13 + 0x20],AL
MOV byte ptr [R13 + 0x21],0x0
MOV qword ptr [RBX + 0x30],R13
MOV qword ptr [RSP + 0x8],R15
CMP EBP,-0x1
JNZ 0x00139b41
MOV RAX,qword ptr [RSP + 0x8]
MOV AL,byte ptr [RAX + 0x5]
AND AL,0x10
JMP 0x00139b43
LAB_00139b25:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x00121922
MOV R14D,0x6
XOR EBX,EBX
JMP 0x00139a5b
LAB_00139b41:
XOR EAX,EAX
LAB_00139b43:
MOV qword ptr [RSP + 0x8],RBX
CMP dword ptr [RSP + 0x10],-0x1
JNZ 0x00139a93
MOV RCX,qword ptr [RSP + 0x8]
MOV DL,byte ptr [RCX + 0x5]
AND DL,0xef
OR DL,AL
MOV byte ptr [RCX + 0x5],DL
JMP 0x00139a93
|
int1 [16] js_proxy_constructor(long param_1)
{
ulong uVar1;
int8 uVar2;
int *piVar3;
int *piVar4;
int1 uVar5;
byte bVar6;
int8 *puVar7;
ulong uVar8;
int8 *in_R8;
int1 auVar9 [16];
int1 auVar10 [16];
int local_48;
uVar1 = in_R8[1];
uVar2 = in_R8[3];
if ((int)uVar2 == -1 && (uVar1 & 0xffffffff) == 0xffffffff) {
piVar3 = (int *)*in_R8;
piVar4 = (int *)in_R8[2];
auVar9 = JS_NewObjectProtoClass(param_1,0,2,0x30);
uVar8 = auVar9._0_8_;
if ((auVar9._8_8_ & 0xffffffff) != 6) {
puVar7 = (int8 *)js_malloc(param_1,0x28);
if (puVar7 == (int8 *)0x0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar8,auVar9._8_8_);
goto LAB_00139a5b;
}
*piVar3 = *piVar3 + 1;
*puVar7 = piVar3;
puVar7[1] = uVar1;
*piVar4 = *piVar4 + 1;
puVar7[2] = piVar4;
puVar7[3] = uVar2;
uVar5 = JS_IsFunction(param_1,piVar3,uVar1);
*(int1 *)(puVar7 + 4) = uVar5;
*(int1 *)((long)puVar7 + 0x21) = 0;
*(int8 **)(uVar8 + 0x30) = puVar7;
if ((int)uVar1 == -1) {
bVar6 = *(byte *)((long)piVar3 + 5) & 0x10;
}
else {
bVar6 = 0;
}
local_48 = auVar9._8_4_;
if (local_48 == -1) {
*(byte *)(uVar8 + 5) = *(byte *)(uVar8 + 5) & 0xef | bVar6;
}
}
uVar8 = uVar8 & 0xffffffff00000000;
}
else {
JS_ThrowTypeError(param_1,"not an object");
LAB_00139a5b:
auVar9 = ZEXT816(6) << 0x40;
uVar8 = 0;
}
auVar10._0_8_ = auVar9._0_8_ & 0xffffffff | uVar8;
auVar10._8_8_ = auVar9._8_8_;
return auVar10;
}
|
|
64,070 |
js_proxy_constructor
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_proxy_constructor(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue target, handler;
JSValue obj;
JSProxyData *s;
target = argv[0];
handler = argv[1];
if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
if (JS_IsException(obj))
return obj;
s = js_malloc(ctx, sizeof(JSProxyData));
if (!s) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
s->target = js_dup(target);
s->handler = js_dup(handler);
s->is_func = JS_IsFunction(ctx, target);
s->is_revoked = FALSE;
JS_SetOpaqueInternal(obj, s);
JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
return obj;
}
|
O2
|
c
|
js_proxy_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x8(%r8), %r13
movl %r13d, %eax
notl %eax
movq 0x18(%r8), %r12
movl %r12d, %ecx
notl %ecx
orl %eax, %ecx
je 0x32e12
movq %r15, %rdi
callq 0x21191
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x32eba
movq (%r8), %rbp
movq 0x10(%r8), %rax
movq %rax, 0x10(%rsp)
pushq $0x2
popq %rdx
pushq $0x30
popq %rcx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1ec19
movq %rax, %r14
movq %rdx, %rbx
movl %ebx, %eax
cmpq $0x6, %rax
je 0x32eaa
movq %rax, (%rsp)
movq %rbp, 0x8(%rsp)
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x1adc4
testq %rax, %rax
je 0x32ed2
movq %rax, %rbp
movq 0x8(%rsp), %rcx
incl (%rcx)
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq 0x10(%rsp), %rax
incl (%rax)
movq %rax, 0x10(%rbp)
movq %r12, 0x18(%rbp)
movq %r15, %rdi
movq %rcx, %r15
movq %rcx, %rsi
movq %r13, %rdx
callq 0x20a2d
movb %al, 0x20(%rbp)
movb $0x0, 0x21(%rbp)
movq %rbp, 0x30(%r14)
cmpl $-0x1, (%rsp)
jne 0x32eaa
movb 0x5(%r15), %al
andb $0x10, %al
movb 0x5(%r14), %cl
andb $-0x11, %cl
orb %al, %cl
movb %cl, 0x5(%r14)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1bbce
jmp 0x32e05
|
js_proxy_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdi
mov r13, [r8+8]
mov eax, r13d
not eax
mov r12, [r8+18h]
mov ecx, r12d
not ecx
or ecx, eax
jz short loc_32E12
mov rdi, r15
call JS_ThrowTypeErrorNotAnObject
loc_32E05:
push 6
pop rbx
xor r14d, r14d
xor ecx, ecx
jmp loc_32EBA
loc_32E12:
mov rbp, [r8]
mov rax, [r8+10h]
mov [rsp+48h+var_38], rax
push 2
pop rdx
push 30h ; '0'
pop rcx
mov rdi, r15
xor esi, esi
call JS_NewObjectProtoClass
mov r14, rax
mov rbx, rdx
mov eax, ebx
cmp rax, 6
jz short loc_32EAA
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rbp
push 28h ; '('
pop rsi
mov rdi, r15
call js_malloc
test rax, rax
jz short loc_32ED2
mov rbp, rax
mov rcx, [rsp+48h+var_40]
inc dword ptr [rcx]
mov [rax], rcx
mov [rax+8], r13
mov rax, [rsp+48h+var_38]
inc dword ptr [rax]
mov [rbp+10h], rax
mov [rbp+18h], r12
mov rdi, r15
mov r15, rcx
mov rsi, rcx
mov rdx, r13
call JS_IsFunction
mov [rbp+20h], al
mov byte ptr [rbp+21h], 0
mov [r14+30h], rbp
cmp dword ptr [rsp+48h+var_48], 0FFFFFFFFh
jnz short loc_32EAA
mov al, [r15+5]
and al, 10h
mov cl, [r14+5]
and cl, 0EFh
or cl, al
mov [r14+5], cl
loc_32EAA:
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
loc_32EBA:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_32ED2:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
jmp loc_32E05
|
unsigned long long js_proxy_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
_QWORD *a13,
long long a14)
{
long long v14; // r13
int v15; // eax
long long v16; // r12
long long v17; // r14
unsigned long long v18; // rcx
long long v19; // rbp
long long v20; // rdx
long long v21; // rbx
long long v22; // rax
long long v23; // rbp
char v25; // [rsp+0h] [rbp-48h]
int v26; // [rsp+0h] [rbp-48h]
long long v27; // [rsp+8h] [rbp-40h]
_DWORD *v28; // [rsp+10h] [rbp-38h]
v14 = a13[1];
v15 = ~*((_DWORD *)a13 + 2);
v16 = a13[3];
if ( !(v15 | ~(_DWORD)v16) )
{
v19 = *a13;
v28 = (_DWORD *)a13[2];
v17 = JS_NewObjectProtoClass(a1, 0LL, 2, 0x30u);
v21 = v20;
if ( (unsigned int)v20 != 6LL )
{
v26 = v20;
v27 = v19;
v22 = js_malloc(a1, 40LL);
if ( !v22 )
{
JS_FreeValue(a1, v17, v21);
goto LABEL_3;
}
v23 = v22;
++*(_DWORD *)v27;
*(_QWORD *)v22 = v27;
*(_QWORD *)(v22 + 8) = v14;
++*v28;
*(_QWORD *)(v22 + 16) = v28;
*(_QWORD *)(v22 + 24) = v16;
*(_BYTE *)(v22 + 32) = JS_IsFunction(a1, v27, v14);
*(_BYTE *)(v23 + 33) = 0;
*(_QWORD *)(v17 + 48) = v23;
if ( v26 == -1 )
*(_BYTE *)(v17 + 5) = *(_BYTE *)(v27 + 5) & 0x10 | *(_BYTE *)(v17 + 5) & 0xEF;
}
v18 = v17 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v17;
}
JS_ThrowTypeErrorNotAnObject(
a1,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a2,
a3,
v15 | ~(unsigned int)a13[3],
(long long)a13,
a14,
v25);
LABEL_3:
LODWORD(v17) = 0;
v18 = 0LL;
return v18 | (unsigned int)v17;
}
|
js_proxy_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOV R13,qword ptr [R8 + 0x8]
MOV EAX,R13D
NOT EAX
MOV R12,qword ptr [R8 + 0x18]
MOV ECX,R12D
NOT ECX
OR ECX,EAX
JZ 0x00132e12
MOV RDI,R15
CALL 0x00121191
LAB_00132e05:
PUSH 0x6
POP RBX
XOR R14D,R14D
XOR ECX,ECX
JMP 0x00132eba
LAB_00132e12:
MOV RBP,qword ptr [R8]
MOV RAX,qword ptr [R8 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
PUSH 0x2
POP RDX
PUSH 0x30
POP RCX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0011ec19
MOV R14,RAX
MOV RBX,RDX
MOV EAX,EBX
CMP RAX,0x6
JZ 0x00132eaa
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RBP
PUSH 0x28
POP RSI
MOV RDI,R15
CALL 0x0011adc4
TEST RAX,RAX
JZ 0x00132ed2
MOV RBP,RAX
MOV RCX,qword ptr [RSP + 0x8]
INC dword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R13
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBP + 0x18],R12
MOV RDI,R15
MOV R15,RCX
MOV RSI,RCX
MOV RDX,R13
CALL 0x00120a2d
MOV byte ptr [RBP + 0x20],AL
MOV byte ptr [RBP + 0x21],0x0
MOV qword ptr [R14 + 0x30],RBP
CMP dword ptr [RSP],-0x1
JNZ 0x00132eaa
MOV AL,byte ptr [R15 + 0x5]
AND AL,0x10
MOV CL,byte ptr [R14 + 0x5]
AND CL,0xef
OR CL,AL
MOV byte ptr [R14 + 0x5],CL
LAB_00132eaa:
MOV RAX,-0x100000000
MOV RCX,R14
AND RCX,RAX
LAB_00132eba:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00132ed2:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011bbce
JMP 0x00132e05
|
int1 [16] js_proxy_constructor(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int *piVar3;
int *piVar4;
int1 uVar5;
int8 *puVar6;
ulong uVar7;
int8 *in_R8;
int1 auVar8 [16];
int1 auVar9 [16];
int local_48;
uVar1 = in_R8[1];
uVar2 = in_R8[3];
if ((int)uVar2 == -1 && (int)uVar1 == -1) {
piVar3 = (int *)*in_R8;
piVar4 = (int *)in_R8[2];
auVar8 = JS_NewObjectProtoClass(param_1,0,2,0x30);
uVar7 = auVar8._0_8_;
if ((auVar8._8_8_ & 0xffffffff) != 6) {
puVar6 = (int8 *)js_malloc(param_1,0x28);
if (puVar6 == (int8 *)0x0) {
JS_FreeValue(param_1,uVar7,auVar8._8_8_);
goto LAB_00132e05;
}
*piVar3 = *piVar3 + 1;
*puVar6 = piVar3;
puVar6[1] = uVar1;
*piVar4 = *piVar4 + 1;
puVar6[2] = piVar4;
puVar6[3] = uVar2;
uVar5 = JS_IsFunction(param_1,piVar3,uVar1);
*(int1 *)(puVar6 + 4) = uVar5;
*(int1 *)((long)puVar6 + 0x21) = 0;
*(int8 **)(uVar7 + 0x30) = puVar6;
local_48 = auVar8._8_4_;
if (local_48 == -1) {
*(byte *)(uVar7 + 5) = *(byte *)(uVar7 + 5) & 0xef | *(byte *)((long)piVar3 + 5) & 0x10;
}
}
uVar7 = uVar7 & 0xffffffff00000000;
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
LAB_00132e05:
auVar8 = ZEXT816(6) << 0x40;
uVar7 = 0;
}
auVar9._0_8_ = auVar8._0_8_ & 0xffffffff | uVar7;
auVar9._8_8_ = auVar8._8_8_;
return auVar9;
}
|
|
64,071 |
nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*)
|
ng-log[P]ng-log/src/logging.cc
|
void base::SetLogger(LogSeverity severity, base::Logger* logger) {
std::lock_guard<std::mutex> l{log_mutex};
LogDestination::log_destination(severity)->SetLoggerImpl(logger);
}
|
O3
|
cpp
|
nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x34d02(%rip), %rdi # 0x40d48
callq 0x7840
testl %eax, %eax
jne 0xc0e8
movl %ebp, %r15d
leaq 0x25c33(%rip), %r12 # 0x31c90
movq (%r12,%r15,8), %r14
testq %r14, %r14
jne 0xc0a6
movl $0xd0, %edi
callq 0x8eb0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xa664
leaq (%r12,%r15,8), %r15
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1295a
movq %r12, %rdi
callq 0x11574
movq (%r15), %r14
movq 0xc8(%r14), %rdi
cmpq %rbx, %rdi
je 0xc0cf
testq %rdi, %rdi
sete %al
cmpq %r14, %rdi
sete %cl
orb %al, %cl
jne 0xc0c8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0xc8(%r14)
leaq 0x34c72(%rip), %rdi # 0x40d48
callq 0x73e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7350
movq %rax, %rbx
movl $0xd0, %esi
movq %r14, %rdi
callq 0x8efc
jmp 0xc104
movq %rax, %rbx
leaq 0x34c3d(%rip), %rdi # 0x40d48
callq 0x73e0
movq %rbx, %rdi
callq 0x79b0
|
_ZN5nglog4base9SetLoggerENS_11LogSeverityEPNS0_6LoggerE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov ebp, edi
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz loc_C0E8
mov r15d, ebp
lea r12, _ZN5nglog14LogDestination17log_destinations_E; nglog::LogDestination::log_destinations_
mov r14, [r12+r15*8]
test r14, r14
jnz short loc_C0A6
mov edi, 0D0h; unsigned __int64
call _Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax
mov esi, ebp
xor edx, edx
call _ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc; nglog::LogDestination::LogDestination(nglog::LogSeverity,char const*)
lea r15, [r12+r15*8]
lea r12, [rsp+38h+var_30]
mov qword ptr [r12], 0
mov rdi, r15
mov rsi, r14
call _ZNSt15__uniq_ptr_implIN5nglog14LogDestinationESt14default_deleteIS1_EE5resetEPS1_; std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(nglog::LogDestination*)
mov rdi, r12
call _ZNSt10unique_ptrIN5nglog14LogDestinationESt14default_deleteIS1_EED2Ev; std::unique_ptr<nglog::LogDestination>::~unique_ptr()
mov r14, [r15]
loc_C0A6:
mov rdi, [r14+0C8h]
cmp rdi, rbx
jz short loc_C0CF
test rdi, rdi
setz al
cmp rdi, r14
setz cl
or cl, al
jnz short loc_C0C8
mov rax, [rdi]
call qword ptr [rax+8]
loc_C0C8:
mov [r14+0C8h], rbx
loc_C0CF:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_C0E8:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
mov esi, 0D0h; unsigned __int64
mov rdi, r14; void *
call _ZdlPvm; operator delete(void *,ulong)
jmp short loc_C104
mov rbx, rax
loc_C104:
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
|
long long nglog::base::SetLogger(int a1, long long a2)
{
int v2; // eax
long long v3; // r14
long long v4; // r14
long long v5; // rdi
_QWORD v7[6]; // [rsp+8h] [rbp-30h] BYREF
v2 = pthread_mutex_lock(&nglog::log_mutex);
if ( v2 )
std::__throw_system_error(v2);
v3 = nglog::LogDestination::log_destinations_[a1];
if ( !v3 )
{
v4 = operator new(208LL);
nglog::LogDestination::LogDestination(v4, a1, 0LL);
v7[0] = 0LL;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset(
&nglog::LogDestination::log_destinations_[a1],
v4);
std::unique_ptr<nglog::LogDestination>::~unique_ptr(v7);
v3 = nglog::LogDestination::log_destinations_[a1];
}
v5 = *(_QWORD *)(v3 + 200);
if ( v5 != a2 )
{
if ( v5 != 0 && v5 != v3 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
*(_QWORD *)(v3 + 200) = a2;
}
return pthread_mutex_unlock(&nglog::log_mutex);
}
|
SetLogger:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV EBP,EDI
LEA RDI,[0x140d48]
CALL 0x00107840
TEST EAX,EAX
JNZ 0x0010c0e8
MOV R15D,EBP
LEA R12,[0x131c90]
MOV R14,qword ptr [R12 + R15*0x8]
TEST R14,R14
JNZ 0x0010c0a6
LAB_0010c066:
MOV EDI,0xd0
CALL 0x00108eb0
LAB_0010c070:
MOV R14,RAX
MOV RDI,RAX
MOV ESI,EBP
XOR EDX,EDX
CALL 0x0010a664
LAB_0010c07f:
LEA R15,[R12 + R15*0x8]
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],0x0
MOV RDI,R15
MOV RSI,R14
CALL 0x0011295a
MOV RDI,R12
CALL 0x00111574
MOV R14,qword ptr [R15]
LAB_0010c0a6:
MOV RDI,qword ptr [R14 + 0xc8]
CMP RDI,RBX
JZ 0x0010c0cf
TEST RDI,RDI
SETZ AL
CMP RDI,R14
SETZ CL
OR CL,AL
JNZ 0x0010c0c8
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010c0c8:
MOV qword ptr [R14 + 0xc8],RBX
LAB_0010c0cf:
LEA RDI,[0x140d48]
CALL 0x001073e0
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010c0e8:
MOV EDI,EAX
CALL 0x00107350
|
/* nglog::base::SetLogger(nglog::LogSeverity, nglog::base::Logger*) */
void nglog::base::SetLogger(uint param_1,long *param_2)
{
long *plVar1;
int iVar2;
LogDestination *pLVar3;
long *plVar4;
int8 local_30;
iVar2 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
if (iVar2 == 0) {
plVar4 = (long *)(&LogDestination::log_destinations_)[param_1];
if (plVar4 == (long *)0x0) {
/* try { // try from 0010c066 to 0010c06f has its CatchHandler @ 0010c101 */
pLVar3 = (LogDestination *)operator_new(0xd0);
/* try { // try from 0010c070 to 0010c07e has its CatchHandler @ 0010c0ef */
LogDestination::LogDestination(pLVar3,param_1,0);
local_30 = 0;
std::__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::reset
((__uniq_ptr_impl<nglog::LogDestination,std::default_delete<nglog::LogDestination>>
*)(&LogDestination::log_destinations_ + param_1),pLVar3);
std::unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>>::~unique_ptr
((unique_ptr<nglog::LogDestination,std::default_delete<nglog::LogDestination>> *)
&local_30);
plVar4 = *(long **)(&LogDestination::log_destinations_ + param_1);
}
plVar1 = (long *)plVar4[0x19];
if (plVar1 != param_2) {
if (plVar1 != plVar4 && plVar1 != (long *)0x0) {
(**(code **)(*plVar1 + 8))();
}
plVar4[0x19] = (long)param_2;
}
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar2);
}
|
|
64,072 |
LefDefParser::lefiPropType::bumpProps()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiPropType.cpp
|
void
lefiPropType::bumpProps()
{
int lim = propertiesAllocated_;
int news;
char **newpn;
char *newt;
news = lim ? lim + lim : 2;
newpn = (char**) malloc(sizeof(char*) * news);
newt = (char*) malloc(sizeof(char) * news);
lim = propertiesAllocated_ = news;
if (lim > 2) {
int i;
for (i = 0; i < numProperties_; i++) {
newpn[i] = propNames_[i];
newt[i] = propTypes_[i];
}
free((char*) (propNames_));
free((char*) (propTypes_));
}
propNames_ = newpn;
propTypes_ = newt;
}
|
O0
|
cpp
|
LefDefParser::lefiPropType::bumpProps():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rax), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x7269f
movl 0x2c(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x726aa
movl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0x726aa
movl 0x4(%rsp), %eax
movl %eax, 0x28(%rsp)
movslq 0x28(%rsp), %rdi
shlq $0x3, %rdi
callq 0x2310
movq %rax, 0x20(%rsp)
movslq 0x28(%rsp), %rdi
shlq $0x0, %rdi
callq 0x2310
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rcx)
movl %eax, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
jle 0x72766
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x7274a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x20(%rsp), %rcx
movslq 0x14(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x726f7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x22d0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x22d0
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser12lefiPropType9bumpPropsEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_30], rax
mov eax, [rax+4]
mov [rsp+38h+var_C], eax
cmp [rsp+38h+var_C], 0
jz short loc_7269F
mov eax, [rsp+38h+var_C]
add eax, [rsp+38h+var_C]
mov [rsp+38h+var_34], eax
jmp short loc_726AA
loc_7269F:
mov eax, 2
mov [rsp+38h+var_34], eax
jmp short $+2
loc_726AA:
mov eax, [rsp+38h+var_34]
mov [rsp+38h+var_10], eax
movsxd rdi, [rsp+38h+var_10]
shl rdi, 3
call _malloc
mov [rsp+38h+var_18], rax
movsxd rdi, [rsp+38h+var_10]
shl rdi, 0
call _malloc
mov rcx, [rsp+38h+var_30]
mov [rsp+38h+var_20], rax
mov eax, [rsp+38h+var_10]
mov [rcx+4], eax
mov [rsp+38h+var_C], eax
cmp [rsp+38h+var_C], 2
jle short loc_72766
mov [rsp+38h+var_24], 0
loc_726F7:
mov rcx, [rsp+38h+var_30]
mov eax, [rsp+38h+var_24]
cmp eax, [rcx]
jge short loc_7274A
mov rax, [rsp+38h+var_30]
mov rcx, [rax+8]
movsxd rdx, [rsp+38h+var_24]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+38h+var_18]
movsxd rdx, [rsp+38h+var_24]
mov [rcx+rdx*8], rsi
mov rax, [rax+10h]
movsxd rcx, [rsp+38h+var_24]
mov dl, [rax+rcx]
mov rax, [rsp+38h+var_20]
movsxd rcx, [rsp+38h+var_24]
mov [rax+rcx], dl
mov eax, [rsp+38h+var_24]
add eax, 1
mov [rsp+38h+var_24], eax
jmp short loc_726F7
loc_7274A:
mov rax, [rsp+38h+var_30]
mov rdi, [rax+8]
call _free
mov rax, [rsp+38h+var_30]
mov rdi, [rax+10h]
call _free
loc_72766:
mov rax, [rsp+38h+var_30]
mov rcx, [rsp+38h+var_18]
mov [rax+8], rcx
mov rcx, [rsp+38h+var_20]
mov [rax+10h], rcx
add rsp, 38h
retn
|
LefDefParser::lefiPropType * LefDefParser::lefiPropType::bumpProps(LefDefParser::lefiPropType *this)
{
long long v1; // rax
LefDefParser::lefiPropType *result; // rax
int v3; // [rsp+4h] [rbp-34h]
int i; // [rsp+14h] [rbp-24h]
long long v5; // [rsp+18h] [rbp-20h]
long long v6; // [rsp+20h] [rbp-18h]
int v7; // [rsp+2Ch] [rbp-Ch]
v7 = *((_DWORD *)this + 1);
if ( v7 )
v3 = 2 * v7;
else
v3 = 2;
v6 = malloc(8LL * v3);
v1 = malloc(v3);
v5 = v1;
*((_DWORD *)this + 1) = v3;
if ( v3 > 2 )
{
for ( i = 0; i < *(_DWORD *)this; ++i )
{
*(_QWORD *)(v6 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 1) + 8LL * i);
*(_BYTE *)(v1 + i) = *(_BYTE *)(*((_QWORD *)this + 2) + i);
}
free(*((_QWORD *)this + 1));
free(*((_QWORD *)this + 2));
}
result = this;
*((_QWORD *)this + 1) = v6;
*((_QWORD *)this + 2) = v5;
return result;
}
|
bumpProps:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x2c],EAX
CMP dword ptr [RSP + 0x2c],0x0
JZ 0x0017269f
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001726aa
LAB_0017269f:
MOV EAX,0x2
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001726aa
LAB_001726aa:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x28],EAX
MOVSXD RDI,dword ptr [RSP + 0x28]
SHL RDI,0x3
CALL 0x00102310
MOV qword ptr [RSP + 0x20],RAX
MOVSXD RDI,dword ptr [RSP + 0x28]
SHL RDI,0x0
CALL 0x00102310
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RCX + 0x4],EAX
MOV dword ptr [RSP + 0x2c],EAX
CMP dword ptr [RSP + 0x2c],0x2
JLE 0x00172766
MOV dword ptr [RSP + 0x14],0x0
LAB_001726f7:
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,dword ptr [RCX]
JGE 0x0017274a
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,dword ptr [RSP + 0x14]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RDX,dword ptr [RSP + 0x14]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RAX,qword ptr [RAX + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x14]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001726f7
LAB_0017274a:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001022d0
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x001022d0
LAB_00172766:
MOV RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
ADD RSP,0x38
RET
|
/* LefDefParser::lefiPropType::bumpProps() */
void __thiscall LefDefParser::lefiPropType::bumpProps(lefiPropType *this)
{
void *pvVar1;
void *pvVar2;
int local_34;
int local_24;
if (*(int *)(this + 4) == 0) {
local_34 = 2;
}
else {
local_34 = *(int *)(this + 4) * 2;
}
pvVar1 = malloc((long)local_34 << 3);
pvVar2 = malloc((long)local_34);
*(int *)(this + 4) = local_34;
if (2 < local_34) {
for (local_24 = 0; local_24 < *(int *)this; local_24 = local_24 + 1) {
*(int8 *)((long)pvVar1 + (long)local_24 * 8) =
*(int8 *)(*(long *)(this + 8) + (long)local_24 * 8);
*(int1 *)((long)pvVar2 + (long)local_24) =
*(int1 *)(*(long *)(this + 0x10) + (long)local_24);
}
free(*(void **)(this + 8));
free(*(void **)(this + 0x10));
}
*(void **)(this + 8) = pvVar1;
*(void **)(this + 0x10) = pvVar2;
return;
}
|
|
64,073 |
LefDefParser::lefiPropType::bumpProps()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiPropType.cpp
|
void
lefiPropType::bumpProps()
{
int lim = propertiesAllocated_;
int news;
char **newpn;
char *newt;
news = lim ? lim + lim : 2;
newpn = (char**) malloc(sizeof(char*) * news);
newt = (char*) malloc(sizeof(char) * news);
lim = propertiesAllocated_ = news;
if (lim > 2) {
int i;
for (i = 0; i < numProperties_; i++) {
newpn[i] = propNames_[i];
newt[i] = propTypes_[i];
}
free((char*) (propNames_));
free((char*) (propTypes_));
}
propNames_ = newpn;
propTypes_ = newt;
}
|
O3
|
cpp
|
LefDefParser::lefiPropType::bumpProps():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %eax
cmovnel %ecx, %eax
movslq %eax, %r12
leaq (,%r12,8), %rdi
callq 0x2290
movq %rax, %r14
movq %r12, %rdi
callq 0x2290
movq %rax, %r15
movl %r12d, 0x4(%rbx)
cmpl $0x3, %r12d
jl 0x49a63
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
testq %rax, %rax
jle 0x49a55
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rdi,%rdx,8), %rsi
movq %rsi, (%r14,%rdx,8)
movb (%rcx,%rdx), %sil
movb %sil, (%r15,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x49a3d
callq 0x2240
movq 0x10(%rbx), %rdi
callq 0x2240
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN12LefDefParser12lefiPropType9bumpPropsEv:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+4]
lea ecx, [rax+rax]
test eax, eax
mov eax, 2
cmovnz eax, ecx
movsxd r12, eax
lea rdi, ds:0[r12*8]
call _malloc
mov r14, rax
mov rdi, r12
call _malloc
mov r15, rax
mov [rbx+4], r12d
cmp r12d, 3
jl short loc_49A63
movsxd rax, dword ptr [rbx]
mov rdi, [rbx+8]
test rax, rax
jle short loc_49A55
mov rcx, [rbx+10h]
xor edx, edx
loc_49A3D:
mov rsi, [rdi+rdx*8]
mov [r14+rdx*8], rsi
mov sil, [rcx+rdx]
mov [r15+rdx], sil
inc rdx
cmp rax, rdx
jnz short loc_49A3D
loc_49A55:
call _free
mov rdi, [rbx+10h]
call _free
loc_49A63:
mov [rbx+8], r14
mov [rbx+10h], r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long LefDefParser::lefiPropType::bumpProps(LefDefParser::lefiPropType *this)
{
int v2; // eax
int v3; // ecx
bool v4; // zf
int v5; // eax
long long v6; // r12
long long v7; // r14
long long result; // rax
long long v9; // r15
long long v10; // rax
long long v11; // rdi
long long v12; // rcx
long long i; // rdx
v2 = *((_DWORD *)this + 1);
v3 = 2 * v2;
v4 = v2 == 0;
v5 = 2;
if ( !v4 )
v5 = v3;
v6 = v5;
v7 = malloc(8LL * v5);
result = malloc(v6);
v9 = result;
*((_DWORD *)this + 1) = v6;
if ( (int)v6 >= 3 )
{
v10 = *(int *)this;
v11 = *((_QWORD *)this + 1);
if ( v10 > 0 )
{
v12 = *((_QWORD *)this + 2);
for ( i = 0LL; i != v10; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(v11 + 8 * i);
*(_BYTE *)(v9 + i) = *(_BYTE *)(v12 + i);
}
}
free(v11);
result = free(*((_QWORD *)this + 2));
}
*((_QWORD *)this + 1) = v7;
*((_QWORD *)this + 2) = v9;
return result;
}
|
bumpProps:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x4]
LEA ECX,[RAX + RAX*0x1]
TEST EAX,EAX
MOV EAX,0x2
CMOVNZ EAX,ECX
MOVSXD R12,EAX
LEA RDI,[R12*0x8]
CALL 0x00102290
MOV R14,RAX
MOV RDI,R12
CALL 0x00102290
MOV R15,RAX
MOV dword ptr [RBX + 0x4],R12D
CMP R12D,0x3
JL 0x00149a63
MOVSXD RAX,dword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x8]
TEST RAX,RAX
JLE 0x00149a55
MOV RCX,qword ptr [RBX + 0x10]
XOR EDX,EDX
LAB_00149a3d:
MOV RSI,qword ptr [RDI + RDX*0x8]
MOV qword ptr [R14 + RDX*0x8],RSI
MOV SIL,byte ptr [RCX + RDX*0x1]
MOV byte ptr [R15 + RDX*0x1],SIL
INC RDX
CMP RAX,RDX
JNZ 0x00149a3d
LAB_00149a55:
CALL 0x00102240
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x00102240
LAB_00149a63:
MOV qword ptr [RBX + 0x8],R14
MOV qword ptr [RBX + 0x10],R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::lefiPropType::bumpProps() */
void __thiscall LefDefParser::lefiPropType::bumpProps(lefiPropType *this)
{
void *__ptr;
long lVar1;
int iVar2;
void *pvVar3;
void *pvVar4;
long lVar5;
iVar2 = 2;
if (*(int *)(this + 4) != 0) {
iVar2 = *(int *)(this + 4) * 2;
}
pvVar3 = malloc((long)iVar2 * 8);
pvVar4 = malloc((long)iVar2);
*(int *)(this + 4) = iVar2;
if (2 < iVar2) {
iVar2 = *(int *)this;
__ptr = *(void **)(this + 8);
if (0 < (long)iVar2) {
lVar1 = *(long *)(this + 0x10);
lVar5 = 0;
do {
*(int8 *)((long)pvVar3 + lVar5 * 8) = *(int8 *)((long)__ptr + lVar5 * 8);
*(int1 *)((long)pvVar4 + lVar5) = *(int1 *)(lVar1 + lVar5);
lVar5 = lVar5 + 1;
} while (iVar2 != lVar5);
}
free(__ptr);
free(*(void **)(this + 0x10));
}
*(void **)(this + 8) = pvVar3;
*(void **)(this + 0x10) = pvVar4;
return;
}
|
|
64,074 |
my_strxfrm_pad_desc_and_reverse_nopad
|
eloqsql/strings/ctype-simple.c
|
size_t
my_strxfrm_pad_desc_and_reverse_nopad(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level)
{
if (nweights && frmend < strend && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
uint fill_length= MY_MIN((uint) (strend - frmend), nweights * cs->mbminlen);
memset(frmend, 0x00, fill_length);
frmend+= fill_length;
}
my_strxfrm_desc_and_reverse(str, frmend, flags, level);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && frmend < strend)
{
size_t fill_length= strend - frmend;
memset(frmend, 0x00, fill_length);
frmend= strend;
}
return frmend - str;
}
|
O3
|
c
|
my_strxfrm_pad_desc_and_reverse_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movl 0x10(%rbp), %ecx
testl %r8d, %r8d
sete %al
cmpq %r15, %rdx
setae %sil
testb $0x40, %r12b
sete %dl
orb %al, %dl
orb %sil, %dl
jne 0x38a21
movl %r8d, %r13d
movl %r15d, %eax
imull 0x98(%rdi), %r13d
subl %r14d, %eax
cmpl %eax, %r13d
cmovael %eax, %r13d
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x241b0
movl 0x10(%rbp), %ecx
addq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x3a262
testb %r12b, %r12b
jns 0x38a4c
cmpq %r15, %r14
jae 0x38a4c
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x241b0
movq %r15, %r14
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strxfrm_pad_desc_and_reverse_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12d, r9d
mov r15, rcx
mov r14, rdx
mov rbx, rsi
mov ecx, [rbp+arg_0]
test r8d, r8d
setz al
cmp rdx, r15
setnb sil
test r12b, 40h
setz dl
or dl, al
or dl, sil
jnz short loc_38A21
mov r13d, r8d
mov eax, r15d
imul r13d, [rdi+98h]
sub eax, r14d
cmp r13d, eax
cmovnb r13d, eax
mov rdi, r14
xor esi, esi
mov rdx, r13
call _memset
mov ecx, [rbp+arg_0]
add r14, r13
loc_38A21:
mov rdi, rbx
mov rsi, r14
mov edx, r12d
call my_strxfrm_desc_and_reverse
test r12b, r12b
jns short loc_38A4C
cmp r14, r15
jnb short loc_38A4C
mov rdx, r15
sub rdx, r14
mov rdi, r14
xor esi, esi
call _memset
mov r14, r15
loc_38A4C:
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strxfrm_pad_desc_and_reverse_nopad(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
int a5,
unsigned int a6,
unsigned int a7)
{
unsigned long long v9; // r14
long long v10; // rcx
long long v11; // r13
v9 = a3;
v10 = a7;
if ( a3 < a4 && a5 != 0 && (a6 & 0x40) != 0 )
{
v11 = (unsigned int)(*(_DWORD *)(a1 + 152) * a5);
if ( (unsigned int)v11 >= (int)a4 - (int)a3 )
v11 = (unsigned int)(a4 - a3);
memset(a3, 0LL, v11);
v10 = a7;
v9 += v11;
}
my_strxfrm_desc_and_reverse(a2, v9, a6, v10);
if ( (a6 & 0x80u) != 0 && v9 < a4 )
{
memset(v9, 0LL, a4 - v9);
v9 = a4;
}
return v9 - a2;
}
|
my_strxfrm_pad_desc_and_reverse_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12D,R9D
MOV R15,RCX
MOV R14,RDX
MOV RBX,RSI
MOV ECX,dword ptr [RBP + 0x10]
TEST R8D,R8D
SETZ AL
CMP RDX,R15
SETNC SIL
TEST R12B,0x40
SETZ DL
OR DL,AL
OR DL,SIL
JNZ 0x00138a21
MOV R13D,R8D
MOV EAX,R15D
IMUL R13D,dword ptr [RDI + 0x98]
SUB EAX,R14D
CMP R13D,EAX
CMOVNC R13D,EAX
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R13
CALL 0x001241b0
MOV ECX,dword ptr [RBP + 0x10]
ADD R14,R13
LAB_00138a21:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R12D
CALL 0x0013a262
TEST R12B,R12B
JNS 0x00138a4c
CMP R14,R15
JNC 0x00138a4c
MOV RDX,R15
SUB RDX,R14
MOV RDI,R14
XOR ESI,ESI
CALL 0x001241b0
MOV R14,R15
LAB_00138a4c:
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strxfrm_pad_desc_and_reverse_nopad
(long param_1,long param_2,void *param_3,void *param_4,int param_5,uint param_6,
int4 param_7)
{
uint uVar1;
uint uVar2;
if (((param_6 & 0x40) != 0 && param_5 != 0) && param_3 < param_4) {
uVar2 = param_5 * *(int *)(param_1 + 0x98);
uVar1 = (int)param_4 - (int)param_3;
if (uVar1 <= uVar2) {
uVar2 = uVar1;
}
memset(param_3,0,(ulong)uVar2);
param_3 = (void *)((long)param_3 + (ulong)uVar2);
}
my_strxfrm_desc_and_reverse(param_2,param_3,param_6,param_7);
if (((char)param_6 < '\0') && (param_3 < param_4)) {
memset(param_3,0,(long)param_4 - (long)param_3);
param_3 = param_4;
}
return (long)param_3 - param_2;
}
|
|
64,075 |
translog_write_file_header
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_write_file_header()
{
TRANSLOG_FILE *file;
ulonglong timestamp;
uchar page_buff[TRANSLOG_PAGE_SIZE], *page= page_buff;
my_bool rc;
DBUG_ENTER("translog_write_file_header");
/* file tag */
memcpy(page, maria_trans_file_magic, sizeof(maria_trans_file_magic));
page+= sizeof(maria_trans_file_magic);
/* timestamp */
timestamp= my_hrtime().val;
int8store(page, timestamp);
page+= 8;
/* maria version */
int4store(page, TRANSLOG_VERSION_ID);
page+= 4;
/* mysql version (MYSQL_VERSION_ID) */
int4store(page, log_descriptor.server_version);
page+= 4;
/* server ID */
int4store(page, log_descriptor.server_id);
page+= 4;
/* loghandler page_size */
int2store(page, TRANSLOG_PAGE_SIZE - 1);
page+= 2;
/* file number */
int3store(page, LSN_FILE_NO(log_descriptor.horizon));
page+= 3;
lsn_store(page, LSN_IMPOSSIBLE);
page+= LSN_STORE_SIZE;
memset(page, TRANSLOG_FILLER, sizeof(page_buff) - (page- page_buff));
file= get_current_logfile();
rc= my_pwrite(file->handler.file, page_buff, sizeof(page_buff), 0,
log_write_flags) != 0;
/*
Dropping the flag in such way can make false alarm: signalling than the
file in not sync when it is sync, but the situation is quite rare and
protections with mutexes give much more overhead to the whole engine
*/
file->is_sync= 0;
DBUG_RETURN(rc);
}
|
O3
|
c
|
translog_write_file_header:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2008, %rsp # imm = 0x2008
movq %fs:0x28, %rax
movq %rax, -0x10(%rbp)
movl 0x335031(%rip), %eax # 0x3841b0
leaq -0x1fe4(%rbp), %rbx
movl %eax, -0x24(%rbx)
movq 0x335018(%rip), %rax # 0x3841a8
movq %rax, -0x2c(%rbx)
callq 0x9e588
movq %rax, -0x20(%rbx)
movl $0x2710, -0x18(%rbx) # imm = 0x2710
movq 0x3af629(%rip), %rax # 0x3fe7d4
movq %rax, -0x14(%rbx)
movw $0x1fff, -0xc(%rbx) # imm = 0x1FFF
movq 0xbb024c(%rip), %rax # 0xbff408
movq %rax, %rcx
shrq $0x20, %rcx
movb %cl, -0xa(%rbx)
movq %rax, %rcx
shrq $0x28, %rcx
movb %cl, -0x9(%rbx)
shrq $0x30, %rax
movb %al, -0x8(%rbx)
xorl %eax, %eax
movl %eax, -0x7(%rbx)
movl %eax, -0x4(%rbx)
movl $0x1fd4, %edx # imm = 0x1FD4
movq %rbx, %rdi
movl $0xff, %esi
callq 0x292c0
callq 0x50358
movq %rax, %rbx
movl 0x18(%rax), %edi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx # imm = 0x2000
movl $0x34, %r8d
xorl %ecx, %ecx
callq 0xa07ee
testq %rax, %rax
setne %al
movb $0x0, 0x51(%rbx)
movq %fs:0x28, %rcx
cmpq -0x10(%rbp), %rcx
jne 0x4f238
addq $0x2008, %rsp # imm = 0x2008
popq %rbx
popq %rbp
retq
callq 0x29270
|
translog_write_file_header:
push rbp
mov rbp, rsp
push rbx
sub rsp, 2008h
mov rax, fs:28h
mov [rbp+var_10], rax
mov eax, cs:dword_3841B0
lea rbx, [rbp+var_1FE4]
mov [rbx-24h], eax
mov rax, cs:maria_trans_file_magic
mov [rbx-2Ch], rax
call my_hrtime
mov [rbx-20h], rax
mov dword ptr [rbx-18h], 2710h
mov rax, cs:qword_3FE7D4
mov [rbx-14h], rax
mov word ptr [rbx-0Ch], 1FFFh
mov rax, cs:qword_BFF408
mov rcx, rax
shr rcx, 20h
mov [rbx-0Ah], cl
mov rcx, rax
shr rcx, 28h
mov [rbx-9], cl
shr rax, 30h
mov [rbx-8], al
xor eax, eax
mov [rbx-7], eax
mov [rbx-4], eax
mov edx, 1FD4h
mov rdi, rbx
mov esi, 0FFh
call _memset
call get_current_logfile
mov rbx, rax
mov edi, [rax+18h]
lea rsi, [rbp+var_2010]
mov edx, 2000h
mov r8d, 34h ; '4'
xor ecx, ecx
call my_pwrite
test rax, rax
setnz al
mov byte ptr [rbx+51h], 0
mov rcx, fs:28h
cmp rcx, [rbp+var_10]
jnz short loc_4F238
add rsp, 2008h
pop rbx
pop rbp
retn
loc_4F238:
call ___stack_chk_fail
|
bool translog_write_file_header(long long a1, long long a2)
{
long long current_logfile; // rbx
bool result; // al
long long v4; // [rsp+0h] [rbp-2010h] BYREF
int v5; // [rsp+8h] [rbp-2008h]
long long v6; // [rsp+Ch] [rbp-2004h]
int v7; // [rsp+14h] [rbp-1FFCh]
long long v8; // [rsp+18h] [rbp-1FF8h]
__int16 v9; // [rsp+20h] [rbp-1FF0h]
__int16 v10; // [rsp+22h] [rbp-1FEEh]
char v11; // [rsp+24h] [rbp-1FECh]
_BYTE v12[7]; // [rsp+25h] [rbp-1FEBh] BYREF
_BYTE v13[8148]; // [rsp+2Ch] [rbp-1FE4h] BYREF
unsigned long long v14; // [rsp+2000h] [rbp-10h]
v14 = __readfsqword(0x28u);
v5 = dword_3841B0;
v4 = maria_trans_file_magic;
v6 = my_hrtime(a1, a2);
v7 = 10000;
v8 = qword_3FE7D4;
v9 = 0x1FFF;
v10 = WORD2(qword_BFF408);
v11 = BYTE6(qword_BFF408);
memset(v12, 0, sizeof(v12));
memset(v13, 255LL, sizeof(v13));
current_logfile = get_current_logfile(v13);
result = my_pwrite(*(unsigned int *)(current_logfile + 24), &v4, 0x2000LL, 0LL, 52LL) != 0;
*(_BYTE *)(current_logfile + 81) = 0;
return result;
}
|
translog_write_file_header:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x2008
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [0x004841b0]
LEA RBX,[RBP + -0x1fe4]
MOV dword ptr [RBX + -0x24],EAX
MOV RAX,qword ptr [0x004841a8]
MOV qword ptr [RBX + -0x2c],RAX
CALL 0x0019e588
MOV qword ptr [RBX + -0x20],RAX
MOV dword ptr [RBX + -0x18],0x2710
MOV RAX,qword ptr [0x004fe7d4]
MOV qword ptr [RBX + -0x14],RAX
MOV word ptr [RBX + -0xc],0x1fff
MOV RAX,qword ptr [0x00cff408]
MOV RCX,RAX
SHR RCX,0x20
MOV byte ptr [RBX + -0xa],CL
MOV RCX,RAX
SHR RCX,0x28
MOV byte ptr [RBX + -0x9],CL
SHR RAX,0x30
MOV byte ptr [RBX + -0x8],AL
XOR EAX,EAX
MOV dword ptr [RBX + -0x7],EAX
MOV dword ptr [RBX + -0x4],EAX
MOV EDX,0x1fd4
MOV RDI,RBX
MOV ESI,0xff
CALL 0x001292c0
CALL 0x00150358
MOV RBX,RAX
MOV EDI,dword ptr [RAX + 0x18]
LEA RSI,[RBP + -0x2010]
MOV EDX,0x2000
MOV R8D,0x34
XOR ECX,ECX
CALL 0x001a07ee
TEST RAX,RAX
SETNZ AL
MOV byte ptr [RBX + 0x51],0x0
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x10]
JNZ 0x0014f238
ADD RSP,0x2008
POP RBX
POP RBP
RET
LAB_0014f238:
CALL 0x00129270
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
bool translog_write_file_header(void)
{
long lVar1;
long lVar2;
long in_FS_OFFSET;
int8 local_2018;
char local_2010 [4];
int8 local_200c;
int4 local_2004;
int8 local_2000;
int2 local_1ff8;
int1 local_1ff6;
int1 local_1ff5;
int1 local_1ff4;
int4 local_1ff3;
int3 uStack_1fef;
int1 local_1fec [8148];
long local_18;
local_18 = *(long *)(in_FS_OFFSET + 0x28);
local_2010 = (char [4])s_MARIALOG_004841ac._4_4_;
local_2018 = _maria_trans_file_magic;
local_200c = my_hrtime();
local_2004 = 10000;
local_2000 = DAT_004fe7d4;
local_1ff8 = 0x1fff;
local_1ff6 = (int1)((ulong)DAT_00cff408 >> 0x20);
local_1ff5 = (int1)((ulong)DAT_00cff408 >> 0x28);
local_1ff4 = (int1)((ulong)DAT_00cff408 >> 0x30);
local_1ff3 = 0;
uStack_1fef = 0;
memset(local_1fec,0xff,0x1fd4);
lVar1 = get_current_logfile();
lVar2 = my_pwrite(*(int4 *)(lVar1 + 0x18),&local_2018,0x2000,0,0x34);
*(int1 *)(lVar1 + 0x51) = 0;
if (*(long *)(in_FS_OFFSET + 0x28) == local_18) {
return lVar2 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
64,076 |
recursive_iterate
|
eloqsql/mysys/lf_dynarray.c
|
static int recursive_iterate(LF_DYNARRAY *array, void *ptr, int level,
lf_dynarray_func func, void *arg)
{
int res, i;
if (!ptr)
return 0;
if (!level)
return func(ptr, arg);
for (i= 0; i < LF_DYNARRAY_LEVEL_LENGTH; i++)
if ((res= recursive_iterate(array, ((void **)ptr)[i], level-1, func, arg)))
return res;
return 0;
}
|
O3
|
c
|
recursive_iterate:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb09c4
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %r15d
movq %rdi, %r14
testl %esi, %esi
je 0xb09d5
decl %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movl %r15d, %esi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xb0979
testl %eax, %eax
jne 0xb09c6
incq %r12
cmpq $0x100, %r12 # imm = 0x100
jne 0xb09a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
|
recursive_iterate:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
test rdi, rdi
jz short loc_B09C4
mov rbx, rcx
mov r13, rdx
mov r15d, esi
mov r14, rdi
test esi, esi
jz short loc_B09D5
dec r15d
xor r12d, r12d
loc_B09A2:
mov rdi, [r14+r12*8]
mov esi, r15d
mov rdx, r13
mov rcx, rbx
call recursive_iterate
test eax, eax
jnz short loc_B09C6
inc r12
cmp r12, 100h
jnz short loc_B09A2
loc_B09C4:
xor eax, eax
loc_B09C6:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B09D5:
mov rdi, r14
mov rsi, rbx
mov rax, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
|
long long recursive_iterate(long long a1, int a2, long long ( *a3)(long long, long long), long long a4)
{
long long v6; // r12
long long result; // rax
if ( !a1 )
return 0LL;
if ( !a2 )
return a3(a1, a4);
v6 = 0LL;
while ( 1 )
{
result = recursive_iterate(*(_QWORD *)(a1 + 8 * v6), (unsigned int)(a2 - 1), a3, a4);
if ( (_DWORD)result )
break;
if ( ++v6 == 256 )
return 0LL;
}
return result;
}
|
recursive_iterate:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x001b09c4
MOV RBX,RCX
MOV R13,RDX
MOV R15D,ESI
MOV R14,RDI
TEST ESI,ESI
JZ 0x001b09d5
DEC R15D
XOR R12D,R12D
LAB_001b09a2:
MOV RDI,qword ptr [R14 + R12*0x8]
MOV ESI,R15D
MOV RDX,R13
MOV RCX,RBX
CALL 0x001b0979
TEST EAX,EAX
JNZ 0x001b09c6
INC R12
CMP R12,0x100
JNZ 0x001b09a2
LAB_001b09c4:
XOR EAX,EAX
LAB_001b09c6:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b09d5:
MOV RDI,R14
MOV RSI,RBX
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
|
int8
recursive_iterate(long param_1,int param_2,code *UNRECOVERED_JUMPTABLE,int8 param_4)
{
int8 uVar1;
long lVar2;
if (param_1 != 0) {
if (param_2 == 0) {
/* WARNING: Could not recover jumptable at 0x001b09ec. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar1 = (*UNRECOVERED_JUMPTABLE)(param_1,param_4);
return uVar1;
}
lVar2 = 0;
do {
uVar1 = recursive_iterate(*(int8 *)(param_1 + lVar2 * 8),param_2 + -1,
UNRECOVERED_JUMPTABLE,param_4);
if ((int)uVar1 != 0) {
return uVar1;
}
lVar2 = lVar2 + 1;
} while (lVar2 != 0x100);
}
return 0;
}
|
|
64,077 |
link_block
|
eloqsql/mysys/mf_keycache.c
|
static void link_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block,
my_bool hot, my_bool at_end)
{
BLOCK_LINK *ins;
BLOCK_LINK **pins;
DBUG_ASSERT((block->status & ~BLOCK_CHANGED) == (BLOCK_READ | BLOCK_IN_USE));
DBUG_ASSERT(block->hash_link); /*backptr to block NULL from free_block()*/
DBUG_ASSERT(!block->requests);
DBUG_ASSERT(block->prev_changed && *block->prev_changed == block);
DBUG_ASSERT(!block->next_used);
DBUG_ASSERT(!block->prev_used);
if (!hot && keycache->waiting_for_block.last_thread)
{
/* Signal that in the LRU warm sub-chain an available block has appeared */
struct st_my_thread_var *last_thread=
keycache->waiting_for_block.last_thread;
struct st_my_thread_var *first_thread= last_thread->next;
struct st_my_thread_var *next_thread= first_thread;
HASH_LINK *hash_link= (HASH_LINK *) first_thread->keycache_link;
struct st_my_thread_var *thread;
do
{
thread= next_thread;
next_thread= thread->next;
/*
We notify about the event all threads that ask
for the same page as the first thread in the queue
*/
if ((HASH_LINK *) thread->keycache_link == hash_link)
{
KEYCACHE_DBUG_PRINT("link_block: signal",
("thread %ld", (ulong) thread->id));
keycache_pthread_cond_signal(&thread->suspend);
unlink_from_queue(&keycache->waiting_for_block, thread);
block->requests++;
}
}
while (thread != last_thread);
hash_link->block= block;
/*
NOTE: We assigned the block to the hash_link and signalled the
requesting thread(s). But it is possible that other threads runs
first. These threads see the hash_link assigned to a block which
is assigned to another hash_link and not marked BLOCK_IN_SWITCH.
This can be a problem for functions that do not select the block
via its hash_link: flush and free. They do only see a block which
is in a "normal" state and don't know that it will be evicted soon.
We cannot set BLOCK_IN_SWITCH here because only one of the
requesting threads must handle the eviction. All others must wait
for it to complete. If we set the flag here, the threads would not
know who is in charge of the eviction. Without the flag, the first
thread takes the stick and sets the flag.
But we need to note in the block that is has been selected for
eviction. It must not be freed. The evicting thread will not
expect the block in the free list. Before freeing we could also
check if block->requests > 1. But I think including another flag
in the check of block->status is slightly more efficient and
probably easier to read.
*/
block->status|= BLOCK_IN_EVICTION;
KEYCACHE_THREAD_TRACE("link_block: after signaling");
#if defined(KEYCACHE_DEBUG)
KEYCACHE_DBUG_PRINT("link_block",
("linked,unlinked block %u status=%x #requests=%u #available=%u",
BLOCK_NUMBER(block), block->status,
block->requests, keycache->blocks_available));
#endif
return;
}
pins= hot ? &keycache->used_ins : &keycache->used_last;
ins= *pins;
if (ins)
{
ins->next_used->prev_used= &block->next_used;
block->next_used= ins->next_used;
block->prev_used= &ins->next_used;
ins->next_used= block;
if (at_end)
*pins= block;
}
else
{
/* The LRU ring is empty. Let the block point to itself. */
keycache->used_last= keycache->used_ins= block->next_used= block;
block->prev_used= &block->next_used;
}
KEYCACHE_THREAD_TRACE("link_block");
#if defined(KEYCACHE_DEBUG)
keycache->blocks_available++;
KEYCACHE_DBUG_PRINT("link_block",
("linked block %u:%1u status=%x #requests=%u #available=%u",
BLOCK_NUMBER(block), at_end, block->status,
block->requests, keycache->blocks_available));
KEYCACHE_DBUG_ASSERT((ulong) keycache->blocks_available <=
keycache->blocks_used);
#endif
}
|
O0
|
c
|
link_block:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
jmp 0xe581c
jmp 0xe581e
jmp 0xe5820
jmp 0xe5822
jmp 0xe5824
jmp 0xe5826
jmp 0xe5828
jmp 0xe582a
jmp 0xe582c
jmp 0xe582e
jmp 0xe5830
cmpb $0x0, -0x11(%rbp)
jne 0xe5908
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0xe5908
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rax
movq 0xa8(%rax), %rax
cmpq -0x48(%rbp), %rax
jne 0xe58db
jmp 0xe58ab
jmp 0xe58ad
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0xe55d0
movq -0x8(%rbp), %rdi
addq $0x120, %rdi # imm = 0x120
movq -0x50(%rbp), %rsi
callq 0xe5630
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0xe58dd
movq -0x50(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xe5881
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x50(%rax)
jmp 0xe59bd
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0xe5921
movq -0x8(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x58(%rbp)
jmp 0xe592f
movq -0x8(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe5990
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpb $0x0, -0x12(%rbp)
je 0xe598e
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe59bd
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
link_block_0:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, cl
mov cl, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], cl
mov [rbp+var_12], al
jmp short $+2
loc_E581C:
jmp short $+2
loc_E581E:
jmp short $+2
loc_E5820:
jmp short $+2
loc_E5822:
jmp short $+2
loc_E5824:
jmp short $+2
loc_E5826:
jmp short $+2
loc_E5828:
jmp short $+2
loc_E582A:
jmp short $+2
loc_E582C:
jmp short $+2
loc_E582E:
jmp short $+2
loc_E5830:
cmp [rbp+var_11], 0
jnz loc_E5908
mov rax, [rbp+var_8]
cmp qword ptr [rax+120h], 0
jz loc_E5908
mov rax, [rbp+var_8]
mov rax, [rax+120h]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax+88h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov rax, [rax+0A8h]
mov [rbp+var_48], rax
loc_E5881:
mov rax, [rbp+var_40]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rax, [rax+88h]
mov [rbp+var_40], rax
mov rax, [rbp+var_50]
mov rax, [rax+0A8h]
cmp rax, [rbp+var_48]
jnz short loc_E58DB
jmp short $+2
loc_E58AB:
jmp short $+2
loc_E58AD:
mov rdi, [rbp+var_50]
add rdi, 8
call inline_mysql_cond_signal_2
mov rdi, [rbp+var_8]
add rdi, 120h
mov rsi, [rbp+var_50]
call unlink_from_queue
mov rax, [rbp+var_10]
mov ecx, [rax+38h]
add ecx, 1
mov [rax+38h], ecx
loc_E58DB:
jmp short $+2
loc_E58DD:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_30]
jnz short loc_E5881
mov rcx, [rbp+var_10]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
or ecx, 80h
mov [rax+50h], ecx
jmp loc_E59BD
loc_E5908:
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_E5921
mov rax, [rbp+var_8]
add rax, 0B8h
mov [rbp+var_58], rax
jmp short loc_E592F
loc_E5921:
mov rax, [rbp+var_8]
add rax, 0B0h
mov [rbp+var_58], rax
loc_E592F:
mov rax, [rbp+var_58]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_E5990
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax], rcx
cmp [rbp+var_12], 0
jz short loc_E598E
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax], rcx
loc_E598E:
jmp short loc_E59BD
loc_E5990:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_8]
mov [rax+0B8h], rcx
mov rax, [rbp+var_8]
mov [rax+0B0h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+8], rcx
loc_E59BD:
add rsp, 60h
pop rbp
retn
|
_QWORD * link_block_0(_QWORD *a1, long long a2, char a3, char a4)
{
_QWORD *result; // rax
_QWORD *v5; // [rsp+8h] [rbp-58h]
long long v6; // [rsp+10h] [rbp-50h]
long long v7; // [rsp+18h] [rbp-48h]
long long v8; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+30h] [rbp-30h]
_QWORD *v10; // [rsp+40h] [rbp-20h]
if ( a3 || !a1[36] )
{
if ( a3 )
v5 = a1 + 23;
else
v5 = a1 + 22;
v10 = (_QWORD *)*v5;
if ( *v5 )
{
*(_QWORD *)(*v10 + 8LL) = a2;
*(_QWORD *)a2 = *v10;
*(_QWORD *)(a2 + 8) = v10;
result = v10;
*v10 = a2;
if ( a4 )
{
result = v5;
*v5 = a2;
}
}
else
{
*(_QWORD *)a2 = a2;
a1[23] = a2;
a1[22] = a2;
result = (_QWORD *)a2;
*(_QWORD *)(a2 + 8) = a2;
}
}
else
{
v9 = a1[36];
v8 = *(_QWORD *)(v9 + 136);
v7 = *(_QWORD *)(v8 + 168);
do
{
v6 = v8;
v8 = *(_QWORD *)(v8 + 136);
if ( *(_QWORD *)(v6 + 168) == v7 )
{
inline_mysql_cond_signal_2(v6 + 8);
unlink_from_queue(a1 + 36, v6);
++*(_DWORD *)(a2 + 56);
}
}
while ( v6 != v9 );
*(_QWORD *)(v7 + 16) = a2;
result = (_QWORD *)a2;
*(_DWORD *)(a2 + 80) |= 0x80u;
}
return result;
}
|
link_block:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,CL
MOV CL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],CL
MOV byte ptr [RBP + -0x12],AL
JMP 0x001e581c
LAB_001e581c:
JMP 0x001e581e
LAB_001e581e:
JMP 0x001e5820
LAB_001e5820:
JMP 0x001e5822
LAB_001e5822:
JMP 0x001e5824
LAB_001e5824:
JMP 0x001e5826
LAB_001e5826:
JMP 0x001e5828
LAB_001e5828:
JMP 0x001e582a
LAB_001e582a:
JMP 0x001e582c
LAB_001e582c:
JMP 0x001e582e
LAB_001e582e:
JMP 0x001e5830
LAB_001e5830:
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x001e5908
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x120],0x0
JZ 0x001e5908
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xa8]
MOV qword ptr [RBP + -0x48],RAX
LAB_001e5881:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RAX + 0xa8]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x001e58db
JMP 0x001e58ab
LAB_001e58ab:
JMP 0x001e58ad
LAB_001e58ad:
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x8
CALL 0x001e55d0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x120
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x001e5630
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x38]
ADD ECX,0x1
MOV dword ptr [RAX + 0x38],ECX
LAB_001e58db:
JMP 0x001e58dd
LAB_001e58dd:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001e5881
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x80
MOV dword ptr [RAX + 0x50],ECX
JMP 0x001e59bd
LAB_001e5908:
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x001e5921
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xb8
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e592f
LAB_001e5921:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xb0
MOV qword ptr [RBP + -0x58],RAX
LAB_001e592f:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e5990
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
CMP byte ptr [RBP + -0x12],0x0
JZ 0x001e598e
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
LAB_001e598e:
JMP 0x001e59bd
LAB_001e5990:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb0],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001e59bd:
ADD RSP,0x60
POP RBP
RET
|
void link_block(long param_1,long *param_2,char param_3,char param_4)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
bool bVar5;
long *local_60;
long local_48;
if ((param_3 == '\0') && (*(long *)(param_1 + 0x120) != 0)) {
lVar1 = *(long *)(param_1 + 0x120);
local_48 = *(long *)(lVar1 + 0x88);
lVar2 = *(long *)(local_48 + 0xa8);
do {
lVar3 = *(long *)(local_48 + 0x88);
if (*(long *)(local_48 + 0xa8) == lVar2) {
inline_mysql_cond_signal(local_48 + 8);
unlink_from_queue(param_1 + 0x120,local_48);
*(int *)(param_2 + 7) = (int)param_2[7] + 1;
}
bVar5 = local_48 != lVar1;
local_48 = lVar3;
} while (bVar5);
*(long **)(lVar2 + 0x10) = param_2;
*(uint *)(param_2 + 10) = *(uint *)(param_2 + 10) | 0x80;
}
else {
if (param_3 == '\0') {
local_60 = (long *)(param_1 + 0xb0);
}
else {
local_60 = (long *)(param_1 + 0xb8);
}
plVar4 = (long *)*local_60;
if (plVar4 == (long *)0x0) {
*param_2 = (long)param_2;
*(long **)(param_1 + 0xb8) = param_2;
*(long **)(param_1 + 0xb0) = param_2;
param_2[1] = (long)param_2;
}
else {
*(long **)(*plVar4 + 8) = param_2;
*param_2 = *plVar4;
param_2[1] = (long)plVar4;
*plVar4 = (long)param_2;
if (param_4 != '\0') {
*local_60 = (long)param_2;
}
}
}
return;
}
|
|
64,078 |
minja::Value::operator<(minja::Value const&) const
|
llama.cpp/common/minja/minja.hpp
|
bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw std::runtime_error("Cannot compare values: " + dump() + " < " + other.dump());
}
|
O3
|
cpp
|
minja::Value::operator<(minja::Value const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0x7d0ad
cmpq $0x0, 0x10(%r15)
jne 0x7d0ad
testb %al, %al
jne 0x7d0ad
cmpq $0x0, 0x30(%r15)
je 0x7d1b0
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x7d0e7
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0x7d1e2
movq %r15, %rdi
callq 0x75d7c
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
callq 0x75d7c
ucomisd 0x48(%rsp), %xmm0
seta %bl
jmp 0x7d19e
cmpb $0x3, %al
jne 0x7d1e2
cmpb $0x3, 0x40(%r14)
jne 0x7d1e2
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x75e92
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x75e92
movq 0x10(%rsp), %r15
movq 0x28(%rsp), %r14
movq 0x30(%rsp), %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
testq %rdx, %rdx
je 0x7d145
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1ccd0
movl %eax, %ebx
testl %eax, %eax
jne 0x7d166
subq %r12, %r15
cmpq $-0x7fffffff, %r15 # imm = 0x80000001
movq $-0x80000000, %rbx # imm = 0x80000000
cmovgeq %r15, %rbx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpq %rax, %rbx
cmovgeq %rax, %rbx
leaq 0x38(%rsp), %rax
cmpq %rax, %r14
je 0x7d180
movq 0x38(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1c110
shrl $0x1f, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d19e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1c460
movq %rax, %rbx
leaq 0x4edb6(%rip), %rsi # 0xcbf7a
movq %rax, %rdi
callq 0x1c280
movq 0x82de5(%rip), %rsi # 0xfffb8
movq 0x82d9e(%rip), %rdx # 0xfff78
movq %rbx, %rdi
callq 0x1c7b0
movl $0x10, %edi
callq 0x1c460
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x6cb9a
leaq 0x4f2fd(%rip), %rsi # 0xcc507
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x66b64
leaq 0x4f2fc(%rip), %rdx # 0xcc51f
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x38738
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x6cb9a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x67fe9
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c2c0
xorl %ebp, %ebp
movq 0x82d42(%rip), %rsi # 0xfffb8
movq 0x82cfb(%rip), %rdx # 0xfff78
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d2ab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x7d2ab
movq %rax, %r14
movb $0x1, %bpl
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d2d4
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x7d2d4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d2f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x7d2f7
movq %rax, %r14
movb $0x1, %bpl
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d318
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x1c110
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d333
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x7d37f
jmp 0x7d387
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d37f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x7d37f
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7d387
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x7d387
jmp 0x7d37c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
|
_ZNK5minja5ValueltERKS0_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 0B0h
mov r14, rsi
mov r15, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_7D0AD
cmp qword ptr [r15+10h], 0
jnz short loc_7D0AD
test al, al
jnz short loc_7D0AD
cmp qword ptr [r15+30h], 0
jz loc_7D1B0
loc_7D0AD:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_7D0E7
mov al, [r14+40h]
add al, 0FBh
cmp al, 2
ja loc_7D1E2
mov rdi, r15
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+0D8h+var_90], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
ucomisd xmm0, [rsp+0D8h+var_90]
setnbe bl
jmp loc_7D19E
loc_7D0E7:
cmp al, 3
jnz loc_7D1E2
cmp byte ptr [r14+40h], 3
jnz loc_7D1E2
lea rdi, [rsp+0D8h+var_D0]
mov rsi, r15
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+0D8h+var_B0]
mov rsi, r14
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r15, [rsp+0D8h+var_C8]
mov r14, [rsp+0D8h+var_B0]
mov r12, [rsp+0D8h+var_A8]
cmp r12, r15
mov rdx, r15
cmovb rdx, r12
test rdx, rdx
jz short loc_7D145
mov rdi, [rsp+0D8h+var_D0]
mov rsi, r14
call _memcmp
mov ebx, eax
test eax, eax
jnz short loc_7D166
loc_7D145:
sub r15, r12
cmp r15, 0FFFFFFFF80000001h
mov rbx, 0FFFFFFFF80000000h
cmovge rbx, r15
mov eax, 7FFFFFFFh
cmp rbx, rax
cmovge rbx, rax
loc_7D166:
lea rax, [rsp+0D8h+var_A0]
cmp r14, rax
jz short loc_7D180
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_7D180:
shr ebx, 1Fh
lea rax, [rsp+0D8h+var_C0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D19E
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7D19E:
mov eax, ebx
add rsp, 0B0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7D1B0:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7D1E2:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0D8h+var_88]
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aCannotCompareV; "Cannot compare values: "
lea rdi, [rsp+0D8h+var_48]
lea rdx, [rsp+0D8h+var_88]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdx, asc_CC51F; " < "
lea rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+0D8h+var_68]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rdi, [rsp+0D8h+var_D0]
lea rsi, [rsp+0D8h+var_B0]
lea rdx, [rsp+0D8h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+0D8h+var_D0]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+0D8h+var_C0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D2AB
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7D2AB
mov r14, rax
mov bpl, 1
loc_7D2AB:
lea rax, [rsp+0D8h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D2D4
mov rsi, [rsp+0D8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7D2D4
mov r14, rax
mov bpl, 1
loc_7D2D4:
lea rax, [rsp+0D8h+var_A0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D2F7
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7D2F7
mov r14, rax
mov bpl, 1
loc_7D2F7:
lea rax, [rsp+0D8h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D318
mov rsi, [rsp+0D8h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7D318:
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D333
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7D333:
test bpl, bpl
jnz short loc_7D37F
jmp short loc_7D387
mov r14, rax
lea rax, [rsp+0D8h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D37F
mov rsi, [rsp+0D8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7D37F
mov r14, rax
lea rax, [rsp+0D8h+var_C0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7D387
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7D387
jmp short $+2
loc_7D37C:
mov r14, rax
loc_7D37F:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7D387:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::operator<(long long a1, long long a2)
{
unsigned int v2; // ebx
char v3; // al
unsigned long long v4; // r15
long long *v5; // r14
unsigned long long v6; // r12
unsigned long long v7; // rdx
long long v8; // rbx
long long v9; // r15
std::runtime_error *exception; // rbx
void *v12; // rbx
long long *v13; // [rsp+8h] [rbp-D0h] BYREF
unsigned long long v14; // [rsp+10h] [rbp-C8h]
long long v15; // [rsp+18h] [rbp-C0h] BYREF
void *v16; // [rsp+28h] [rbp-B0h] BYREF
unsigned long long v17; // [rsp+30h] [rbp-A8h]
long long v18; // [rsp+38h] [rbp-A0h] BYREF
double v19; // [rsp+48h] [rbp-90h]
_BYTE v20[16]; // [rsp+50h] [rbp-88h] BYREF
_QWORD v21[2]; // [rsp+70h] [rbp-68h] BYREF
_QWORD v22[2]; // [rsp+90h] [rbp-48h] BYREF
v3 = *(_BYTE *)(a1 + 64);
if ( !*(_QWORD *)(a1 + 32) && !*(_QWORD *)(a1 + 16) && !v3 && !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (unsigned __int8)(v3 - 5) <= 2u )
{
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) <= 2u )
{
v19 = minja::Value::get<double>((_QWORD *)a1);
LOBYTE(v2) = minja::Value::get<double>((_QWORD *)a2) > v19;
return v2;
}
LABEL_24:
v12 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v20, a1, 0xFFFFFFFF, 0);
std::operator+<char>(v22, (long long)"Cannot compare values: ", (long long)v20);
std::operator+<char>(&v16, (long long)v22, (long long)" < ");
minja::Value::dump[abi:cxx11]((long long)v21, a2, 0xFFFFFFFF, 0);
std::operator+<char>(&v13, &v16, v21);
std::runtime_error::runtime_error(v12, &v13);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 != 3 || *(_BYTE *)(a2 + 64) != 3 )
goto LABEL_24;
minja::Value::get<std::string>((long long)&v13, (_QWORD *)a1);
minja::Value::get<std::string>((long long)&v16, (_QWORD *)a2);
v4 = v14;
v5 = (long long *)v16;
v6 = v17;
v7 = v14;
if ( v17 < v14 )
v7 = v17;
if ( !v7 || (LODWORD(v8) = memcmp(v13, v16), !(_DWORD)v8) )
{
v9 = v4 - v6;
v8 = 0xFFFFFFFF80000000LL;
if ( v9 >= -2147483647 )
v8 = v9;
if ( v8 >= 0x7FFFFFFF )
LODWORD(v8) = 0x7FFFFFFF;
}
if ( v5 != &v18 )
operator delete(v5, v18 + 1);
v2 = (unsigned int)v8 >> 31;
if ( v13 != &v15 )
operator delete(v13, v15 + 1);
return v2;
}
|
operator<:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xb0
MOV R14,RSI
MOV R15,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x0017d0ad
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x0017d0ad
TEST AL,AL
JNZ 0x0017d0ad
CMP qword ptr [R15 + 0x30],0x0
JZ 0x0017d1b0
LAB_0017d0ad:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x0017d0e7
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JA 0x0017d1e2
MOV RDI,R15
CALL 0x00175d7c
MOVSD qword ptr [RSP + 0x48],XMM0
MOV RDI,R14
CALL 0x00175d7c
UCOMISD XMM0,qword ptr [RSP + 0x48]
SETA BL
JMP 0x0017d19e
LAB_0017d0e7:
CMP AL,0x3
JNZ 0x0017d1e2
CMP byte ptr [R14 + 0x40],0x3
JNZ 0x0017d1e2
LEA RDI,[RSP + 0x8]
MOV RSI,R15
CALL 0x00175e92
LAB_0017d107:
LEA RDI,[RSP + 0x28]
MOV RSI,R14
CALL 0x00175e92
LAB_0017d114:
MOV R15,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x28]
MOV R12,qword ptr [RSP + 0x30]
CMP R12,R15
MOV RDX,R15
CMOVC RDX,R12
TEST RDX,RDX
JZ 0x0017d145
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
CALL 0x0011ccd0
MOV EBX,EAX
TEST EAX,EAX
JNZ 0x0017d166
LAB_0017d145:
SUB R15,R12
CMP R15,-0x7fffffff
MOV RBX,-0x80000000
CMOVGE RBX,R15
MOV EAX,0x7fffffff
CMP RBX,RAX
CMOVGE RBX,RAX
LAB_0017d166:
LEA RAX,[RSP + 0x38]
CMP R14,RAX
JZ 0x0017d180
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
MOV RDI,R14
CALL 0x0011c110
LAB_0017d180:
SHR EBX,0x1f
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017d19e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_0017d19e:
MOV EAX,EBX
ADD RSP,0xb0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017d1b0:
MOV EDI,0x10
CALL 0x0011c460
MOV RBX,RAX
LAB_0017d1bd:
LEA RSI,[0x1cbf7a]
MOV RDI,RAX
CALL 0x0011c280
LAB_0017d1cc:
MOV RSI,qword ptr [0x001fffb8]
MOV RDX,qword ptr [0x001fff78]
MOV RDI,RBX
CALL 0x0011c7b0
LAB_0017d1e2:
MOV EDI,0x10
CALL 0x0011c460
MOV RBX,RAX
LAB_0017d1ef:
LEA RDI,[RSP + 0x50]
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0016cb9a
LAB_0017d203:
LEA RSI,[0x1cc507]
LEA RDI,[RSP + 0x90]
LEA RDX,[RSP + 0x50]
CALL 0x00166b64
LAB_0017d21c:
LEA RDX,[0x1cc51f]
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x90]
CALL 0x00138738
LAB_0017d235:
LEA RDI,[RSP + 0x70]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0016cb9a
LAB_0017d249:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x70]
CALL 0x00167fe9
MOV BPL,0x1
LAB_0017d260:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011c2c0
XOR EBP,EBP
MOV RSI,qword ptr [0x001fffb8]
MOV RDX,qword ptr [0x001fff78]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall minja::Value::operator<(Value *this,Value *param_1)
{
Value VVar1;
uint uVar2;
runtime_error *prVar3;
ulong uVar4;
int8 unaff_RBX;
double dVar5;
long *local_d0;
ulong local_c8;
long local_c0 [2];
long *local_b0;
ulong local_a8;
long local_a0 [2];
double local_90;
int1 local_88 [32];
int1 local_68 [32];
char local_48 [32];
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017d1bd to 0017d1cb has its CatchHandler @ 0017d37c */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fffb8,PTR__runtime_error_001fff78);
}
if ((byte)((char)VVar1 - 5U) < 3) {
if (2 < (byte)((char)param_1[0x40] - 5U)) {
LAB_0017d1e2:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017d1ef to 0017d202 has its CatchHandler @ 0017d37a */
dump_abi_cxx11_((int)local_88,SUB81(this,0));
/* try { // try from 0017d203 to 0017d21b has its CatchHandler @ 0017d33a */
std::operator+(local_48,(string *)"Cannot compare values: ");
/* try { // try from 0017d21c to 0017d234 has its CatchHandler @ 0017d2f1 */
std::operator+((string *)&local_b0,local_48);
/* try { // try from 0017d235 to 0017d248 has its CatchHandler @ 0017d2ce */
dump_abi_cxx11_((int)local_68,SUB81(param_1,0));
/* try { // try from 0017d249 to 0017d25c has its CatchHandler @ 0017d2a5 */
std::operator+((string *)&local_d0,(string *)&local_b0);
/* try { // try from 0017d260 to 0017d284 has its CatchHandler @ 0017d285 */
std::runtime_error::runtime_error(prVar3,(string *)&local_d0);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_001fffb8,PTR__runtime_error_001fff78);
}
local_90 = get<double>(this);
dVar5 = get<double>(param_1);
uVar4 = CONCAT71((int7)((ulong)unaff_RBX >> 8),local_90 < dVar5);
goto LAB_0017d19e;
}
if ((VVar1 != (Value)0x3) || (param_1[0x40] != (Value)0x3)) goto LAB_0017d1e2;
get<std::__cxx11::string>();
/* try { // try from 0017d107 to 0017d113 has its CatchHandler @ 0017d35a */
get<std::__cxx11::string>();
uVar4 = local_c8;
if (local_a8 < local_c8) {
uVar4 = local_a8;
}
if (uVar4 == 0) {
LAB_0017d145:
uVar4 = 0xffffffff80000000;
if (-0x80000000 < (long)(local_c8 - local_a8)) {
uVar4 = local_c8 - local_a8;
}
if (0x7ffffffe < (long)uVar4) {
uVar4 = 0;
}
}
else {
uVar2 = memcmp(local_d0,local_b0,uVar4);
uVar4 = (ulong)uVar2;
if (uVar2 == 0) goto LAB_0017d145;
}
if (local_b0 != local_a0) {
operator_delete(local_b0,local_a0[0] + 1);
}
uVar4 = uVar4 >> 0x1f & 1;
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
LAB_0017d19e:
return uVar4 & 0xffffffff;
}
|
|
64,079 |
string_buffer_concat_value
|
bluesky950520[P]quickjs/quickjs.c
|
static int string_buffer_concat_value(StringBuffer *s, JSValue v)
{
JSString *p;
JSValue v1;
int res;
if (s->error_status) {
/* prevent exception overload */
return -1;
}
if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
v1 = JS_ToString(s->ctx, v);
if (JS_IsException(v1))
return string_buffer_set_error(s);
p = JS_VALUE_GET_STRING(v1);
res = string_buffer_concat(s, p, 0, p->len);
JS_FreeValue(s->ctx, v1);
return res;
}
p = JS_VALUE_GET_STRING(v);
return string_buffer_concat(s, p, 0, p->len);
}
|
O0
|
c
|
string_buffer_concat_value:
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x8bcab
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x8bda8
movq 0x48(%rsp), %rax
cmpl $-0x7, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x8bd78
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x30030
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x8bd27
movq 0x38(%rsp), %rdi
callq 0x76140
movl %eax, 0x54(%rsp)
jmp 0x8bda8
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x75f20
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x29f80
movl 0x1c(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x8bda8
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x75f20
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
|
string_buffer_concat_value:
sub rsp, 58h
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_10], rdx
mov [rsp+58h+var_20], rdi
mov rax, [rsp+58h+var_20]
cmp dword ptr [rax+1Ch], 0
jz short loc_8BCAB
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp loc_8BDA8
loc_8BCAB:
mov rax, [rsp+58h+var_10]
cmp eax, 0FFFFFFF9h
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_8BD78
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_18]
mov rdx, [rsp+58h+var_10]
call JS_ToString
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_8BD27
mov rdi, [rsp+58h+var_20]
call string_buffer_set_error
mov [rsp+58h+var_4], eax
jmp loc_8BDA8
loc_8BD27:
mov rax, [rsp+58h+var_38]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_3C], eax
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
call JS_FreeValue
mov eax, [rsp+58h+var_3C]
mov [rsp+58h+var_4], eax
jmp short loc_8BDA8
loc_8BD78:
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_4], eax
loc_8BDA8:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
|
long long string_buffer_concat_value(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rdx
long long v8; // [rsp+8h] [rbp-50h]
unsigned int v9; // [rsp+1Ch] [rbp-3Ch]
long long v10; // [rsp+28h] [rbp-30h]
if ( *(_DWORD *)(a1 + 28) )
{
return (unsigned int)-1;
}
else if ( (_DWORD)a3 == -7 )
{
return (unsigned int)string_buffer_concat(a1, a2, 0, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
}
else
{
v8 = JS_ToString(*(_QWORD *)a1, a2, a3, a4, a5, a6);
v10 = v6;
if ( JS_IsException_1(v8, v6) )
{
return (unsigned int)string_buffer_set_error(a1);
}
else
{
v9 = string_buffer_concat(a1, v8, 0, *(_DWORD *)(v8 + 4) & 0x7FFFFFFF);
JS_FreeValue(*(_QWORD *)a1, v8, v10);
return v9;
}
}
}
|
string_buffer_concat_value:
SUB RSP,0x58
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x1c],0x0
JZ 0x0018bcab
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x0018bda8
LAB_0018bcab:
MOV RAX,qword ptr [RSP + 0x48]
CMP EAX,-0x7
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0018bd78
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00130030
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0018bd27
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00176140
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0018bda8
LAB_0018bd27:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x00175f20
MOV dword ptr [RSP + 0x1c],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00129f80
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0018bda8
LAB_0018bd78:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x00175f20
MOV dword ptr [RSP + 0x54],EAX
LAB_0018bda8:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 string_buffer_concat_value(int8 *param_1,long param_2,int8 param_3)
{
int iVar1;
long lVar2;
int1 auVar3 [16];
int4 local_4;
if (*(int *)((long)param_1 + 0x1c) == 0) {
if ((int)param_3 == -7) {
local_4 = string_buffer_concat
(param_1,param_2,0,(uint)*(int8 *)(param_2 + 4) & 0x7fffffff);
}
else {
auVar3 = JS_ToString(*param_1,param_2,param_3);
lVar2 = auVar3._0_8_;
iVar1 = JS_IsException(lVar2,auVar3._8_8_);
if (iVar1 == 0) {
local_4 = string_buffer_concat
(param_1,lVar2,0,(uint)*(int8 *)(lVar2 + 4) & 0x7fffffff);
JS_FreeValue(*param_1,lVar2,auVar3._8_8_);
}
else {
local_4 = string_buffer_set_error(param_1);
}
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
64,080 |
maria_rtree_find_next
|
eloqsql/storage/maria/ma_rt_index.c
|
int maria_rtree_find_next(MARIA_HA *info, uint keynr, uint32 search_flag)
{
my_off_t root;
uint32 nod_cmp_flag;
MARIA_KEYDEF *keyinfo= info->s->keyinfo + keynr;
DBUG_ASSERT(info->last_key.keyinfo == keyinfo);
/*
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 maria_rtree_find_first(info, &info->last_key, search_flag);
if (!info->keyread_buff_used)
{
uchar *key= info->int_keypos;
while (key < info->int_maxpos)
{
if (!maria_rtree_key_cmp(keyinfo->seg,
info->first_mbr_key, key,
info->last_rkey_length, search_flag))
{
uchar *after_key= key + keyinfo->keylength;
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= key;
tmp_key.data_length= keyinfo->keylength - info->s->base.rec_reflength;
info->cur_row.lastpos= _ma_row_pos_from_key(&tmp_key);
memcpy(info->last_key.data, key, info->last_key.data_length);
if (after_key < info->int_maxpos)
info->int_keypos= after_key;
else
info->keyread_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 maria_rtree_find_req(info, keyinfo, search_flag, nod_cmp_flag, root,
0);
}
|
O0
|
c
|
maria_rtree_find_next:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x8da63
movl $0x400, -0x24(%rbp) # imm = 0x400
movl $0x400, -0x18(%rbp) # imm = 0x400
movq -0x10(%rbp), %rax
movl 0x624(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x8daa2
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movl -0x18(%rbp), %edx
callq 0x8d3c0
movl %eax, -0x4(%rbp)
jmp 0x8dc2e
movq -0x10(%rbp), %rax
cmpb $0x0, 0x685(%rax)
jne 0x8dbde
movq -0x10(%rbp), %rax
movq 0x3b0(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x8dbdc
movq -0x30(%rbp), %rax
movq 0xc0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x398(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x630(%rax), %ecx
movl -0x18(%rbp), %r8d
callq 0x908b0
cmpl $0x0, %eax
jne 0x8dbbe
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movzwl 0xaa(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xaa(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subl 0x3e0(%rcx), %eax
movl %eax, -0x50(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6b020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0x200(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %edx
callq 0x2a090
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x8dbaa
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x3b0(%rax)
jmp 0x8dbb5
movq -0x10(%rbp), %rax
movb $0x1, 0x685(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8dc2e
movq -0x30(%rbp), %rax
movzwl 0xaa(%rax), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x8dac2
jmp 0x8dbde
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x118(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0x8dc11
callq 0xf6090
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8dc2e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %r8
xorl %r9d, %r9d
callq 0x8d4b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
maria_rtree_find_next:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_14]
imul rcx, 118h
add rax, rcx
mov [rbp+var_30], rax
jmp short $+2
loc_8DA63:
mov [rbp+var_24], 400h
mov [rbp+var_18], 400h
mov rax, [rbp+var_10]
mov eax, [rax+624h]
and eax, 8
cmp eax, 0
jz short loc_8DAA2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 200h
mov edx, [rbp+var_18]
call maria_rtree_find_first
mov [rbp+var_4], eax
jmp loc_8DC2E
loc_8DAA2:
mov rax, [rbp+var_10]
cmp byte ptr [rax+685h], 0
jnz loc_8DBDE
mov rax, [rbp+var_10]
mov rax, [rax+3B0h]
mov [rbp+var_38], rax
loc_8DAC2:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
cmp rax, [rcx+3B8h]
jnb loc_8DBDC
mov rax, [rbp+var_30]
mov rdi, [rax+0C0h]
mov rax, [rbp+var_10]
mov rsi, [rax+398h]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_10]
mov ecx, [rax+630h]
mov r8d, [rbp+var_18]
call maria_rtree_key_cmp
cmp eax, 0
jnz loc_8DBBE
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
movzx ecx, word ptr [rcx+0AAh]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_30]
mov [rbp+var_58], rax
mov rax, [rbp+var_38]
mov [rbp+var_60], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0AAh]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
sub eax, [rcx+3E0h]
mov [rbp+var_50], eax
lea rdi, [rbp+var_60]
call _ma_row_pos_from_key
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+98h], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+200h]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov eax, [rax+210h]
mov edx, eax
call _memcpy
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
cmp rax, [rcx+3B8h]
jnb short loc_8DBAA
mov rcx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+3B0h], rcx
jmp short loc_8DBB5
loc_8DBAA:
mov rax, [rbp+var_10]
mov byte ptr [rax+685h], 1
loc_8DBB5:
mov [rbp+var_4], 0
jmp short loc_8DC2E
loc_8DBBE:
mov rax, [rbp+var_30]
movzx ecx, word ptr [rax+0AAh]
mov rax, [rbp+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_38], rax
jmp loc_8DAC2
loc_8DBDC:
jmp short $+2
loc_8DBDE:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+118h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_8DC11
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_8DC2E
loc_8DC11:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov edx, [rbp+var_18]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_20]
xor r9d, r9d
call maria_rtree_find_req
mov [rbp+var_4], eax
loc_8DC2E:
mov eax, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
long long maria_rtree_find_next(_DWORD *a1, const char *a2, unsigned int a3)
{
long long v3; // rax
_QWORD v5[2]; // [rsp+0h] [rbp-60h] BYREF
int v6; // [rsp+10h] [rbp-50h]
unsigned long long v7; // [rsp+20h] [rbp-40h]
unsigned long long i; // [rsp+28h] [rbp-38h]
long long v9; // [rsp+30h] [rbp-30h]
unsigned int v10; // [rsp+3Ch] [rbp-24h]
unsigned long long v11; // [rsp+40h] [rbp-20h]
unsigned int v12; // [rsp+48h] [rbp-18h]
unsigned int v13; // [rsp+4Ch] [rbp-14h]
_DWORD *v14; // [rsp+50h] [rbp-10h]
v14 = a1;
v13 = (unsigned int)a2;
v12 = a3;
v9 = 280LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 1392LL);
v10 = 1024;
v12 = 1024;
if ( (a1[393] & 8) != 0 )
{
return (unsigned int)maria_rtree_find_first((long long)v14, (const char *)v14 + 512);
}
else
{
if ( !*((_BYTE *)v14 + 1669) )
{
for ( i = *((_QWORD *)v14 + 118); i < *((_QWORD *)v14 + 119); i += *(unsigned __int16 *)(v9 + 170) )
{
a1 = *(_DWORD **)(v9 + 192);
a2 = (const char *)*((_QWORD *)v14 + 115);
if ( !(unsigned int)maria_rtree_key_cmp(a1, a2, i, (unsigned int)v14[396], v12) )
{
v7 = *(unsigned __int16 *)(v9 + 170) + i;
v5[1] = v9;
v5[0] = i;
v6 = *(unsigned __int16 *)(v9 + 170) - *(_DWORD *)(*(_QWORD *)v14 + 992LL);
v3 = ma_row_pos_from_key((long long)v5);
*((_QWORD *)v14 + 19) = v3;
memcpy(*((_QWORD *)v14 + 64), i, (unsigned int)v14[132]);
if ( v7 >= *((_QWORD *)v14 + 119) )
*((_BYTE *)v14 + 1669) = 1;
else
*((_QWORD *)v14 + 118) = v7;
return 0;
}
}
}
v11 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)v14 + 280LL) + 8LL * v13);
if ( v11 == -1LL )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else
{
return (unsigned int)maria_rtree_find_req((long long)v14, v9, v12, v10, v11, 0);
}
}
}
|
maria_rtree_find_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0018da63
LAB_0018da63:
MOV dword ptr [RBP + -0x24],0x400
MOV dword ptr [RBP + -0x18],0x400
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x624]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0018daa2
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x200
MOV EDX,dword ptr [RBP + -0x18]
CALL 0x0018d3c0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018dc2e
LAB_0018daa2:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x685],0x0
JNZ 0x0018dbde
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3b0]
MOV qword ptr [RBP + -0x38],RAX
LAB_0018dac2:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0018dbdc
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x398]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x630]
MOV R8D,dword ptr [RBP + -0x18]
CALL 0x001908b0
CMP EAX,0x0
JNZ 0x0018dbbe
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RCX + 0xaa]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xaa]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
SUB EAX,dword ptr [RCX + 0x3e0]
MOV dword ptr [RBP + -0x50],EAX
LEA RDI,[RBP + -0x60]
CALL 0x0016b020
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x98],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x200]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x210]
MOV EDX,EAX
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0018dbaa
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x3b0],RCX
JMP 0x0018dbb5
LAB_0018dbaa:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x685],0x1
LAB_0018dbb5:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0018dc2e
LAB_0018dbbe:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX ECX,word ptr [RAX + 0xaa]
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0018dac2
LAB_0018dbdc:
JMP 0x0018dbde
LAB_0018dbde:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x118]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x0018dc11
CALL 0x001f6090
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0018dc2e
LAB_0018dc11:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x20]
XOR R9D,R9D
CALL 0x0018d4b0
MOV dword ptr [RBP + -0x4],EAX
LAB_0018dc2e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
int4 maria_rtree_find_next(long *param_1,uint param_2)
{
int iVar1;
long lVar2;
int4 *puVar3;
void *local_68;
long local_60;
int local_58;
ulong local_48;
void *local_40;
long local_38;
int4 local_2c;
long local_28;
int4 local_20;
uint local_1c;
long *local_18;
int4 local_c;
local_38 = *(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118;
local_2c = 0x400;
local_20 = 0x400;
local_1c = param_2;
local_18 = param_1;
if ((*(uint *)((long)param_1 + 0x624) & 8) == 0) {
if (*(char *)((long)param_1 + 0x685) == '\0') {
for (local_40 = (void *)param_1[0x76]; local_40 < (void *)local_18[0x77];
local_40 = (void *)((long)local_40 + (long)(int)(uint)*(ushort *)(local_38 + 0xaa))) {
iVar1 = maria_rtree_key_cmp(*(int8 *)(local_38 + 0xc0),local_18[0x73],local_40,
(int)local_18[0xc6],local_20);
if (iVar1 == 0) {
local_48 = (long)local_40 + (long)(int)(uint)*(ushort *)(local_38 + 0xaa);
local_60 = local_38;
local_68 = local_40;
local_58 = (uint)*(ushort *)(local_38 + 0xaa) - *(int *)(*local_18 + 0x3e0);
lVar2 = _ma_row_pos_from_key(&local_68);
local_18[0x13] = lVar2;
memcpy((void *)local_18[0x40],local_40,(ulong)*(uint *)(local_18 + 0x42));
if (local_48 < (ulong)local_18[0x77]) {
local_18[0x76] = local_48;
}
else {
*(int1 *)((long)local_18 + 0x685) = 1;
}
return 0;
}
}
}
local_28 = *(long *)(*(long *)(*local_18 + 0x118) + (ulong)local_1c * 8);
if (local_28 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
local_c = maria_rtree_find_req(local_18,local_38,local_20,local_2c,local_28,0);
}
}
else {
local_c = maria_rtree_find_first(param_1,param_1 + 0x40,0x400);
}
return local_c;
}
|
|
64,081 |
cli::hex& cli::hex::set<unsigned int>(unsigned int&)
|
msxemulator/build_O3/_deps/picotool-src/cli.h
|
hex &set(T &t) {
unsigned int min = _min_value;
unsigned int max = _max_value;
string nm = "<" + name() + ">";
// note we cannot capture "this"
on_action([&t, min, max, nm](string value) {
auto ovalue = value;
if (value.find("0x") == 0) value = value.substr(2);
size_t pos = 0;
long lvalue = std::numeric_limits<long>::max();
try {
lvalue = std::stoul(value, &pos, 16);
if (pos != value.length()) {
return "Garbage after hex value: " + value.substr(pos);
}
} catch (std::invalid_argument&) {
return ovalue + " is not a valid hex value";
} catch (std::out_of_range&) {
}
if (lvalue != (unsigned int)lvalue) {
return value + " is not a valid 32 bit value";
}
t = (unsigned int)lvalue;
if (t < min) {
std::stringstream ss;
ss << nm << " must be >= 0x" << std::hex << std::to_string(min);
return ss.str();
}
if (t > max) {
std::stringstream ss;
ss << nm << " must be M= 0x" << std::hex << std::to_string(min);
return ss.str();
}
return string("");
});
return *this;
}
|
O3
|
c
|
cli::hex& cli::hex::set<unsigned int>(unsigned int&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xd8(%rdi), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x1d410
leaq 0x4c16e(%rip), %rcx # 0xa3ff0
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf4e0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x57eba
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x57ec2
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x4e0c5(%rip), %rsi # 0xa5fa8
callq 0xf830
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x57f0f
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x57f16
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x57f44
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf470
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x57f5e
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xf470
leaq 0x10(%rsp), %rdi
movq %r14, -0x10(%rdi)
movaps 0x90(%rsp), %xmm0
movlps %xmm0, -0x8(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
callq 0x1d410
leaq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x58a20
leaq 0x8(%rbx), %rdi
leaq 0x50(%rsp), %rsi
callq 0x58a7e
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x57fc2
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x57fd9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf470
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x57ff0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x58024
movq %rax, %rbx
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x5802f
leaq 0x50(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5802f
movq %rax, %rdi
callq 0x1d2b2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x5804b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xf470
jmp 0x5804b
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x58094
movq 0x40(%rsp), %rsi
jmp 0x5808c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5807a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf470
jmp 0x5807a
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x58094
movq 0x80(%rsp), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
|
_ZN3cli3hex3setIjEERS0_RT_:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A0h
mov r14, rsi
mov rbx, rdi
movsd xmm0, qword ptr [rdi+0D8h]
movaps [rsp+0C8h+var_38], xmm0
lea r12, [rsp+0C8h+var_48]
mov [r12-10h], r12
mov rsi, [rdi+48h]
mov rdx, [rdi+50h]
add rdx, rsi
lea r15, [rsp+0C8h+var_58]
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)
lea rcx, aMissing+8; "<"
mov r8d, 1
mov rdi, r15
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r13, [rsp+0C8h+var_B8]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_57EBA
mov [rsp+0C8h+var_C8], rdx
mov rdx, [rcx]
mov [rsp+0C8h+var_B8], rdx
jmp short loc_57EC2
loc_57EBA:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_57EC2:
mov rdx, [rax+8]
mov rdi, rsp
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, asc_A5FA7+1; ">"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r15, [rsp+0C8h+var_88]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_57F0F
mov [rsp+0C8h+var_98], rdx
mov rdx, [rcx]
mov [rsp+0C8h+var_88], rdx
jmp short loc_57F16
loc_57F0F:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_57F16:
mov rdx, [rax+8]
mov [rsp+0C8h+var_90], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+0C8h+var_C8]; void *
cmp rdi, r13
jz short loc_57F44
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_57F44:
mov rdi, [rsp+0C8h+var_58]; void *
cmp rdi, r12
jz short loc_57F5E
mov rsi, [rsp+0C8h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_57F5E:
lea rdi, [rsp+0C8h+var_B8]
mov [rdi-10h], r14
movaps xmm0, [rsp+0C8h+var_38]
movlps qword ptr [rdi-8], xmm0
lea r14, [rsp+0C8h+var_A8]
mov [r14-10h], r14
mov rsi, [rsp+0C8h+var_98]
mov rdx, [rsp+0C8h+var_90]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdi, [rsp+0C8h+var_78]
mov rsi, rsp
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKS5_EEC2IZN3cli3hex3setIjEERSC_RT_EUlS5_E_vEEOSF_; std::function<std::string ()(std::string const&)>::function<cli::hex::set<uint>(uint &)::{lambda(std::string)#1},void>(uint&&)
lea rdi, [rbx+8]
lea rsi, [rsp+0C8h+var_78]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EEaSIRS_IFS5_RKS5_EEEENSt9enable_ifIXsrNS7_9_CallableIT_NSE_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISG_E4typeEE4typeES7_EE5valueESt5decayISG_EE4type4typeESt15__invoke_resultIRSR_JS5_EEEE5valueERS7_E4typeEOSG_
mov rax, [rsp+0C8h+var_68]
test rax, rax
jz short loc_57FC2
lea rdi, [rsp+0C8h+var_78]
mov rsi, rdi
mov edx, 3
call rax
loc_57FC2:
mov rdi, [rsp+0C8h+var_B8]; void *
cmp rdi, r14
jz short loc_57FD9
mov rsi, [rsp+0C8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_57FD9:
mov rdi, [rsp+0C8h+var_98]; void *
cmp rdi, r15
jz short loc_57FF0
mov rsi, [rsp+0C8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_57FF0:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_58024
mov rbx, rax
mov rax, [rsp+0C8h+var_68]
test rax, rax
jz short loc_5802F
lea rdi, [rsp+0C8h+var_78]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_5802F
loc_58024:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_5802F:
mov rdi, [rsp+0C8h+var_B8]; void *
cmp rdi, r14
jz short loc_5804B
mov rsi, [rsp+0C8h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5804B
mov rbx, rax
loc_5804B:
mov rdi, [rsp+0C8h+var_98]
cmp rdi, r15
jz short loc_58094
mov rsi, [rsp+0C8h+var_88]
jmp short loc_5808C
mov rbx, rax
mov rdi, [rsp+0C8h+var_C8]; void *
cmp rdi, r13
jz short loc_5807A
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5807A
mov rbx, rax
loc_5807A:
mov rdi, [rsp+0C8h+var_58]; void *
cmp rdi, r12
jz short loc_58094
mov rsi, [rsp+0C8h+var_48]
loc_5808C:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_58094:
mov rdi, rbx
call __Unwind_Resume
|
long long cli::hex::set<unsigned int>(long long a1, void *a2)
{
long long v2; // rax
__int128 *v3; // rcx
long long v4; // rax
__int128 *v5; // rcx
void *v7[2]; // [rsp+0h] [rbp-C8h] BYREF
__int128 v8; // [rsp+10h] [rbp-B8h] BYREF
_QWORD v9[2]; // [rsp+20h] [rbp-A8h] BYREF
void *v10; // [rsp+30h] [rbp-98h]
long long v11; // [rsp+38h] [rbp-90h]
__int128 v12; // [rsp+40h] [rbp-88h] BYREF
_BYTE v13[16]; // [rsp+50h] [rbp-78h] BYREF
void ( *v14)(_BYTE *, _BYTE *, long long); // [rsp+60h] [rbp-68h]
void *v15[2]; // [rsp+70h] [rbp-58h] BYREF
_QWORD v16[2]; // [rsp+80h] [rbp-48h] BYREF
__m128 v17; // [rsp+90h] [rbp-38h]
v17 = (__m128)*(unsigned long long *)(a1 + 216);
v15[0] = v16;
std::string::_M_construct<char *>((long long)v15, *(_BYTE **)(a1 + 72), *(_QWORD *)(a1 + 72) + *(_QWORD *)(a1 + 80));
v2 = std::string::replace(v15, 0LL, 0LL, "<", 1LL);
v7[0] = &v8;
v3 = (__int128 *)(v2 + 16);
if ( *(_QWORD *)v2 == v2 + 16 )
{
v8 = *v3;
}
else
{
v7[0] = *(void **)v2;
*(_QWORD *)&v8 = *(_QWORD *)v3;
}
v7[1] = *(void **)(v2 + 8);
*(_QWORD *)v2 = v3;
*(_QWORD *)(v2 + 8) = 0LL;
*(_BYTE *)(v2 + 16) = 0;
v4 = std::string::append(v7, ">");
v10 = &v12;
v5 = (__int128 *)(v4 + 16);
if ( *(_QWORD *)v4 == v4 + 16 )
{
v12 = *v5;
}
else
{
v10 = *(void **)v4;
*(_QWORD *)&v12 = *(_QWORD *)v5;
}
v11 = *(_QWORD *)(v4 + 8);
*(_QWORD *)v4 = v5;
*(_QWORD *)(v4 + 8) = 0LL;
*(_BYTE *)(v4 + 16) = 0;
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
v7[0] = a2;
_mm_storel_ps((double *)&v7[1], v17);
*(_QWORD *)&v8 = v9;
std::string::_M_construct<char *>((long long)&v8, v10, (long long)v10 + v11);
std::function<std::string ()(std::string const&)>::function<cli::hex& cli::hex::set<unsigned int>(unsigned int &)::{lambda(std::string)#1},void>(
v13,
v7);
std::function<std::string ()(std::string)>::operator=<std::function&<std::string ()(std::string const&)>>(a1 + 8, v13);
if ( v14 )
v14(v13, v13, 3LL);
if ( (_QWORD *)v8 != v9 )
operator delete((void *)v8, v9[0] + 1LL);
if ( v10 != &v12 )
operator delete(v10, v12 + 1);
return a1;
}
|
set<unsigned_int>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa0
MOV R14,RSI
MOV RBX,RDI
MOVSD XMM0,qword ptr [RDI + 0xd8]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
LEA R12,[RSP + 0x80]
MOV qword ptr [R12 + -0x10],R12
MOV RSI,qword ptr [RDI + 0x48]
MOV RDX,qword ptr [RDI + 0x50]
ADD RDX,RSI
LEA R15,[RSP + 0x70]
MOV RDI,R15
CALL 0x0011d410
LAB_00157e7b:
LEA RCX,[0x1a3ff0]
MOV R8D,0x1
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0010f4e0
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00157eba
MOV qword ptr [RSP],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x10],RDX
JMP 0x00157ec2
LAB_00157eba:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_00157ec2:
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RSP
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_00157edc:
LEA RSI,[0x1a5fa8]
CALL 0x0010f830
LEA R15,[RSP + 0x40]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00157f0f
MOV qword ptr [RSP + 0x30],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x40],RDX
JMP 0x00157f16
LAB_00157f0f:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_00157f16:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00157f44
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0010f470
LAB_00157f44:
MOV RDI,qword ptr [RSP + 0x70]
CMP RDI,R12
JZ 0x00157f5e
MOV RSI,qword ptr [RSP + 0x80]
INC RSI
CALL 0x0010f470
LAB_00157f5e:
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI + -0x10],R14
MOVAPS XMM0,xmmword ptr [RSP + 0x90]
MOVLPS qword ptr [RDI + -0x8],XMM0
LEA R14,[RSP + 0x20]
MOV qword ptr [R14 + -0x10],R14
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
ADD RDX,RSI
LAB_00157f89:
CALL 0x0011d410
LAB_00157f8e:
LEA RDI,[RSP + 0x50]
MOV RSI,RSP
CALL 0x00158a20
LEA RDI,[RBX + 0x8]
LAB_00157f9f:
LEA RSI,[RSP + 0x50]
CALL 0x00158a7e
MOV RAX,qword ptr [RSP + 0x60]
TEST RAX,RAX
JZ 0x00157fc2
LAB_00157fb3:
LEA RDI,[RSP + 0x50]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00157fc2:
MOV RDI,qword ptr [RSP + 0x10]
CMP RDI,R14
JZ 0x00157fd9
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0010f470
LAB_00157fd9:
MOV RDI,qword ptr [RSP + 0x30]
CMP RDI,R15
JZ 0x00157ff0
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x0010f470
LAB_00157ff0:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* cli::hex& cli::hex::set<unsigned int>(unsigned int&) */
hex * __thiscall cli::hex::set<unsigned_int>(hex *this,uint *param_1)
{
long *plVar1;
long **pplVar2;
long *plVar3;
int8 **local_c8;
long local_c0;
long *local_b8;
long lStack_b0;
long local_a8 [2];
long *local_98;
long local_90;
long local_88;
long lStack_80;
uint local_78 [4];
code *local_68;
long *local_58 [2];
long local_48 [2];
int8 local_38;
int8 uStack_30;
local_38 = *(int8 *)(this + 0xd8);
uStack_30 = 0;
local_58[0] = local_48;
std::__cxx11::string::_M_construct<char*>
(local_58,*(long *)(this + 0x48),*(long *)(this + 0x50) + *(long *)(this + 0x48));
/* try { // try from 00157e7b to 00157e93 has its CatchHandler @ 00158077 */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_58,0,(char *)0x0,0x1a3ff0);
pplVar2 = (long **)(plVar1 + 2);
if ((long **)*plVar1 == pplVar2) {
local_b8 = *pplVar2;
lStack_b0 = plVar1[3];
local_c8 = &local_b8;
}
else {
local_b8 = *pplVar2;
local_c8 = (long **)*plVar1;
}
local_c0 = plVar1[1];
*plVar1 = (long)pplVar2;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 00157edc to 00157ee7 has its CatchHandler @ 0015805c */
plVar1 = (long *)std::__cxx11::string::append((char *)&local_c8);
plVar3 = plVar1 + 2;
if ((long *)*plVar1 == plVar3) {
local_88 = *plVar3;
lStack_80 = plVar1[3];
local_98 = &local_88;
}
else {
local_88 = *plVar3;
local_98 = (long *)*plVar1;
}
local_90 = plVar1[1];
*plVar1 = (long)plVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
if (local_c8 != &local_b8) {
operator_delete(local_c8,(long)local_b8 + 1);
}
if (local_58[0] != local_48) {
operator_delete(local_58[0],local_48[0] + 1);
}
local_c0 = local_38;
local_c8 = (int8 **)param_1;
local_b8 = local_a8;
/* try { // try from 00157f89 to 00157f8d has its CatchHandler @ 00158048 */
std::__cxx11::string::_M_construct<char*>(&local_b8,local_98,local_90 + (long)local_98);
/* try { // try from 00157f8e to 00157f9a has its CatchHandler @ 0015802c */
std::function<std::__cxx11::string(std::__cxx11::string_const&)>::
function<cli::hex::set<unsigned_int>(unsigned_int&)::_lambda(std::__cxx11::string)_1_,void>
(local_78);
/* try { // try from 00157f9f to 00157fa8 has its CatchHandler @ 00158006 */
std::function<std::__cxx11::string(std::__cxx11::string)>::operator=
((function<std::__cxx11::string(std::__cxx11::string)> *)(this + 8),(function *)local_78
);
if (local_68 != (code *)0x0) {
/* try { // try from 00157fb3 to 00157fc1 has its CatchHandler @ 00158004 */
(*local_68)(local_78,local_78,3);
}
if (local_b8 != local_a8) {
operator_delete(local_b8,local_a8[0] + 1);
}
if (local_98 != &local_88) {
operator_delete(local_98,local_88 + 1);
}
return this;
}
|
|
64,082 |
my_strxfrm_flag_normalize
|
eloqsql/strings/ctype-simple.c
|
uint my_strxfrm_flag_normalize(uint flags, uint maximum)
{
DBUG_ASSERT(maximum >= 1 && maximum <= MY_STRXFRM_NLEVELS);
/* If levels are omitted, then 1-maximum is assumed*/
if (!(flags & MY_STRXFRM_LEVEL_ALL))
{
static uint def_level_flags[]= {0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F };
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
flags= def_level_flags[maximum] | flag_pad;
}
else
{
uint i;
uint flag_lev= flags & MY_STRXFRM_LEVEL_ALL;
uint flag_dsc= (flags >> MY_STRXFRM_DESC_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_rev= (flags >> MY_STRXFRM_REVERSE_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
/*
If any level number is greater than the maximum,
it is treated as the maximum.
*/
for (maximum--, flags= 0, i= 0; i < MY_STRXFRM_NLEVELS; i++)
{
uint src_bit= 1 << i;
if (flag_lev & src_bit)
{
uint dst_bit= 1 << MY_MIN(i, maximum);
flags|= dst_bit;
flags|= (flag_dsc & dst_bit) << MY_STRXFRM_DESC_SHIFT;
flags|= (flag_rev & dst_bit) << MY_STRXFRM_REVERSE_SHIFT;
}
}
flags|= flag_pad;
}
return flags;
}
|
O3
|
c
|
my_strxfrm_flag_normalize:
movl %edi, %eax
movl %edi, %edx
andl $0x3f, %edx
je 0x59400
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
decl %esi
movl %eax, %r8d
andl $0x3f00, %r8d # imm = 0x3F00
movl %eax, %r9d
andl $0x3f0000, %r9d # imm = 0x3F0000
xorl %edi, %edi
xorl %r10d, %r10d
btl %r10d, %edx
jae 0x593eb
cmpl %esi, %r10d
movl %esi, %ecx
cmovbl %r10d, %ecx
movl $0x1, %r11d
shll %cl, %r11d
movl $0x100, %ebx # imm = 0x100
shll %cl, %ebx
andl %r8d, %ebx
movl $0x10000, %r14d # imm = 0x10000
shll %cl, %r14d
addl %r11d, %ebx
andl %r9d, %r14d
addl %ebx, %r14d
orl %r14d, %edi
incl %r10d
cmpl $0x6, %r10d
jne 0x593b4
andl $0xc0, %eax
orl %edi, %eax
popq %rbx
popq %r14
popq %rbp
retq
andl $0xc0, %eax
movl %esi, %ecx
leaq 0x16a252(%rip), %rdx # 0x1c3660
orl (%rdx,%rcx,4), %eax
retq
|
my_strxfrm_flag_normalize:
mov eax, edi
mov edx, edi
and edx, 3Fh
jz short loc_59400
push rbp
mov rbp, rsp
push r14
push rbx
dec esi
mov r8d, eax
and r8d, 3F00h
mov r9d, eax
and r9d, 3F0000h
xor edi, edi
xor r10d, r10d
loc_593B4:
bt edx, r10d
jnb short loc_593EB
cmp r10d, esi
mov ecx, esi
cmovb ecx, r10d
mov r11d, 1
shl r11d, cl
mov ebx, 100h
shl ebx, cl
and ebx, r8d
mov r14d, 10000h
shl r14d, cl
add ebx, r11d
and r14d, r9d
add r14d, ebx
or edi, r14d
loc_593EB:
inc r10d
cmp r10d, 6
jnz short loc_593B4
and eax, 0C0h
or eax, edi
pop rbx
pop r14
pop rbp
retn
loc_59400:
and eax, 0C0h
mov ecx, esi
lea rdx, my_strxfrm_flag_normalize_def_level_flags
or eax, [rdx+rcx*4]
retn
|
long long my_strxfrm_flag_normalize(int a1, int a2)
{
int v3; // edx
unsigned int v4; // esi
int v5; // r8d
int v6; // edi
unsigned int i; // r10d
char v8; // cl
v3 = a1 & 0x3F;
if ( (a1 & 0x3F) == 0 )
return my_strxfrm_flag_normalize_def_level_flags[a2] | a1 & 0xC0u;
v4 = a2 - 1;
v5 = a1 & 0x3F00;
v6 = 0;
for ( i = 0; i != 6; ++i )
{
if ( _bittest(&v3, i) )
{
v8 = v4;
if ( i < v4 )
v8 = i;
v6 |= (1 << v8) + (v5 & (256 << v8)) + (a1 & 0x3F0000 & (0x10000 << v8));
}
}
return v6 | a1 & 0xC0u;
}
|
my_strxfrm_flag_normalize:
MOV EAX,EDI
MOV EDX,EDI
AND EDX,0x3f
JZ 0x00159400
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
DEC ESI
MOV R8D,EAX
AND R8D,0x3f00
MOV R9D,EAX
AND R9D,0x3f0000
XOR EDI,EDI
XOR R10D,R10D
LAB_001593b4:
BT EDX,R10D
JNC 0x001593eb
CMP R10D,ESI
MOV ECX,ESI
CMOVC ECX,R10D
MOV R11D,0x1
SHL R11D,CL
MOV EBX,0x100
SHL EBX,CL
AND EBX,R8D
MOV R14D,0x10000
SHL R14D,CL
ADD EBX,R11D
AND R14D,R9D
ADD R14D,EBX
OR EDI,R14D
LAB_001593eb:
INC R10D
CMP R10D,0x6
JNZ 0x001593b4
AND EAX,0xc0
OR EAX,EDI
POP RBX
POP R14
POP RBP
RET
LAB_00159400:
AND EAX,0xc0
MOV ECX,ESI
LEA RDX,[0x2c3660]
OR EAX,dword ptr [RDX + RCX*0x4]
RET
|
uint my_strxfrm_flag_normalize(uint param_1,uint param_2)
{
uint uVar1;
byte bVar2;
uint uVar3;
uint uVar4;
if ((param_1 & 0x3f) != 0) {
uVar3 = 0;
uVar4 = 0;
do {
if (((param_1 & 0x3f) >> (uVar4 & 0x1f) & 1) != 0) {
uVar1 = param_2 - 1;
if (uVar4 < param_2 - 1) {
uVar1 = uVar4;
}
bVar2 = (byte)uVar1;
uVar3 = uVar3 | (0x10000 << (bVar2 & 0x1f) & param_1 & 0x3f0000) +
(0x100 << (bVar2 & 0x1f) & param_1 & 0x3f00) + (1 << (bVar2 & 0x1f));
}
uVar4 = uVar4 + 1;
} while (uVar4 != 6);
return param_1 & 0xc0 | uVar3;
}
return param_1 & 0xc0 | *(uint *)(my_strxfrm_flag_normalize_def_level_flags + (ulong)param_2 * 4);
}
|
|
64,083 |
mysql_load_plugin_v
|
eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c
|
struct st_mysql_client_plugin * STDCALL
mysql_load_plugin_v(MYSQL *mysql, const char *name, int type,
int argc, va_list args)
{
const char *errmsg;
#ifdef _WIN32
char errbuf[1024];
#endif
char dlpath[FN_REFLEN+1];
void *sym, *dlhandle = NULL;
struct st_mysql_client_plugin *plugin;
char *env_plugin_dir= getenv("MARIADB_PLUGIN_DIR");
CLEAR_CLIENT_ERROR(mysql);
if (is_not_initialized(mysql, name))
return NULL;
pthread_mutex_lock(&LOCK_load_client_plugin);
/* make sure the plugin wasn't loaded meanwhile */
if (type >= 0 && find_plugin(name, type))
{
errmsg= "it is already loaded";
goto err;
}
/* Compile dll path */
#ifndef WIN32
snprintf(dlpath, sizeof(dlpath) - 1, "%s/%s%s",
mysql->options.extension && mysql->options.extension->plugin_dir ?
mysql->options.extension->plugin_dir : (env_plugin_dir) ? env_plugin_dir :
MARIADB_PLUGINDIR, name, SO_EXT);
#else
{
char *p= (mysql->options.extension && mysql->options.extension->plugin_dir) ?
mysql->options.extension->plugin_dir : env_plugin_dir;
snprintf(dlpath, sizeof(dlpath), "%s%s%s%s", p ? p : "", p ? "\\" : "", name, SO_EXT);
}
#endif
if (strpbrk(name, "()[]!@#$%^&/*;.,'?\\"))
{
errmsg= "invalid plugin name";
goto err;
}
/* Open new dll handle */
if (!(dlhandle= dlopen((const char *)dlpath, RTLD_NOW)))
{
#ifdef _WIN32
char winmsg[255];
size_t len;
winmsg[0] = 0;
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
winmsg, 255, NULL);
len= strlen(winmsg);
while (len > 0 && (winmsg[len - 1] == '\n' || winmsg[len - 1] == '\r'))
len--;
if (len)
winmsg[len] = 0;
snprintf(errbuf, sizeof(errbuf), "%s Library path is '%s'", winmsg, dlpath);
errmsg= errbuf;
#else
errmsg= dlerror();
#endif
goto err;
}
if (!(sym= dlsym(dlhandle, plugin_declarations_sym)))
{
errmsg= "not a plugin";
(void)dlclose(dlhandle);
goto err;
}
plugin= (struct st_mysql_client_plugin*)sym;
if (type >=0 && type != plugin->type)
{
errmsg= "type mismatch";
goto err;
}
if (strcmp(name, plugin->name))
{
errmsg= "name mismatch";
goto err;
}
if (type < 0 && find_plugin(name, plugin->type))
{
errmsg= "it is already loaded";
goto err;
}
plugin= add_plugin(mysql, plugin, dlhandle, argc, args);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return plugin;
err:
if (dlhandle)
dlclose(dlhandle);
pthread_mutex_unlock(&LOCK_load_client_plugin);
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, errmsg);
return NULL;
}
|
O3
|
c
|
mysql_load_plugin_v:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %r8, -0x258(%rbp)
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0xf857(%rip), %rdi # 0x3c129
callq 0x13590
movq %rax, %r15
movl $0x0, 0x90(%r14)
movl $0x30303030, 0x297(%r14) # imm = 0x30303030
movw $0x30, 0x29b(%r14)
movb $0x0, 0x97(%r14)
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x2c915
movl $0x0, 0x4(%rax)
cmpb $0x0, 0x26304(%rip) # 0x52c20
je 0x2c94b
leaq 0x26303(%rip), %rdi # 0x52c28
callq 0x136a0
testl %r13d, %r13d
js 0x2c97d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2c827
testq %rax, %rax
je 0x2c97d
leaq 0xf7f6(%rip), %r15 # 0x3c13c
jmp 0x2ca87
leaq 0x2458e(%rip), %rax # 0x50ee0
movq (%rax), %rdx
leaq 0x24594(%rip), %rax # 0x50ef0
movq 0x1d8(%rax), %rcx
leaq 0xf8f0(%rip), %r9 # 0x3c25a
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
jmp 0x2cabc
movq 0x480(%r14), %rax
testq %rax, %rax
je 0x2c991
movq (%rax), %r9
testq %r9, %r9
jne 0x2c99f
testq %r15, %r15
leaq 0xf7be(%rip), %r9 # 0x3c159
cmovneq %r15, %r9
leaq 0xf7d1(%rip), %r10 # 0x3c177
leaq 0xf7a4(%rip), %r8 # 0x3c151
leaq -0x240(%rbp), %rdi
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movl $0x1, %edx
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0x132c0
addq $0x10, %rsp
leaq 0xf7a3(%rip), %rsi # 0x3c17b
movq %rbx, %rdi
callq 0x137a0
testq %rax, %rax
je 0x2c9f1
leaq 0xf7a3(%rip), %r15 # 0x3c18f
jmp 0x2ca87
leaq -0x240(%rbp), %rdi
movl $0x2, %esi
callq 0x13630
testq %rax, %rax
je 0x2ca56
movl %r12d, -0x24c(%rbp)
leaq 0xf78e(%rip), %rsi # 0x3c1a3
movq %rax, %r12
movq %rax, %rdi
callq 0x13410
testq %rax, %rax
je 0x2ca60
movq %rax, %r15
movq %r12, -0x248(%rbp)
testl %r13d, %r13d
js 0x2ca39
cmpl %r13d, (%r15)
jne 0x2ca71
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x13640
testl %eax, %eax
je 0x2cae7
leaq 0xf78c(%rip), %r15 # 0x3c1e0
jmp 0x2ca78
callq 0x13420
movq %rax, %r15
jmp 0x2ca87
movq %r12, %rdi
callq 0x13360
leaq 0xf756(%rip), %r15 # 0x3c1c5
jmp 0x2ca7f
leaq 0xf75a(%rip), %r15 # 0x3c1d2
movq -0x248(%rbp), %r12
movq %r12, %rdi
callq 0x13360
leaq 0x2619a(%rip), %rdi # 0x52c28
callq 0x13330
leaq 0x24446(%rip), %rax # 0x50ee0
movq (%rax), %rdx
leaq 0x2444c(%rip), %rax # 0x50ef0
movq 0x1d8(%rax), %rcx
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x1a8dd
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2cb38
movq %r12, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r13d, %r13d
js 0x2cb1c
movq %r14, %rdi
movq %r15, %rsi
movq -0x248(%rbp), %rdx
movl -0x24c(%rbp), %ecx
movq -0x258(%rbp), %r8
callq 0x2c598
movq %rax, %r12
leaq 0x26113(%rip), %rdi # 0x52c28
callq 0x13330
jmp 0x2cac3
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2c827
testq %rax, %rax
je 0x2caec
leaq 0xf609(%rip), %r15 # 0x3c13c
jmp 0x2ca78
callq 0x13500
|
mysql_load_plugin_v:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 238h
mov [rbp+var_258], r8
mov r12d, ecx
mov r13d, edx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rdi, aMariadbPluginD; "MARIADB_PLUGIN_DIR"
call _getenv
mov r15, rax
mov dword ptr [r14+90h], 0
mov dword ptr [r14+297h], 30303030h
mov word ptr [r14+29Bh], 30h ; '0'
mov byte ptr [r14+97h], 0
mov rax, [r14+2A0h]
test rax, rax
jz short loc_2C915
mov dword ptr [rax+4], 0
loc_2C915:
cmp cs:initialized, 0
jz short loc_2C94B
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_lock
test r13d, r13d
js short loc_2C97D
mov rdi, rbx
mov esi, r13d
call find_plugin
test rax, rax
jz short loc_2C97D
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_2CA87
loc_2C94B:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aNotInitialized; "not initialized"
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
jmp loc_2CABC
loc_2C97D:
mov rax, [r14+480h]
test rax, rax
jz short loc_2C991
mov r9, [rax]
test r9, r9
jnz short loc_2C99F
loc_2C991:
test r15, r15
lea r9, aHomeMonoInstal; "/home/mono/install/lib/plugin"
cmovnz r9, r15
loc_2C99F:
lea r10, aSo; ".so"
lea r8, aSSS; "%s/%s%s"
lea rdi, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov edx, 1
xor eax, eax
push r10
push rbx
call ___snprintf_chk
add rsp, 10h
lea rsi, asc_3C17B; "()[]!@#$%^&/*;.,'?\\"
mov rdi, rbx
call _strpbrk
test rax, rax
jz short loc_2C9F1
lea r15, aInvalidPluginN; "invalid plugin name"
jmp loc_2CA87
loc_2C9F1:
lea rdi, [rbp+var_240]
mov esi, 2
call _dlopen
test rax, rax
jz short loc_2CA56
mov [rbp+var_24C], r12d
lea rsi, aMysqlClientPlu; "_mysql_client_plugin_declaration_"
mov r12, rax
mov rdi, rax
call _dlsym
test rax, rax
jz short loc_2CA60
mov r15, rax
mov [rbp+var_248], r12
test r13d, r13d
js short loc_2CA39
cmp [r15], r13d
jnz short loc_2CA71
loc_2CA39:
mov rsi, [r15+8]
mov rdi, rbx
call _strcmp
test eax, eax
jz loc_2CAE7
lea r15, aNameMismatch; "name mismatch"
jmp short loc_2CA78
loc_2CA56:
call _dlerror
mov r15, rax
jmp short loc_2CA87
loc_2CA60:
mov rdi, r12
call _dlclose
lea r15, aNotAPlugin; "not a plugin"
jmp short loc_2CA7F
loc_2CA71:
lea r15, aTypeMismatch; "type mismatch"
loc_2CA78:
mov r12, [rbp+var_248]
loc_2CA7F:
mov rdi, r12
call _dlclose
loc_2CA87:
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
mov r9, r15
loc_2CABC:
xor eax, eax
call my_set_error
loc_2CAC3:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2CB38
mov rax, r12
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2CAE7:
test r13d, r13d
js short loc_2CB1C
loc_2CAEC:
mov rdi, r14
mov rsi, r15
mov rdx, [rbp+var_248]
mov ecx, [rbp+var_24C]
mov r8, [rbp+var_258]
call add_plugin
mov r12, rax
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_unlock
jmp short loc_2CAC3
loc_2CB1C:
mov esi, [r15]
mov rdi, rbx
call find_plugin
test rax, rax
jz short loc_2CAEC
lea r15, aItIsAlreadyLoa; "it is already loaded"
jmp loc_2CA78
loc_2CB38:
call ___stack_chk_fail
|
long long mysql_load_plugin_v(long long a1, const char *a2, int a3, unsigned int a4, long long a5)
{
long long v7; // r15
long long v8; // rax
const char *v9; // r15
long long v10; // r12
const char **v11; // rax
const char *v12; // r9
double v13; // xmm0_8
long long v14; // rax
long long v15; // r12
long long v16; // rax
int *v17; // r15
unsigned int v20; // [rsp+14h] [rbp-24Ch]
_BYTE v21[528]; // [rsp+20h] [rbp-240h] BYREF
unsigned long long v22; // [rsp+230h] [rbp-30h]
v22 = __readfsqword(0x28u);
v7 = getenv("MARIADB_PLUGIN_DIR");
*(_DWORD *)(a1 + 144) = 0;
strcpy((char *)(a1 + 663), "00000");
*(_BYTE *)(a1 + 151) = 0;
v8 = *(_QWORD *)(a1 + 672);
if ( v8 )
*(_DWORD *)(v8 + 4) = 0;
if ( initialized )
{
pthread_mutex_lock(&LOCK_load_client_plugin);
if ( a3 >= 0 && find_plugin((long long)a2, a3) )
{
v9 = "it is already loaded";
}
else
{
v11 = *(const char ***)(a1 + 1152);
if ( !v11 || (v12 = *v11) == 0LL )
{
v12 = "/home/mono/install/lib/plugin";
if ( v7 )
v12 = (const char *)v7;
}
v13 = __snprintf_chk(v21, 512LL, 1LL, 513LL, "%s/%s%s", v12, a2, ".so");
if ( strpbrk(a2, "()[]!@#$%^&/*;.,'?\\", v13) )
{
v9 = "invalid plugin name";
}
else
{
v14 = dlopen(v21, 2LL);
if ( v14 )
{
v20 = a4;
v15 = v14;
v16 = dlsym(v14, "_mysql_client_plugin_declaration_");
if ( v16 )
{
v17 = (int *)v16;
if ( a3 < 0 || *(_DWORD *)v16 == a3 )
{
if ( !(unsigned int)strcmp(a2, *(_QWORD *)(v16 + 8)) )
{
if ( a3 >= 0 || !find_plugin((long long)a2, *v17) )
{
v10 = add_plugin(a1, (long long)v17, v15, v20, a5);
pthread_mutex_unlock(&LOCK_load_client_plugin);
return v10;
}
v9 = "it is already loaded";
}
else
{
v9 = "name mismatch";
}
}
else
{
v9 = "type mismatch";
}
}
else
{
dlclose(v15);
v9 = "not a plugin";
}
dlclose(v15);
}
else
{
v9 = (const char *)dlerror();
}
}
}
pthread_mutex_unlock(&LOCK_load_client_plugin);
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, v9);
}
else
{
v10 = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "not initialized");
}
return v10;
}
|
mysql_load_plugin_v:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x258],R8
MOV R12D,ECX
MOV R13D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x13c129]
CALL 0x00113590
MOV R15,RAX
MOV dword ptr [R14 + 0x90],0x0
MOV dword ptr [R14 + 0x297],0x30303030
MOV word ptr [R14 + 0x29b],0x30
MOV byte ptr [R14 + 0x97],0x0
MOV RAX,qword ptr [R14 + 0x2a0]
TEST RAX,RAX
JZ 0x0012c915
MOV dword ptr [RAX + 0x4],0x0
LAB_0012c915:
CMP byte ptr [0x00152c20],0x0
JZ 0x0012c94b
LEA RDI,[0x152c28]
CALL 0x001136a0
TEST R13D,R13D
JS 0x0012c97d
MOV RDI,RBX
MOV ESI,R13D
CALL 0x0012c827
TEST RAX,RAX
JZ 0x0012c97d
LEA R15,[0x13c13c]
JMP 0x0012ca87
LAB_0012c94b:
LEA RAX,[0x150ee0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x150ef0]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x13c25a]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
JMP 0x0012cabc
LAB_0012c97d:
MOV RAX,qword ptr [R14 + 0x480]
TEST RAX,RAX
JZ 0x0012c991
MOV R9,qword ptr [RAX]
TEST R9,R9
JNZ 0x0012c99f
LAB_0012c991:
TEST R15,R15
LEA R9,[0x13c159]
CMOVNZ R9,R15
LAB_0012c99f:
LEA R10,[0x13c177]
LEA R8,[0x13c151]
LEA RDI,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV EDX,0x1
XOR EAX,EAX
PUSH R10
PUSH RBX
CALL 0x001132c0
ADD RSP,0x10
LEA RSI,[0x13c17b]
MOV RDI,RBX
CALL 0x001137a0
TEST RAX,RAX
JZ 0x0012c9f1
LEA R15,[0x13c18f]
JMP 0x0012ca87
LAB_0012c9f1:
LEA RDI,[RBP + -0x240]
MOV ESI,0x2
CALL 0x00113630
TEST RAX,RAX
JZ 0x0012ca56
MOV dword ptr [RBP + -0x24c],R12D
LEA RSI,[0x13c1a3]
MOV R12,RAX
MOV RDI,RAX
CALL 0x00113410
TEST RAX,RAX
JZ 0x0012ca60
MOV R15,RAX
MOV qword ptr [RBP + -0x248],R12
TEST R13D,R13D
JS 0x0012ca39
CMP dword ptr [R15],R13D
JNZ 0x0012ca71
LAB_0012ca39:
MOV RSI,qword ptr [R15 + 0x8]
MOV RDI,RBX
CALL 0x00113640
TEST EAX,EAX
JZ 0x0012cae7
LEA R15,[0x13c1e0]
JMP 0x0012ca78
LAB_0012ca56:
CALL 0x00113420
MOV R15,RAX
JMP 0x0012ca87
LAB_0012ca60:
MOV RDI,R12
CALL 0x00113360
LEA R15,[0x13c1c5]
JMP 0x0012ca7f
LAB_0012ca71:
LEA R15,[0x13c1d2]
LAB_0012ca78:
MOV R12,qword ptr [RBP + -0x248]
LAB_0012ca7f:
MOV RDI,R12
CALL 0x00113360
LAB_0012ca87:
LEA RDI,[0x152c28]
CALL 0x00113330
LEA RAX,[0x150ee0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x150ef0]
MOV RCX,qword ptr [RAX + 0x1d8]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
MOV R9,R15
LAB_0012cabc:
XOR EAX,EAX
CALL 0x0011a8dd
LAB_0012cac3:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012cb38
MOV RAX,R12
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012cae7:
TEST R13D,R13D
JS 0x0012cb1c
LAB_0012caec:
MOV RDI,R14
MOV RSI,R15
MOV RDX,qword ptr [RBP + -0x248]
MOV ECX,dword ptr [RBP + -0x24c]
MOV R8,qword ptr [RBP + -0x258]
CALL 0x0012c598
MOV R12,RAX
LEA RDI,[0x152c28]
CALL 0x00113330
JMP 0x0012cac3
LAB_0012cb1c:
MOV ESI,dword ptr [R15]
MOV RDI,RBX
CALL 0x0012c827
TEST RAX,RAX
JZ 0x0012caec
LEA R15,[0x13c13c]
JMP 0x0012ca78
LAB_0012cb38:
CALL 0x00113500
|
int8
mysql_load_plugin_v(long param_1,char *param_2,int param_3,int4 param_4,int8 param_5)
{
int iVar1;
char *pcVar2;
long lVar3;
int *piVar4;
int8 uVar5;
long lVar6;
char *pcVar7;
long in_FS_OFFSET;
int1 local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = getenv("MARIADB_PLUGIN_DIR");
*(int4 *)(param_1 + 0x90) = 0;
*(int4 *)(param_1 + 0x297) = 0x30303030;
*(int2 *)(param_1 + 0x29b) = 0x30;
*(int1 *)(param_1 + 0x97) = 0;
if (*(long *)(param_1 + 0x2a0) != 0) {
*(int4 *)(*(long *)(param_1 + 0x2a0) + 4) = 0;
}
if (initialized == '\0') {
pcVar2 = "not initialized";
}
else {
pthread_mutex_lock((pthread_mutex_t *)LOCK_load_client_plugin);
if ((param_3 < 0) || (lVar3 = find_plugin(param_2,param_3), lVar3 == 0)) {
if (((*(long **)(param_1 + 0x480) == (long *)0x0) ||
(pcVar7 = (char *)**(long **)(param_1 + 0x480), pcVar7 == (char *)0x0)) &&
(pcVar7 = "/home/mono/install/lib/plugin", pcVar2 != (char *)0x0)) {
pcVar7 = pcVar2;
}
__snprintf_chk(local_248,0x200,1,0x201,"%s/%s%s",pcVar7,param_2,&DAT_0013c177);
pcVar2 = strpbrk(param_2,"()[]!@#$%^&/*;.,\'?\\");
if (pcVar2 == (char *)0x0) {
lVar3 = dlopen(local_248,2);
if (lVar3 == 0) {
pcVar2 = (char *)dlerror();
}
else {
piVar4 = (int *)dlsym(lVar3,"_mysql_client_plugin_declaration_");
if (piVar4 == (int *)0x0) {
dlclose(lVar3);
pcVar2 = "not a plugin";
}
else if ((param_3 < 0) || (*piVar4 == param_3)) {
iVar1 = strcmp(param_2,*(char **)(piVar4 + 2));
if (iVar1 == 0) {
if ((-1 < param_3) || (lVar6 = find_plugin(param_2,*piVar4), lVar6 == 0)) {
uVar5 = add_plugin(param_1,piVar4,lVar3,param_4,param_5);
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
goto LAB_0012cac3;
}
pcVar2 = "it is already loaded";
}
else {
pcVar2 = "name mismatch";
}
}
else {
pcVar2 = "type mismatch";
}
dlclose(lVar3);
}
}
else {
pcVar2 = "invalid plugin name";
}
}
else {
pcVar2 = "it is already loaded";
}
pthread_mutex_unlock((pthread_mutex_t *)LOCK_load_client_plugin);
}
uVar5 = 0;
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____001510c8,
param_2,pcVar2);
LAB_0012cac3:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar5;
}
|
|
64,084 |
ma_change_bitmap_page
|
eloqsql/storage/maria/ma_bitmap.c
|
static my_bool _ma_change_bitmap_page(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
DBUG_ENTER("_ma_change_bitmap_page");
_ma_check_bitmap(bitmap);
/*
We have to mark the file changed here, as otherwise the following
read/write to pagecache may force a page out from this file, which would
cause _ma_mark_file_changed() to be called with bitmaplock hold!
*/
_ma_bitmap_mark_file_changed(info->s, 1);
if (bitmap->changed)
{
if (write_changed_bitmap(info->s, bitmap))
DBUG_RETURN(1);
bitmap->changed= 0;
}
DBUG_RETURN(_ma_read_bitmap_page(info, bitmap, page));
}
|
O3
|
c
|
ma_change_bitmap_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
cmpb $0x0, 0x7df(%rdi)
jne 0x40bf5
testb $0x1, 0x170(%rdi)
jne 0x40f01
cmpb $0x0, 0x20(%rbx)
je 0x40ce0
movb $0x1, 0x21(%rbx)
cmpl $0x0, 0x38(%rbx)
je 0x40c7b
movq 0x600(%rdi), %rdi
leaq 0x40(%rbx), %rsi
movq 0x8(%rbx), %r8
movq 0x10(%rbx), %rdx
movl 0x80(%rdi), %eax
subq $0x8, %rsp
movq %r15, -0x48(%rbp)
movq %r14, %r15
xorl %r14d, %r14d
leaq -0x90(%rbp), %r12
xorl %ecx, %ecx
movl $0x1, %r9d
pushq %rax
pushq %r14
pushq $0x0
pushq %r12
pushq %r14
pushq $0x2
pushq %r14
callq 0x335ee
addq $0x40, %rsp
movl %eax, %r13d
movl %r14d, 0x8(%r12)
movq %r15, %r14
movq -0x48(%rbp), %r15
movb $0x1, 0x10(%r12)
leaq 0x140(%rbx), %rdi
movq %r12, %rsi
callq 0x91716
jmp 0x40ccd
movq 0x600(%rdi), %rdi
leaq 0x40(%rbx), %rsi
movq 0x8(%rbx), %r8
movq 0x10(%rbx), %rdx
movl 0x80(%rdi), %eax
subq $0x40, %rsp
movl %eax, 0x30(%rsp)
xorl %eax, %eax
movl %eax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %eax, 0x10(%rsp)
movl %eax, (%rsp)
movl $0x1, 0x8(%rsp)
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x335ee
addq $0x40, %rsp
movl %eax, %r13d
movb $0x1, %r12b
testb %r13b, %r13b
jne 0x40ee0
movb $0x0, 0x20(%rbx)
movq (%r14), %rdi
movq %r15, 0x10(%rbx)
leaq 0x1(%r15), %rsi
movl 0x134(%rbx), %ecx
movq %rsi, %rax
imulq %rcx, %rax
movq (%r14), %r13
cmpq 0x40(%rdi), %rax
jbe 0x40e49
movq 0x40(%r13), %rax
movb $0x1, %r12b
cmpq %rcx, %rax
jb 0x40ee0
movq %rcx, %rdx
imulq %r15, %rdx
cmpq 0x368(%r13), %rdx
jae 0x40ed5
movq %rsi, -0x50(%rbp)
xorl %edx, %edx
divq %rcx
decq %rax
movq 0x138(%rbx), %rsi
xorl %edx, %edx
divq %rsi
incq %rax
imulq %rsi, %rax
cmpb $0x0, 0x7e7(%r13)
movq %rax, -0x48(%rbp)
je 0x40dc8
leaq -0x3c(%rbp), %r11
movl %eax, 0x2(%r11)
movq %rax, %rcx
shrq $0x20, %rcx
movb %cl, 0x6(%r11)
movl %r15d, 0x7(%r11)
movq %r15, %rcx
shrq $0x20, %rcx
movb %cl, 0xb(%r11)
leaq -0x90(%rbp), %r10
movq %r11, 0x20(%r10)
movq $0xc, 0x28(%r10)
subq $0x8, %rsp
leaq 0x3bc24d(%rip), %rdx # 0x3fcfe0
leaq -0x58(%rbp), %rdi
movl $0x28, %esi
movq %r14, %rcx
movl $0xc, %r8d
movl $0x3, %r9d
pushq $0x0
pushq %r11
pushq %r10
callq 0x2a8ac
addq $0x20, %rsp
testb %al, %al
jne 0x40ee0
movl 0x134(%rbx), %ecx
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x292c0
movq -0x48(%rbp), %rdx
movl $0x0, 0x2c(%rbx)
movq $0x0, 0x24(%rbx)
movb $0x1, 0x20(%rbx)
movq %r15, %rcx
subq 0x138(%rbx), %rcx
cmpq %rcx, %rdx
ja 0x40e13
movq 0x8(%rbx), %r8
movq %r13, %rdi
movq %rbx, %rsi
callq 0x41b8a
testb %al, %al
jne 0x40ee0
movl 0x134(%rbx), %eax
movq -0x50(%rbp), %rcx
imulq %rax, %rcx
movq %rcx, 0x40(%r13)
movq (%r14), %rax
xorl %ecx, %ecx
cmpq %r15, 0xa28(%rax)
setbe %cl
movl 0xb3c(%rax,%rcx,4), %ecx
movl %ecx, 0xb38(%rax)
xorl %r12d, %r12d
jmp 0x40ee0
xorl %eax, %eax
cmpq %r15, 0xa28(%r13)
setbe %al
movl 0xb3c(%r13,%rax,4), %eax
movl %eax, 0xb38(%r13)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq 0x600(%rdi), %rdi
leaq 0x40(%rbx), %rsi
movq 0x8(%rbx), %r8
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
pushq %rax
pushq $0x0
callq 0x3218a
addq $0x10, %rsp
testq %rax, %rax
sete %r12b
je 0x40ec1
movq 0x8(%rbx), %rax
movl 0x128(%rbx), %esi
leaq -0x1(%rax), %rcx
movq %rsi, %rdx
leaq (%rcx,%rsi), %rdi
cmpq %rax, %rdi
jb 0x40ebc
leaq -0x1(%rdx), %rsi
cmpb $0x0, (%rdi)
je 0x40ea7
movl %edx, 0x24(%rbx)
jmp 0x40ee0
callq 0xa1672
movl (%rax), %esi
movq %r14, %rdi
callq 0x3659c
movb $0x1, %r12b
jmp 0x40ee0
callq 0xa1672
movl $0x87, (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x40f1c
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x90(%rbp), %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x29d22
movq (%r12), %rdi
jmp 0x40bf5
callq 0x29270
|
_ma_change_bitmap_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rdi, [rdi]
cmp byte ptr [rdi+7DFh], 0
jnz short loc_40BF5
test byte ptr [rdi+170h], 1
jnz loc_40F01
loc_40BF5:
cmp byte ptr [rbx+20h], 0
jz loc_40CE0
mov byte ptr [rbx+21h], 1
cmp dword ptr [rbx+38h], 0
jz short loc_40C7B
mov rdi, [rdi+600h]
lea rsi, [rbx+40h]
mov r8, [rbx+8]
mov rdx, [rbx+10h]
mov eax, [rdi+80h]
sub rsp, 8
mov [rbp+var_48], r15
mov r15, r14
xor r14d, r14d
lea r12, [rbp+var_90]
xor ecx, ecx
mov r9d, 1
push rax
push r14
push 0
push r12
push r14
push 2
push r14
call pagecache_write_part
add rsp, 40h
mov r13d, eax
mov [r12+8], r14d
mov r14, r15
mov r15, [rbp+var_48]
mov byte ptr [r12+10h], 1
lea rdi, [rbx+140h]
mov rsi, r12
call insert_dynamic
jmp short loc_40CCD
loc_40C7B:
mov rdi, [rdi+600h]
lea rsi, [rbx+40h]
mov r8, [rbx+8]
mov rdx, [rbx+10h]
mov eax, [rdi+80h]
sub rsp, 40h
mov [rsp+0D0h+var_A0], eax
xor eax, eax
mov [rsp+0D0h+var_A8], eax
xorps xmm0, xmm0
movups [rsp+0D0h+var_B8], xmm0
mov [rsp+0D0h+var_C0], eax
mov [rsp+0D0h+var_D0], eax
mov [rsp+0D0h+var_C8], 1
xor ecx, ecx
mov r9d, 1
call pagecache_write_part
add rsp, 40h
mov r13d, eax
loc_40CCD:
mov r12b, 1
test r13b, r13b
jnz loc_40EE0
mov byte ptr [rbx+20h], 0
mov rdi, [r14]
loc_40CE0:
mov [rbx+10h], r15
lea rsi, [r15+1]
mov ecx, [rbx+134h]
mov rax, rsi
imul rax, rcx
mov r13, [r14]
cmp rax, [rdi+40h]
jbe loc_40E49
mov rax, [r13+40h]
mov r12b, 1
cmp rax, rcx
jb loc_40EE0
mov rdx, rcx
imul rdx, r15
cmp rdx, [r13+368h]
jnb loc_40ED5
mov [rbp+var_50], rsi
xor edx, edx
div rcx
dec rax
mov rsi, [rbx+138h]
xor edx, edx
div rsi
inc rax
imul rax, rsi
cmp byte ptr [r13+7E7h], 0
mov [rbp+var_48], rax
jz short loc_40DC8
lea r11, [rbp+var_3C]
mov [r11+2], eax
mov rcx, rax
shr rcx, 20h
mov [r11+6], cl
mov [r11+7], r15d
mov rcx, r15
shr rcx, 20h
mov [r11+0Bh], cl
lea r10, [rbp+var_90]
mov [r10+20h], r11
mov qword ptr [r10+28h], 0Ch
sub rsp, 8
lea rdx, dummy_transaction_object
lea rdi, [rbp+var_58]
mov esi, 28h ; '('
mov rcx, r14
mov r8d, 0Ch
mov r9d, 3
push 0
push r11
push r10
call translog_write_record
add rsp, 20h
test al, al
jnz loc_40EE0
mov ecx, [rbx+134h]
loc_40DC8:
mov rdi, [rbx+8]
xor esi, esi
mov rdx, rcx
call _memset
mov rdx, [rbp+var_48]
mov dword ptr [rbx+2Ch], 0
mov qword ptr [rbx+24h], 0
mov byte ptr [rbx+20h], 1
mov rcx, r15
sub rcx, [rbx+138h]
cmp rdx, rcx
ja short loc_40E13
mov r8, [rbx+8]
mov rdi, r13
mov rsi, rbx
call _ma_bitmap_create_missing_into_pagecache
test al, al
jnz loc_40EE0
loc_40E13:
mov eax, [rbx+134h]
mov rcx, [rbp+var_50]
imul rcx, rax
mov [r13+40h], rcx
mov rax, [r14]
xor ecx, ecx
cmp [rax+0A28h], r15
setbe cl
mov ecx, [rax+rcx*4+0B3Ch]
mov [rax+0B38h], ecx
xor r12d, r12d
jmp loc_40EE0
loc_40E49:
xor eax, eax
cmp [r13+0A28h], r15
setbe al
mov eax, [r13+rax*4+0B3Ch]
mov [r13+0B38h], eax
xor eax, eax
mov [rbx+28h], rax
mov rdi, [rdi+600h]
lea rsi, [rbx+40h]
mov r8, [rbx+8]
mov rdx, r15
xor ecx, ecx
mov r9d, 1
push rax
push 0
call pagecache_read
add rsp, 10h
test rax, rax
setz r12b
jz short loc_40EC1
mov rax, [rbx+8]
mov esi, [rbx+128h]
lea rcx, [rax-1]
loc_40EA7:
mov rdx, rsi
lea rdi, [rcx+rsi]
cmp rdi, rax
jb short loc_40EBC
lea rsi, [rdx-1]
cmp byte ptr [rdi], 0
jz short loc_40EA7
loc_40EBC:
mov [rbx+24h], edx
jmp short loc_40EE0
loc_40EC1:
call _my_thread_var
mov esi, [rax]
mov rdi, r14
call _ma_set_fatal_error
mov r12b, 1
jmp short loc_40EE0
loc_40ED5:
call _my_thread_var
mov dword ptr [rax], 87h
loc_40EE0:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_40F1C
mov eax, r12d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40F01:
lea r12, [rbp+var_90]
mov rsi, r14
mov rdx, r12
call _ma_change_bitmap_page_cold_1
mov rdi, [r12]
jmp loc_40BF5
loc_40F1C:
call ___stack_chk_fail
|
long long ma_change_bitmap_page(long long *a1, long long a2, unsigned long long a3, long long a4, long long a5)
{
__int128 *v5; // r12
long long v9; // rdi
__m128i *v10; // rdi
char *v11; // r8
long long v12; // rdx
unsigned __int32 v13; // eax
char v14; // r13
unsigned long long v15; // rcx
long long v16; // r13
unsigned long long v17; // rax
unsigned long long v18; // rax
bool v19; // zf
unsigned long long v20; // rdx
unsigned long long v21; // rcx
long long v22; // rdi
long long v23; // rax
long long v24; // rdx
long long v25; // rcx
long long v26; // r8
unsigned long long v27; // rax
long long v28; // rsi
unsigned long long v29; // rcx
int v30; // edx
_BYTE *v31; // rdi
unsigned int *v32; // rax
long long v33; // rdx
long long v34; // rcx
long long v35; // r8
int v36; // r9d
__int128 v38; // [rsp+40h] [rbp-90h] BYREF
char v39; // [rsp+50h] [rbp-80h]
__int16 *v40; // [rsp+60h] [rbp-70h]
long long v41; // [rsp+68h] [rbp-68h]
char v42[8]; // [rsp+78h] [rbp-58h] BYREF
unsigned long long v43; // [rsp+80h] [rbp-50h]
unsigned long long v44; // [rsp+88h] [rbp-48h]
__int16 v45; // [rsp+94h] [rbp-3Ch] BYREF
int v46; // [rsp+96h] [rbp-3Ah]
char v47; // [rsp+9Ah] [rbp-36h]
int v48; // [rsp+9Bh] [rbp-35h]
char v49; // [rsp+9Fh] [rbp-31h]
unsigned long long v50; // [rsp+A0h] [rbp-30h]
v50 = __readfsqword(0x28u);
v9 = *a1;
if ( !*(_BYTE *)(v9 + 2015) && (*(_BYTE *)(v9 + 368) & 1) != 0 )
{
v5 = &v38;
ma_change_bitmap_page_cold_1(v9, a1, (long long *)&v38);
v9 = v38;
}
if ( *(_BYTE *)(a2 + 32) )
{
*(_BYTE *)(a2 + 33) = 1;
if ( *(_DWORD *)(a2 + 56) )
{
v10 = *(__m128i **)(v9 + 1536);
v11 = *(char **)(a2 + 8);
v12 = *(_QWORD *)(a2 + 16);
v13 = v10[8].m128i_u32[0];
v44 = a3;
v5 = &v38;
v14 = pagecache_write_part(v10, (char *)(a2 + 64), v12, 0, v11, 1, 0, 2u, 0, &v38, 0LL, 0, v13);
DWORD2(v38) = 0;
a3 = v44;
v39 = 1;
insert_dynamic(a2 + 320, &v38);
}
else
{
v14 = pagecache_write_part(
*(__m128i **)(v9 + 1536),
(char *)(a2 + 64),
*(_QWORD *)(a2 + 16),
0,
*(char **)(a2 + 8),
1,
0,
1u,
0,
0LL,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v9 + 1536) + 128LL));
}
LOBYTE(v5) = 1;
if ( v14 )
return (unsigned int)v5;
*(_BYTE *)(a2 + 32) = 0;
v9 = *a1;
}
*(_QWORD *)(a2 + 16) = a3;
v15 = *(unsigned int *)(a2 + 308);
v16 = *a1;
if ( v15 * (a3 + 1) <= *(_QWORD *)(v9 + 64) )
{
*(_DWORD *)(v16 + 2872) = *(_DWORD *)(v16 + 4LL * (*(_QWORD *)(v16 + 2600) <= a3) + 2876);
*(_QWORD *)(a2 + 40) = 0LL;
v22 = *(_QWORD *)(v9 + 1536);
v23 = pagecache_read(v22, a2 + 64, a3, 0, *(_QWORD *)(a2 + 8), 1, 0, 0LL);
LOBYTE(v5) = v23 == 0;
if ( v23 )
{
v27 = *(_QWORD *)(a2 + 8);
v28 = *(unsigned int *)(a2 + 296);
v29 = v27 - 1;
do
{
v30 = v28;
v31 = (_BYTE *)(v29 + v28);
if ( v29 + v28 < v27 )
break;
--v28;
}
while ( !*v31 );
*(_DWORD *)(a2 + 36) = v30;
}
else
{
v32 = (unsigned int *)my_thread_var(v22, a2 + 64, v24, v25, v26);
ma_set_fatal_error(a1, *v32, v33, v34, v35, v36);
LOBYTE(v5) = 1;
}
}
else
{
v17 = *(_QWORD *)(v16 + 64);
LOBYTE(v5) = 1;
if ( v17 >= v15 )
{
if ( a3 * v15 >= *(_QWORD *)(v16 + 872) )
{
*(_DWORD *)my_thread_var(v9, a3 + 1, a3 * v15, v15, a5) = 135;
return (unsigned int)v5;
}
v43 = a3 + 1;
v18 = *(_QWORD *)(a2 + 312) * ((v17 / v15 - 1) / *(_QWORD *)(a2 + 312) + 1);
v19 = *(_BYTE *)(v16 + 2023) == 0;
v44 = v18;
if ( !v19 )
{
v46 = v18;
v47 = BYTE4(v18);
v48 = a3;
v49 = BYTE4(a3);
v40 = &v45;
v41 = 12LL;
if ( (unsigned __int8)translog_write_record(
(unsigned long long)v42,
&qword_28,
(long long)dummy_transaction_object,
a1,
0xCu,
3,
&v38,
&v45,
0LL) )
return (unsigned int)v5;
v15 = *(unsigned int *)(a2 + 308);
}
memset(*(_QWORD *)(a2 + 8), 0LL, v15);
v20 = v44;
*(_DWORD *)(a2 + 44) = 0;
*(_QWORD *)(a2 + 36) = 0LL;
*(_BYTE *)(a2 + 32) = 1;
v21 = a3 - *(_QWORD *)(a2 + 312);
if ( v20 > v21
|| !(unsigned __int8)ma_bitmap_create_missing_into_pagecache(v16, a2, v20, v21, *(_QWORD *)(a2 + 8)) )
{
*(_QWORD *)(v16 + 64) = *(unsigned int *)(a2 + 308) * v43;
*(_DWORD *)(*a1 + 2872) = *(_DWORD *)(*a1 + 4LL * (*(_QWORD *)(*a1 + 2600) <= a3) + 2876);
LODWORD(v5) = 0;
}
}
}
return (unsigned int)v5;
}
|
_ma_change_bitmap_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RDI]
CMP byte ptr [RDI + 0x7df],0x0
JNZ 0x00140bf5
TEST byte ptr [RDI + 0x170],0x1
JNZ 0x00140f01
LAB_00140bf5:
CMP byte ptr [RBX + 0x20],0x0
JZ 0x00140ce0
MOV byte ptr [RBX + 0x21],0x1
CMP dword ptr [RBX + 0x38],0x0
JZ 0x00140c7b
MOV RDI,qword ptr [RDI + 0x600]
LEA RSI,[RBX + 0x40]
MOV R8,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX + 0x10]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x8
MOV qword ptr [RBP + -0x48],R15
MOV R15,R14
XOR R14D,R14D
LEA R12,[RBP + -0x90]
XOR ECX,ECX
MOV R9D,0x1
PUSH RAX
PUSH R14
PUSH 0x0
PUSH R12
PUSH R14
PUSH 0x2
PUSH R14
CALL 0x001335ee
ADD RSP,0x40
MOV R13D,EAX
MOV dword ptr [R12 + 0x8],R14D
MOV R14,R15
MOV R15,qword ptr [RBP + -0x48]
MOV byte ptr [R12 + 0x10],0x1
LEA RDI,[RBX + 0x140]
MOV RSI,R12
CALL 0x00191716
JMP 0x00140ccd
LAB_00140c7b:
MOV RDI,qword ptr [RDI + 0x600]
LEA RSI,[RBX + 0x40]
MOV R8,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [RBX + 0x10]
MOV EAX,dword ptr [RDI + 0x80]
SUB RSP,0x40
MOV dword ptr [RSP + 0x30],EAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x28],EAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP],EAX
MOV dword ptr [RSP + 0x8],0x1
XOR ECX,ECX
MOV R9D,0x1
CALL 0x001335ee
ADD RSP,0x40
MOV R13D,EAX
LAB_00140ccd:
MOV R12B,0x1
TEST R13B,R13B
JNZ 0x00140ee0
MOV byte ptr [RBX + 0x20],0x0
MOV RDI,qword ptr [R14]
LAB_00140ce0:
MOV qword ptr [RBX + 0x10],R15
LEA RSI,[R15 + 0x1]
MOV ECX,dword ptr [RBX + 0x134]
MOV RAX,RSI
IMUL RAX,RCX
MOV R13,qword ptr [R14]
CMP RAX,qword ptr [RDI + 0x40]
JBE 0x00140e49
MOV RAX,qword ptr [R13 + 0x40]
MOV R12B,0x1
CMP RAX,RCX
JC 0x00140ee0
MOV RDX,RCX
IMUL RDX,R15
CMP RDX,qword ptr [R13 + 0x368]
JNC 0x00140ed5
MOV qword ptr [RBP + -0x50],RSI
XOR EDX,EDX
DIV RCX
DEC RAX
MOV RSI,qword ptr [RBX + 0x138]
XOR EDX,EDX
DIV RSI
INC RAX
IMUL RAX,RSI
CMP byte ptr [R13 + 0x7e7],0x0
MOV qword ptr [RBP + -0x48],RAX
JZ 0x00140dc8
LEA R11,[RBP + -0x3c]
MOV dword ptr [R11 + 0x2],EAX
MOV RCX,RAX
SHR RCX,0x20
MOV byte ptr [R11 + 0x6],CL
MOV dword ptr [R11 + 0x7],R15D
MOV RCX,R15
SHR RCX,0x20
MOV byte ptr [R11 + 0xb],CL
LEA R10,[RBP + -0x90]
MOV qword ptr [R10 + 0x20],R11
MOV qword ptr [R10 + 0x28],0xc
SUB RSP,0x8
LEA RDX,[0x4fcfe0]
LEA RDI,[RBP + -0x58]
MOV ESI,0x28
MOV RCX,R14
MOV R8D,0xc
MOV R9D,0x3
PUSH 0x0
PUSH R11
PUSH R10
CALL 0x0012a8ac
ADD RSP,0x20
TEST AL,AL
JNZ 0x00140ee0
MOV ECX,dword ptr [RBX + 0x134]
LAB_00140dc8:
MOV RDI,qword ptr [RBX + 0x8]
XOR ESI,ESI
MOV RDX,RCX
CALL 0x001292c0
MOV RDX,qword ptr [RBP + -0x48]
MOV dword ptr [RBX + 0x2c],0x0
MOV qword ptr [RBX + 0x24],0x0
MOV byte ptr [RBX + 0x20],0x1
MOV RCX,R15
SUB RCX,qword ptr [RBX + 0x138]
CMP RDX,RCX
JA 0x00140e13
MOV R8,qword ptr [RBX + 0x8]
MOV RDI,R13
MOV RSI,RBX
CALL 0x00141b8a
TEST AL,AL
JNZ 0x00140ee0
LAB_00140e13:
MOV EAX,dword ptr [RBX + 0x134]
MOV RCX,qword ptr [RBP + -0x50]
IMUL RCX,RAX
MOV qword ptr [R13 + 0x40],RCX
MOV RAX,qword ptr [R14]
XOR ECX,ECX
CMP qword ptr [RAX + 0xa28],R15
SETBE CL
MOV ECX,dword ptr [RAX + RCX*0x4 + 0xb3c]
MOV dword ptr [RAX + 0xb38],ECX
XOR R12D,R12D
JMP 0x00140ee0
LAB_00140e49:
XOR EAX,EAX
CMP qword ptr [R13 + 0xa28],R15
SETBE AL
MOV EAX,dword ptr [R13 + RAX*0x4 + 0xb3c]
MOV dword ptr [R13 + 0xb38],EAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x28],RAX
MOV RDI,qword ptr [RDI + 0x600]
LEA RSI,[RBX + 0x40]
MOV R8,qword ptr [RBX + 0x8]
MOV RDX,R15
XOR ECX,ECX
MOV R9D,0x1
PUSH RAX
PUSH 0x0
CALL 0x0013218a
ADD RSP,0x10
TEST RAX,RAX
SETZ R12B
JZ 0x00140ec1
MOV RAX,qword ptr [RBX + 0x8]
MOV ESI,dword ptr [RBX + 0x128]
LEA RCX,[RAX + -0x1]
LAB_00140ea7:
MOV RDX,RSI
LEA RDI,[RCX + RSI*0x1]
CMP RDI,RAX
JC 0x00140ebc
LEA RSI,[RDX + -0x1]
CMP byte ptr [RDI],0x0
JZ 0x00140ea7
LAB_00140ebc:
MOV dword ptr [RBX + 0x24],EDX
JMP 0x00140ee0
LAB_00140ec1:
CALL 0x001a1672
MOV ESI,dword ptr [RAX]
MOV RDI,R14
CALL 0x0013659c
MOV R12B,0x1
JMP 0x00140ee0
LAB_00140ed5:
CALL 0x001a1672
MOV dword ptr [RAX],0x87
LAB_00140ee0:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00140f1c
MOV EAX,R12D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140f01:
LEA R12,[RBP + -0x90]
MOV RSI,R14
MOV RDX,R12
CALL 0x00129d22
MOV RDI,qword ptr [R12]
JMP 0x00140bf5
LAB_00140f1c:
CALL 0x00129270
|
ulong _ma_change_bitmap_page(long *param_1,long param_2,ulong param_3)
{
long lVar1;
char *pcVar2;
long lVar3;
char cVar4;
long lVar5;
int4 *puVar6;
size_t __n;
ulong uVar7;
ulong uVar8;
long *unaff_R12;
int7 uVar9;
long in_FS_OFFSET;
ulong in_stack_ffffffffffffff28;
ulong in_stack_ffffffffffffff38;
ulong in_stack_ffffffffffffff50;
long local_98;
int4 local_90;
int1 local_88;
int1 *local_78;
int8 local_70;
int1 local_60 [8];
long local_58;
ulong local_50;
int1 local_44 [2];
int4 local_42;
int1 local_3e;
int4 local_3d;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = *param_1;
if ((*(char *)(lVar5 + 0x7df) == '\0') && ((*(byte *)(lVar5 + 0x170) & 1) != 0)) {
unaff_R12 = &local_98;
_ma_change_bitmap_page_cold_1(lVar5,param_1,unaff_R12);
lVar5 = local_98;
}
if (*(char *)(param_2 + 0x20) != '\0') {
*(int1 *)(param_2 + 0x21) = 1;
if (*(int *)(param_2 + 0x38) == 0) {
cVar4 = pagecache_write_part
(*(long *)(lVar5 + 0x600),param_2 + 0x40,*(int8 *)(param_2 + 0x10),0,
*(int8 *)(param_2 + 8),1,
in_stack_ffffffffffffff28 & 0xffffffff00000000,1,
in_stack_ffffffffffffff38 & 0xffffffff00000000,0,0,
in_stack_ffffffffffffff50 & 0xffffffff00000000,
*(int4 *)(*(long *)(lVar5 + 0x600) + 0x80));
}
else {
unaff_R12 = &local_98;
local_50 = param_3;
cVar4 = pagecache_write_part
(*(long *)(lVar5 + 0x600),param_2 + 0x40,*(int8 *)(param_2 + 0x10),0,
*(int8 *)(param_2 + 8),1,0,2,0,unaff_R12,0,0,
*(int4 *)(*(long *)(lVar5 + 0x600) + 0x80));
param_3 = local_50;
local_90 = 0;
local_88 = 1;
insert_dynamic(param_2 + 0x140,unaff_R12);
}
unaff_R12 = (long *)CONCAT71((int7)((ulong)unaff_R12 >> 8),1);
if (cVar4 != '\0') goto LAB_00140ee0;
*(int1 *)(param_2 + 0x20) = 0;
lVar5 = *param_1;
}
*(ulong *)(param_2 + 0x10) = param_3;
lVar1 = param_3 + 1;
__n = (size_t)*(uint *)(param_2 + 0x134);
lVar3 = *param_1;
uVar9 = (int7)((ulong)unaff_R12 >> 8);
if (lVar1 * __n < *(ulong *)(lVar5 + 0x40) || lVar1 * __n - *(ulong *)(lVar5 + 0x40) == 0) {
*(int4 *)(lVar3 + 0xb38) =
*(int4 *)(lVar3 + 0xb3c + (ulong)(*(ulong *)(lVar3 + 0xa28) <= param_3) * 4);
*(int8 *)(param_2 + 0x28) = 0;
lVar5 = pagecache_read(*(int8 *)(lVar5 + 0x600),param_2 + 0x40,param_3,0,
*(int8 *)(param_2 + 8),1,0,0);
unaff_R12 = (long *)CONCAT71(uVar9,lVar5 == 0);
if (lVar5 == 0) {
puVar6 = (int4 *)_my_thread_var();
_ma_set_fatal_error(param_1,*puVar6);
unaff_R12 = (long *)CONCAT71(uVar9,1);
}
else {
uVar7 = (ulong)*(uint *)(param_2 + 0x128);
do {
uVar8 = uVar7;
pcVar2 = *(char **)(param_2 + 8) + (uVar8 - 1);
if (pcVar2 < *(char **)(param_2 + 8)) break;
uVar7 = uVar8 - 1;
} while (*pcVar2 == '\0');
*(int *)(param_2 + 0x24) = (int)uVar8;
}
}
else {
unaff_R12 = (long *)CONCAT71(uVar9,1);
if (__n <= *(ulong *)(lVar3 + 0x40)) {
if (__n * param_3 < *(ulong *)(lVar3 + 0x368)) {
local_50 = ((*(ulong *)(lVar3 + 0x40) / __n - 1) / *(ulong *)(param_2 + 0x138) + 1) *
*(ulong *)(param_2 + 0x138);
local_58 = lVar1;
if (*(char *)(lVar3 + 0x7e7) != '\0') {
local_78 = local_44;
local_42 = (int4)local_50;
local_3e = (int1)(local_50 >> 0x20);
local_3d = (int4)param_3;
local_39 = (int1)(param_3 >> 0x20);
local_70 = 0xc;
cVar4 = translog_write_record
(local_60,0x28,dummy_transaction_object,param_1,0xc,3,&local_98,local_78
,0);
if (cVar4 != '\0') goto LAB_00140ee0;
__n = (size_t)*(uint *)(param_2 + 0x134);
}
memset(*(void **)(param_2 + 8),0,__n);
*(int4 *)(param_2 + 0x2c) = 0;
*(int8 *)(param_2 + 0x24) = 0;
*(int1 *)(param_2 + 0x20) = 1;
uVar7 = param_3 - *(long *)(param_2 + 0x138);
if (local_50 <= uVar7) {
cVar4 = _ma_bitmap_create_missing_into_pagecache
(lVar3,param_2,local_50,uVar7,*(int8 *)(param_2 + 8));
if (cVar4 != '\0') goto LAB_00140ee0;
}
*(ulong *)(lVar3 + 0x40) = local_58 * (ulong)*(uint *)(param_2 + 0x134);
lVar5 = *param_1;
*(int4 *)(lVar5 + 0xb38) =
*(int4 *)(lVar5 + 0xb3c + (ulong)(*(ulong *)(lVar5 + 0xa28) <= param_3) * 4);
unaff_R12 = (long *)0x0;
}
else {
puVar6 = (int4 *)_my_thread_var();
*puVar6 = 0x87;
}
}
}
LAB_00140ee0:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (ulong)unaff_R12 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
64,085 |
my_strnxfrm_simple_nopad
|
eloqsql/strings/ctype-simple.c
|
size_t my_strnxfrm_simple_nopad(CHARSET_INFO * cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *d0= dst;
dst= d0 + my_strnxfrm_simple_internal(cs, dst, dstlen, &nweights,
src, srclen);
return my_strxfrm_pad_desc_and_reverse_nopad(cs, d0, dst, d0 + dstlen,
nweights, flags, 0);
}
|
O0
|
c
|
my_strnxfrm_simple_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0x42b40
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x42ea0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
my_strnxfrm_simple_nopad:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_simple_internal
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
mov [rbp+var_10], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
add rcx, [rbp+var_18]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+50h+var_50], 0
call my_strxfrm_pad_desc_and_reverse_nopad
add rsp, 50h
pop rbp
retn
|
long long my_strnxfrm_simple_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
unsigned __int8 *a5,
unsigned long long a6,
int a7)
{
_BYTE *v7; // rax
unsigned int v9; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
unsigned __int8 *v11; // [rsp+40h] [rbp-10h]
long long v12; // [rsp+48h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v7 = my_strnxfrm_simple_internal(a1, a2, a3, &v9, a5, a6);
v11 = &a2[(_QWORD)v7];
return my_strxfrm_pad_desc_and_reverse_nopad(v12, (_DWORD)a2, (int)v7 + (int)a2, (int)v10 + (int)a2, v9, a7, 0);
}
|
my_strnxfrm_simple_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x00142b40
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00142ea0
ADD RSP,0x50
POP RBP
RET
|
void my_strnxfrm_simple_nopad
(int8 param_1,long param_2,long param_3,int4 param_4,int8 param_5,
int8 param_6,int4 param_7)
{
int4 local_24;
long local_20;
long local_18;
int8 local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_18 = my_strnxfrm_simple_internal(param_1,param_2,param_3,&local_24,param_5,param_6);
local_18 = param_2 + local_18;
my_strxfrm_pad_desc_and_reverse_nopad
(local_10,param_2,local_18,param_2 + local_20,local_24,param_7,0);
return;
}
|
|
64,086 |
js_typed_array_get_toStringTag
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_UNDEFINED;
p = JS_VALUE_GET_OBJ(this_val);
if (!(p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY))
return JS_UNDEFINED;
return JS_AtomToString(ctx, ctx->rt->class_array[p->class_id].class_name);
}
|
O0
|
c
|
js_typed_array_get_toStringTag:
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $-0x1, %eax
je 0xde080
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
jmp 0xde0f0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x15, %eax
jl 0xde0a6
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x20, %eax
jle 0xde0b9
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
jmp 0xde0f0
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x80(%rax), %rax
movq 0x8(%rsp), %rcx
movzwl 0x6(%rcx), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x27d40
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nop
|
js_typed_array_get_toStringTag:
sub rsp, 38h
mov [rsp+38h+var_20], rsi
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_28], rdi
mov rax, [rsp+38h+var_18]
cmp eax, 0FFFFFFFFh
jz short loc_DE080
mov dword ptr [rsp+38h+var_10], 0
mov [rsp+38h+var_8], 3
jmp short loc_DE0F0
loc_DE080:
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_30], rax
mov rax, [rsp+38h+var_30]
movzx eax, word ptr [rax+6]
cmp eax, 15h
jl short loc_DE0A6
mov rax, [rsp+38h+var_30]
movzx eax, word ptr [rax+6]
cmp eax, 20h ; ' '
jle short loc_DE0B9
loc_DE0A6:
mov dword ptr [rsp+38h+var_10], 0
mov [rsp+38h+var_8], 3
jmp short loc_DE0F0
loc_DE0B9:
mov rdi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_28]
mov rax, [rax+18h]
mov rax, [rax+80h]
mov rcx, [rsp+38h+var_30]
movzx ecx, word ptr [rcx+6]
imul rcx, 28h ; '('
add rax, rcx
mov esi, [rax+4]
call JS_AtomToString
mov [rsp+38h+var_10], rax
mov [rsp+38h+var_8], rdx
loc_DE0F0:
mov rax, [rsp+38h+var_10]
mov rdx, [rsp+38h+var_8]
add rsp, 38h
retn
|
long long js_typed_array_get_toStringTag(long long a1, long long a2, int a3)
{
long long v4; // [rsp+28h] [rbp-10h]
if ( a3 == -1 )
{
if ( *(unsigned __int16 *)(a2 + 6) >= 0x15u && *(unsigned __int16 *)(a2 + 6) <= 0x20u )
return JS_AtomToString(
a1,
*(_DWORD *)(40LL * *(unsigned __int16 *)(a2 + 6) + *(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 4));
else
LODWORD(v4) = 0;
}
else
{
LODWORD(v4) = 0;
}
return v4;
}
|
js_typed_array_get_toStringTag:
SUB RSP,0x38
MOV qword ptr [RSP + 0x18],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x20]
CMP EAX,-0x1
JZ 0x001de080
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
JMP 0x001de0f0
LAB_001de080:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x15
JL 0x001de0a6
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RAX + 0x6]
CMP EAX,0x20
JLE 0x001de0b9
LAB_001de0a6:
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
JMP 0x001de0f0
LAB_001de0b9:
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV RCX,qword ptr [RSP + 0x8]
MOVZX ECX,word ptr [RCX + 0x6]
IMUL RCX,RCX,0x28
ADD RAX,RCX
MOV ESI,dword ptr [RAX + 0x4]
CALL 0x00127d40
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
LAB_001de0f0:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
int1 [16] js_typed_array_get_toStringTag(long param_1,long param_2,int param_3)
{
int1 auVar1 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
if (param_3 == -1) {
if ((*(ushort *)(param_2 + 6) < 0x15) || (0x20 < *(ushort *)(param_2 + 6))) {
local_10 = 0;
local_8 = 3;
}
else {
auVar1 = JS_AtomToString(param_1,*(int4 *)
(*(long *)(*(long *)(param_1 + 0x18) + 0x80) +
(ulong)*(ushort *)(param_2 + 6) * 0x28 + 4));
local_8 = auVar1._8_8_;
local_10 = auVar1._0_4_;
uStack_c = auVar1._4_4_;
}
}
else {
local_10 = 0;
local_8 = 3;
}
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
|
|
64,087 |
js_typed_array_get_toStringTag
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_UNDEFINED;
p = JS_VALUE_GET_OBJ(this_val);
if (!(p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY))
return JS_UNDEFINED;
return JS_AtomToString(ctx, ctx->rt->class_array[p->class_id].class_name);
}
|
O1
|
c
|
js_typed_array_get_toStringTag:
pushq %rax
movq %rdx, %rax
movq %rsi, (%rsp)
movl $0x3, %edx
cmpl $-0x1, %eax
jne 0x801d5
movq (%rsp), %rax
movzwl 0x6(%rax), %eax
leal -0x15(%rax), %ecx
cmpw $0xb, %cx
ja 0x801d5
movq 0x18(%rdi), %rcx
movq 0x80(%rcx), %rcx
leaq (%rax,%rax,4), %rax
movl 0x4(%rcx,%rax,8), %esi
movl $0x1, %edx
callq 0x1fb46
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
jmp 0x801d9
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
popq %rcx
retq
|
js_typed_array_get_toStringTag:
push rax
mov rax, rdx
mov [rsp+8+var_8], rsi
mov edx, 3
cmp eax, 0FFFFFFFFh
jnz short loc_801D5
mov rax, [rsp+8+var_8]
movzx eax, word ptr [rax+6]
lea ecx, [rax-15h]
cmp cx, 0Bh
ja short loc_801D5
mov rcx, [rdi+18h]
mov rcx, [rcx+80h]
lea rax, [rax+rax*4]
mov esi, [rcx+rax*8+4]
mov edx, 1
call __JS_AtomToValue
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
jmp short loc_801D9
loc_801D5:
xor eax, eax
xor ecx, ecx
loc_801D9:
or rax, rcx
pop rcx
retn
|
unsigned long long js_typed_array_get_toStringTag(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned long long v4; // rcx
long long v5; // rax
if ( a3 == -1 && (v3 = *(unsigned __int16 *)(a2 + 6), (unsigned __int16)(v3 - 21) <= 0xBu) )
{
v5 = _JS_AtomToValue(a1, *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v3 + 4), 1);
v4 = v5 & 0xFFFFFFFF00000000LL;
v5 = (unsigned int)v5;
}
else
{
v5 = 0LL;
v4 = 0LL;
}
return v4 | v5;
}
|
js_typed_array_get_toStringTag:
PUSH RAX
MOV RAX,RDX
MOV qword ptr [RSP],RSI
MOV EDX,0x3
CMP EAX,-0x1
JNZ 0x001801d5
MOV RAX,qword ptr [RSP]
MOVZX EAX,word ptr [RAX + 0x6]
LEA ECX,[RAX + -0x15]
CMP CX,0xb
JA 0x001801d5
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
LEA RAX,[RAX + RAX*0x4]
MOV ESI,dword ptr [RCX + RAX*0x8 + 0x4]
MOV EDX,0x1
CALL 0x0011fb46
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
JMP 0x001801d9
LAB_001801d5:
XOR EAX,EAX
XOR ECX,ECX
LAB_001801d9:
OR RAX,RCX
POP RCX
RET
|
ulong js_typed_array_get_toStringTag(long param_1,long param_2,int param_3)
{
ulong uVar1;
ulong uVar2;
if ((param_3 == -1) && ((ushort)(*(ushort *)(param_2 + 6) - 0x15) < 0xc)) {
uVar1 = __JS_AtomToValue(param_1,*(int4 *)
(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 4 +
(ulong)*(ushort *)(param_2 + 6) * 0x28),1);
uVar2 = uVar1 & 0xffffffff00000000;
uVar1 = uVar1 & 0xffffffff;
}
else {
uVar1 = 0;
uVar2 = 0;
}
return uVar1 | uVar2;
}
|
|
64,088 |
js_typed_array_get_toStringTag
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
JSValue this_val)
{
JSObject *p;
if (JS_VALUE_GET_TAG(this_val) != JS_TAG_OBJECT)
return JS_UNDEFINED;
p = JS_VALUE_GET_OBJ(this_val);
if (!(p->class_id >= JS_CLASS_UINT8C_ARRAY &&
p->class_id <= JS_CLASS_FLOAT64_ARRAY))
return JS_UNDEFINED;
return JS_AtomToString(ctx, ctx->rt->class_array[p->class_id].class_name);
}
|
O3
|
c
|
js_typed_array_get_toStringTag:
movq %rdx, %rax
movl $0x3, %edx
cmpl $-0x1, %eax
jne 0x82cd6
movzwl 0x6(%rsi), %eax
leal -0x15(%rax), %ecx
cmpw $0xb, %cx
ja 0x82cd6
pushq %rax
movq 0x18(%rdi), %rcx
movq 0x80(%rcx), %rcx
leaq (%rax,%rax,4), %rax
movl 0x4(%rcx,%rax,8), %esi
movl $0x1, %edx
callq 0x20277
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
addq $0x8, %rsp
jmp 0x82cda
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
retq
|
js_typed_array_get_toStringTag:
mov rax, rdx
mov edx, 3
cmp eax, 0FFFFFFFFh
jnz short loc_82CD6
movzx eax, word ptr [rsi+6]
lea ecx, [rax-15h]
cmp cx, 0Bh
ja short loc_82CD6
push rax
mov rcx, [rdi+18h]
mov rcx, [rcx+80h]
lea rax, [rax+rax*4]
mov esi, [rcx+rax*8+4]
mov edx, 1
call __JS_AtomToValue
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
add rsp, 8
jmp short loc_82CDA
loc_82CD6:
xor eax, eax
xor ecx, ecx
loc_82CDA:
or rax, rcx
retn
|
unsigned long long js_typed_array_get_toStringTag(long long a1, long long a2, int a3)
{
long long v3; // rax
unsigned long long v4; // rcx
long long v5; // rax
if ( a3 == -1 && (v3 = *(unsigned __int16 *)(a2 + 6), (unsigned __int16)(v3 - 21) <= 0xBu) )
{
v5 = _JS_AtomToValue(a1, *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v3 + 4), 1);
v4 = v5 & 0xFFFFFFFF00000000LL;
v5 = (unsigned int)v5;
}
else
{
v5 = 0LL;
v4 = 0LL;
}
return v4 | v5;
}
|
js_typed_array_get_toStringTag:
MOV RAX,RDX
MOV EDX,0x3
CMP EAX,-0x1
JNZ 0x00182cd6
MOVZX EAX,word ptr [RSI + 0x6]
LEA ECX,[RAX + -0x15]
CMP CX,0xb
JA 0x00182cd6
PUSH RAX
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
LEA RAX,[RAX + RAX*0x4]
MOV ESI,dword ptr [RCX + RAX*0x8 + 0x4]
MOV EDX,0x1
CALL 0x00120277
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
ADD RSP,0x8
JMP 0x00182cda
LAB_00182cd6:
XOR EAX,EAX
XOR ECX,ECX
LAB_00182cda:
OR RAX,RCX
RET
|
ulong js_typed_array_get_toStringTag(long param_1,long param_2,int param_3)
{
ulong uVar1;
ulong uVar2;
if ((param_3 == -1) && ((ushort)(*(ushort *)(param_2 + 6) - 0x15) < 0xc)) {
uVar1 = __JS_AtomToValue(param_1,*(int4 *)
(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 4 +
(ulong)*(ushort *)(param_2 + 6) * 0x28),1);
uVar2 = uVar1 & 0xffffffff00000000;
uVar1 = uVar1 & 0xffffffff;
}
else {
uVar1 = 0;
uVar2 = 0;
}
return uVar1 | uVar2;
}
|
|
64,089 |
string_buffer_realloc
|
bluesky950520[P]quickjs/quickjs.c
|
static no_inline int string_buffer_realloc(StringBuffer *s, int new_len, int c)
{
JSString *new_str;
int new_size;
size_t new_size_bytes, slack;
if (s->error_status)
return -1;
if (new_len > JS_STRING_LEN_MAX) {
JS_ThrowRangeError(s->ctx, "invalid string length");
return string_buffer_set_error(s);
}
new_size = min_int(max_int(new_len, s->size * 3 / 2), JS_STRING_LEN_MAX);
if (!s->is_wide_char && c >= 0x100) {
return string_buffer_widen(s, new_size);
}
new_size_bytes = sizeof(JSString) + (new_size << s->is_wide_char) + 1 - s->is_wide_char;
new_str = js_realloc2(s->ctx, s->str, new_size_bytes, &slack);
if (!new_str)
return string_buffer_set_error(s);
new_size = min_int(new_size + (slack >> s->is_wide_char), JS_STRING_LEN_MAX);
s->size = new_size;
s->str = new_str;
return 0;
}
|
O0
|
c
|
string_buffer_realloc:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x6ea39
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x6eb80
cmpl $0x3fffffff, 0x34(%rsp) # imm = 0x3FFFFFFF
jle 0x6ea75
movq 0x38(%rsp), %rax
movq (%rax), %rdi
leaq 0x9d80c(%rip), %rsi # 0x10c25e
movb $0x0, %al
callq 0x283b0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x6eb90
movl %eax, 0x44(%rsp)
jmp 0x6eb80
movl 0x34(%rsp), %edi
movq 0x38(%rsp), %rax
imull $0x3, 0x14(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0x5c050
movl %eax, %edi
movl $0x3fffffff, %esi # imm = 0x3FFFFFFF
callq 0x4fa40
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x6eacd
cmpl $0x100, 0x30(%rsp) # imm = 0x100
jl 0x6eacd
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x6ebe0
movl %eax, 0x44(%rsp)
jmp 0x6eb80
movl 0x24(%rsp), %eax
movq 0x38(%rsp), %rcx
movl 0x18(%rcx), %ecx
shll %cl, %eax
cltq
addq $0x18, %rax
addq $0x1, %rax
movq 0x38(%rsp), %rcx
movslq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x20bc0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x6eb33
movq 0x38(%rsp), %rdi
callq 0x6eb90
movl %eax, 0x44(%rsp)
jmp 0x6eb80
movslq 0x24(%rsp), %rax
movq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rcx
movl 0x18(%rcx), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
addq %rcx, %rax
movl %eax, %edi
movl $0x3fffffff, %esi # imm = 0x3FFFFFFF
callq 0x4fa40
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
|
string_buffer_realloc:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_14], esi
mov [rsp+48h+var_18], edx
mov rax, [rsp+48h+var_10]
cmp dword ptr [rax+1Ch], 0
jz short loc_6EA39
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp loc_6EB80
loc_6EA39:
cmp [rsp+48h+var_14], 3FFFFFFFh
jle short loc_6EA75
mov rax, [rsp+48h+var_10]
mov rdi, [rax]
lea rsi, aInvalidStringL; "invalid string length"
mov al, 0
call JS_ThrowRangeError
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rdx
mov rdi, [rsp+48h+var_10]
call string_buffer_set_error
mov [rsp+48h+var_4], eax
jmp loc_6EB80
loc_6EA75:
mov edi, [rsp+48h+var_14]
mov rax, [rsp+48h+var_10]
imul eax, [rax+14h], 3
mov ecx, 2
cdq
idiv ecx
mov esi, eax
call max_int_0
mov edi, eax
mov esi, 3FFFFFFFh
call min_int_0
mov [rsp+48h+var_24], eax
mov rax, [rsp+48h+var_10]
cmp dword ptr [rax+18h], 0
jnz short loc_6EACD
cmp [rsp+48h+var_18], 100h
jl short loc_6EACD
mov rdi, [rsp+48h+var_10]
mov esi, [rsp+48h+var_24]
call string_buffer_widen
mov [rsp+48h+var_4], eax
jmp loc_6EB80
loc_6EACD:
mov eax, [rsp+48h+var_24]
mov rcx, [rsp+48h+var_10]
mov ecx, [rcx+18h]
shl eax, cl
cdqe
add rax, 18h
add rax, 1
mov rcx, [rsp+48h+var_10]
movsxd rcx, dword ptr [rcx+18h]
sub rax, rcx
mov [rsp+48h+var_30], rax
mov rax, [rsp+48h+var_10]
mov rdi, [rax]
mov rax, [rsp+48h+var_10]
mov rsi, [rax+8]
mov rdx, [rsp+48h+var_30]
lea rcx, [rsp+48h+var_38]
call js_realloc2
mov [rsp+48h+var_20], rax
cmp [rsp+48h+var_20], 0
jnz short loc_6EB33
mov rdi, [rsp+48h+var_10]
call string_buffer_set_error
mov [rsp+48h+var_4], eax
jmp short loc_6EB80
loc_6EB33:
movsxd rax, [rsp+48h+var_24]
mov rdx, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_10]
mov ecx, [rcx+18h]
shr rdx, cl
mov rcx, rdx
add rax, rcx
mov edi, eax
mov esi, 3FFFFFFFh
call min_int_0
mov [rsp+48h+var_24], eax
mov ecx, [rsp+48h+var_24]
mov rax, [rsp+48h+var_10]
mov [rax+14h], ecx
mov rcx, [rsp+48h+var_20]
mov rax, [rsp+48h+var_10]
mov [rax+8], rcx
mov [rsp+48h+var_4], 0
loc_6EB80:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long string_buffer_realloc(
long long a1,
signed int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // eax
char v16; // [rsp+0h] [rbp-48h]
unsigned long long v17; // [rsp+10h] [rbp-38h] BYREF
unsigned long long v18; // [rsp+18h] [rbp-30h]
unsigned int v19; // [rsp+24h] [rbp-24h]
long long v20; // [rsp+28h] [rbp-20h]
int v21; // [rsp+30h] [rbp-18h]
signed int v22; // [rsp+34h] [rbp-14h]
long long v23; // [rsp+38h] [rbp-10h]
v23 = a1;
v22 = a2;
v21 = a3;
if ( *(_DWORD *)(a1 + 28) )
{
return (unsigned int)-1;
}
else if ( v22 <= 0x3FFFFFFF )
{
v14 = max_int_0(v22, 3 * *(_DWORD *)(v23 + 20) / 2);
v19 = min_int_0(v14, 0x3FFFFFFFu);
if ( *(_DWORD *)(v23 + 24) || v21 < 256 )
{
v18 = (int)(v19 << *(_DWORD *)(v23 + 24)) + 25LL - *(int *)(v23 + 24);
v20 = js_realloc2(*(_QWORD *)v23, *(_QWORD *)(v23 + 8), v18, &v17);
if ( v20 )
{
v19 = min_int_0((unsigned int)(v17 >> *(_DWORD *)(v23 + 24)) + v19, 0x3FFFFFFFu);
*(_DWORD *)(v23 + 20) = v19;
*(_QWORD *)(v23 + 8) = v20;
return 0;
}
else
{
return (unsigned int)string_buffer_set_error(v23);
}
}
else
{
return (unsigned int)string_buffer_widen(v23, v19);
}
}
else
{
JS_ThrowRangeError(
*(_QWORD *)v23,
(long long)"invalid string length",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v16);
return (unsigned int)string_buffer_set_error(v23);
}
}
|
string_buffer_realloc:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV dword ptr [RSP + 0x34],ESI
MOV dword ptr [RSP + 0x30],EDX
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x1c],0x0
JZ 0x0016ea39
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x0016eb80
LAB_0016ea39:
CMP dword ptr [RSP + 0x34],0x3fffffff
JLE 0x0016ea75
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x20c25e]
MOV AL,0x0
CALL 0x001283b0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0016eb90
MOV dword ptr [RSP + 0x44],EAX
JMP 0x0016eb80
LAB_0016ea75:
MOV EDI,dword ptr [RSP + 0x34]
MOV RAX,qword ptr [RSP + 0x38]
IMUL EAX,dword ptr [RAX + 0x14],0x3
MOV ECX,0x2
CDQ
IDIV ECX
MOV ESI,EAX
CALL 0x0015c050
MOV EDI,EAX
MOV ESI,0x3fffffff
CALL 0x0014fa40
MOV dword ptr [RSP + 0x24],EAX
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x18],0x0
JNZ 0x0016eacd
CMP dword ptr [RSP + 0x30],0x100
JL 0x0016eacd
MOV RDI,qword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x24]
CALL 0x0016ebe0
MOV dword ptr [RSP + 0x44],EAX
JMP 0x0016eb80
LAB_0016eacd:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x38]
MOV ECX,dword ptr [RCX + 0x18]
SHL EAX,CL
CDQE
ADD RAX,0x18
ADD RAX,0x1
MOV RCX,qword ptr [RSP + 0x38]
MOVSXD RCX,dword ptr [RCX + 0x18]
SUB RAX,RCX
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RSP + 0x18]
LEA RCX,[RSP + 0x10]
CALL 0x00120bc0
MOV qword ptr [RSP + 0x28],RAX
CMP qword ptr [RSP + 0x28],0x0
JNZ 0x0016eb33
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0016eb90
MOV dword ptr [RSP + 0x44],EAX
JMP 0x0016eb80
LAB_0016eb33:
MOVSXD RAX,dword ptr [RSP + 0x24]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x38]
MOV ECX,dword ptr [RCX + 0x18]
SHR RDX,CL
MOV RCX,RDX
ADD RAX,RCX
MOV EDI,EAX
MOV ESI,0x3fffffff
CALL 0x0014fa40
MOV dword ptr [RSP + 0x24],EAX
MOV ECX,dword ptr [RSP + 0x24]
MOV RAX,qword ptr [RSP + 0x38]
MOV dword ptr [RAX + 0x14],ECX
MOV RCX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RSP + 0x44],0x0
LAB_0016eb80:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4 string_buffer_realloc(int8 *param_1,int param_2,int param_3)
{
long lVar1;
int4 uVar2;
ulong local_38;
long local_30;
int local_24;
long local_20;
int local_18;
int local_14;
int8 *local_10;
int4 local_4;
if (*(int *)((long)param_1 + 0x1c) == 0) {
local_18 = param_3;
local_14 = param_2;
local_10 = param_1;
if (param_2 < 0x40000000) {
lVar1 = (long)(*(int *)((long)param_1 + 0x14) * 3);
uVar2 = max_int(param_2,lVar1 / 2 & 0xffffffff,lVar1 % 2 & 0xffffffff);
local_24 = min_int(uVar2,0x3fffffff);
if ((*(int *)(local_10 + 3) == 0) && (0xff < local_18)) {
local_4 = string_buffer_widen(local_10,local_24);
}
else {
local_30 = ((long)(local_24 << ((byte)*(int4 *)(local_10 + 3) & 0x1f)) + 0x19) -
(long)*(int *)(local_10 + 3);
local_20 = js_realloc2(*local_10,local_10[1],local_30,&local_38);
if (local_20 == 0) {
local_4 = string_buffer_set_error(local_10);
}
else {
uVar2 = min_int(local_24 + (int)(local_38 >> ((byte)*(int4 *)(local_10 + 3) & 0x3f))
,0x3fffffff);
*(int4 *)((long)local_10 + 0x14) = uVar2;
local_10[1] = local_20;
local_4 = 0;
}
}
}
else {
JS_ThrowRangeError(*param_1,"invalid string length");
local_4 = string_buffer_set_error(local_10);
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
64,090 |
string_buffer_realloc
|
bluesky950520[P]quickjs/quickjs.c
|
static no_inline int string_buffer_realloc(StringBuffer *s, int new_len, int c)
{
JSString *new_str;
int new_size;
size_t new_size_bytes, slack;
if (s->error_status)
return -1;
if (new_len > JS_STRING_LEN_MAX) {
JS_ThrowRangeError(s->ctx, "invalid string length");
return string_buffer_set_error(s);
}
new_size = min_int(max_int(new_len, s->size * 3 / 2), JS_STRING_LEN_MAX);
if (!s->is_wide_char && c >= 0x100) {
return string_buffer_widen(s, new_size);
}
new_size_bytes = sizeof(JSString) + (new_size << s->is_wide_char) + 1 - s->is_wide_char;
new_str = js_realloc2(s->ctx, s->str, new_size_bytes, &slack);
if (!new_str)
return string_buffer_set_error(s);
new_size = min_int(new_size + (slack >> s->is_wide_char), JS_STRING_LEN_MAX);
s->size = new_size;
s->str = new_str;
return 0;
}
|
O3
|
c
|
string_buffer_realloc:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x0, 0x1c(%rdi)
jne 0x43137
movq %rdi, %rbx
cmpl $0x40000000, %esi # imm = 0x40000000
jl 0x430ad
movq (%rbx), %rdi
leaq 0x5d1af(%rip), %rsi # 0xa0236
xorl %eax, %eax
callq 0x205f0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1c845
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movl $0xffffffff, 0x1c(%rbx) # imm = 0xFFFFFFFF
jmp 0x43137
movl 0x14(%rbx), %eax
leal (%rax,%rax,2), %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
cmpl %r14d, %esi
cmovgl %esi, %r14d
movslq 0x18(%rbx), %rcx
testq %rcx, %rcx
setne %al
cmpl $0x100, %edx # imm = 0x100
setl %dl
orb %al, %dl
jne 0x430ee
movq %rbx, %rdi
movl %r14d, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4315e
movl %r14d, %eax
shll %cl, %eax
movslq %eax, %rdx
subq %rcx, %rdx
addq $0x19, %rdx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rcx
callq 0x1c8be
testq %rax, %rax
je 0x43142
movq 0x8(%rsp), %rdx
movb 0x18(%rbx), %cl
shrq %cl, %rdx
addl %edx, %r14d
movl $0x3fffffff, %ecx # imm = 0x3FFFFFFF
cmpl %ecx, %r14d
cmovgel %ecx, %r14d
movl %r14d, 0x14(%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8(%rbx), %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1c845
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
jmp 0x430a1
|
string_buffer_realloc:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, 0FFFFFFFFh
cmp dword ptr [rdi+1Ch], 0
jnz loc_43137
mov rbx, rdi
cmp esi, 40000000h
jl short loc_430AD
mov rdi, [rbx]
lea rsi, aInvalidStringL; "invalid string length"
xor eax, eax
call JS_ThrowRangeError
mov rdi, [rbx]
mov rsi, [rbx+8]
call js_free
xorps xmm0, xmm0
movups xmmword ptr [rbx+8], xmm0
loc_430A1:
mov dword ptr [rbx+1Ch], 0FFFFFFFFh
jmp loc_43137
loc_430AD:
mov eax, [rbx+14h]
lea eax, [rax+rax*2]
mov r14d, eax
shr r14d, 1Fh
add r14d, eax
sar r14d, 1
cmp esi, r14d
cmovg r14d, esi
movsxd rcx, dword ptr [rbx+18h]
test rcx, rcx
setnz al
cmp edx, 100h
setl dl
or dl, al
jnz short loc_430EE
mov rdi, rbx
mov esi, r14d
add rsp, 10h
pop rbx
pop r14
pop rbp
jmp short string_buffer_widen
loc_430EE:
mov eax, r14d
shl eax, cl
movsxd rdx, eax
sub rdx, rcx
add rdx, 19h
mov rdi, [rbx]
mov rsi, [rbx+8]
lea rcx, [rsp+28h+var_20]
call js_realloc2
test rax, rax
jz short loc_43142
mov rdx, [rsp+28h+var_20]
mov cl, [rbx+18h]
shr rdx, cl
add r14d, edx
mov ecx, 3FFFFFFFh
cmp r14d, ecx
cmovge r14d, ecx
mov [rbx+14h], r14d
mov [rbx+8], rax
xor ebp, ebp
loc_43137:
mov eax, ebp
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_43142:
lea r14, [rbx+8]
mov rdi, [rbx]
mov rsi, [rbx+8]
call js_free
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
jmp loc_430A1
|
long long string_buffer_realloc(
long long a1,
int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
unsigned int v14; // ebp
int v15; // r14d
long long v16; // rcx
long long v18; // rax
int v19; // r14d
char v20; // [rsp+0h] [rbp-28h]
unsigned long long v21[4]; // [rsp+8h] [rbp-20h] BYREF
v14 = -1;
if ( !*(_DWORD *)(a1 + 28) )
{
if ( a2 < 0x40000000 )
{
v15 = 3 * *(_DWORD *)(a1 + 20) / 2;
if ( a2 > v15 )
v15 = a2;
v16 = *(int *)(a1 + 24);
if ( v16 == 0 && (int)a3 >= 256 )
return string_buffer_widen(a1);
v18 = js_realloc2(*(_QWORD *)a1, *(_QWORD *)(a1 + 8), (v15 << v16) - v16 + 25, v21);
if ( v18 )
{
v19 = (v21[0] >> *(_BYTE *)(a1 + 24)) + v15;
if ( v19 >= 0x3FFFFFFF )
v19 = 0x3FFFFFFF;
*(_DWORD *)(a1 + 20) = v19;
*(_QWORD *)(a1 + 8) = v18;
return 0;
}
js_free(*(_QWORD *)a1, *(_QWORD *)(a1 + 8));
*(_OWORD *)(a1 + 8) = 0LL;
}
else
{
JS_ThrowRangeError(
*(_QWORD *)a1,
(long long)"invalid string length",
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v20);
js_free(*(_QWORD *)a1, *(_QWORD *)(a1 + 8));
*(_OWORD *)(a1 + 8) = 0LL;
}
*(_DWORD *)(a1 + 28) = -1;
}
return v14;
}
|
string_buffer_realloc:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBP,0xffffffff
CMP dword ptr [RDI + 0x1c],0x0
JNZ 0x00143137
MOV RBX,RDI
CMP ESI,0x40000000
JL 0x001430ad
MOV RDI,qword ptr [RBX]
LEA RSI,[0x1a0236]
XOR EAX,EAX
CALL 0x001205f0
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
CALL 0x0011c845
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x8],XMM0
LAB_001430a1:
MOV dword ptr [RBX + 0x1c],0xffffffff
JMP 0x00143137
LAB_001430ad:
MOV EAX,dword ptr [RBX + 0x14]
LEA EAX,[RAX + RAX*0x2]
MOV R14D,EAX
SHR R14D,0x1f
ADD R14D,EAX
SAR R14D,0x1
CMP ESI,R14D
CMOVG R14D,ESI
MOVSXD RCX,dword ptr [RBX + 0x18]
TEST RCX,RCX
SETNZ AL
CMP EDX,0x100
SETL DL
OR DL,AL
JNZ 0x001430ee
MOV RDI,RBX
MOV ESI,R14D
ADD RSP,0x10
POP RBX
POP R14
POP RBP
JMP 0x0014315e
LAB_001430ee:
MOV EAX,R14D
SHL EAX,CL
MOVSXD RDX,EAX
SUB RDX,RCX
ADD RDX,0x19
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
LEA RCX,[RSP + 0x8]
CALL 0x0011c8be
TEST RAX,RAX
JZ 0x00143142
MOV RDX,qword ptr [RSP + 0x8]
MOV CL,byte ptr [RBX + 0x18]
SHR RDX,CL
ADD R14D,EDX
MOV ECX,0x3fffffff
CMP R14D,ECX
CMOVGE R14D,ECX
MOV dword ptr [RBX + 0x14],R14D
MOV qword ptr [RBX + 0x8],RAX
XOR EBP,EBP
LAB_00143137:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_00143142:
LEA R14,[RBX + 0x8]
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
CALL 0x0011c845
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
JMP 0x001430a1
|
int8 string_buffer_realloc(int8 *param_1,int param_2,int param_3)
{
int iVar1;
int8 uVar2;
long lVar3;
int iVar4;
ulong local_20;
if (*(int *)((long)param_1 + 0x1c) == 0) {
if (param_2 < 0x40000000) {
iVar4 = (*(int *)((long)param_1 + 0x14) * 3) / 2;
if (iVar4 < param_2) {
iVar4 = param_2;
}
iVar1 = *(int *)(param_1 + 3);
if (0xff < param_3 && (long)iVar1 == 0) {
uVar2 = string_buffer_widen(param_1,iVar4);
return uVar2;
}
lVar3 = js_realloc2(*param_1,param_1[1],
((long)(iVar4 << ((byte)iVar1 & 0x1f)) - (long)iVar1) + 0x19,&local_20);
if (lVar3 != 0) {
iVar4 = iVar4 + (int)(local_20 >> (*(byte *)(param_1 + 3) & 0x3f));
if (0x3ffffffe < iVar4) {
iVar4 = 0x3fffffff;
}
*(int *)((long)param_1 + 0x14) = iVar4;
param_1[1] = lVar3;
return 0;
}
js_free(*param_1,param_1[1]);
param_1[1] = 0;
param_1[2] = 0;
}
else {
JS_ThrowRangeError(*param_1,"invalid string length");
js_free(*param_1,param_1[1]);
param_1[1] = 0;
param_1[2] = 0;
}
*(int4 *)((long)param_1 + 0x1c) = 0xffffffff;
}
return 0xffffffff;
}
|
|
64,091 |
ggml_graph_compute
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
enum ggml_status ggml_graph_compute(struct ggml_cgraph * cgraph, struct ggml_cplan * cplan) {
ggml_cpu_init();
GGML_ASSERT(cplan);
GGML_ASSERT(cplan->n_threads > 0);
GGML_ASSERT(cplan->work_size == 0 || cplan->work_data != NULL);
int n_threads = cplan->n_threads;
struct ggml_threadpool * threadpool = cplan->threadpool;
bool disposable_threadpool = false;
if (threadpool == NULL) {
//GGML_PRINT_DEBUG("Threadpool is not specified. Will create a disposable threadpool : n_threads %d\n", n_threads);
disposable_threadpool = true;
struct ggml_threadpool_params ttp = ggml_threadpool_params_default(n_threads);
threadpool = ggml_threadpool_new_impl(&ttp, cgraph, cplan);
} else {
// Reset some of the parameters that need resetting
// No worker threads should be accessing the parameters below at this stage
threadpool->cgraph = cgraph;
threadpool->cplan = cplan;
threadpool->current_chunk = 0;
threadpool->abort = -1;
threadpool->ec = GGML_STATUS_SUCCESS;
}
#ifdef GGML_USE_OPENMP
if (n_threads > 1) {
#pragma omp parallel num_threads(n_threads)
{
#pragma omp single
{
// update the number of threads from the actual number of threads that we got from OpenMP
n_threads = omp_get_num_threads();
atomic_store_explicit(&threadpool->n_threads_cur, n_threads, memory_order_relaxed);
}
ggml_graph_compute_thread(&threadpool->workers[omp_get_thread_num()]);
}
} else {
atomic_store_explicit(&threadpool->n_threads_cur, 1, memory_order_relaxed);
ggml_graph_compute_thread(&threadpool->workers[0]);
}
#else
if (n_threads > threadpool->n_threads_max) {
GGML_LOG_WARN("cplan requested more threads (%d) than available (%d)\n", n_threads, threadpool->n_threads_max);
n_threads = threadpool->n_threads_max;
}
// Kick all threads to start the new graph
ggml_graph_compute_kickoff(threadpool, n_threads);
// This is a work thread too
ggml_graph_compute_thread(&threadpool->workers[0]);
#endif
// don't leave affinity set on the main thread
clear_numa_thread_affinity();
enum ggml_status ret = threadpool->ec;
if (disposable_threadpool) {
ggml_threadpool_free(threadpool);
}
return ret;
}
|
O1
|
c
|
ggml_graph_compute:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
callq 0x87e0
testq %rbx, %rbx
je 0xb058
movl 0x10(%rbx), %ebp
testl %ebp, %ebp
jle 0xb074
cmpq $0x0, (%rbx)
je 0xae98
cmpq $0x0, 0x8(%rbx)
je 0xb090
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0xaed3
movq %r14, 0x58(%r12)
movq %rbx, 0x60(%r12)
xorl %eax, %eax
xchgl %eax, 0xc4(%r12)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xchgl %eax, 0xcc(%r12)
movl $0x0, 0xe8(%r12)
movq %r12, %rbx
jmp 0xaef1
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x8bd0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xaba0
movq %rax, %rbx
movl 0xd8(%rbx), %ecx
cmpl %ecx, %ebp
jle 0xaf16
leaq 0x2bb55(%rip), %rsi # 0x36a57
movl $0x3, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x82d0
movl 0xd8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8850
movl %ebp, 0xdc(%rbx)
lock
incl 0x68(%rbx)
movb 0xc9(%rbx), %al
testb $0x1, %al
je 0xaf88
movl 0xe0(%rbx), %edi
callq 0x21733
movq 0xd0(%rbx), %rdi
cmpb $0x0, 0x8(%rdi)
jne 0xaf77
movq $-0x1, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
je 0xaf69
leaq 0x1(%rax), %rcx
cmpb $0x1, 0xa(%rdi,%rax)
movq %rcx, %rax
jne 0xaf51
jmp 0xaf6e
movl $0x1ff, %ecx # imm = 0x1FF
cmpq $0x1fe, %rcx # imm = 0x1FE
ja 0xaf80
addq $0x8, %rdi
callq 0x217d4
xorl %eax, %eax
xchgb %al, 0xc9(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x81e0
movq %rbx, %rdi
callq 0x8430
movq 0xd0(%rbx), %rdi
callq 0xb1dd
cmpl $0x2, 0x42728(%rip) # 0x4d6d4
jb 0xb02a
movl 0x42724(%rip), %edi # 0x4d6d8
leaq 0x3f(%rdi), %r15
shrq $0x3, %r15
andl $-0x8, %r15d
callq 0x8550
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x8330
movl 0x426fd(%rip), %eax # 0x4d6d8
testq %rax, %rax
je 0xb00b
xorl %ecx, %ecx
movl $0x1, %edx
movq %rcx, %rsi
shrq $0x3, %rsi
cmpq %r15, %rsi
jae 0xb003
shlxq %rcx, %rdx, %rsi
movq %rcx, %rdi
shrq $0x6, %rdi
orq %rsi, (%r14,%rdi,8)
incq %rcx
cmpq %rcx, %rax
jne 0xafe7
callq 0x8570
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8a50
testl %eax, %eax
jne 0xb04f
movq %r14, %rdi
callq 0x8810
movl 0xe8(%rbx), %ebp
testq %r12, %r12
jne 0xb03d
movq %rbx, %rdi
callq 0x8c48
movl %ebp, %eax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x8cf5
jmp 0xb022
leaq 0x2b663(%rip), %rdi # 0x366c2
leaq 0x2b6bb(%rip), %rdx # 0x36721
leaq 0x2b99d(%rip), %rcx # 0x36a0a
movl $0x36c3, %esi # imm = 0x36C3
jmp 0xb0aa
leaq 0x2b647(%rip), %rdi # 0x366c2
leaq 0x2b69f(%rip), %rdx # 0x36721
leaq 0x2b987(%rip), %rcx # 0x36a10
movl $0x36c4, %esi # imm = 0x36C4
jmp 0xb0aa
leaq 0x2b62b(%rip), %rdi # 0x366c2
leaq 0x2b683(%rip), %rdx # 0x36721
leaq 0x2b980(%rip), %rcx # 0x36a25
movl $0x36c5, %esi # imm = 0x36C5
xorl %eax, %eax
callq 0x89c0
|
ggml_graph_compute:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 210h
mov rbx, rsi
mov r14, rdi
call _ggml_cpu_init
test rbx, rbx
jz loc_B058
mov ebp, [rbx+10h]
test ebp, ebp
jle loc_B074
cmp qword ptr [rbx], 0
jz short loc_AE98
cmp qword ptr [rbx+8], 0
jz loc_B090
loc_AE98:
mov r12, [rbx+18h]
test r12, r12
jz short loc_AED3
mov [r12+58h], r14
mov [r12+60h], rbx
xor eax, eax
xchg eax, [r12+0C4h]
mov eax, 0FFFFFFFFh
xchg eax, [r12+0CCh]
mov dword ptr [r12+0E8h], 0
mov rbx, r12
jmp short loc_AEF1
loc_AED3:
mov r15, rsp
mov rdi, r15
mov esi, ebp
call _ggml_threadpool_params_default
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ggml_threadpool_new_impl
mov rbx, rax
loc_AEF1:
mov ecx, [rbx+0D8h]
cmp ebp, ecx
jle short loc_AF16
lea rsi, aCplanRequested; "cplan requested more threads (%d) than "...
mov edi, 3
mov edx, ebp
xor eax, eax
call _ggml_log_internal
mov ebp, [rbx+0D8h]
loc_AF16:
mov rdi, rbx
call _pthread_mutex_lock
mov [rbx+0DCh], ebp
lock inc dword ptr [rbx+68h]
mov al, [rbx+0C9h]
test al, 1
jz short loc_AF88
mov edi, [rbx+0E0h]
call ggml_thread_apply_priority
mov rdi, [rbx+0D0h]
cmp byte ptr [rdi+8], 0
jnz short loc_AF77
mov rax, 0FFFFFFFFFFFFFFFFh
loc_AF51:
cmp rax, 1FEh
jz short loc_AF69
lea rcx, [rax+1]
cmp byte ptr [rdi+rax+0Ah], 1
mov rax, rcx
jnz short loc_AF51
jmp short loc_AF6E
loc_AF69:
mov ecx, 1FFh
loc_AF6E:
cmp rcx, 1FEh
ja short loc_AF80
loc_AF77:
add rdi, 8
call ggml_thread_apply_affinity
loc_AF80:
xor eax, eax
xchg al, [rbx+0C9h]
loc_AF88:
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, [rbx+0D0h]
call ggml_graph_compute_thread
cmp cs:dword_4D6D4, 2
jb short loc_B02A
mov edi, cs:dword_4D6D8
lea r15, [rdi+3Fh]
shr r15, 3
and r15d, 0FFFFFFF8h
call ___sched_cpualloc
mov r14, rax
mov rdi, rax
xor esi, esi
mov rdx, r15
call _memset
mov eax, cs:dword_4D6D8
test rax, rax
jz short loc_B00B
xor ecx, ecx
mov edx, 1
loc_AFE7:
mov rsi, rcx
shr rsi, 3
cmp rsi, r15
jnb short loc_B003
shlx rsi, rdx, rcx
mov rdi, rcx
shr rdi, 6
or [r14+rdi*8], rsi
loc_B003:
inc rcx
cmp rax, rcx
jnz short loc_AFE7
loc_B00B:
call _pthread_self
mov rdi, rax
mov rsi, r15
mov rdx, r14
call _pthread_setaffinity_np
test eax, eax
jnz short loc_B04F
loc_B022:
mov rdi, r14
call ___sched_cpufree
loc_B02A:
mov ebp, [rbx+0E8h]
test r12, r12
jnz short loc_B03D
mov rdi, rbx
call j_ggml_threadpool_free
loc_B03D:
mov eax, ebp
add rsp, 210h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B04F:
mov edi, eax
call ggml_graph_compute_cold_1
jmp short loc_B022
loc_B058:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplan; "cplan"
mov esi, 36C3h
jmp short loc_B0AA
loc_B074:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplanNThreads0; "cplan->n_threads > 0"
mov esi, 36C4h
jmp short loc_B0AA
loc_B090:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplanWorkSize0; "cplan->work_size == 0 || cplan->work_da"...
mov esi, 36C5h
loc_B0AA:
xor eax, eax
call _ggml_abort
|
long long ggml_graph_compute(long long a1, long long a2)
{
int v2; // ebp
long long v3; // r12
long long v4; // rbx
int v5; // ecx
long long v6; // rdi
long long v7; // rax
unsigned long long v8; // rcx
unsigned long long v10; // r15
long long v11; // r14
long long v12; // rax
unsigned long long v13; // rcx
long long v14; // rax
unsigned int v15; // ebp
_BYTE v17[568]; // [rsp+0h] [rbp-238h] BYREF
ggml_cpu_init();
if ( !a2 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14019LL,
"GGML_ASSERT(%s) failed",
"cplan");
return ggml_cpu_init();
}
v2 = *(_DWORD *)(a2 + 16);
if ( v2 <= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14020LL,
"GGML_ASSERT(%s) failed",
"cplan->n_threads > 0");
return ggml_cpu_init();
}
if ( *(_QWORD *)a2 && !*(_QWORD *)(a2 + 8) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14021LL,
"GGML_ASSERT(%s) failed",
"cplan->work_size == 0 || cplan->work_data != NULL");
return ggml_cpu_init();
}
v3 = *(_QWORD *)(a2 + 24);
if ( v3 )
{
*(_QWORD *)(v3 + 88) = a1;
*(_QWORD *)(v3 + 96) = a2;
_InterlockedExchange((volatile __int32 *)(v3 + 196), 0);
_InterlockedExchange((volatile __int32 *)(v3 + 204), -1);
*(_DWORD *)(v3 + 232) = 0;
v4 = v3;
}
else
{
ggml_threadpool_params_default(v17, (unsigned int)v2);
v4 = ggml_threadpool_new_impl((long long)v17, a1, a2);
}
v5 = *(_DWORD *)(v4 + 216);
if ( v2 > v5 )
{
ggml_log_internal(3LL, "cplan requested more threads (%d) than available (%d)\n", v2, v5);
v2 = *(_DWORD *)(v4 + 216);
}
pthread_mutex_lock(v4);
*(_DWORD *)(v4 + 220) = v2;
_InterlockedIncrement((volatile signed __int32 *)(v4 + 104));
if ( (*(_BYTE *)(v4 + 201) & 1) != 0 )
{
ggml_thread_apply_priority(*(unsigned int *)(v4 + 224));
v6 = *(_QWORD *)(v4 + 208);
if ( *(_BYTE *)(v6 + 8) )
goto LABEL_18;
v7 = -1LL;
while ( v7 != 510 )
{
v8 = v7 + 1;
if ( *(_BYTE *)(v6 + v7++ + 10) == 1 )
goto LABEL_17;
}
v8 = 511LL;
LABEL_17:
if ( v8 <= 0x1FE )
LABEL_18:
ggml_thread_apply_affinity(v6 + 8);
*(_BYTE *)(v4 + 201) = 0;
}
pthread_cond_broadcast(v4 + 40);
pthread_mutex_unlock(v4);
ggml_graph_compute_thread(*(_QWORD *)(v4 + 208));
if ( (unsigned int)dword_4D6D4 >= 2 )
{
v10 = (((unsigned long long)(unsigned int)dword_4D6D8 + 63) >> 3) & 0xFFFFFFF8;
v11 = __sched_cpualloc();
memset(v11, 0LL, v10);
v12 = (unsigned int)dword_4D6D8;
if ( dword_4D6D8 )
{
v13 = 0LL;
do
{
if ( v13 >> 3 < v10 )
*(_QWORD *)(v11 + 8 * (v13 >> 6)) |= 1LL << v13;
++v13;
}
while ( v12 != v13 );
}
v14 = pthread_self();
if ( (unsigned int)pthread_setaffinity_np(v14, v10, v11) )
ggml_graph_compute_cold_1();
__sched_cpufree(v11);
}
v15 = *(_DWORD *)(v4 + 232);
if ( !v3 )
j_ggml_threadpool_free(v4);
return v15;
}
|
ggml_graph_compute:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x210
MOV RBX,RSI
MOV R14,RDI
CALL 0x001087e0
TEST RBX,RBX
JZ 0x0010b058
MOV EBP,dword ptr [RBX + 0x10]
TEST EBP,EBP
JLE 0x0010b074
CMP qword ptr [RBX],0x0
JZ 0x0010ae98
CMP qword ptr [RBX + 0x8],0x0
JZ 0x0010b090
LAB_0010ae98:
MOV R12,qword ptr [RBX + 0x18]
TEST R12,R12
JZ 0x0010aed3
MOV qword ptr [R12 + 0x58],R14
MOV qword ptr [R12 + 0x60],RBX
XOR EAX,EAX
XCHG dword ptr [R12 + 0xc4],EAX
MOV EAX,0xffffffff
XCHG dword ptr [R12 + 0xcc],EAX
MOV dword ptr [R12 + 0xe8],0x0
MOV RBX,R12
JMP 0x0010aef1
LAB_0010aed3:
MOV R15,RSP
MOV RDI,R15
MOV ESI,EBP
CALL 0x00108bd0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0010aba0
MOV RBX,RAX
LAB_0010aef1:
MOV ECX,dword ptr [RBX + 0xd8]
CMP EBP,ECX
JLE 0x0010af16
LEA RSI,[0x136a57]
MOV EDI,0x3
MOV EDX,EBP
XOR EAX,EAX
CALL 0x001082d0
MOV EBP,dword ptr [RBX + 0xd8]
LAB_0010af16:
MOV RDI,RBX
CALL 0x00108850
MOV dword ptr [RBX + 0xdc],EBP
INC.LOCK dword ptr [RBX + 0x68]
MOV AL,byte ptr [RBX + 0xc9]
TEST AL,0x1
JZ 0x0010af88
MOV EDI,dword ptr [RBX + 0xe0]
CALL 0x00121733
MOV RDI,qword ptr [RBX + 0xd0]
CMP byte ptr [RDI + 0x8],0x0
JNZ 0x0010af77
MOV RAX,-0x1
LAB_0010af51:
CMP RAX,0x1fe
JZ 0x0010af69
LEA RCX,[RAX + 0x1]
CMP byte ptr [RDI + RAX*0x1 + 0xa],0x1
MOV RAX,RCX
JNZ 0x0010af51
JMP 0x0010af6e
LAB_0010af69:
MOV ECX,0x1ff
LAB_0010af6e:
CMP RCX,0x1fe
JA 0x0010af80
LAB_0010af77:
ADD RDI,0x8
CALL 0x001217d4
LAB_0010af80:
XOR EAX,EAX
XCHG byte ptr [RBX + 0xc9],AL
LAB_0010af88:
LEA RDI,[RBX + 0x28]
CALL 0x001081e0
MOV RDI,RBX
CALL 0x00108430
MOV RDI,qword ptr [RBX + 0xd0]
CALL 0x0010b1dd
CMP dword ptr [0x0014d6d4],0x2
JC 0x0010b02a
MOV EDI,dword ptr [0x0014d6d8]
LEA R15,[RDI + 0x3f]
SHR R15,0x3
AND R15D,0xfffffff8
CALL 0x00108550
MOV R14,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R15
CALL 0x00108330
MOV EAX,dword ptr [0x0014d6d8]
TEST RAX,RAX
JZ 0x0010b00b
XOR ECX,ECX
MOV EDX,0x1
LAB_0010afe7:
MOV RSI,RCX
SHR RSI,0x3
CMP RSI,R15
JNC 0x0010b003
SHLX RSI,RDX,RCX
MOV RDI,RCX
SHR RDI,0x6
OR qword ptr [R14 + RDI*0x8],RSI
LAB_0010b003:
INC RCX
CMP RAX,RCX
JNZ 0x0010afe7
LAB_0010b00b:
CALL 0x00108570
MOV RDI,RAX
MOV RSI,R15
MOV RDX,R14
CALL 0x00108a50
TEST EAX,EAX
JNZ 0x0010b04f
LAB_0010b022:
MOV RDI,R14
CALL 0x00108810
LAB_0010b02a:
MOV EBP,dword ptr [RBX + 0xe8]
TEST R12,R12
JNZ 0x0010b03d
MOV RDI,RBX
CALL 0x00108c48
LAB_0010b03d:
MOV EAX,EBP
ADD RSP,0x210
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010b04f:
MOV EDI,EAX
CALL 0x00108cf5
JMP 0x0010b022
LAB_0010b058:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136a0a]
MOV ESI,0x36c3
JMP 0x0010b0aa
LAB_0010b074:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136a10]
MOV ESI,0x36c4
JMP 0x0010b0aa
LAB_0010b090:
LEA RDI,[0x1366c2]
LEA RDX,[0x136721]
LEA RCX,[0x136a25]
MOV ESI,0x36c5
LAB_0010b0aa:
XOR EAX,EAX
CALL 0x001089c0
|
int4 ggml_graph_compute(int8 param_1,long *param_2)
{
int4 uVar1;
pthread_mutex_t *ppVar2;
long lVar3;
int iVar4;
pthread_mutex_t *__mutex;
cpu_set_t *__cpuset;
ulong uVar5;
pthread_t __th;
ulong uVar6;
ulong uVar7;
char *pcVar8;
int8 uVar9;
int1 auStack_238 [528];
ggml_cpu_init();
if (param_2 == (long *)0x0) {
pcVar8 = "cplan";
uVar9 = 0x36c3;
LAB_0010b0aa:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,uVar9,"GGML_ASSERT(%s) failed",pcVar8);
}
iVar4 = (int)param_2[2];
if (iVar4 < 1) {
pcVar8 = "cplan->n_threads > 0";
uVar9 = 0x36c4;
goto LAB_0010b0aa;
}
if ((*param_2 != 0) && (param_2[1] == 0)) {
pcVar8 = "cplan->work_size == 0 || cplan->work_data != NULL";
uVar9 = 0x36c5;
goto LAB_0010b0aa;
}
ppVar2 = (pthread_mutex_t *)param_2[3];
if (ppVar2 == (pthread_mutex_t *)0x0) {
ggml_threadpool_params_default(auStack_238,iVar4);
__mutex = (pthread_mutex_t *)ggml_threadpool_new_impl(auStack_238,param_1,param_2);
}
else {
*(int8 *)((long)ppVar2 + 0x58) = param_1;
*(long **)((long)ppVar2 + 0x60) = param_2;
LOCK();
*(int4 *)((long)ppVar2 + 0xc4) = 0;
UNLOCK();
LOCK();
*(int4 *)((long)ppVar2 + 0xcc) = 0xffffffff;
UNLOCK();
*(int4 *)((long)ppVar2 + 0xe8) = 0;
__mutex = ppVar2;
}
if (*(int *)((long)__mutex + 0xd8) < iVar4) {
ggml_log_internal(3,"cplan requested more threads (%d) than available (%d)\n",iVar4);
iVar4 = *(int *)((long)__mutex + 0xd8);
}
pthread_mutex_lock(__mutex);
*(int *)((long)__mutex + 0xdc) = iVar4;
LOCK();
*(int *)((long)__mutex + 0x68) = *(int *)((long)__mutex + 0x68) + 1;
UNLOCK();
if ((*(byte *)((long)__mutex + 0xc9) & 1) == 0) goto LAB_0010af88;
ggml_thread_apply_priority(*(int4 *)((long)__mutex + 0xe0));
lVar3 = *(long *)((long)__mutex + 0xd0);
if (*(char *)(lVar3 + 8) == '\0') {
uVar5 = 0xffffffffffffffff;
do {
if (uVar5 == 0x1fe) {
uVar6 = 0x1ff;
break;
}
uVar6 = uVar5 + 1;
pcVar8 = (char *)(lVar3 + 10 + uVar5);
uVar5 = uVar6;
} while (*pcVar8 != '\x01');
if (uVar6 < 0x1ff) goto LAB_0010af77;
}
else {
LAB_0010af77:
ggml_thread_apply_affinity(lVar3 + 8);
}
LOCK();
*(int1 *)((long)__mutex + 0xc9) = 0;
UNLOCK();
LAB_0010af88:
pthread_cond_broadcast((pthread_cond_t *)(__mutex + 1));
pthread_mutex_unlock(__mutex);
ggml_graph_compute_thread(*(int8 *)((long)__mutex + 0xd0));
if (1 < DAT_0014d6d4) {
uVar6 = (ulong)((uint)((ulong)DAT_0014d6d8 + 0x3f >> 3) & 0xfffffff8);
__cpuset = __sched_cpualloc((ulong)DAT_0014d6d8);
memset(__cpuset,0,uVar6);
uVar5 = (ulong)DAT_0014d6d8;
if (uVar5 != 0) {
uVar7 = 0;
do {
if (uVar7 >> 3 < uVar6) {
__cpuset->__bits[uVar7 >> 6] = __cpuset->__bits[uVar7 >> 6] | 1L << (uVar7 & 0x3f);
}
uVar7 = uVar7 + 1;
} while (uVar5 != uVar7);
}
__th = pthread_self();
iVar4 = pthread_setaffinity_np(__th,uVar6,__cpuset);
if (iVar4 != 0) {
ggml_graph_compute_cold_1(iVar4);
}
__sched_cpufree(__cpuset);
}
uVar1 = *(int4 *)((long)__mutex + 0xe8);
if (ppVar2 == (pthread_mutex_t *)0x0) {
ggml_threadpool_free(__mutex);
}
return uVar1;
}
|
|
64,092 |
ggml_graph_compute
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
enum ggml_status ggml_graph_compute(struct ggml_cgraph * cgraph, struct ggml_cplan * cplan) {
ggml_cpu_init();
GGML_ASSERT(cplan);
GGML_ASSERT(cplan->n_threads > 0);
GGML_ASSERT(cplan->work_size == 0 || cplan->work_data != NULL);
int n_threads = cplan->n_threads;
struct ggml_threadpool * threadpool = cplan->threadpool;
bool disposable_threadpool = false;
if (threadpool == NULL) {
//GGML_PRINT_DEBUG("Threadpool is not specified. Will create a disposable threadpool : n_threads %d\n", n_threads);
disposable_threadpool = true;
struct ggml_threadpool_params ttp = ggml_threadpool_params_default(n_threads);
threadpool = ggml_threadpool_new_impl(&ttp, cgraph, cplan);
} else {
// Reset some of the parameters that need resetting
// No worker threads should be accessing the parameters below at this stage
threadpool->cgraph = cgraph;
threadpool->cplan = cplan;
threadpool->current_chunk = 0;
threadpool->abort = -1;
threadpool->ec = GGML_STATUS_SUCCESS;
}
#ifdef GGML_USE_OPENMP
if (n_threads > 1) {
#pragma omp parallel num_threads(n_threads)
{
#pragma omp single
{
// update the number of threads from the actual number of threads that we got from OpenMP
n_threads = omp_get_num_threads();
atomic_store_explicit(&threadpool->n_threads_cur, n_threads, memory_order_relaxed);
}
ggml_graph_compute_thread(&threadpool->workers[omp_get_thread_num()]);
}
} else {
atomic_store_explicit(&threadpool->n_threads_cur, 1, memory_order_relaxed);
ggml_graph_compute_thread(&threadpool->workers[0]);
}
#else
if (n_threads > threadpool->n_threads_max) {
GGML_LOG_WARN("cplan requested more threads (%d) than available (%d)\n", n_threads, threadpool->n_threads_max);
n_threads = threadpool->n_threads_max;
}
// Kick all threads to start the new graph
ggml_graph_compute_kickoff(threadpool, n_threads);
// This is a work thread too
ggml_graph_compute_thread(&threadpool->workers[0]);
#endif
// don't leave affinity set on the main thread
clear_numa_thread_affinity();
enum ggml_status ret = threadpool->ec;
if (disposable_threadpool) {
ggml_threadpool_free(threadpool);
}
return ret;
}
|
O3
|
c
|
ggml_graph_compute:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
callq 0x87e0
testq %rbx, %rbx
je 0xb534
movl 0x10(%rbx), %ebp
testl %ebp, %ebp
jle 0xb550
cmpq $0x0, (%rbx)
je 0xb36a
cmpq $0x0, 0x8(%rbx)
je 0xb56c
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0xb3a5
movq %r14, 0x58(%r12)
movq %rbx, 0x60(%r12)
xorl %eax, %eax
xchgl %eax, 0xc4(%r12)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xchgl %eax, 0xcc(%r12)
movl $0x0, 0xe8(%r12)
movq %r12, %rbx
jmp 0xb3c3
movq %rsp, %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x8bd0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb00b
movq %rax, %rbx
movl 0xd8(%rbx), %ecx
cmpl %ecx, %ebp
jle 0xb3e8
leaq 0x2b82b(%rip), %rsi # 0x36bff
movl $0x3, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x82d0
movl 0xd8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8850
movl %ebp, 0xdc(%rbx)
lock
incl 0x68(%rbx)
movb 0xc9(%rbx), %al
testb $0x1, %al
je 0xb431
movl 0xe0(%rbx), %edi
callq 0x22053
movq 0xd0(%rbx), %rdi
cmpb $0x0, 0x8(%rdi)
je 0xb4f8
addq $0x8, %rdi
callq 0x220e8
xorl %eax, %eax
xchgb %al, 0xc9(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x81e0
movq %rbx, %rdi
callq 0x8430
movq 0xd0(%rbx), %rdi
callq 0xb6b9
cmpl $0x2, 0x4227f(%rip) # 0x4d6d4
jb 0xb4d3
movl 0x4227b(%rip), %edi # 0x4d6d8
leaq 0x3f(%rdi), %r15
shrq $0x3, %r15
andl $-0x8, %r15d
callq 0x8550
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x8330
movl 0x42254(%rip), %eax # 0x4d6d8
testq %rax, %rax
je 0xb4b4
xorl %ecx, %ecx
movl $0x1, %edx
movq %rcx, %rsi
shrq $0x3, %rsi
cmpq %r15, %rsi
jae 0xb4ac
shlxq %rcx, %rdx, %rsi
movq %rcx, %rdi
shrq $0x6, %rdi
orq %rsi, (%r14,%rdi,8)
incq %rcx
cmpq %rcx, %rax
jne 0xb490
callq 0x8570
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8a50
testl %eax, %eax
jne 0xb52b
movq %r14, %rdi
callq 0x8810
movl 0xe8(%rbx), %ebp
testq %r12, %r12
jne 0xb4e6
movq %rbx, %rdi
callq 0x8c48
movl %ebp, %eax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $-0x1, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
je 0xb429
leaq 0x1(%rax), %rcx
cmpb $0x1, 0xa(%rdi,%rax)
movq %rcx, %rax
jne 0xb4ff
cmpq $0x1fe, %rcx # imm = 0x1FE
jbe 0xb420
jmp 0xb429
movl %eax, %edi
callq 0x8cf5
jmp 0xb4cb
leaq 0x2b32f(%rip), %rdi # 0x3686a
leaq 0x2b387(%rip), %rdx # 0x368c9
leaq 0x2b669(%rip), %rcx # 0x36bb2
movl $0x36c3, %esi # imm = 0x36C3
jmp 0xb586
leaq 0x2b313(%rip), %rdi # 0x3686a
leaq 0x2b36b(%rip), %rdx # 0x368c9
leaq 0x2b653(%rip), %rcx # 0x36bb8
movl $0x36c4, %esi # imm = 0x36C4
jmp 0xb586
leaq 0x2b2f7(%rip), %rdi # 0x3686a
leaq 0x2b34f(%rip), %rdx # 0x368c9
leaq 0x2b64c(%rip), %rcx # 0x36bcd
movl $0x36c5, %esi # imm = 0x36C5
xorl %eax, %eax
callq 0x89c0
|
ggml_graph_compute:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 210h
mov rbx, rsi
mov r14, rdi
call _ggml_cpu_init
test rbx, rbx
jz loc_B534
mov ebp, [rbx+10h]
test ebp, ebp
jle loc_B550
cmp qword ptr [rbx], 0
jz short loc_B36A
cmp qword ptr [rbx+8], 0
jz loc_B56C
loc_B36A:
mov r12, [rbx+18h]
test r12, r12
jz short loc_B3A5
mov [r12+58h], r14
mov [r12+60h], rbx
xor eax, eax
xchg eax, [r12+0C4h]
mov eax, 0FFFFFFFFh
xchg eax, [r12+0CCh]
mov dword ptr [r12+0E8h], 0
mov rbx, r12
jmp short loc_B3C3
loc_B3A5:
mov r15, rsp
mov rdi, r15
mov esi, ebp
call _ggml_threadpool_params_default
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ggml_threadpool_new_impl
mov rbx, rax
loc_B3C3:
mov ecx, [rbx+0D8h]
cmp ebp, ecx
jle short loc_B3E8
lea rsi, aCplanRequested; "cplan requested more threads (%d) than "...
mov edi, 3
mov edx, ebp
xor eax, eax
call _ggml_log_internal
mov ebp, [rbx+0D8h]
loc_B3E8:
mov rdi, rbx
call _pthread_mutex_lock
mov [rbx+0DCh], ebp
lock inc dword ptr [rbx+68h]
mov al, [rbx+0C9h]
test al, 1
jz short loc_B431
mov edi, [rbx+0E0h]
call ggml_thread_apply_priority
mov rdi, [rbx+0D0h]
cmp byte ptr [rdi+8], 0
jz loc_B4F8
loc_B420:
add rdi, 8
call ggml_thread_apply_affinity
loc_B429:
xor eax, eax
xchg al, [rbx+0C9h]
loc_B431:
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, [rbx+0D0h]
call ggml_graph_compute_thread
cmp cs:dword_4D6D4, 2
jb short loc_B4D3
mov edi, cs:dword_4D6D8
lea r15, [rdi+3Fh]
shr r15, 3
and r15d, 0FFFFFFF8h
call ___sched_cpualloc
mov r14, rax
mov rdi, rax
xor esi, esi
mov rdx, r15
call _memset
mov eax, cs:dword_4D6D8
test rax, rax
jz short loc_B4B4
xor ecx, ecx
mov edx, 1
loc_B490:
mov rsi, rcx
shr rsi, 3
cmp rsi, r15
jnb short loc_B4AC
shlx rsi, rdx, rcx
mov rdi, rcx
shr rdi, 6
or [r14+rdi*8], rsi
loc_B4AC:
inc rcx
cmp rax, rcx
jnz short loc_B490
loc_B4B4:
call _pthread_self
mov rdi, rax
mov rsi, r15
mov rdx, r14
call _pthread_setaffinity_np
test eax, eax
jnz short loc_B52B
loc_B4CB:
mov rdi, r14
call ___sched_cpufree
loc_B4D3:
mov ebp, [rbx+0E8h]
test r12, r12
jnz short loc_B4E6
mov rdi, rbx
call j_ggml_threadpool_free
loc_B4E6:
mov eax, ebp
add rsp, 210h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B4F8:
mov rax, 0FFFFFFFFFFFFFFFFh
loc_B4FF:
cmp rax, 1FEh
jz loc_B429
lea rcx, [rax+1]
cmp byte ptr [rdi+rax+0Ah], 1
mov rax, rcx
jnz short loc_B4FF
cmp rcx, 1FEh
jbe loc_B420
jmp loc_B429
loc_B52B:
mov edi, eax
call ggml_graph_compute_cold_1
jmp short loc_B4CB
loc_B534:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplan; "cplan"
mov esi, 36C3h
jmp short loc_B586
loc_B550:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplanNThreads0; "cplan->n_threads > 0"
mov esi, 36C4h
jmp short loc_B586
loc_B56C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCplanWorkSize0; "cplan->work_size == 0 || cplan->work_da"...
mov esi, 36C5h
loc_B586:
xor eax, eax
call _ggml_abort
|
long long ggml_graph_compute(long long a1, long long a2)
{
int v2; // ebp
long long v3; // r12
long long v4; // rbx
int v5; // ecx
long long v6; // rdi
unsigned long long v7; // r15
long long v8; // r14
long long v9; // rax
unsigned long long v10; // rcx
long long v11; // rax
unsigned int v12; // ebp
long long v14; // rax
unsigned long long v15; // rcx
_BYTE v17[568]; // [rsp+0h] [rbp-238h] BYREF
ggml_cpu_init();
if ( !a2 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14019LL,
"GGML_ASSERT(%s) failed",
"cplan");
return ggml_cpu_init();
}
v2 = *(_DWORD *)(a2 + 16);
if ( v2 <= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14020LL,
"GGML_ASSERT(%s) failed",
"cplan->n_threads > 0");
return ggml_cpu_init();
}
if ( *(_QWORD *)a2 && !*(_QWORD *)(a2 + 8) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
14021LL,
"GGML_ASSERT(%s) failed",
"cplan->work_size == 0 || cplan->work_data != NULL");
return ggml_cpu_init();
}
v3 = *(_QWORD *)(a2 + 24);
if ( v3 )
{
*(_QWORD *)(v3 + 88) = a1;
*(_QWORD *)(v3 + 96) = a2;
_InterlockedExchange((volatile __int32 *)(v3 + 196), 0);
_InterlockedExchange((volatile __int32 *)(v3 + 204), -1);
*(_DWORD *)(v3 + 232) = 0;
v4 = v3;
}
else
{
ggml_threadpool_params_default(v17, (unsigned int)v2);
v4 = ggml_threadpool_new_impl((long long)v17, a1, a2);
}
v5 = *(_DWORD *)(v4 + 216);
if ( v2 > v5 )
{
ggml_log_internal(3LL, "cplan requested more threads (%d) than available (%d)\n", v2, v5);
v2 = *(_DWORD *)(v4 + 216);
}
pthread_mutex_lock(v4);
*(_DWORD *)(v4 + 220) = v2;
_InterlockedIncrement((volatile signed __int32 *)(v4 + 104));
if ( (*(_BYTE *)(v4 + 201) & 1) != 0 )
{
ggml_thread_apply_priority(*(unsigned int *)(v4 + 224));
v6 = *(_QWORD *)(v4 + 208);
if ( *(_BYTE *)(v6 + 8) )
{
LABEL_12:
ggml_thread_apply_affinity(v6 + 8);
}
else
{
v14 = -1LL;
while ( v14 != 510 )
{
v15 = v14 + 1;
if ( *(_BYTE *)(v6 + v14++ + 10) == 1 )
{
if ( v15 <= 0x1FE )
goto LABEL_12;
break;
}
}
}
*(_BYTE *)(v4 + 201) = 0;
}
pthread_cond_broadcast(v4 + 40);
pthread_mutex_unlock(v4);
ggml_graph_compute_thread(*(_QWORD *)(v4 + 208));
if ( (unsigned int)dword_4D6D4 >= 2 )
{
v7 = (((unsigned long long)(unsigned int)dword_4D6D8 + 63) >> 3) & 0xFFFFFFF8;
v8 = __sched_cpualloc();
memset(v8, 0LL, v7);
v9 = (unsigned int)dword_4D6D8;
if ( dword_4D6D8 )
{
v10 = 0LL;
do
{
if ( v10 >> 3 < v7 )
*(_QWORD *)(v8 + 8 * (v10 >> 6)) |= 1LL << v10;
++v10;
}
while ( v9 != v10 );
}
v11 = pthread_self();
if ( (unsigned int)pthread_setaffinity_np(v11, v7, v8) )
ggml_graph_compute_cold_1();
__sched_cpufree(v8);
}
v12 = *(_DWORD *)(v4 + 232);
if ( !v3 )
j_ggml_threadpool_free(v4);
return v12;
}
|
ggml_graph_compute:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x210
MOV RBX,RSI
MOV R14,RDI
CALL 0x001087e0
TEST RBX,RBX
JZ 0x0010b534
MOV EBP,dword ptr [RBX + 0x10]
TEST EBP,EBP
JLE 0x0010b550
CMP qword ptr [RBX],0x0
JZ 0x0010b36a
CMP qword ptr [RBX + 0x8],0x0
JZ 0x0010b56c
LAB_0010b36a:
MOV R12,qword ptr [RBX + 0x18]
TEST R12,R12
JZ 0x0010b3a5
MOV qword ptr [R12 + 0x58],R14
MOV qword ptr [R12 + 0x60],RBX
XOR EAX,EAX
XCHG dword ptr [R12 + 0xc4],EAX
MOV EAX,0xffffffff
XCHG dword ptr [R12 + 0xcc],EAX
MOV dword ptr [R12 + 0xe8],0x0
MOV RBX,R12
JMP 0x0010b3c3
LAB_0010b3a5:
MOV R15,RSP
MOV RDI,R15
MOV ESI,EBP
CALL 0x00108bd0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0010b00b
MOV RBX,RAX
LAB_0010b3c3:
MOV ECX,dword ptr [RBX + 0xd8]
CMP EBP,ECX
JLE 0x0010b3e8
LEA RSI,[0x136bff]
MOV EDI,0x3
MOV EDX,EBP
XOR EAX,EAX
CALL 0x001082d0
MOV EBP,dword ptr [RBX + 0xd8]
LAB_0010b3e8:
MOV RDI,RBX
CALL 0x00108850
MOV dword ptr [RBX + 0xdc],EBP
INC.LOCK dword ptr [RBX + 0x68]
MOV AL,byte ptr [RBX + 0xc9]
TEST AL,0x1
JZ 0x0010b431
MOV EDI,dword ptr [RBX + 0xe0]
CALL 0x00122053
MOV RDI,qword ptr [RBX + 0xd0]
CMP byte ptr [RDI + 0x8],0x0
JZ 0x0010b4f8
LAB_0010b420:
ADD RDI,0x8
CALL 0x001220e8
LAB_0010b429:
XOR EAX,EAX
XCHG byte ptr [RBX + 0xc9],AL
LAB_0010b431:
LEA RDI,[RBX + 0x28]
CALL 0x001081e0
MOV RDI,RBX
CALL 0x00108430
MOV RDI,qword ptr [RBX + 0xd0]
CALL 0x0010b6b9
CMP dword ptr [0x0014d6d4],0x2
JC 0x0010b4d3
MOV EDI,dword ptr [0x0014d6d8]
LEA R15,[RDI + 0x3f]
SHR R15,0x3
AND R15D,0xfffffff8
CALL 0x00108550
MOV R14,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R15
CALL 0x00108330
MOV EAX,dword ptr [0x0014d6d8]
TEST RAX,RAX
JZ 0x0010b4b4
XOR ECX,ECX
MOV EDX,0x1
LAB_0010b490:
MOV RSI,RCX
SHR RSI,0x3
CMP RSI,R15
JNC 0x0010b4ac
SHLX RSI,RDX,RCX
MOV RDI,RCX
SHR RDI,0x6
OR qword ptr [R14 + RDI*0x8],RSI
LAB_0010b4ac:
INC RCX
CMP RAX,RCX
JNZ 0x0010b490
LAB_0010b4b4:
CALL 0x00108570
MOV RDI,RAX
MOV RSI,R15
MOV RDX,R14
CALL 0x00108a50
TEST EAX,EAX
JNZ 0x0010b52b
LAB_0010b4cb:
MOV RDI,R14
CALL 0x00108810
LAB_0010b4d3:
MOV EBP,dword ptr [RBX + 0xe8]
TEST R12,R12
JNZ 0x0010b4e6
MOV RDI,RBX
CALL 0x00108c48
LAB_0010b4e6:
MOV EAX,EBP
ADD RSP,0x210
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010b4f8:
MOV RAX,-0x1
LAB_0010b4ff:
CMP RAX,0x1fe
JZ 0x0010b429
LEA RCX,[RAX + 0x1]
CMP byte ptr [RDI + RAX*0x1 + 0xa],0x1
MOV RAX,RCX
JNZ 0x0010b4ff
CMP RCX,0x1fe
JBE 0x0010b420
JMP 0x0010b429
LAB_0010b52b:
MOV EDI,EAX
CALL 0x00108cf5
JMP 0x0010b4cb
LAB_0010b534:
LEA RDI,[0x13686a]
LEA RDX,[0x1368c9]
LEA RCX,[0x136bb2]
MOV ESI,0x36c3
JMP 0x0010b586
LAB_0010b550:
LEA RDI,[0x13686a]
LEA RDX,[0x1368c9]
LEA RCX,[0x136bb8]
MOV ESI,0x36c4
JMP 0x0010b586
LAB_0010b56c:
LEA RDI,[0x13686a]
LEA RDX,[0x1368c9]
LEA RCX,[0x136bcd]
MOV ESI,0x36c5
LAB_0010b586:
XOR EAX,EAX
CALL 0x001089c0
|
int4 ggml_graph_compute(int8 param_1,long *param_2)
{
int4 uVar1;
pthread_mutex_t *ppVar2;
long lVar3;
int iVar4;
pthread_mutex_t *__mutex;
cpu_set_t *__cpuset;
ulong uVar5;
pthread_t __th;
ulong uVar6;
char *pcVar7;
int8 uVar8;
ulong uVar9;
int1 auStack_238 [528];
ggml_cpu_init();
if (param_2 == (long *)0x0) {
pcVar7 = "cplan";
uVar8 = 0x36c3;
LAB_0010b586:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,uVar8,"GGML_ASSERT(%s) failed",pcVar7);
}
iVar4 = (int)param_2[2];
if (iVar4 < 1) {
pcVar7 = "cplan->n_threads > 0";
uVar8 = 0x36c4;
goto LAB_0010b586;
}
if ((*param_2 != 0) && (param_2[1] == 0)) {
pcVar7 = "cplan->work_size == 0 || cplan->work_data != NULL";
uVar8 = 0x36c5;
goto LAB_0010b586;
}
ppVar2 = (pthread_mutex_t *)param_2[3];
if (ppVar2 == (pthread_mutex_t *)0x0) {
ggml_threadpool_params_default(auStack_238,iVar4);
__mutex = (pthread_mutex_t *)ggml_threadpool_new_impl(auStack_238,param_1,param_2);
}
else {
*(int8 *)((long)ppVar2 + 0x58) = param_1;
*(long **)((long)ppVar2 + 0x60) = param_2;
LOCK();
*(int4 *)((long)ppVar2 + 0xc4) = 0;
UNLOCK();
LOCK();
*(int4 *)((long)ppVar2 + 0xcc) = 0xffffffff;
UNLOCK();
*(int4 *)((long)ppVar2 + 0xe8) = 0;
__mutex = ppVar2;
}
if (*(int *)((long)__mutex + 0xd8) < iVar4) {
ggml_log_internal(3,"cplan requested more threads (%d) than available (%d)\n",iVar4);
iVar4 = *(int *)((long)__mutex + 0xd8);
}
pthread_mutex_lock(__mutex);
*(int *)((long)__mutex + 0xdc) = iVar4;
LOCK();
*(int *)((long)__mutex + 0x68) = *(int *)((long)__mutex + 0x68) + 1;
UNLOCK();
if ((*(byte *)((long)__mutex + 0xc9) & 1) == 0) goto LAB_0010b431;
ggml_thread_apply_priority(*(int4 *)((long)__mutex + 0xe0));
lVar3 = *(long *)((long)__mutex + 0xd0);
if (*(char *)(lVar3 + 8) == '\0') {
uVar5 = 0xffffffffffffffff;
do {
if (uVar5 == 0x1fe) goto LAB_0010b429;
uVar9 = uVar5 + 1;
pcVar7 = (char *)(lVar3 + 10 + uVar5);
uVar5 = uVar9;
} while (*pcVar7 != '\x01');
if (uVar9 < 0x1ff) goto LAB_0010b420;
}
else {
LAB_0010b420:
ggml_thread_apply_affinity(lVar3 + 8);
}
LAB_0010b429:
LOCK();
*(int1 *)((long)__mutex + 0xc9) = 0;
UNLOCK();
LAB_0010b431:
pthread_cond_broadcast((pthread_cond_t *)(__mutex + 1));
pthread_mutex_unlock(__mutex);
ggml_graph_compute_thread(*(int8 *)((long)__mutex + 0xd0));
if (1 < DAT_0014d6d4) {
uVar9 = (ulong)((uint)((ulong)DAT_0014d6d8 + 0x3f >> 3) & 0xfffffff8);
__cpuset = __sched_cpualloc((ulong)DAT_0014d6d8);
memset(__cpuset,0,uVar9);
uVar5 = (ulong)DAT_0014d6d8;
if (uVar5 != 0) {
uVar6 = 0;
do {
if (uVar6 >> 3 < uVar9) {
__cpuset->__bits[uVar6 >> 6] = __cpuset->__bits[uVar6 >> 6] | 1L << (uVar6 & 0x3f);
}
uVar6 = uVar6 + 1;
} while (uVar5 != uVar6);
}
__th = pthread_self();
iVar4 = pthread_setaffinity_np(__th,uVar9,__cpuset);
if (iVar4 != 0) {
ggml_graph_compute_cold_1(iVar4);
}
__sched_cpufree(__cpuset);
}
uVar1 = *(int4 *)((long)__mutex + 0xe8);
if (ppVar2 == (pthread_mutex_t *)0x0) {
ggml_threadpool_free(__mutex);
}
return uVar1;
}
|
|
64,093 |
translog_finish_page
|
eloqsql/storage/maria/ma_loghandler.c
|
static void translog_finish_page(TRANSLOG_ADDRESS *horizon,
struct st_buffer_cursor *cursor)
{
uint16 left= TRANSLOG_PAGE_SIZE - cursor->current_page_fill;
uchar *page= cursor->ptr - cursor->current_page_fill;
DBUG_ENTER("translog_finish_page");
DBUG_PRINT("enter", ("Buffer: #%u %p "
"Buffer addr: " LSN_FMT " "
"Page addr: " LSN_FMT " "
"size:%u (%u) Pg:%u left:%u",
(uint) cursor->buffer_no, cursor->buffer,
LSN_IN_PARTS(cursor->buffer->offset),
(uint)LSN_FILE_NO(*horizon),
(uint)(LSN_OFFSET(*horizon) -
cursor->current_page_fill),
(uint) cursor->buffer->size,
(uint) (cursor->ptr -cursor->buffer->buffer),
(uint) cursor->current_page_fill, (uint) left));
DBUG_ASSERT(LSN_FILE_NO(*horizon) == LSN_FILE_NO(cursor->buffer->offset)
|| translog_status == TRANSLOG_UNINITED);
if ((LSN_FILE_NO(*horizon) != LSN_FILE_NO(cursor->buffer->offset)))
DBUG_VOID_RETURN; // everything wrong do not write to awoid more problems
translog_check_cursor(cursor);
if (cursor->protected)
{
DBUG_PRINT("info", ("Already protected and finished"));
DBUG_VOID_RETURN;
}
cursor->protected= 1;
DBUG_ASSERT(left < TRANSLOG_PAGE_SIZE);
if (left != 0)
{
DBUG_PRINT("info", ("left: %u", (uint) left));
memset(cursor->ptr, TRANSLOG_FILLER, left);
cursor->ptr+= left;
(*horizon)+= left; /* offset increasing */
if (!cursor->chaser)
cursor->buffer->size+= left;
/* We are finishing the page so reset the counter */
cursor->current_page_fill= 0;
DBUG_PRINT("info", ("Finish Page buffer #%u: %p "
"chaser: %d Size: %lu (%lu)",
(uint) cursor->buffer->buffer_no,
cursor->buffer, cursor->chaser,
(ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer)));
translog_check_cursor(cursor);
}
/*
When we are finishing the page other thread might not finish the page
header yet (in case if we started from the middle of the page) so we
have to read log_descriptor.flags but not the flags from the page.
*/
if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)
{
translog_put_sector_protection(page, cursor);
DBUG_PRINT("info", ("drop write_counter"));
cursor->write_counter= 0;
cursor->previous_offset= 0;
}
if (log_descriptor.flags & TRANSLOG_PAGE_CRC)
{
uint32 crc= translog_crc(page + log_descriptor.page_overhead,
TRANSLOG_PAGE_SIZE -
log_descriptor.page_overhead);
DBUG_PRINT("info", ("CRC: %lx", (ulong) crc));
/* We have page number, file number and flag before crc */
int4store(page + 3 + 3 + 1, crc);
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_finish_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %ecx
movl $0x2000, %eax # imm = 0x2000
subl %ecx, %eax
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x30(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xb155c4
jmp 0xb155c6
jmp 0xb155c8
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq 0x100010(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
je 0xb155f1
jmp 0xb155ec
jmp 0xb15727
movq -0x10(%rbp), %rdi
callq 0xb14380
movq -0x10(%rbp), %rax
cmpb $0x0, 0x38(%rax)
je 0xb1560f
jmp 0xb15606
jmp 0xb15608
jmp 0xb1560a
jmp 0xb15727
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
jmp 0xb15619
movzwl -0x12(%rbp), %eax
cmpl $0x0, %eax
je 0xb1569b
jmp 0xb15624
jmp 0xb15626
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movzwl -0x12(%rbp), %eax
movl %eax, %edx
movl $0xff, %esi
callq 0x433730
movzwl -0x12(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movzwl -0x12(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x37(%rax)
jne 0xb15686
movzwl -0x12(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addl 0x100030(%rax), %ecx
movl %ecx, 0x100030(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x30(%rax)
jmp 0xb15692
movq -0x10(%rbp), %rdi
callq 0xb14380
movl 0xae32e7(%rip), %eax # 0x15f8988
andl $0x2, %eax
cmpl $0x0, %eax
je 0xb156cc
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb1b2a0
jmp 0xb156b8
movq -0x10(%rbp), %rax
movw $0x0, 0x32(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x34(%rax)
movl 0xae32b6(%rip), %eax # 0x15f8988
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb15723
movq -0x20(%rbp), %rdi
movzwl 0xae32bf(%rip), %eax # 0x15f89a4
cltq
addq %rax, %rdi
movzwl 0xae32b3(%rip), %eax # 0x15f89a4
movl $0x2000, %esi # imm = 0x2000
subl %eax, %esi
callq 0xb1a5f0
movl %eax, -0x24(%rbp)
jmp 0xb15702
jmp 0xb15704
movq -0x20(%rbp), %rax
addq $0x3, %rax
addq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xb15723
jmp 0xb15725
jmp 0xb15727
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
translog_finish_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
movzx ecx, word ptr [rax+30h]
mov eax, 2000h
sub eax, ecx
mov [rbp+var_12], ax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov rcx, [rbp+var_10]
movzx ecx, word ptr [rcx+30h]
movsxd rdx, ecx
xor ecx, ecx
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_B155C4:
jmp short $+2
loc_B155C6:
jmp short $+2
loc_B155C8:
mov rax, [rbp+var_8]
mov rax, [rax]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+28h]
mov rcx, qword ptr ds:stru_100010.r_offset[rcx]
sar rcx, 20h
cmp eax, ecx
jz short loc_B155F1
jmp short $+2
loc_B155EC:
jmp loc_B15727
loc_B155F1:
mov rdi, [rbp+var_10]
call translog_check_cursor
mov rax, [rbp+var_10]
cmp byte ptr [rax+38h], 0
jz short loc_B1560F
jmp short $+2
loc_B15606:
jmp short $+2
loc_B15608:
jmp short $+2
loc_B1560A:
jmp loc_B15727
loc_B1560F:
mov rax, [rbp+var_10]
mov byte ptr [rax+38h], 1
jmp short $+2
loc_B15619:
movzx eax, [rbp+var_12]
cmp eax, 0
jz short loc_B1569B
jmp short $+2
loc_B15624:
jmp short $+2
loc_B15626:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
movzx eax, [rbp+var_12]
mov edx, eax
mov esi, 0FFh
call _memset
movzx edx, [rbp+var_12]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
movsxd rdx, edx
add rcx, rdx
mov [rax+20h], rcx
movzx eax, [rbp+var_12]
mov ecx, eax
mov rax, [rbp+var_8]
add rcx, [rax]
mov [rax], rcx
mov rax, [rbp+var_10]
cmp byte ptr [rax+37h], 0
jnz short loc_B15686
movzx ecx, [rbp+var_12]
mov rax, [rbp+var_10]
mov rax, [rax+28h]
add ecx, [rax+100030h]
mov [rax+100030h], ecx
loc_B15686:
mov rax, [rbp+var_10]
mov word ptr [rax+30h], 0
jmp short $+2
loc_B15692:
mov rdi, [rbp+var_10]
call translog_check_cursor
loc_B1569B:
mov eax, cs:dword_15F8988
and eax, 2
cmp eax, 0
jz short loc_B156CC
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
call translog_put_sector_protection
jmp short $+2
loc_B156B8:
mov rax, [rbp+var_10]
mov word ptr [rax+32h], 0
mov rax, [rbp+var_10]
mov word ptr [rax+34h], 0
loc_B156CC:
mov eax, cs:dword_15F8988
and eax, 1
cmp eax, 0
jz short loc_B15723
mov rdi, [rbp+var_20]
movzx eax, cs:word_15F89A4
cdqe
add rdi, rax
movzx eax, cs:word_15F89A4
mov esi, 2000h
sub esi, eax
call translog_crc
mov [rbp+var_24], eax
jmp short $+2
loc_B15702:
jmp short $+2
loc_B15704:
mov rax, [rbp+var_20]
add rax, 3
add rax, 3
add rax, 1
mov [rbp+var_30], rax
mov ecx, [rbp+var_24]
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_B15723:
jmp short $+2
loc_B15725:
jmp short $+2
loc_B15727:
add rsp, 30h
pop rbp
retn
|
long long translog_finish_page(long long *a1, long long a2)
{
long long result; // rax
int v3; // [rsp+Ch] [rbp-24h]
long long v4; // [rsp+10h] [rbp-20h]
unsigned __int16 v5; // [rsp+1Eh] [rbp-12h]
v5 = 0x2000 - *(_WORD *)(a2 + 48);
v4 = *(_QWORD *)(a2 + 32) - *(unsigned __int16 *)(a2 + 48);
result = *a1 >> 32;
if ( (_DWORD)result == HIDWORD(*(unsigned long long *)((char *)&stru_100010.r_offset + *(_QWORD *)(a2 + 40))) )
{
translog_check_cursor();
result = a2;
if ( !*(_BYTE *)(a2 + 56) )
{
*(_BYTE *)(a2 + 56) = 1;
if ( v5 )
{
memset(*(_QWORD *)(a2 + 32), 255LL);
*(_QWORD *)(a2 + 32) += v5;
*a1 += v5;
if ( !*(_BYTE *)(a2 + 55) )
*(_DWORD *)(*(_QWORD *)(a2 + 40) + 1048624LL) += v5;
*(_WORD *)(a2 + 48) = 0;
translog_check_cursor();
}
if ( (dword_15F8988 & 2) != 0 )
{
translog_put_sector_protection(v4, a2);
*(_WORD *)(a2 + 50) = 0;
*(_WORD *)(a2 + 52) = 0;
}
result = dword_15F8988 & 1;
if ( (dword_15F8988 & 1) != 0 )
{
v3 = translog_crc((unsigned __int16)word_15F89A4 + v4, 0x2000 - (unsigned int)(unsigned __int16)word_15F89A4);
result = v4 + 7;
*(_DWORD *)(v4 + 7) = v3;
}
}
}
return result;
}
|
_ZNSt4pairImiEC2ImiTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIS3_S4_EEEbE4typeELb1EEEOS3_OS4_:
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 RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX + 0x8],ECX
POP RBP
RET
|
void _ZNSt4pairImiEC2ImiTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIS3_S4_EEEbE4typeELb1EEEOS3_OS4_
(int8 *param_1,int8 *param_2,int4 *param_3)
{
*param_1 = *param_2;
*(int4 *)(param_1 + 1) = *param_3;
return;
}
|
|
64,094 |
my_wc_mb_filename
|
eloqsql/strings/ctype-utf8.c
|
static int
my_wc_mb_filename(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
static const char hex[]= "0123456789abcdef";
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 128 && filename_safe_char[wc])
{
*s= (uchar) wc;
return 1;
}
if (s + 3 > e)
return MY_CS_TOOSMALL3;
*s++= MY_FILENAME_ESCAPE;
if ((wc >= 0x00C0 && wc <= 0x05FF && (code= uni_0C00_05FF[wc - 0x00C0])) ||
(wc >= 0x1E00 && wc <= 0x1FFF && (code= uni_1E00_1FFF[wc - 0x1E00])) ||
(wc >= 0x2160 && wc <= 0x217F && (code= uni_2160_217F[wc - 0x2160])) ||
(wc >= 0x24B0 && wc <= 0x24EF && (code= uni_24B0_24EF[wc - 0x24B0])) ||
(wc >= 0xFF20 && wc <= 0xFF5F && (code= uni_FF20_FF5F[wc - 0xFF20])))
{
*s++= (code / 80) + 0x30;
*s++= (code % 80) + 0x30;
return 3;
}
/* Non letter */
if (s + 4 > e)
return MY_CS_TOOSMALL5;
*s++= hex[(wc >> 12) & 15];
*s++= hex[(wc >> 8) & 15];
*s++= hex[(wc >> 4) & 15];
*s++= hex[(wc) & 15];
return 5;
}
|
O0
|
c
|
my_wc_mb_filename:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0xc7cba
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0xc7f25
cmpq $0x80, -0x18(%rbp)
jae 0xc7cf0
movq -0x18(%rbp), %rcx
leaq 0x14be91(%rip), %rax # 0x213b60
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xc7cf0
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xc7f25
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0xc7d0a
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0xc7f25
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x40, (%rax)
cmpq $0xc0, -0x18(%rbp)
jb 0xc7d52
cmpq $0x5ff, -0x18(%rbp) # imm = 0x5FF
ja 0xc7d52
movq -0x18(%rbp), %rcx
subq $0xc0, %rcx
leaq 0x14efde(%rip), %rax # 0x216d20
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xc7e1e
cmpq $0x1e00, -0x18(%rbp) # imm = 0x1E00
jb 0xc7d88
cmpq $0x1fff, -0x18(%rbp) # imm = 0x1FFF
ja 0xc7d88
movq -0x18(%rbp), %rcx
subq $0x1e00, %rcx # imm = 0x1E00
leaq 0x327458(%rip), %rax # 0x3ef1d0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xc7e1e
cmpq $0x2160, -0x18(%rbp) # imm = 0x2160
jb 0xc7dba
cmpq $0x217f, -0x18(%rbp) # imm = 0x217F
ja 0xc7dba
movq -0x18(%rbp), %rcx
subq $0x2160, %rcx # imm = 0x2160
leaq 0x14ee32(%rip), %rax # 0x216be0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xc7e1e
cmpq $0x24b0, -0x18(%rbp) # imm = 0x24B0
jb 0xc7dec
cmpq $0x24ef, -0x18(%rbp) # imm = 0x24EF
ja 0xc7dec
movq -0x18(%rbp), %rcx
subq $0x24b0, %rcx # imm = 0x24B0
leaq 0x14ee40(%rip), %rax # 0x216c20
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xc7e1e
cmpq $0xff20, -0x18(%rbp) # imm = 0xFF20
jb 0xc7e6c
cmpq $0xff5f, -0x18(%rbp) # imm = 0xFF5F
ja 0xc7e6c
movq -0x18(%rbp), %rcx
subq $0xff20, %rcx # imm = 0xFF20
leaq 0x14ee8e(%rip), %rax # 0x216ca0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0xc7e6c
movl -0x2c(%rbp), %eax
movl $0x50, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
movl $0x50, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0xc7f25
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0xc7e86
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF97
jmp 0xc7f25
movq -0x18(%rbp), %rcx
shrq $0xc, %rcx
andq $0xf, %rcx
leaq 0x14ed27(%rip), %rax # 0x216bc0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
shrq $0x8, %rcx
andq $0xf, %rcx
leaq 0x14ed00(%rip), %rax # 0x216bc0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
shrq $0x4, %rcx
andq $0xf, %rcx
leaq 0x14ecd9(%rip), %rax # 0x216bc0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
andq $0xf, %rcx
leaq 0x14ecb6(%rip), %rax # 0x216bc0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_wc_mb_filename:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_C7CBA
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_C7F25
loc_C7CBA:
cmp [rbp+var_18], 80h
jnb short loc_C7CF0
mov rcx, [rbp+var_18]
lea rax, filename_safe_char
movsx eax, byte ptr [rax+rcx]
cmp eax, 0
jz short loc_C7CF0
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_C7F25
loc_C7CF0:
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_C7D0A
mov [rbp+var_4], 0FFFFFF99h
jmp loc_C7F25
loc_C7D0A:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov byte ptr [rax], 40h ; '@'
cmp [rbp+var_18], 0C0h
jb short loc_C7D52
cmp [rbp+var_18], 5FFh
ja short loc_C7D52
mov rcx, [rbp+var_18]
sub rcx, 0C0h
lea rax, uni_0C00_05FF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz loc_C7E1E
loc_C7D52:
cmp [rbp+var_18], 1E00h
jb short loc_C7D88
cmp [rbp+var_18], 1FFFh
ja short loc_C7D88
mov rcx, [rbp+var_18]
sub rcx, 1E00h
lea rax, uni_1E00_1FFF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz loc_C7E1E
loc_C7D88:
cmp [rbp+var_18], 2160h
jb short loc_C7DBA
cmp [rbp+var_18], 217Fh
ja short loc_C7DBA
mov rcx, [rbp+var_18]
sub rcx, 2160h
lea rax, uni_2160_217F
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_C7E1E
loc_C7DBA:
cmp [rbp+var_18], 24B0h
jb short loc_C7DEC
cmp [rbp+var_18], 24EFh
ja short loc_C7DEC
mov rcx, [rbp+var_18]
sub rcx, 24B0h
lea rax, uni_24B0_24EF
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_C7E1E
loc_C7DEC:
cmp [rbp+var_18], 0FF20h
jb short loc_C7E6C
cmp [rbp+var_18], 0FF5Fh
ja short loc_C7E6C
mov rcx, [rbp+var_18]
sub rcx, 0FF20h
lea rax, uni_FF20_FF5F
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_C7E6C
loc_C7E1E:
mov eax, [rbp+var_2C]
mov ecx, 50h ; 'P'
cdq
idiv ecx
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov eax, [rbp+var_2C]
mov ecx, 50h ; 'P'
cdq
idiv ecx
add edx, 30h ; '0'
mov cl, dl
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov [rbp+var_4], 3
jmp loc_C7F25
loc_C7E6C:
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_C7E86
mov [rbp+var_4], 0FFFFFF97h
jmp loc_C7F25
loc_C7E86:
mov rcx, [rbp+var_18]
shr rcx, 0Ch
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
shr rcx, 8
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
shr rcx, 4
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rcx, [rbp+var_18]
and rcx, 0Fh
lea rax, my_wc_mb_filename_hex; "0123456789abcdef"
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov [rbp+var_4], 5
loc_C7F25:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_filename(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+0h] [rbp-2Ch]
_BYTE *v6; // [rsp+Ch] [rbp-20h]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 < 0x80 && filename_safe_char[a2] )
{
*a3 = a2;
return 1;
}
else if ( (unsigned long long)(a3 + 3) <= a4 )
{
v6 = a3 + 1;
*a3 = 64;
if ( a2 >= 0xC0 && a2 <= 0x5FF && (v5 = uni_0C00_05FF[a2 - 192]) != 0
|| a2 >= 0x1E00 && a2 <= 0x1FFF && (v5 = uni_1E00_1FFF[a2 - 7680]) != 0
|| a2 >= 0x2160 && a2 <= 0x217F && (v5 = uni_2160_217F[a2 - 8544]) != 0
|| a2 >= 0x24B0 && a2 <= 0x24EF && (v5 = uni_24B0_24EF[a2 - 9392]) != 0
|| a2 >= 0xFF20 && a2 <= 0xFF5F && (v5 = uni_FF20_FF5F[a2 - 65312]) != 0 )
{
*v6 = v5 / 80 + 48;
a3[2] = v5 % 80 + 48;
return 3;
}
else if ( (unsigned long long)(a3 + 5) <= a4 )
{
*v6 = my_wc_mb_filename_hex[(unsigned __int16)a2 >> 12];
a3[2] = my_wc_mb_filename_hex[(a2 >> 8) & 0xF];
a3[3] = my_wc_mb_filename_hex[(unsigned __int8)a2 >> 4];
a3[4] = my_wc_mb_filename_hex[a2 & 0xF];
return 5;
}
else
{
return (unsigned int)-105;
}
}
else
{
return (unsigned int)-103;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_filename:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x001c7cba
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x001c7f25
LAB_001c7cba:
CMP qword ptr [RBP + -0x18],0x80
JNC 0x001c7cf0
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x313b60]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JZ 0x001c7cf0
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 0x001c7f25
LAB_001c7cf0:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001c7d0a
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x001c7f25
LAB_001c7d0a:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOV byte ptr [RAX],0x40
CMP qword ptr [RBP + -0x18],0xc0
JC 0x001c7d52
CMP qword ptr [RBP + -0x18],0x5ff
JA 0x001c7d52
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0xc0
LEA RAX,[0x316d20]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001c7e1e
LAB_001c7d52:
CMP qword ptr [RBP + -0x18],0x1e00
JC 0x001c7d88
CMP qword ptr [RBP + -0x18],0x1fff
JA 0x001c7d88
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x1e00
LEA RAX,[0x4ef1d0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001c7e1e
LAB_001c7d88:
CMP qword ptr [RBP + -0x18],0x2160
JC 0x001c7dba
CMP qword ptr [RBP + -0x18],0x217f
JA 0x001c7dba
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x2160
LEA RAX,[0x316be0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001c7e1e
LAB_001c7dba:
CMP qword ptr [RBP + -0x18],0x24b0
JC 0x001c7dec
CMP qword ptr [RBP + -0x18],0x24ef
JA 0x001c7dec
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0x24b0
LEA RAX,[0x316c20]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001c7e1e
LAB_001c7dec:
CMP qword ptr [RBP + -0x18],0xff20
JC 0x001c7e6c
CMP qword ptr [RBP + -0x18],0xff5f
JA 0x001c7e6c
MOV RCX,qword ptr [RBP + -0x18]
SUB RCX,0xff20
LEA RAX,[0x316ca0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x001c7e6c
LAB_001c7e1e:
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x50
CDQ
IDIV ECX
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,0x50
CDQ
IDIV ECX
ADD EDX,0x30
MOV CL,DL
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001c7f25
LAB_001c7e6c:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001c7e86
MOV dword ptr [RBP + -0x4],0xffffff97
JMP 0x001c7f25
LAB_001c7e86:
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0xc
AND RCX,0xf
LEA RAX,[0x316bc0]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x8
AND RCX,0xf
LEA RAX,[0x316bc0]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x4
AND RCX,0xf
LEA RAX,[0x316bc0]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x18]
AND RCX,0xf
LEA RAX,[0x316bc0]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x5
LAB_001c7f25:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4
my_wc_mb_filename(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
uint local_34;
int4 local_c;
if (param_3 < param_4) {
if ((param_2 < 0x80) && (filename_safe_char[param_2] != '\0')) {
*param_3 = (char)param_2;
local_c = 1;
}
else if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = 0x40;
if ((((((param_2 < 0xc0) || (0x5ff < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_0C00_05FF + (param_2 - 0xc0) * 2), local_34 == 0)) &&
(((param_2 < 0x1e00 || (0x1fff < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_1E00_1FFF + (param_2 - 0x1e00) * 2), local_34 == 0))))
&& (((param_2 < 0x2160 || (0x217f < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_2160_217F + (param_2 - 0x2160) * 2), local_34 == 0))
)) && ((((param_2 < 0x24b0 || (0x24ef < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_24B0_24EF + (param_2 - 0x24b0) * 2),
local_34 == 0)) &&
(((param_2 < 0xff20 || (0xff5f < param_2)) ||
(local_34 = (uint)*(ushort *)(uni_FF20_FF5F + (param_2 - 0xff20) * 2),
local_34 == 0)))))) {
if (param_4 < param_3 + 5) {
local_c = 0xffffff97;
}
else {
param_3[1] = "0123456789abcdef"[param_2 >> 0xc & 0xf];
param_3[2] = "0123456789abcdef"[param_2 >> 8 & 0xf];
param_3[3] = "0123456789abcdef"[param_2 >> 4 & 0xf];
param_3[4] = "0123456789abcdef"[param_2 & 0xf];
local_c = 5;
}
}
else {
param_3[1] = (char)(local_34 / 0x50) + '0';
param_3[2] = (char)(local_34 % 0x50) + '0';
local_c = 3;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
64,095 |
promise_reaction_data_free
|
bluesky950520[P]quickjs/quickjs.c
|
static void promise_reaction_data_free(JSRuntime *rt,
JSPromiseReactionData *rd)
{
JS_FreeValueRT(rt, rd->resolving_funcs[0]);
JS_FreeValueRT(rt, rd->resolving_funcs[1]);
JS_FreeValueRT(rt, rd->handler);
js_free_rt(rt, rd);
}
|
O1
|
c
|
promise_reaction_data_free:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
movq 0x18(%rbx), %rdx
callq 0x1ccb2
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x1ccb2
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x1ccb2
testq %rbx, %rbx
je 0x4363f
decq 0x28(%r14)
movq %rbx, %rdi
callq *0x20(%r14)
movq 0x10(%r14), %rcx
movq 0x30(%r14), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%r14)
movq 0x40(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
promise_reaction_data_free:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rsi, [rsi+10h]
mov rdx, [rbx+18h]
call JS_FreeValueRT
mov rsi, [rbx+20h]
mov rdx, [rbx+28h]
mov rdi, r14
call JS_FreeValueRT
mov rsi, [rbx+30h]
mov rdx, [rbx+38h]
mov rdi, r14
call JS_FreeValueRT
test rbx, rbx
jz short loc_4363F
dec qword ptr [r14+28h]
mov rdi, rbx
call qword ptr [r14+20h]
mov rcx, [r14+10h]
mov rdx, [r14+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [r14+30h], rdx
mov rdi, [r14+40h]
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_4363F:
add rsp, 8
pop rbx
pop r14
retn
|
long long promise_reaction_data_free(long long a1, long long a2)
{
long long result; // rax
long long v4; // rax
long long ( *v5)(_QWORD, long long); // rcx
JS_FreeValueRT(a1, *(_DWORD **)(a2 + 16), *(_QWORD *)(a2 + 24));
JS_FreeValueRT(a1, *(_DWORD **)(a2 + 32), *(_QWORD *)(a2 + 40));
result = JS_FreeValueRT(a1, *(_DWORD **)(a2 + 48), *(_QWORD *)(a2 + 56));
if ( a2 )
{
--*(_QWORD *)(a1 + 40);
v4 = (*(long long ( **)(long long))(a1 + 32))(a2);
v5 = *(long long ( **)(_QWORD, long long))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v4 - 8;
return v5(*(_QWORD *)(a1 + 64), a2);
}
return result;
}
|
promise_reaction_data_free:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RSI + 0x10]
MOV RDX,qword ptr [RBX + 0x18]
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RBX + 0x28]
MOV RDI,R14
CALL 0x0011ccb2
MOV RSI,qword ptr [RBX + 0x30]
MOV RDX,qword ptr [RBX + 0x38]
MOV RDI,R14
CALL 0x0011ccb2
TEST RBX,RBX
JZ 0x0014363f
DEC qword ptr [R14 + 0x28]
MOV RDI,RBX
CALL qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [R14 + 0x30],RDX
MOV RDI,qword ptr [R14 + 0x40]
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_0014363f:
ADD RSP,0x8
POP RBX
POP R14
RET
|
void promise_reaction_data_free(long param_1,long param_2)
{
long lVar1;
JS_FreeValueRT(param_1,*(int8 *)(param_2 + 0x10),*(int8 *)(param_2 + 0x18));
JS_FreeValueRT(param_1,*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x28));
JS_FreeValueRT(param_1,*(int8 *)(param_2 + 0x30),*(int8 *)(param_2 + 0x38));
if (param_2 != 0) {
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar1 = (**(code **)(param_1 + 0x20))(param_2);
lVar1 = (*(long *)(param_1 + 0x30) - lVar1) + -8;
*(long *)(param_1 + 0x30) = lVar1;
/* WARNING: Could not recover jumptable at 0x0014363d. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),param_2,lVar1,*(code **)(param_1 + 0x10));
return;
}
return;
}
|
|
64,096 |
inline_mysql_file_create
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline File
inline_mysql_file_create(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int create_flags, int access_flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create(filename, create_flags, access_flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create(filename, create_flags, access_flags, myFlags);
return file;
}
|
O0
|
c
|
inline_mysql_file_create:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
leaq 0x201724(%rip), %rax # 0x238fa0
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x37913
leaq 0x2016dc(%rip), %rax # 0x238fa0
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0x7bb30
movl %eax, -0x2c(%rbp)
leaq 0x2016a8(%rip), %rax # 0x238fa0
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3792f
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0x7bb30
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
inline_mysql_file_create:
push rbp
mov rbp, rsp
sub rsp, 80h
mov rax, [rbp+arg_0]
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_28], r9d
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_80]
xor edx, edx
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_37913
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov edx, [rbp+var_28]
mov rcx, [rbp+arg_0]
call my_create
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_3792F
loc_37913:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov edx, [rbp+var_28]
mov rcx, [rbp+arg_0]
call my_create
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_3792F:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_create(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
unsigned int a6,
long long a7)
{
_BYTE v8[72]; // [rsp+0h] [rbp-80h] BYREF
long long v9; // [rsp+48h] [rbp-38h] BYREF
unsigned int v10; // [rsp+54h] [rbp-2Ch]
unsigned int v11; // [rsp+58h] [rbp-28h]
unsigned int v12; // [rsp+5Ch] [rbp-24h]
long long v13; // [rsp+60h] [rbp-20h]
unsigned int v14; // [rsp+6Ch] [rbp-14h]
long long v15; // [rsp+70h] [rbp-10h]
unsigned int v16; // [rsp+78h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = a6;
v9 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(v8, a1, 0LL, a4, &v9);
if ( v9 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v9, v15, v14);
v10 = my_create(v13, v12, v11, a7);
((void ( *)(long long, _QWORD))PSI_server[64])(v9, v10);
}
else
{
return (unsigned int)my_create(v13, v12, v11, a7);
}
return v10;
}
|
inline_mysql_file_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV dword ptr [RBP + -0x28],R9D
LEA RAX,[0x338fa0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x80]
XOR EDX,EDX
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00137913
LEA RAX,[0x338fa0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + 0x10]
CALL 0x0017bb30
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x338fa0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013792f
LAB_00137913:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + 0x10]
CALL 0x0017bb30
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013792f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_create
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int4 param_6,int8 param_7)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int4 local_30;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_30 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0,param_4,&local_40);
if (local_40 == 0) {
local_c = my_create(local_28,local_2c,local_30,param_7);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_40,local_18,local_1c);
local_34 = my_create(local_28,local_2c,local_30,param_7);
(**(code **)(PSI_server + 0x200))(local_40,local_34);
local_c = local_34;
}
return local_c;
}
|
|
64,097 |
LefDefParser::defwPinNetExpr(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwPinNetExpr(const char *pinExpr)
{
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_PIN)
return DEFW_BAD_ORDER;
if (defVersionNum < 5.6)
return DEFW_WRONG_VERSION;
if (pinExpr && pinExpr != 0 && *pinExpr != 0)
fprintf(defwFile, "\n + NETEXPR \"%s\"", pinExpr);
defwLines++;
return DEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::defwPinNetExpr(char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x149a8(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x167c3
movl $0x1, 0x14(%rsp)
jmp 0x1684c
leaq 0x1499a(%rip), %rax # 0x2b164
cmpl $0x25, (%rax)
je 0x167d9
movl $0x2, 0x14(%rsp)
jmp 0x1684c
movsd 0xcb07(%rip), %xmm0 # 0x232e8
ucomisd 0x148c7(%rip), %xmm0 # 0x2b0b0
jbe 0x167f5
movl $0x5, 0x14(%rsp)
jmp 0x1684c
cmpq $0x0, 0x8(%rsp)
je 0x1682f
cmpq $0x0, 0x8(%rsp)
je 0x1682f
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1682f
leaq 0x1493f(%rip), %rax # 0x2b158
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0xe000(%rip), %rsi # 0x24828
movb $0x0, %al
callq 0x10f0
leaq 0x1492a(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1491e(%rip), %rax # 0x2b160
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN12LefDefParser14defwPinNetExprEPKc:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_167C3
mov [rsp+18h+var_4], 1
jmp loc_1684C
loc_167C3:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 25h ; '%'
jz short loc_167D9
mov [rsp+18h+var_4], 2
jmp short loc_1684C
loc_167D9:
movsd xmm0, cs:dbl_232E8
ucomisd xmm0, cs:_ZN12LefDefParserL13defVersionNumE; LefDefParser::defVersionNum
jbe short loc_167F5
mov [rsp+18h+var_4], 5
jmp short loc_1684C
loc_167F5:
cmp [rsp+18h+var_10], 0
jz short loc_1682F
cmp [rsp+18h+var_10], 0
jz short loc_1682F
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_1682F
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aNetexprS; "\n + NETEXPR \"%s\""
mov al, 0
call _fprintf
loc_1682F:
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_1684C:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::defwPinNetExpr(LefDefParser *this, const char *a2)
{
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 37 )
{
if ( *(double *)&LefDefParser::defVersionNum >= 5.6 )
{
if ( this && *(_BYTE *)this )
fprintf(LefDefParser::defwFile, "\n + NETEXPR \"%s\"", (const char *)this);
++LefDefParser::defwLines;
return 0;
}
else
{
return 5;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
defwPinNetExpr:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x001167c3
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0011684c
LAB_001167c3:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x25
JZ 0x001167d9
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011684c
LAB_001167d9:
MOVSD XMM0,qword ptr [0x001232e8]
UCOMISD XMM0,qword ptr [0x0012b0b0]
JBE 0x001167f5
MOV dword ptr [RSP + 0x14],0x5
JMP 0x0011684c
LAB_001167f5:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0011682f
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0011682f
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0011682f
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x124828]
MOV AL,0x0
CALL 0x001010f0
LAB_0011682f:
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_0011684c:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::defwPinNetExpr(char const*) */
int4 LefDefParser::defwPinNetExpr(char *param_1)
{
int4 local_4;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if (defwState == 0x25) {
if (DAT_001232e8 <= defVersionNum) {
if (((param_1 != (char *)0x0) && (param_1 != (char *)0x0)) && (*param_1 != '\0')) {
fprintf(defwFile,"\n + NETEXPR \"%s\"",param_1);
}
defwLines = defwLines + 1;
local_4 = 0;
}
else {
local_4 = 5;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
64,098 |
ma_crypt_post_write_hook
|
eloqsql/storage/maria/ma_crypt.c
|
static void ma_crypt_post_write_hook(int res,
PAGECACHE_IO_HOOK_ARGS *args)
{
if (args->crypt_buf != NULL)
{
uchar *tmp= args->page;
args->page= args->crypt_buf;
args->crypt_buf= NULL;
my_free(tmp);
}
maria_page_write_failure(res, args);
}
|
O3
|
c
|
ma_crypt_post_write_hook:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x67486
movq (%rbx), %rdi
movq %rax, (%rbx)
movq $0x0, 0x18(%rbx)
callq 0x9ff6e
movl %r14d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3e10e
|
ma_crypt_post_write_hook:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14d, edi
mov rax, [rsi+18h]
test rax, rax
jz short loc_67486
mov rdi, [rbx]
mov [rbx], rax
mov qword ptr [rbx+18h], 0
call my_free
loc_67486:
mov edi, r14d
mov rsi, rbx
pop rbx
pop r14
pop rbp
jmp maria_page_write_failure
|
long long ma_crypt_post_write_hook(int a1, long long *a2)
{
long long v3; // rax
long long v4; // rdi
v3 = a2[3];
if ( v3 )
{
v4 = *a2;
*a2 = v3;
a2[3] = 0LL;
my_free(v4);
}
return maria_page_write_failure(a1, (long long)a2);
}
|
ma_crypt_post_write_hook:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14D,EDI
MOV RAX,qword ptr [RSI + 0x18]
TEST RAX,RAX
JZ 0x00167486
MOV RDI,qword ptr [RBX]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x18],0x0
CALL 0x0019ff6e
LAB_00167486:
MOV EDI,R14D
MOV RSI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0013e10e
|
void ma_crypt_post_write_hook(int4 param_1,long *param_2)
{
long lVar1;
if (param_2[3] != 0) {
lVar1 = *param_2;
*param_2 = param_2[3];
param_2[3] = 0;
my_free(lVar1);
}
maria_page_write_failure(param_1,param_2);
return;
}
|
|
64,099 |
mi_calc_total_blob_length
|
eloqsql/storage/myisam/mi_dynrec.c
|
ulong _mi_calc_total_blob_length(MI_INFO *info, const uchar *record)
{
ulong length;
MI_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
length+=blob->length;
}
return length;
}
|
O3
|
c
|
mi_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl 0x188(%rax), %eax
testq %rax, %rax
je 0x9295b
movq 0x48(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %edi, %edi
leaq 0x73209(%rip), %r8 # 0x105b08
xorl %eax, %eax
movl 0x8(%rcx,%rdi), %r10d
decl %r10d
cmpl $0x3, %r10d
ja 0x92945
movq (%rcx,%rdi), %r9
movslq (%r8,%r10,4), %r10
addq %r8, %r10
jmpq *%r10
movzbl (%rsi,%r9), %r9d
jmp 0x92948
movzwl (%rsi,%r9), %r10d
movzbl 0x2(%rsi,%r9), %r9d
shll $0x10, %r9d
orq %r10, %r9
jmp 0x92948
movl (%rsi,%r9), %r9d
jmp 0x92948
movzwl (%rsi,%r9), %r9d
jmp 0x92948
xorl %r9d, %r9d
movq %r9, 0x10(%rcx,%rdi)
addq %r9, %rax
addq $0x18, %rdi
cmpq %rdi, %rdx
jne 0x92901
jmp 0x9295d
xorl %eax, %eax
popq %rbp
retq
|
_mi_calc_total_blob_length:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov eax, [rax+188h]
test rax, rax
jz short loc_9295B
mov rcx, [rdi+48h]
shl rax, 3
lea rdx, [rax+rax*2]
xor edi, edi
lea r8, jpt_9291A
xor eax, eax
loc_92901:
mov r10d, [rcx+rdi+8]
dec r10d; switch 4 cases
cmp r10d, 3
ja short def_9291A; jumptable 000000000009291A default case
mov r9, [rcx+rdi]
movsxd r10, ds:(jpt_9291A - 105B08h)[r8+r10*4]
add r10, r8
jmp r10; switch jump
loc_9291D:
movzx r9d, byte ptr [rsi+r9]; jumptable 000000000009291A case 1
jmp short loc_92948
loc_92924:
movzx r10d, word ptr [rsi+r9]; jumptable 000000000009291A case 3
movzx r9d, byte ptr [rsi+r9+2]
shl r9d, 10h
or r9, r10
jmp short loc_92948
loc_92938:
mov r9d, [rsi+r9]; jumptable 000000000009291A case 4
jmp short loc_92948
loc_9293E:
movzx r9d, word ptr [rsi+r9]; jumptable 000000000009291A case 2
jmp short loc_92948
def_9291A:
xor r9d, r9d; jumptable 000000000009291A default case
loc_92948:
mov [rcx+rdi+10h], r9
add rax, r9
add rdi, 18h
cmp rdx, rdi
jnz short loc_92901
jmp short loc_9295D
loc_9295B:
xor eax, eax
loc_9295D:
pop rbp
retn
|
long long mi_calc_total_blob_length(_QWORD *a1, long long a2)
{
long long v2; // rcx
long long v3; // rdx
long long v4; // rdi
long long result; // rax
long long v6; // r9
unsigned long long v7; // r9
if ( !*(_DWORD *)(*a1 + 392LL) )
return 0LL;
v2 = a1[9];
v3 = 24LL * *(unsigned int *)(*a1 + 392LL);
v4 = 0LL;
result = 0LL;
do
{
v6 = *(_QWORD *)(v2 + v4);
switch ( *(_DWORD *)(v2 + v4 + 8) )
{
case 1:
v7 = *(unsigned __int8 *)(a2 + v6);
break;
case 2:
v7 = *(unsigned __int16 *)(a2 + v6);
break;
case 3:
v7 = *(unsigned __int16 *)(a2 + v6) | (unsigned long long)(*(unsigned __int8 *)(a2 + v6 + 2) << 16);
break;
case 4:
v7 = *(unsigned int *)(a2 + v6);
break;
default:
v7 = 0LL;
break;
}
*(_QWORD *)(v2 + v4 + 16) = v7;
result += v7;
v4 += 24LL;
}
while ( v3 != v4 );
return result;
}
|
_mi_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x188]
TEST RAX,RAX
JZ 0x0019295b
MOV RCX,qword ptr [RDI + 0x48]
SHL RAX,0x3
LEA RDX,[RAX + RAX*0x2]
XOR EDI,EDI
LEA R8,[0x205b08]
XOR EAX,EAX
LAB_00192901:
MOV R10D,dword ptr [RCX + RDI*0x1 + 0x8]
DEC R10D
CMP R10D,0x3
JA 0x00192945
MOV R9,qword ptr [RCX + RDI*0x1]
MOVSXD R10,dword ptr [R8 + R10*0x4]
ADD R10,R8
switchD:
JMP R10
caseD_1:
MOVZX R9D,byte ptr [RSI + R9*0x1]
JMP 0x00192948
caseD_3:
MOVZX R10D,word ptr [RSI + R9*0x1]
MOVZX R9D,byte ptr [RSI + R9*0x1 + 0x2]
SHL R9D,0x10
OR R9,R10
JMP 0x00192948
caseD_4:
MOV R9D,dword ptr [RSI + R9*0x1]
JMP 0x00192948
caseD_2:
MOVZX R9D,word ptr [RSI + R9*0x1]
JMP 0x00192948
LAB_00192945:
XOR R9D,R9D
LAB_00192948:
MOV qword ptr [RCX + RDI*0x1 + 0x10],R9
ADD RAX,R9
ADD RDI,0x18
CMP RDX,RDI
JNZ 0x00192901
JMP 0x0019295d
LAB_0019295b:
XOR EAX,EAX
LAB_0019295d:
POP RBP
RET
|
long _mi_calc_total_blob_length(long *param_1,long param_2)
{
uint uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
uVar1 = *(uint *)(*param_1 + 0x188);
if ((ulong)uVar1 == 0) {
lVar5 = 0;
}
else {
lVar3 = param_1[9];
lVar6 = 0;
lVar5 = 0;
do {
iVar2 = *(int *)(lVar3 + 8 + lVar6);
if (iVar2 - 1U < 4) {
lVar4 = *(long *)(lVar3 + lVar6);
switch(iVar2) {
case 1:
uVar7 = (ulong)*(byte *)(param_2 + lVar4);
break;
case 2:
uVar7 = (ulong)*(ushort *)(param_2 + lVar4);
break;
case 3:
uVar7 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + lVar4),
*(int2 *)(param_2 + lVar4));
break;
case 4:
uVar7 = (ulong)*(uint *)(param_2 + lVar4);
}
}
else {
uVar7 = 0;
}
*(ulong *)(lVar3 + 0x10 + lVar6) = uVar7;
lVar5 = lVar5 + uVar7;
lVar6 = lVar6 + 0x18;
} while ((ulong)uVar1 * 0x18 != lVar6);
}
return lVar5;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.