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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
13,700
|
ma_write_keypage
|
eloqsql/storage/maria/ma_page.c
|
my_bool _ma_write_keypage(MARIA_PAGE *page, enum pagecache_page_lock lock,
int level)
{
MARIA_SHARE *share= page->info->s;
uint block_size= share->block_size;
uchar *buff= page->buff;
my_bool res;
MARIA_PINNED_PAGE page_link;
DBUG_ENTER("_ma_write_keypage");
/*
The following ensures that for transactional tables we have logged
all changes that changes the page size (as the logging code sets
page->org_size)
*/
DBUG_ASSERT(!share->now_transactional || page->size == page->org_size);
#ifdef EXTRA_DEBUG /* Safety check */
{
uint page_length, nod_flag;
page_length= _ma_get_page_used(share, buff);
nod_flag= _ma_test_if_nod(share, buff);
DBUG_ASSERT(page->size == page_length);
DBUG_ASSERT(page->size <= share->max_index_block_size);
DBUG_ASSERT(page->flag == _ma_get_keypage_flag(share, buff));
if (page->pos < share->base.keystart ||
page->pos+block_size > share->state.state.key_file_length ||
(page->pos & (maria_block_size-1)))
{
DBUG_PRINT("error",("Trying to write inside key status region: "
"key_start: %lu length: %lu page_pos: %lu",
(long) share->base.keystart,
(long) share->state.state.key_file_length,
(long) page->pos));
my_errno=EINVAL;
DBUG_ASSERT(0);
DBUG_RETURN(1);
}
DBUG_PRINT("page",("write page at: %lu",(ulong) (page->pos / block_size)));
DBUG_DUMP("buff", buff, page_length);
DBUG_ASSERT(page_length >= share->keypage_header + nod_flag +
page->keyinfo->minlength || maria_in_recovery);
}
#endif
/* Verify that keynr is correct */
DBUG_ASSERT(_ma_get_keynr(share, buff) == page->keyinfo->key_nr);
#if defined(EXTRA_DEBUG) && defined(HAVE_valgrind) && defined(WHEN_DEBUGGING)
MEM_CHECK_DEFINED(buff, block_size);
#endif
page_cleanup(share, page);
{
PAGECACHE_BLOCK_LINK **link;
enum pagecache_page_pin pin;
if (lock == PAGECACHE_LOCK_LEFT_WRITELOCKED)
{
pin= PAGECACHE_PIN_LEFT_PINNED;
link= &page_link.link;
}
else if (lock == PAGECACHE_LOCK_WRITE_UNLOCK)
{
pin= PAGECACHE_UNPIN;
/*
We unlock this page so link should be 0 to prevent it usage
even accidentally
*/
link= NULL;
}
else
{
pin= PAGECACHE_PIN;
link= &page_link.link;
}
res= pagecache_write(share->pagecache,
&share->kfile,
(pgcache_page_no_t) (page->pos / block_size),
level, buff, share->page_type,
lock, pin, PAGECACHE_WRITE_DELAY, link,
LSN_IMPOSSIBLE);
}
if (lock == PAGECACHE_LOCK_WRITE)
{
/* It was not locked before, we have to unlock it when we unpin pages */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&page->info->pinned_pages, (void*) &page_link);
}
DBUG_RETURN(res);
}
|
O3
|
c
|
ma_write_keypage:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %r8
movq (%rax), %r9
movl 0x7bc(%r9), %r12d
leaq -0x38(%rbp), %r11
xorl %r10d, %r10d
cmpl $0x2, %esi
je 0x3b39a
cmpl $0x6, %r14d
jne 0x3b39f
movl $0x3, %r15d
xorl %r11d, %r11d
jmp 0x3b3a5
xorl %r15d, %r15d
jmp 0x3b3a5
movl $0x2, %r15d
movq 0x600(%r9), %rdi
leaq 0x750(%r9), %rsi
movq 0x18(%rbx), %rax
xorl %edx, %edx
divq %r12
movl 0x7d4(%r9), %r9d
movl 0x80(%rdi), %r12d
subq $0x8, %rsp
movq %rax, %rdx
pushq %r12
pushq %r10
pushq $0x0
pushq %r11
pushq %r10
pushq %r15
pushq %r14
callq 0x6fe5e
addq $0x40, %rsp
movl %eax, %r15d
cmpl $0x4, %r14d
jne 0x3b40d
leaq -0x38(%rbp), %rsi
movl $0x6, 0x8(%rsi)
movb $0x1, 0x10(%rsi)
movl $0x2e8, %edi # imm = 0x2E8
addq (%rbx), %rdi
callq 0x948aa
movl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ma_write_keypage:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov ecx, edx
mov r14d, esi
mov rbx, rdi
mov rax, [rdi]
mov r8, [rdi+10h]
mov r9, [rax]
mov r12d, [r9+7BCh]
lea r11, [rbp+var_38]
xor r10d, r10d
cmp esi, 2
jz short loc_3B39A
cmp r14d, 6
jnz short loc_3B39F
mov r15d, 3
xor r11d, r11d
jmp short loc_3B3A5
loc_3B39A:
xor r15d, r15d
jmp short loc_3B3A5
loc_3B39F:
mov r15d, 2
loc_3B3A5:
mov rdi, [r9+600h]
lea rsi, [r9+750h]
mov rax, [rbx+18h]
xor edx, edx
div r12
mov r9d, [r9+7D4h]
mov r12d, [rdi+80h]
sub rsp, 8
mov rdx, rax
push r12
push r10
push 0
push r11
push r10
push r15
push r14
call pagecache_write_part
add rsp, 40h
mov r15d, eax
cmp r14d, 4
jnz short loc_3B40D
lea rsi, [rbp+var_38]
mov dword ptr [rsi+8], 6
mov byte ptr [rsi+10h], 1
mov edi, 2E8h
add rdi, [rbx]
call insert_dynamic
loc_3B40D:
mov eax, r15d
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long ma_write_keypage(long long **a1, int a2, int a3)
{
long long v3; // r9
_BYTE *v4; // r11
int v5; // r15d
unsigned int v6; // r15d
_BYTE v8[8]; // [rsp+8h] [rbp-38h] BYREF
int v9; // [rsp+10h] [rbp-30h]
char v10; // [rsp+18h] [rbp-28h]
v4 = v8;
if ( a2 == 2 )
{
v5 = 0;
}
else if ( a2 == 6 )
{
v5 = 3;
v4 = 0LL;
}
else
{
v5 = 2;
}
v3 = **a1;
v6 = pagecache_write_part(
*(_QWORD *)(v3 + 1536),
(int)v3 + 1872,
(unsigned long long)a1[3] / *(unsigned int *)(v3 + 1980),
a3,
(unsigned int)a1[2],
*(_DWORD *)(v3 + 2004),
a2,
v5,
0,
(long long)v4,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v3 + 1536) + 128LL));
if ( a2 == 4 )
{
v9 = 6;
v10 = 1;
insert_dynamic(*a1 + 93, v8);
}
return v6;
}
|
_ma_write_keypage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV ECX,EDX
MOV R14D,ESI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x10]
MOV R9,qword ptr [RAX]
MOV R12D,dword ptr [R9 + 0x7bc]
LEA R11,[RBP + -0x38]
XOR R10D,R10D
CMP ESI,0x2
JZ 0x0013b39a
CMP R14D,0x6
JNZ 0x0013b39f
MOV R15D,0x3
XOR R11D,R11D
JMP 0x0013b3a5
LAB_0013b39a:
XOR R15D,R15D
JMP 0x0013b3a5
LAB_0013b39f:
MOV R15D,0x2
LAB_0013b3a5:
MOV RDI,qword ptr [R9 + 0x600]
LEA RSI,[R9 + 0x750]
MOV RAX,qword ptr [RBX + 0x18]
XOR EDX,EDX
DIV R12
MOV R9D,dword ptr [R9 + 0x7d4]
MOV R12D,dword ptr [RDI + 0x80]
SUB RSP,0x8
MOV RDX,RAX
PUSH R12
PUSH R10
PUSH 0x0
PUSH R11
PUSH R10
PUSH R15
PUSH R14
CALL 0x0016fe5e
ADD RSP,0x40
MOV R15D,EAX
CMP R14D,0x4
JNZ 0x0013b40d
LEA RSI,[RBP + -0x38]
MOV dword ptr [RSI + 0x8],0x6
MOV byte ptr [RSI + 0x10],0x1
MOV EDI,0x2e8
ADD RDI,qword ptr [RBX]
CALL 0x001948aa
LAB_0013b40d:
MOV EAX,R15D
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int4 _ma_write_keypage(long *param_1,int param_2,int4 param_3)
{
long lVar1;
int4 uVar2;
int1 *puVar3;
int8 uVar4;
int1 local_40 [8];
int4 local_38;
int1 local_30;
lVar1 = *(long *)*param_1;
puVar3 = local_40;
if (param_2 == 2) {
uVar4 = 0;
}
else if (param_2 == 6) {
uVar4 = 3;
puVar3 = (int1 *)0x0;
}
else {
uVar4 = 2;
}
uVar2 = pagecache_write_part
(*(long *)(lVar1 + 0x600),lVar1 + 0x750,
(ulong)param_1[3] / (ulong)*(uint *)(lVar1 + 0x7bc),param_3,param_1[2],
*(int4 *)(lVar1 + 0x7d4),param_2,uVar4,0,puVar3,0,0,
*(int4 *)(*(long *)(lVar1 + 0x600) + 0x80));
if (param_2 == 4) {
local_38 = 6;
local_30 = 1;
insert_dynamic(*param_1 + 0x2e8);
}
return uVar2;
}
|
|
13,701
|
chess::Bitboard chess::movegen::generateCastleMoves<(chess::Color::underlying)1, (chess::movegen::MoveGenType)0>(chess::Board const&, chess::Square, chess::Bitboard, chess::Bitboard)
|
Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp
|
[[nodiscard]] static constexpr bool back_rank(Square sq, Color color) noexcept {
if (color == Color::WHITE)
return sq.rank() == Rank::RANK_1;
else
return sq.rank() == Rank::RANK_8;
}
|
O1
|
cpp
|
chess::Bitboard chess::movegen::generateCastleMoves<(chess::Color::underlying)1, (chess::movegen::MoveGenType)0>(chess::Board const&, chess::Square, chess::Bitboard, chess::Bitboard):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
andl $-0x8, %eax
cmpl $0x38, %eax
jne 0x9ac8
movq %rcx, %r8
movl 0xa8(%rdi), %eax
movl %eax, %ecx
andl $0xffff0000, %ecx # imm = 0xFFFF0000
cmpl $0x8080000, %ecx # imm = 0x8080000
jne 0x9acf
xorl %eax, %eax
jmp 0x9bc9
movl %eax, 0x4(%rsp)
movw $0x100, 0x2(%rsp) # imm = 0x100
movl %esi, %eax
shlq $0x9, %rax
leaq 0xc721(%rip), %r9 # 0x16208
addq %rax, %r9
movq 0x58(%rdi), %r15
movl $0x1, %r11d
movl %esi, %ecx
shlq %cl, %r11
orq 0x50(%rdi), %r15
movq $-0x2, %rdi
rolq %cl, %rdi
xorl %r12d, %r12d
xorl %eax, %eax
movzbl 0x2(%rsp,%r12), %ebp
movzbl 0x6(%rsp,%rbp), %ecx
cmpl $0x8, %ecx
je 0x9bbc
xorl %r10d, %r10d
testb %bpl, %bpl
sete %bl
cmpb $0x8, %cl
jae 0x9bd8
addl $0x38, %ecx
movl $0x1, %r13d
shlq %cl, %r13
cmpl $0x40, %esi
jae 0x9bd8
movb %bl, %r10b
leal 0x3a(,%r10,4), %ebx
movq %r15, %r14
btrq %rcx, %r14
movq %r14, %r10
orq %rdx, %r10
testq %r10, (%r9,%rbx,8)
jne 0x9bbc
movq (%r9,%rcx,8), %rcx
andq %r15, %rcx
jne 0x9bbc
movq %r13, %rcx
andq %r8, %rcx
shrq $0x38, %rcx
jne 0x9bbc
testb %bpl, %bpl
movabsq $0x800000000000000, %rcx # imm = 0x800000000000000
movabsq $0x2000000000000000, %r10 # imm = 0x2000000000000000
cmoveq %r10, %rcx
movq %r13, %r10
orq %r11, %r10
notq %r10
andq %rcx, %r10
testq %r15, %r10
jne 0x9bbc
andq %rdi, %r14
orq %rdx, %r14
btq %rbx, %r14
movl $0x0, %ecx
cmovbq %rcx, %r13
orq %r13, %rax
incq %r12
cmpq $0x2, %r12
jne 0x9b0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x499f(%rip), %rdi # 0xe57e
leaq 0x6ff6(%rip), %rsi # 0x10bdc
leaq 0x49b4(%rip), %rcx # 0xe5a1
movl $0x269, %edx # imm = 0x269
callq 0x3130
nop
|
_ZN5chess7movegen19generateCastleMovesILNS_5Color10underlyingE1ELNS0_11MoveGenTypeE0EEENS_8BitboardERKNS_5BoardENS_6SquareES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov eax, esi
and eax, 0FFFFFFF8h
cmp eax, 38h ; '8'
jnz short loc_9AC8
mov r8, rcx
mov eax, [rdi+0A8h]
mov ecx, eax
and ecx, 0FFFF0000h
cmp ecx, 8080000h
jnz short loc_9ACF
loc_9AC8:
xor eax, eax
jmp loc_9BC9
loc_9ACF:
mov [rsp+38h+var_34], eax
mov [rsp+38h+var_36], 100h
mov eax, esi
shl rax, 9
lea r9, _ZN5chess7movegen18SQUARES_BETWEEN_BBE; chess::movegen::SQUARES_BETWEEN_BB
add r9, rax
mov r15, [rdi+58h]
mov r11d, 1
mov ecx, esi
shl r11, cl
or r15, [rdi+50h]
mov rdi, 0FFFFFFFFFFFFFFFEh
rol rdi, cl
xor r12d, r12d
xor eax, eax
loc_9B0C:
movzx ebp, byte ptr [rsp+r12+38h+var_36]
movzx ecx, byte ptr [rsp+rbp+38h+var_34+2]
cmp ecx, 8
jz loc_9BBC
xor r10d, r10d
test bpl, bpl
setz bl
cmp cl, 8
jnb loc_9BD8
add ecx, 38h ; '8'
mov r13d, 1
shl r13, cl
cmp esi, 40h ; '@'
jnb loc_9BD8
mov r10b, bl
lea ebx, ds:3Ah[r10*4]
mov r14, r15
btr r14, rcx
mov r10, r14
or r10, rdx
test [r9+rbx*8], r10
jnz short loc_9BBC
mov rcx, [r9+rcx*8]
and rcx, r15
jnz short loc_9BBC
mov rcx, r13
and rcx, r8
shr rcx, 38h
jnz short loc_9BBC
test bpl, bpl
mov rcx, 800000000000000h
mov r10, 2000000000000000h
cmovz rcx, r10
mov r10, r13
or r10, r11
not r10
and r10, rcx
test r10, r15
jnz short loc_9BBC
and r14, rdi
or r14, rdx
bt r14, rbx
mov ecx, 0
cmovb r13, rcx
or rax, r13
loc_9BBC:
inc r12
cmp r12, 2
jnz loc_9B0C
loc_9BC9:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9BD8:
lea rdi, aSqIndex0SqInde; "sq.index() >= 0 && sq.index() < 64"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStaticBitboard; "static Bitboard chess::Bitboard::fromSq"...
mov edx, 269h
call ___assert_fail
|
long long chess::movegen::generateCastleMoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>(
long long a1,
unsigned int a2,
long long a3,
long long a4)
{
long long v4; // rax
long long result; // rax
_QWORD *v7; // r9
long long v8; // r15
long long v9; // rdi
long long v10; // r12
long long v11; // rbp
int v12; // ecx
int v13; // r10d
long long v14; // rcx
long long v15; // r13
unsigned long long v16; // rbx
long long v17; // r14
long long v18; // rcx
long long v19; // r14
_QWORD v20[7]; // [rsp-2h] [rbp-38h]
v20[0] = v4;
if ( (a2 & 0xFFFFFFF8) != 0x38 || (*(_DWORD *)(a1 + 168) & 0xFFFF0000) == 0x8080000 )
return 0LL;
HIDWORD(v20[0]) = *(_DWORD *)(a1 + 168);
WORD1(v20[0]) = 256;
v7 = &chess::movegen::SQUARES_BETWEEN_BB[64 * (unsigned long long)a2];
v8 = *(_QWORD *)(a1 + 80) | *(_QWORD *)(a1 + 88);
v9 = __ROL8__(-2LL, a2);
v10 = 0LL;
result = 0LL;
do
{
v11 = *((unsigned __int8 *)v20 + v10 + 2);
v12 = *((unsigned __int8 *)v20 + v11 + 6);
if ( v12 != 8 )
{
v13 = 0;
if ( (unsigned __int8)v12 >= 8u || (v14 = (unsigned int)(v12 + 56), v15 = 1LL << v14, a2 >= 0x40) )
__assert_fail(
"sq.index() >= 0 && sq.index() < 64",
"/workspace/llm4binary/github/2025_star3/Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp",
617LL,
"static Bitboard chess::Bitboard::fromSquare(Square)");
LOBYTE(v13) = (_BYTE)v11 == 0;
v16 = (unsigned int)(4 * v13 + 58);
v17 = v8 & ~(1LL << v14);
if ( ((a3 | v17) & v7[v16]) == 0 && (v8 & v7[v14]) == 0 && !((a4 & (unsigned long long)v15) >> 56) )
{
v18 = 0x800000000000000LL;
if ( !(_BYTE)v11 )
v18 = 0x2000000000000000LL;
if ( (v8 & v18 & ~((1LL << a2) | v15)) == 0 )
{
v19 = a3 | v9 & v17;
if ( _bittest64(&v19, v16) )
v15 = 0LL;
result |= v15;
}
}
}
++v10;
}
while ( v10 != 2 );
return result;
}
|
generateCastleMoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EAX,ESI
AND EAX,0xfffffff8
CMP EAX,0x38
JNZ 0x00109ac8
MOV R8,RCX
MOV EAX,dword ptr [RDI + 0xa8]
MOV ECX,EAX
AND ECX,0xffff0000
CMP ECX,0x8080000
JNZ 0x00109acf
LAB_00109ac8:
XOR EAX,EAX
JMP 0x00109bc9
LAB_00109acf:
MOV dword ptr [RSP + 0x4],EAX
MOV word ptr [RSP + 0x2],0x100
MOV EAX,ESI
SHL RAX,0x9
LEA R9,[0x116208]
ADD R9,RAX
MOV R15,qword ptr [RDI + 0x58]
MOV R11D,0x1
MOV ECX,ESI
SHL R11,CL
OR R15,qword ptr [RDI + 0x50]
MOV RDI,-0x2
ROL RDI,CL
XOR R12D,R12D
XOR EAX,EAX
LAB_00109b0c:
MOVZX EBP,byte ptr [RSP + R12*0x1 + 0x2]
MOVZX ECX,byte ptr [RSP + RBP*0x1 + 0x6]
CMP ECX,0x8
JZ 0x00109bbc
XOR R10D,R10D
TEST BPL,BPL
SETZ BL
CMP CL,0x8
JNC 0x00109bd8
ADD ECX,0x38
MOV R13D,0x1
SHL R13,CL
CMP ESI,0x40
JNC 0x00109bd8
MOV R10B,BL
LEA EBX,[0x3a + R10*0x4]
MOV R14,R15
BTR R14,RCX
MOV R10,R14
OR R10,RDX
TEST qword ptr [R9 + RBX*0x8],R10
JNZ 0x00109bbc
MOV RCX,qword ptr [R9 + RCX*0x8]
AND RCX,R15
JNZ 0x00109bbc
MOV RCX,R13
AND RCX,R8
SHR RCX,0x38
JNZ 0x00109bbc
TEST BPL,BPL
MOV RCX,0x800000000000000
MOV R10,0x2000000000000000
CMOVZ RCX,R10
MOV R10,R13
OR R10,R11
NOT R10
AND R10,RCX
TEST R10,R15
JNZ 0x00109bbc
AND R14,RDI
OR R14,RDX
BT R14,RBX
MOV ECX,0x0
CMOVC R13,RCX
OR RAX,R13
LAB_00109bbc:
INC R12
CMP R12,0x2
JNZ 0x00109b0c
LAB_00109bc9:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00109bd8:
LEA RDI,[0x10e57e]
LEA RSI,[0x110bdc]
LEA RCX,[0x10e5a1]
MOV EDX,0x269
CALL 0x00103130
|
/* chess::Bitboard chess::movegen::generateCastleMoves<(chess::Color::underlying)1,
(chess::movegen::MoveGenType)0>(chess::Board const&, chess::Square, chess::Bitboard,
chess::Bitboard) */
ulong chess::movegen::
generateCastleMoves<(chess::Color::underlying)1,(chess::movegen::MoveGenType)0>
(long param_1,uint param_2,ulong param_3,ulong param_4)
{
byte bVar1;
byte bVar2;
byte bVar3;
ulong uVar4;
uint uVar5;
ulong uVar6;
ulong uVar7;
long lVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
byte local_36 [4];
byte abStack_32 [2];
if (((param_2 & 0xfffffff8) == 0x38) && ((*(uint *)(param_1 + 0xa8) & 0xffff0000) != 0x8080000)) {
uVar11 = *(ulong *)(param_1 + 0x58) | *(ulong *)(param_1 + 0x50);
bVar3 = (byte)param_2 & 0x3f;
lVar8 = 0;
uVar4 = 0;
do {
bVar1 = local_36[lVar8];
bVar2 = abStack_32[bVar1];
if (bVar2 != 8) {
if (7 < bVar2) {
LAB_00109bd8:
/* WARNING: Subroutine does not return */
__assert_fail("sq.index() >= 0 && sq.index() < 64",
"/workspace/llm4binary/github/2025_star3/Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp"
,0x269,"static Bitboard chess::Bitboard::fromSquare(Square)");
}
uVar5 = bVar2 + 0x38;
uVar9 = 1L << ((byte)uVar5 & 0x3f);
if (0x3f < param_2) goto LAB_00109bd8;
uVar7 = (ulong)((uint)(bVar1 == 0) * 4 + 0x3a);
uVar10 = uVar11 & ~(1L << ((ulong)uVar5 & 0x3f));
if ((((*(ulong *)(SQUARES_BETWEEN_BB + uVar7 * 8 + (ulong)param_2 * 0x200) &
(uVar10 | param_3)) == 0) &&
((*(ulong *)(SQUARES_BETWEEN_BB + (ulong)uVar5 * 8 + (ulong)param_2 * 0x200) & uVar11)
== 0)) && ((uVar9 & param_4) >> 0x38 == 0)) {
uVar6 = 0x800000000000000;
if (bVar1 == 0) {
uVar6 = 0x2000000000000000;
}
if ((~(uVar9 | 1L << ((byte)param_2 & 0x3f)) & uVar6 & uVar11) == 0) {
if (((uVar10 & (-2L << bVar3 | 0xfffffffffffffffeU >> 0x40 - bVar3) | param_3) >>
(uVar7 & 0x3f) & 1) != 0) {
uVar9 = 0;
}
uVar4 = uVar4 | uVar9;
}
}
}
lVar8 = lVar8 + 1;
} while (lVar8 != 2);
}
else {
uVar4 = 0;
}
return uVar4;
}
|
|
13,702
|
dequantize_row_q5_1
|
7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c
|
void dequantize_row_q5_1(const block_q5_1 * restrict x, float * restrict y, int k) {
static const int qk = QK5_1;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const float m = GGML_FP16_TO_FP32(x[i].m);
uint32_t qh;
memcpy(&qh, x[i].qh, sizeof(qh));
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int x0 = (x[i].qs[j] & 0x0F) | xh_0;
const int x1 = (x[i].qs[j] >> 4) | xh_1;
y[i*qk + j + 0 ] = x0*d + m;
y[i*qk + j + qk/2] = x1*d + m;
}
}
}
|
O1
|
c
|
dequantize_row_q5_1:
cmpl $0x20, %edx
jl 0xb6deb
shrl $0x5, %edx
leaq 0x8(%rdi), %rax
addq $0x40, %rsi
xorl %ecx, %ecx
leaq 0xc756c(%rip), %r8 # 0x17e280
vpmovsxbd 0xed13(%rip), %ymm0 # 0xc5a30
vpbroadcastd 0x1227e(%rip), %ymm1 # 0xc8fa4
vpbroadcastd 0x1228d(%rip), %ymm2 # 0xc8fbc
vpbroadcastd 0x1227c(%rip), %ymm3 # 0xc8fb4
vpbroadcastd 0xe53f(%rip), %ymm4 # 0xc5280
leaq (%rcx,%rcx,2), %r9
movzwl 0x2(%rdi,%r9,8), %r10d
movzwl (%rdi,%r9,8), %r11d
vpbroadcastd 0x4(%rdi,%r9,8), %ymm5
vbroadcastss (%r8,%r11,4), %ymm6
vbroadcastss (%r8,%r10,4), %ymm7
xorl %r9d, %r9d
vmovdqa %ymm0, %ymm8
vmovdqa %ymm0, %ymm9
vpsrlvd %ymm8, %ymm5, %ymm10
vpslld $0x4, %ymm10, %ymm10
vpand %ymm1, %ymm10, %ymm10
vpaddd %ymm2, %ymm9, %ymm11
vpsrlvd %ymm11, %ymm5, %ymm11
vpand %ymm1, %ymm11, %ymm11
vpmovzxbd (%rax,%r9), %ymm12
vpand %ymm3, %ymm12, %ymm13
vpor %ymm10, %ymm13, %ymm10
vpsrld $0x4, %ymm12, %ymm12
vpor %ymm11, %ymm12, %ymm11
vcvtdq2ps %ymm10, %ymm10
vfmadd213ps %ymm7, %ymm6, %ymm10 # ymm10 = (ymm6 * ymm10) + ymm7
vmovups %ymm10, -0x40(%rsi,%r9,4)
vcvtdq2ps %ymm11, %ymm10
vfmadd213ps %ymm7, %ymm6, %ymm10 # ymm10 = (ymm6 * ymm10) + ymm7
vmovups %ymm10, (%rsi,%r9,4)
addq $0x8, %r9
vpaddd %ymm4, %ymm8, %ymm8
vpaddd %ymm4, %ymm9, %ymm9
cmpq $0x10, %r9
jne 0xb6d6e
incq %rcx
addq $0x18, %rax
subq $-0x80, %rsi
cmpq %rdx, %rcx
jne 0xb6d41
vzeroupper
retq
|
dequantize_row_q5_1:
cmp edx, 20h ; ' '
jl loc_B6DEB
shr edx, 5
lea rax, [rdi+8]
add rsi, 40h ; '@'
xor ecx, ecx
lea r8, ggml_table_f32_f16
vpmovsxbd ymm0, cs:qword_C5A30
vpbroadcastd ymm1, cs:dword_C8FA4
vpbroadcastd ymm2, cs:dword_C8FBC
vpbroadcastd ymm3, cs:dword_C8FB4
vpbroadcastd ymm4, cs:dword_C5280
loc_B6D41:
lea r9, [rcx+rcx*2]
movzx r10d, word ptr [rdi+r9*8+2]
movzx r11d, word ptr [rdi+r9*8]
vpbroadcastd ymm5, dword ptr [rdi+r9*8+4]
vbroadcastss ymm6, dword ptr [r8+r11*4]
vbroadcastss ymm7, dword ptr [r8+r10*4]
xor r9d, r9d
vmovdqa ymm8, ymm0
vmovdqa ymm9, ymm0
loc_B6D6E:
vpsrlvd ymm10, ymm5, ymm8
vpslld ymm10, ymm10, 4
vpand ymm10, ymm10, ymm1
vpaddd ymm11, ymm9, ymm2
vpsrlvd ymm11, ymm5, ymm11
vpand ymm11, ymm11, ymm1
vpmovzxbd ymm12, qword ptr [rax+r9]
vpand ymm13, ymm12, ymm3
vpor ymm10, ymm13, ymm10
vpsrld ymm12, ymm12, 4
vpor ymm11, ymm12, ymm11
vcvtdq2ps ymm10, ymm10
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4-40h], ymm10
vcvtdq2ps ymm10, ymm11
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4], ymm10
add r9, 8
vpaddd ymm8, ymm8, ymm4
vpaddd ymm9, ymm9, ymm4
cmp r9, 10h
jnz short loc_B6D6E
inc rcx
add rax, 18h
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rcx, rdx
jnz loc_B6D41
loc_B6DEB:
vzeroupper
retn
|
void dequantize_row_q5_1(long long _RDI, long long a2, int a3)
{
long long v3; // rdx
long long v6; // rcx
if ( a3 >= 32 )
{
v3 = (unsigned int)a3 >> 5;
_RAX = _RDI + 8;
_RSI = a2 + 64;
v6 = 0LL;
_R8 = &ggml_table_f32_f16;
__asm
{
vpmovsxbd ymm0, cs:qword_C5A30
vpbroadcastd ymm1, cs:dword_C8FA4
vpbroadcastd ymm2, cs:dword_C8FBC
vpbroadcastd ymm3, cs:dword_C8FB4
vpbroadcastd ymm4, cs:dword_C5280
}
do
{
_R9 = 3 * v6;
_R10 = *(unsigned __int16 *)(_RDI + 24 * v6 + 2);
_R11 = *(unsigned __int16 *)(_RDI + 24 * v6);
__asm
{
vpbroadcastd ymm5, dword ptr [rdi+r9*8+4]
vbroadcastss ymm6, dword ptr [r8+r11*4]
vbroadcastss ymm7, dword ptr [r8+r10*4]
}
_R9 = 0LL;
__asm
{
vmovdqa ymm8, ymm0
vmovdqa ymm9, ymm0
}
do
{
__asm
{
vpsrlvd ymm10, ymm5, ymm8
vpslld ymm10, ymm10, 4
vpand ymm10, ymm10, ymm1
vpaddd ymm11, ymm9, ymm2
vpsrlvd ymm11, ymm5, ymm11
vpand ymm11, ymm11, ymm1
vpmovzxbd ymm12, qword ptr [rax+r9]
vpand ymm13, ymm12, ymm3
vpor ymm10, ymm13, ymm10
vpsrld ymm12, ymm12, 4
vpor ymm11, ymm12, ymm11
vcvtdq2ps ymm10, ymm10
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4-40h], ymm10
vcvtdq2ps ymm10, ymm11
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4], ymm10
}
_R9 += 8LL;
__asm
{
vpaddd ymm8, ymm8, ymm4
vpaddd ymm9, ymm9, ymm4
}
}
while ( _R9 != 16 );
++v6;
_RAX += 24LL;
_RSI += 128LL;
}
while ( v6 != v3 );
}
__asm { vzeroupper }
}
| |||
13,703
|
dequantize_row_q5_1
|
7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c
|
void dequantize_row_q5_1(const block_q5_1 * restrict x, float * restrict y, int k) {
static const int qk = QK5_1;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const float m = GGML_FP16_TO_FP32(x[i].m);
uint32_t qh;
memcpy(&qh, x[i].qh, sizeof(qh));
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int x0 = (x[i].qs[j] & 0x0F) | xh_0;
const int x1 = (x[i].qs[j] >> 4) | xh_1;
y[i*qk + j + 0 ] = x0*d + m;
y[i*qk + j + qk/2] = x1*d + m;
}
}
}
|
O2
|
c
|
dequantize_row_q5_1:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %eax
movl $0x20, %ecx
cltd
idivl %ecx
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
addq $0x40, %rsi
leaq 0x8(%rdi), %r9
leaq 0xca570(%rip), %r10 # 0x15d290
cmpq %rax, %r8
je 0x92dae
imulq $0x18, %r8, %rcx
movzwl (%rdi,%rcx), %edx
vmovss (%r10,%rdx,4), %xmm0
movzwl 0x2(%rdi,%rcx), %edx
vmovss (%r10,%rdx,4), %xmm1
movl 0x4(%rdi,%rcx), %r11d
xorl %edx, %edx
cmpq $0x10, %rdx
je 0x92d9e
movl %r11d, %ebx
movl %edx, %ecx
shrl %cl, %ebx
leal 0xc(%rdx), %ecx
movl %r11d, %ebp
shrl %cl, %ebp
shll $0x4, %ebx
andl $0x10, %ebx
andl $0x10, %ebp
movzbl (%r9,%rdx), %ecx
movl %ecx, %r14d
andl $0xf, %r14d
orl %ebx, %r14d
shrl $0x4, %ecx
orl %ebp, %ecx
vcvtsi2ss %r14d, %xmm4, %xmm2
vfmadd213ss %xmm1, %xmm0, %xmm2 # xmm2 = (xmm0 * xmm2) + xmm1
vcvtsi2ss %ecx, %xmm4, %xmm3
vmovss %xmm2, -0x40(%rsi,%rdx,4)
vfmadd213ss %xmm1, %xmm0, %xmm3 # xmm3 = (xmm0 * xmm3) + xmm1
vmovss %xmm3, (%rsi,%rdx,4)
incq %rdx
jmp 0x92d49
incq %r8
subq $-0x80, %rsi
addq $0x18, %r9
jmp 0x92d20
popq %rbx
popq %r14
popq %rbp
retq
|
dequantize_row_q5_1:
push rbp
push r14
push rbx
mov eax, edx
mov ecx, 20h ; ' '
cdq
idiv ecx
xor r8d, r8d
test eax, eax
cmovle eax, r8d
add rsi, 40h ; '@'
lea r9, [rdi+8]
lea r10, ggml_table_f32_f16
loc_92D20:
cmp r8, rax
jz loc_92DAE
imul rcx, r8, 18h
movzx edx, word ptr [rdi+rcx]
vmovss xmm0, dword ptr [r10+rdx*4]
movzx edx, word ptr [rdi+rcx+2]
vmovss xmm1, dword ptr [r10+rdx*4]
mov r11d, [rdi+rcx+4]
xor edx, edx
loc_92D49:
cmp rdx, 10h
jz short loc_92D9E
mov ebx, r11d
mov ecx, edx
shr ebx, cl
lea ecx, [rdx+0Ch]
mov ebp, r11d
shr ebp, cl
shl ebx, 4
and ebx, 10h
and ebp, 10h
movzx ecx, byte ptr [r9+rdx]
mov r14d, ecx
and r14d, 0Fh
or r14d, ebx
shr ecx, 4
or ecx, ebp
vcvtsi2ss xmm2, xmm4, r14d
vfmadd213ss xmm2, xmm0, xmm1
vcvtsi2ss xmm3, xmm4, ecx
vmovss dword ptr [rsi+rdx*4-40h], xmm2
vfmadd213ss xmm3, xmm0, xmm1
vmovss dword ptr [rsi+rdx*4], xmm3
inc rdx
jmp short loc_92D49
loc_92D9E:
inc r8
sub rsi, 0FFFFFFFFFFFFFF80h
add r9, 18h
jmp loc_92D20
loc_92DAE:
pop rbx
pop r14
pop rbp
retn
|
long long dequantize_row_q5_1(
long long a1,
long long a2,
int a3,
double a4,
double a5,
double a6,
double a7,
__m128 _XMM4)
{
long long result; // rax
long long v9; // r8
long long v11; // r9
result = (unsigned int)(a3 / 32);
v9 = 0LL;
if ( (int)result <= 0 )
result = 0LL;
_RSI = a2 + 64;
v11 = a1 + 8;
_R10 = &ggml_table_f32_f16;
while ( v9 != result )
{
_RDX = *(unsigned __int16 *)(a1 + 24 * v9);
__asm { vmovss xmm0, dword ptr [r10+rdx*4] }
_RDX = *(unsigned __int16 *)(a1 + 24 * v9 + 2);
__asm { vmovss xmm1, dword ptr [r10+rdx*4] }
for ( _RDX = 0LL; _RDX != 16; ++_RDX )
{
__asm
{
vcvtsi2ss xmm2, xmm4, r14d
vfmadd213ss xmm2, xmm0, xmm1
vcvtsi2ss xmm3, xmm4, ecx
vmovss dword ptr [rsi+rdx*4-40h], xmm2
vfmadd213ss xmm3, xmm0, xmm1
vmovss dword ptr [rsi+rdx*4], xmm3
}
}
++v9;
_RSI += 128LL;
v11 += 24LL;
}
return result;
}
|
dequantize_row_q5_1:
PUSH RBP
PUSH R14
PUSH RBX
MOV EAX,EDX
MOV ECX,0x20
CDQ
IDIV ECX
XOR R8D,R8D
TEST EAX,EAX
CMOVLE EAX,R8D
ADD RSI,0x40
LEA R9,[RDI + 0x8]
LEA R10,[0x25d290]
LAB_00192d20:
CMP R8,RAX
JZ 0x00192dae
IMUL RCX,R8,0x18
MOVZX EDX,word ptr [RDI + RCX*0x1]
VMOVSS XMM0,dword ptr [R10 + RDX*0x4]
MOVZX EDX,word ptr [RDI + RCX*0x1 + 0x2]
VMOVSS XMM1,dword ptr [R10 + RDX*0x4]
MOV R11D,dword ptr [RDI + RCX*0x1 + 0x4]
XOR EDX,EDX
LAB_00192d49:
CMP RDX,0x10
JZ 0x00192d9e
MOV EBX,R11D
MOV ECX,EDX
SHR EBX,CL
LEA ECX,[RDX + 0xc]
MOV EBP,R11D
SHR EBP,CL
SHL EBX,0x4
AND EBX,0x10
AND EBP,0x10
MOVZX ECX,byte ptr [R9 + RDX*0x1]
MOV R14D,ECX
AND R14D,0xf
OR R14D,EBX
SHR ECX,0x4
OR ECX,EBP
VCVTSI2SS XMM2,XMM4,R14D
VFMADD213SS XMM2,XMM0,XMM1
VCVTSI2SS XMM3,XMM4,ECX
VMOVSS dword ptr [RSI + RDX*0x4 + -0x40],XMM2
VFMADD213SS XMM3,XMM0,XMM1
VMOVSS dword ptr [RSI + RDX*0x4],XMM3
INC RDX
JMP 0x00192d49
LAB_00192d9e:
INC R8
SUB RSI,-0x80
ADD R9,0x18
JMP 0x00192d20
LAB_00192dae:
POP RBX
POP R14
POP RBP
RET
|
void dequantize_row_q5_1(long param_1,long param_2,int param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
long lVar7;
int1 auVar8 [16];
int1 auVar9 [16];
int1 in_register_00001304 [12];
uVar6 = 0;
uVar4 = (long)param_3 / 0x20 & 0xffffffff;
if ((int)((long)param_3 / 0x20) < 1) {
uVar4 = uVar6;
}
param_2 = param_2 + 0x40;
lVar7 = param_1 + 8;
for (; uVar6 != uVar4; uVar6 = uVar6 + 1) {
lVar5 = uVar6 * 0x18;
uVar1 = (&ggml_table_f32_f16)[*(ushort *)(param_1 + lVar5)];
uVar2 = (&ggml_table_f32_f16)[*(ushort *)(param_1 + 2 + lVar5)];
uVar3 = *(uint *)(param_1 + 4 + lVar5);
for (lVar5 = 0; lVar5 != 0x10; lVar5 = lVar5 + 1) {
auVar8._0_4_ = (float)(*(byte *)(lVar7 + lVar5) & 0xf |
(uVar3 >> ((byte)lVar5 & 0x1f) & 1) << 4);
auVar8._4_12_ = in_register_00001304;
auVar8 = vfmadd213ss_fma(auVar8,ZEXT416(uVar1),ZEXT416(uVar2));
auVar9._0_4_ = (float)((uint)(*(byte *)(lVar7 + lVar5) >> 4) |
uVar3 >> ((byte)lVar5 + 0xc & 0x1f) & 0x10);
auVar9._4_12_ = in_register_00001304;
*(int *)(param_2 + -0x40 + lVar5 * 4) = auVar8._0_4_;
auVar8 = vfmadd213ss_fma(auVar9,ZEXT416(uVar1),ZEXT416(uVar2));
*(int *)(param_2 + lVar5 * 4) = auVar8._0_4_;
}
param_2 = param_2 + 0x80;
lVar7 = lVar7 + 0x18;
}
return;
}
|
|
13,704
|
dequantize_row_q5_1
|
7CodeWizard[P]stablediffusion/ggml/src/ggml-quants.c
|
void dequantize_row_q5_1(const block_q5_1 * restrict x, float * restrict y, int k) {
static const int qk = QK5_1;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
const float m = GGML_FP16_TO_FP32(x[i].m);
uint32_t qh;
memcpy(&qh, x[i].qh, sizeof(qh));
for (int j = 0; j < qk/2; ++j) {
const uint8_t xh_0 = ((qh >> (j + 0)) << 4) & 0x10;
const uint8_t xh_1 = ((qh >> (j + 12)) ) & 0x10;
const int x0 = (x[i].qs[j] & 0x0F) | xh_0;
const int x1 = (x[i].qs[j] >> 4) | xh_1;
y[i*qk + j + 0 ] = x0*d + m;
y[i*qk + j + qk/2] = x1*d + m;
}
}
}
|
O3
|
c
|
dequantize_row_q5_1:
cmpl $0x20, %edx
jl 0xb5923
shrl $0x5, %edx
leaq 0x8(%rdi), %rax
addq $0x40, %rsi
xorl %ecx, %ecx
leaq 0xc6a34(%rip), %r8 # 0x17c280
vpmovsxbd 0xeb0b(%rip), %ymm0 # 0xc4360
vpbroadcastd 0x12726(%rip), %ymm1 # 0xc7f84
vpbroadcastd 0x12735(%rip), %ymm2 # 0xc7f9c
vpbroadcastd 0x12724(%rip), %ymm3 # 0xc7f94
vpbroadcastd 0xea27(%rip), %ymm4 # 0xc42a0
leaq (%rcx,%rcx,2), %r9
movzwl 0x2(%rdi,%r9,8), %r10d
movzwl (%rdi,%r9,8), %r11d
vpbroadcastd 0x4(%rdi,%r9,8), %ymm5
vbroadcastss (%r8,%r11,4), %ymm6
vbroadcastss (%r8,%r10,4), %ymm7
xorl %r9d, %r9d
vmovdqa %ymm0, %ymm8
vmovdqa %ymm0, %ymm9
vpsrlvd %ymm8, %ymm5, %ymm10
vpslld $0x4, %ymm10, %ymm10
vpand %ymm1, %ymm10, %ymm10
vpaddd %ymm2, %ymm9, %ymm11
vpsrlvd %ymm11, %ymm5, %ymm11
vpand %ymm1, %ymm11, %ymm11
vpmovzxbd (%rax,%r9), %ymm12
vpand %ymm3, %ymm12, %ymm13
vpor %ymm10, %ymm13, %ymm10
vpsrld $0x4, %ymm12, %ymm12
vpor %ymm11, %ymm12, %ymm11
vcvtdq2ps %ymm10, %ymm10
vfmadd213ps %ymm7, %ymm6, %ymm10 # ymm10 = (ymm6 * ymm10) + ymm7
vmovups %ymm10, -0x40(%rsi,%r9,4)
vcvtdq2ps %ymm11, %ymm10
vfmadd213ps %ymm7, %ymm6, %ymm10 # ymm10 = (ymm6 * ymm10) + ymm7
vmovups %ymm10, (%rsi,%r9,4)
addq $0x8, %r9
vpaddd %ymm4, %ymm8, %ymm8
vpaddd %ymm4, %ymm9, %ymm9
cmpq $0x10, %r9
jne 0xb58a6
incq %rcx
addq $0x18, %rax
subq $-0x80, %rsi
cmpq %rdx, %rcx
jne 0xb5879
vzeroupper
retq
|
dequantize_row_q5_1:
cmp edx, 20h ; ' '
jl loc_B5923
shr edx, 5
lea rax, [rdi+8]
add rsi, 40h ; '@'
xor ecx, ecx
lea r8, ggml_table_f32_f16
vpmovsxbd ymm0, cs:qword_C4360
vpbroadcastd ymm1, cs:dword_C7F84
vpbroadcastd ymm2, cs:dword_C7F9C
vpbroadcastd ymm3, cs:dword_C7F94
vpbroadcastd ymm4, cs:dword_C42A0
loc_B5879:
lea r9, [rcx+rcx*2]
movzx r10d, word ptr [rdi+r9*8+2]
movzx r11d, word ptr [rdi+r9*8]
vpbroadcastd ymm5, dword ptr [rdi+r9*8+4]
vbroadcastss ymm6, dword ptr [r8+r11*4]
vbroadcastss ymm7, dword ptr [r8+r10*4]
xor r9d, r9d
vmovdqa ymm8, ymm0
vmovdqa ymm9, ymm0
loc_B58A6:
vpsrlvd ymm10, ymm5, ymm8
vpslld ymm10, ymm10, 4
vpand ymm10, ymm10, ymm1
vpaddd ymm11, ymm9, ymm2
vpsrlvd ymm11, ymm5, ymm11
vpand ymm11, ymm11, ymm1
vpmovzxbd ymm12, qword ptr [rax+r9]
vpand ymm13, ymm12, ymm3
vpor ymm10, ymm13, ymm10
vpsrld ymm12, ymm12, 4
vpor ymm11, ymm12, ymm11
vcvtdq2ps ymm10, ymm10
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4-40h], ymm10
vcvtdq2ps ymm10, ymm11
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4], ymm10
add r9, 8
vpaddd ymm8, ymm8, ymm4
vpaddd ymm9, ymm9, ymm4
cmp r9, 10h
jnz short loc_B58A6
inc rcx
add rax, 18h
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rcx, rdx
jnz loc_B5879
loc_B5923:
vzeroupper
retn
|
void dequantize_row_q5_1(long long _RDI, long long a2, int a3)
{
long long v3; // rdx
long long v6; // rcx
if ( a3 >= 32 )
{
v3 = (unsigned int)a3 >> 5;
_RAX = _RDI + 8;
_RSI = a2 + 64;
v6 = 0LL;
_R8 = &ggml_table_f32_f16;
__asm
{
vpmovsxbd ymm0, cs:qword_C4360
vpbroadcastd ymm1, cs:dword_C7F84
vpbroadcastd ymm2, cs:dword_C7F9C
vpbroadcastd ymm3, cs:dword_C7F94
vpbroadcastd ymm4, cs:dword_C42A0
}
do
{
_R9 = 3 * v6;
_R10 = *(unsigned __int16 *)(_RDI + 24 * v6 + 2);
_R11 = *(unsigned __int16 *)(_RDI + 24 * v6);
__asm
{
vpbroadcastd ymm5, dword ptr [rdi+r9*8+4]
vbroadcastss ymm6, dword ptr [r8+r11*4]
vbroadcastss ymm7, dword ptr [r8+r10*4]
}
_R9 = 0LL;
__asm
{
vmovdqa ymm8, ymm0
vmovdqa ymm9, ymm0
}
do
{
__asm
{
vpsrlvd ymm10, ymm5, ymm8
vpslld ymm10, ymm10, 4
vpand ymm10, ymm10, ymm1
vpaddd ymm11, ymm9, ymm2
vpsrlvd ymm11, ymm5, ymm11
vpand ymm11, ymm11, ymm1
vpmovzxbd ymm12, qword ptr [rax+r9]
vpand ymm13, ymm12, ymm3
vpor ymm10, ymm13, ymm10
vpsrld ymm12, ymm12, 4
vpor ymm11, ymm12, ymm11
vcvtdq2ps ymm10, ymm10
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4-40h], ymm10
vcvtdq2ps ymm10, ymm11
vfmadd213ps ymm10, ymm6, ymm7
vmovups ymmword ptr [rsi+r9*4], ymm10
}
_R9 += 8LL;
__asm
{
vpaddd ymm8, ymm8, ymm4
vpaddd ymm9, ymm9, ymm4
}
}
while ( _R9 != 16 );
++v6;
_RAX += 24LL;
_RSI += 128LL;
}
while ( v6 != v3 );
}
__asm { vzeroupper }
}
| |||
13,705
|
js_array_buffer_constructor0
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_buffer_constructor0(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv,
JSClassID class_id)
{
uint64_t len, max_len, *pmax_len = NULL;
JSValue obj, val;
int64_t i;
if (JS_ToIndex(ctx, &len, argv[0]))
return JS_EXCEPTION;
if (argc < 2)
goto next;
if (!JS_IsObject(argv[1]))
goto next;
obj = JS_ToObject(ctx, argv[1]);
if (JS_IsException(obj))
return JS_EXCEPTION;
val = JS_GetProperty(ctx, obj, JS_ATOM_maxByteLength);
JS_FreeValue(ctx, obj);
if (JS_IsException(val))
return JS_EXCEPTION;
if (JS_IsUndefined(val))
goto next;
if (JS_ToInt64Free(ctx, &i, val))
return JS_EXCEPTION;
// don't have to check i < 0 because len >= 0
if (len > i || i > MAX_SAFE_INTEGER)
return JS_ThrowRangeError(ctx, "invalid array buffer max length");
max_len = i;
pmax_len = &max_len;
next:
return js_array_buffer_constructor2(ctx, new_target, len, pmax_len,
class_id);
}
|
O0
|
c
|
js_array_buffer_constructor0:
subq $0xa8, %rsp
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq %r8, 0x70(%rsp)
movl %r9d, 0x6c(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x60(%rsp), %rsi
callq 0x3f430
cmpl $0x0, %eax
je 0xe4975
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0xe4b71
cmpl $0x2, 0x7c(%rsp)
jge 0xe4981
jmp 0xe4b35
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
callq 0x31260
cmpl $0x0, %eax
jne 0xe499d
jmp 0xe4b35
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x3da60
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xe4a05
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0xe4b71
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl $0x92, %ecx
callq 0x30070
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29f80
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0xe4a86
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0xe4b71
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
je 0xe4a9f
jmp 0xe4b35
movq 0x80(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x28(%rsp), %rsi
callq 0x3ef50
cmpl $0x0, %eax
je 0xe4adc
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0xe4b71
movq 0x60(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0xe4af9
movabsq $0x1fffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFF
cmpq %rax, 0x28(%rsp)
jle 0xe4b21
movq 0x80(%rsp), %rdi
leaq 0x32d67(%rip), %rsi # 0x11786f
movb $0x0, %al
callq 0x2f960
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
jmp 0xe4b71
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %r8
movl 0x6c(%rsp), %r9d
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xe13a0
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopl (%rax)
|
js_array_buffer_constructor0:
sub rsp, 0A8h
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_28], rdi
mov [rsp+0A8h+var_2C], ecx
mov [rsp+0A8h+var_38], r8
mov [rsp+0A8h+var_3C], r9d
mov [rsp+0A8h+var_58], 0
mov rdi, [rsp+0A8h+var_28]
mov rax, [rsp+0A8h+var_38]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+0A8h+var_48]
call JS_ToIndex
cmp eax, 0
jz short loc_E4975
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp loc_E4B71
loc_E4975:
cmp [rsp+0A8h+var_2C], 2
jge short loc_E4981
jmp loc_E4B35
loc_E4981:
mov rax, [rsp+0A8h+var_38]
mov rdi, [rax+10h]
mov rsi, [rax+18h]
call JS_IsObject
cmp eax, 0
jnz short loc_E499D
jmp loc_E4B35
loc_E499D:
mov rdi, [rsp+0A8h+var_28]
mov rax, [rsp+0A8h+var_38]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_ToObject
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_88], rdx
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_68], rax
mov rax, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_60], rax
mov rdi, [rsp+0A8h+var_68]
mov rsi, [rsp+0A8h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_E4A05
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp loc_E4B71
loc_E4A05:
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_68]
mov rdx, [rsp+0A8h+var_60]
mov ecx, 92h
call JS_GetProperty
mov [rsp+0A8h+var_A0], rax
mov [rsp+0A8h+var_98], rdx
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_78], rax
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_70], rax
mov rdi, [rsp+0A8h+var_28]
mov rsi, [rsp+0A8h+var_68]
mov rdx, [rsp+0A8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0A8h+var_78]
mov rsi, [rsp+0A8h+var_70]
call JS_IsException_1
cmp eax, 0
jz short loc_E4A86
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp loc_E4B71
loc_E4A86:
mov rdi, [rsp+0A8h+var_78]
mov rsi, [rsp+0A8h+var_70]
call JS_IsUndefined_1
cmp eax, 0
jz short loc_E4A9F
jmp loc_E4B35
loc_E4A9F:
mov rdi, [rsp+0A8h+var_28]
mov rdx, [rsp+0A8h+var_78]
mov rcx, [rsp+0A8h+var_70]
lea rsi, [rsp+0A8h+var_80]
call JS_ToInt64Free
cmp eax, 0
jz short loc_E4ADC
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp loc_E4B71
loc_E4ADC:
mov rax, [rsp+0A8h+var_48]
cmp rax, [rsp+0A8h+var_80]
ja short loc_E4AF9
mov rax, 1FFFFFFFFFFFFFh
cmp [rsp+0A8h+var_80], rax
jle short loc_E4B21
loc_E4AF9:
mov rdi, [rsp+0A8h+var_28]
lea rsi, aInvalidArrayBu_1; "invalid array buffer max length"
mov al, 0
call JS_ThrowRangeError
mov [rsp+0A8h+var_10], rax
mov [rsp+0A8h+var_8], rdx
jmp short loc_E4B71
loc_E4B21:
mov rax, [rsp+0A8h+var_80]
mov [rsp+0A8h+var_50], rax
lea rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_58], rax
loc_E4B35:
mov rdi, [rsp+0A8h+var_28]
mov rcx, [rsp+0A8h+var_48]
mov r8, [rsp+0A8h+var_58]
mov r9d, [rsp+0A8h+var_3C]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call js_array_buffer_constructor2
mov [rsp+0A8h+var_10], rax
mov [rsp+0A8h+var_8], rdx
loc_E4B71:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
|
long long js_array_buffer_constructor0(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
unsigned int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
__m128 v14; // xmm4
__m128 v15; // xmm5
long long v16; // rcx
long long v17; // r8
long long v18; // r9
long long v19; // rdx
long long v20; // rdx
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
long long v25; // rdx
long long v26; // rdx
char v28; // [rsp+0h] [rbp-A8h]
long long v29; // [rsp+28h] [rbp-80h] BYREF
long long Property; // [rsp+30h] [rbp-78h]
long long v31; // [rsp+38h] [rbp-70h]
_DWORD *v32; // [rsp+40h] [rbp-68h]
long long v33; // [rsp+48h] [rbp-60h]
unsigned long long *v34; // [rsp+50h] [rbp-58h]
long long v35; // [rsp+58h] [rbp-50h] BYREF
unsigned long long v36; // [rsp+60h] [rbp-48h] BYREF
unsigned int v37; // [rsp+6Ch] [rbp-3Ch]
long long v38; // [rsp+70h] [rbp-38h]
int v39; // [rsp+7Ch] [rbp-2Ch]
long long v40; // [rsp+80h] [rbp-28h]
long long v41; // [rsp+88h] [rbp-20h]
long long v42; // [rsp+90h] [rbp-18h]
long long v43; // [rsp+98h] [rbp-10h]
long long v44; // [rsp+A0h] [rbp-8h]
v41 = a2;
v42 = a3;
v40 = a1;
v39 = a4;
v38 = a5;
v37 = a6;
v34 = 0LL;
if ( !(unsigned int)JS_ToIndex(a1, &v36, *(_DWORD **)a5, *(_QWORD *)(a5 + 8), a7, a8, a9, a10, a11, a12, a13, a14) )
{
if ( v39 >= 2 && JS_IsObject(*(_QWORD *)(v38 + 16), *(_QWORD *)(v38 + 24)) )
{
v32 = JS_ToObject(
v40,
*(_DWORD **)(v38 + 16),
*(_QWORD *)(v38 + 24),
a7,
a8,
a9,
a10,
v14,
v15,
a13,
a14,
v16,
v17,
v18);
v33 = v19;
if ( JS_IsException_1((long long)v32, v19) )
{
LODWORD(v43) = 0;
v44 = 6LL;
return v43;
}
Property = JS_GetProperty(v40, (int)v32, v33, 146);
v31 = v20;
JS_FreeValue(v40, (long long)v32, v33);
if ( JS_IsException_1(Property, v31) )
{
LODWORD(v43) = 0;
v44 = 6LL;
return v43;
}
if ( !JS_IsUndefined_1(Property, v31) )
{
if ( (unsigned int)JS_ToInt64Free(v40, &v29, Property, v31) )
{
LODWORD(v43) = 0;
v44 = 6LL;
return v43;
}
if ( v36 > v29 || v29 > 0x1FFFFFFFFFFFFFLL )
{
v43 = JS_ThrowRangeError(
v40,
(long long)"invalid array buffer max length",
v21,
v22,
v23,
v24,
a7,
a8,
a9,
a10,
v14,
v15,
a13,
a14,
v28);
v44 = v25;
return v43;
}
v35 = v29;
v34 = (unsigned long long *)&v35;
}
}
v43 = js_array_buffer_constructor2(v40, v41, v42, v36, v34, v37, a7, a8, a9, a10, v14, v15, a13, a14);
v44 = v26;
return v43;
}
LODWORD(v43) = 0;
v44 = 6LL;
return v43;
}
|
js_array_buffer_constructor0:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x80],RDI
MOV dword ptr [RSP + 0x7c],ECX
MOV qword ptr [RSP + 0x70],R8
MOV dword ptr [RSP + 0x6c],R9D
MOV qword ptr [RSP + 0x50],0x0
MOV RDI,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x60]
CALL 0x0013f430
CMP EAX,0x0
JZ 0x001e4975
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x001e4b71
LAB_001e4975:
CMP dword ptr [RSP + 0x7c],0x2
JGE 0x001e4981
JMP 0x001e4b35
LAB_001e4981:
MOV RAX,qword ptr [RSP + 0x70]
MOV RDI,qword ptr [RAX + 0x10]
MOV RSI,qword ptr [RAX + 0x18]
CALL 0x00131260
CMP EAX,0x0
JNZ 0x001e499d
JMP 0x001e4b35
LAB_001e499d:
MOV RDI,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x0013da60
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001e4a05
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x001e4b71
LAB_001e4a05:
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV ECX,0x92
CALL 0x00130070
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x001e4a86
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x001e4b71
LAB_001e4a86:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00134550
CMP EAX,0x0
JZ 0x001e4a9f
JMP 0x001e4b35
LAB_001e4a9f:
MOV RDI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x28]
CALL 0x0013ef50
CMP EAX,0x0
JZ 0x001e4adc
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x001e4b71
LAB_001e4adc:
MOV RAX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [RSP + 0x28]
JA 0x001e4af9
MOV RAX,0x1fffffffffffff
CMP qword ptr [RSP + 0x28],RAX
JLE 0x001e4b21
LAB_001e4af9:
MOV RDI,qword ptr [RSP + 0x80]
LEA RSI,[0x21786f]
MOV AL,0x0
CALL 0x0012f960
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
JMP 0x001e4b71
LAB_001e4b21:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[RSP + 0x58]
MOV qword ptr [RSP + 0x50],RAX
LAB_001e4b35:
MOV RDI,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RSP + 0x60]
MOV R8,qword ptr [RSP + 0x50]
MOV R9D,dword ptr [RSP + 0x6c]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x001e13a0
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
LAB_001e4b71:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16]
js_array_buffer_constructor0
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5,
int4 param_6)
{
int iVar1;
int1 auVar2 [16];
ulong local_80;
int1 local_78 [16];
int1 local_68 [16];
ulong *local_58;
ulong local_50;
ulong local_48;
int4 local_3c;
int8 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_58 = (ulong *)0x0;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar1 = JS_ToIndex(param_1,&local_48,*param_5,param_5[1]);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e4b71;
}
if (1 < local_2c) {
iVar1 = JS_IsObject(local_38[2],local_38[3]);
if (iVar1 != 0) {
local_68 = JS_ToObject(local_28,local_38[2],local_38[3]);
iVar1 = JS_IsException(local_68._0_8_,local_68._8_8_);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e4b71;
}
local_78 = JS_GetProperty(local_28,local_68._0_8_,local_68._8_8_,0x92);
JS_FreeValue(local_28,local_68._0_8_,local_68._8_8_);
iVar1 = JS_IsException(local_78._0_8_,local_78._8_8_);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e4b71;
}
iVar1 = JS_IsUndefined(local_78._0_8_,local_78._8_8_);
if (iVar1 == 0) {
iVar1 = JS_ToInt64Free(local_28,&local_80,local_78._0_8_,local_78._8_8_);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_001e4b71;
}
if ((local_80 < local_48) || (0x1fffffffffffff < (long)local_80)) {
auVar2 = JS_ThrowRangeError(local_28,"invalid array buffer max length");
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
goto LAB_001e4b71;
}
local_50 = local_80;
local_58 = &local_50;
}
}
}
auVar2 = js_array_buffer_constructor2(local_28,local_20,local_18,local_48,local_58,local_3c);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
LAB_001e4b71:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
|
|
13,706
|
strmake
|
eloqsql/strings/strmake.c
|
char *strmake(register char *dst, register const char *src, size_t length)
{
while (length--)
{
if (! (*dst++ = *src++))
{
#ifdef EXTRA_DEBUG
/*
'length' is the maximum length of the string; the buffer needs
to be one character larger to accommodate the terminating
'\0'. This is easy to get wrong, so we make sure we write to
the entire length of the buffer to identify incorrect
buffer-sizes. We only initialism the "unused" part of the
buffer here, a) for efficiency, and b) because dst==src is
allowed, so initializing the entire buffer would overwrite the
source-string. Also, we write a character rather than '\0' as
this makes spotting these problems in the results easier.
If we are using purify/valgrind, we only set one character at
end to be able to detect also wrong accesses after the end of
dst.
*/
if (length)
{
#ifdef HAVE_valgrind
dst[length-1]= 'Z';
#else
bfill(dst, length-1, (int) 'Z');
#endif /* HAVE_valgrind */
}
#endif /* EXTRA_DEBUG */
return dst-1;
}
}
*dst=0;
return dst;
}
|
O3
|
c
|
strmake:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %edi, %edi
movq %rdi, %rcx
cmpq %rdi, %rdx
je 0xee71c
movb (%rsi,%rcx), %r8b
movb %r8b, (%rax,%rcx)
leaq 0x1(%rcx), %rdi
testb %r8b, %r8b
jne 0xee701
jmp 0xee720
movb $0x0, (%rax,%rcx)
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
|
strmake:
push rbp
mov rbp, rsp
mov rax, rdi
xor edi, edi
loc_EE701:
mov rcx, rdi
cmp rdx, rdi
jz short loc_EE71C
mov r8b, [rsi+rcx]
mov [rax+rcx], r8b
lea rdi, [rcx+1]
test r8b, r8b
jnz short loc_EE701
jmp short loc_EE720
loc_EE71C:
mov byte ptr [rax+rcx], 0
loc_EE720:
add rax, rcx
pop rbp
retn
|
long long strmake(long long a1, long long a2, long long a3)
{
long long v4; // rdi
long long v5; // rcx
char v6; // r8
v4 = 0LL;
while ( 1 )
{
v5 = v4;
if ( a3 == v4 )
break;
v6 = *(_BYTE *)(a2 + v4);
*(_BYTE *)(a1 + v4++) = v6;
if ( !v6 )
return v5 + a1;
}
*(_BYTE *)(a1 + v4) = 0;
return v5 + a1;
}
|
strmake:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR EDI,EDI
LAB_001ee701:
MOV RCX,RDI
CMP RDX,RDI
JZ 0x001ee71c
MOV R8B,byte ptr [RSI + RCX*0x1]
MOV byte ptr [RAX + RCX*0x1],R8B
LEA RDI,[RCX + 0x1]
TEST R8B,R8B
JNZ 0x001ee701
JMP 0x001ee720
LAB_001ee71c:
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_001ee720:
ADD RAX,RCX
POP RBP
RET
|
long strmake(long param_1,long param_2,long param_3)
{
char cVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
lVar3 = lVar2;
if (param_3 == lVar3) {
*(int1 *)(param_1 + lVar3) = 0;
break;
}
cVar1 = *(char *)(param_2 + lVar3);
*(char *)(param_1 + lVar3) = cVar1;
lVar2 = lVar3 + 1;
} while (cVar1 != '\0');
return param_1 + lVar3;
}
|
|
13,707
|
llama_file::impl::tell() const
|
monkey531[P]llama/src/llama-mmap.cpp
|
size_t tell() const {
// TODO: this ifdef is never true?
#ifdef _WIN32
__int64 ret = _ftelli64(fp);
#else
long ret = std::ftell(fp);
#endif
if (ret == -1) {
throw std::runtime_error(format("ftell error: %s", strerror(errno)));
}
return (size_t) ret;
}
|
O1
|
cpp
|
llama_file::impl::tell() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rdi
callq 0x65060
cmpq $-0x1, %rax
je 0xaea45
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x66ce0
movq %rax, %rbx
callq 0x651e0
movl (%rax), %edi
callq 0x661f0
leaq 0x6b557(%rip), %rsi # 0x119fbc
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6c9c0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6baa0
xorl %ebp, %ebp
movq 0xb2567(%rip), %rsi # 0x160ff0
movq 0xb2260(%rip), %rdx # 0x160cf0
movq %rbx, %rdi
callq 0x6c2d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaeabe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x69220
jmp 0xaeabe
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xaeacb
movq %rbx, %rdi
callq 0x67dc0
movq %r14, %rdi
callq 0x6c640
nop
|
_ZNK10llama_file4impl4tellEv:
push rbp
push r14
push rbx
sub rsp, 20h
mov rdi, [rdi]
call _ftell
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_AEA45
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_AEA45:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
call ___errno_location
mov edi, [rax]
call _strerror
lea rsi, aFtellErrorS; "ftell error: %s"
mov rdi, rsp
mov rdx, rax
xor eax, eax
call __Z6formatB5cxx11PKcz; format(char const*,...)
mov bpl, 1
mov rsi, rsp
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+38h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AEABE
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AEABE
mov r14, rax
mov bpl, 1
loc_AEABE:
test bpl, bpl
jz short loc_AEACB
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AEACB:
mov rdi, r14
call __Unwind_Resume
|
long long llama_file::impl::tell(llama_file::impl *this)
{
long long result; // rax
void *exception; // rbx
unsigned int *v3; // rax
int v4; // eax
int v5; // ecx
int v6; // r8d
int v7; // r9d
_BYTE v8[16]; // [rsp+0h] [rbp-38h] BYREF
result = ftell(*(_QWORD *)this);
if ( result == -1 )
{
exception = __cxa_allocate_exception(0x10uLL);
v3 = (unsigned int *)__errno_location();
v4 = strerror(*v3);
format[abi:cxx11]((unsigned int)v8, (unsigned int)"ftell error: %s", v4, v5, v6, v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
|
tell:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RDI,qword ptr [RDI]
CALL 0x00165060
CMP RAX,-0x1
JZ 0x001aea45
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_001aea45:
MOV EDI,0x10
CALL 0x00166ce0
MOV RBX,RAX
CALL 0x001651e0
MOV EDI,dword ptr [RAX]
CALL 0x001661f0
LAB_001aea5e:
LEA RSI,[0x219fbc]
MOV RDI,RSP
MOV RDX,RAX
XOR EAX,EAX
CALL 0x0016c9c0
MOV BPL,0x1
LAB_001aea75:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0016baa0
XOR EBP,EBP
MOV RSI,qword ptr [0x00260ff0]
MOV RDX,qword ptr [0x00260cf0]
MOV RDI,RBX
CALL 0x0016c2d0
|
/* llama_file::impl::tell() const */
void __thiscall llama_file::impl::tell(impl *this)
{
long lVar1;
runtime_error *this_00;
int *piVar2;
char *pcVar3;
string asStack_38 [32];
lVar1 = ftell(*(FILE **)this);
if (lVar1 != -1) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
piVar2 = __errno_location();
pcVar3 = strerror(*piVar2);
/* try { // try from 001aea5e to 001aea71 has its CatchHandler @ 001aeab8 */
format_abi_cxx11_((char *)asStack_38,"ftell error: %s",pcVar3);
/* try { // try from 001aea75 to 001aea97 has its CatchHandler @ 001aea98 */
std::runtime_error::runtime_error(this_00,asStack_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00260ff0,PTR__runtime_error_00260cf0);
}
|
|
13,708
|
llama_file::impl::tell() const
|
monkey531[P]llama/src/llama-mmap.cpp
|
size_t tell() const {
// TODO: this ifdef is never true?
#ifdef _WIN32
__int64 ret = _ftelli64(fp);
#else
long ret = std::ftell(fp);
#endif
if (ret == -1) {
throw std::runtime_error(format("ftell error: %s", strerror(errno)));
}
return (size_t) ret;
}
|
O3
|
cpp
|
llama_file::impl::tell() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rdi
callq 0x64060
cmpq $-0x1, %rax
je 0xac97d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x65cb0
movq %rax, %rbx
callq 0x641e0
movl (%rax), %edi
callq 0x651d0
leaq 0x6961f(%rip), %rsi # 0x115fbc
movq %rsp, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x6b940
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6aa30
xorl %ebp, %ebp
movq 0xb062f(%rip), %rsi # 0x15cff0
movq 0xb0328(%rip), %rdx # 0x15ccf0
movq %rbx, %rdi
callq 0x6b270
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xac9ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x681a0
testb %bpl, %bpl
jne 0xac9f8
jmp 0xaca00
movq %rax, %r14
movq %rbx, %rdi
callq 0x66d40
movq %r14, %rdi
callq 0x6b5d0
|
_ZNK10llama_file4impl4tellEv:
push rbp
push r14
push rbx
sub rsp, 20h
mov rdi, [rdi]
call _ftell
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_AC97D
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_AC97D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
call ___errno_location
mov edi, [rax]
call _strerror
lea rsi, aFtellErrorS; "ftell error: %s"
mov rdi, rsp
mov rdx, rax
xor eax, eax
call __Z6formatB5cxx11PKcz; format(char const*,...)
mov bpl, 1
mov rsi, rsp
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+38h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AC9EE
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AC9EE:
test bpl, bpl
jnz short loc_AC9F8
jmp short loc_ACA00
mov r14, rax
loc_AC9F8:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_ACA00:
mov rdi, r14
call __Unwind_Resume
|
long long llama_file::impl::tell(llama_file::impl *this)
{
long long result; // rax
void *exception; // rbx
unsigned int *v3; // rax
int v4; // eax
int v5; // ecx
int v6; // r8d
int v7; // r9d
_BYTE v8[16]; // [rsp+0h] [rbp-38h] BYREF
result = ftell(*(_QWORD *)this);
if ( result == -1 )
{
exception = __cxa_allocate_exception(0x10uLL);
v3 = (unsigned int *)__errno_location();
v4 = strerror(*v3);
format[abi:cxx11]((unsigned int)v8, (unsigned int)"ftell error: %s", v4, v5, v6, v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
|
tell:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RDI,qword ptr [RDI]
CALL 0x00164060
CMP RAX,-0x1
JZ 0x001ac97d
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_001ac97d:
MOV EDI,0x10
CALL 0x00165cb0
MOV RBX,RAX
CALL 0x001641e0
MOV EDI,dword ptr [RAX]
CALL 0x001651d0
LAB_001ac996:
LEA RSI,[0x215fbc]
MOV RDI,RSP
MOV RDX,RAX
XOR EAX,EAX
CALL 0x0016b940
MOV BPL,0x1
LAB_001ac9ad:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0016aa30
XOR EBP,EBP
MOV RSI,qword ptr [0x0025cff0]
MOV RDX,qword ptr [0x0025ccf0]
MOV RDI,RBX
CALL 0x0016b270
|
/* llama_file::impl::tell() const */
void __thiscall llama_file::impl::tell(impl *this)
{
long lVar1;
runtime_error *this_00;
int *piVar2;
char *pcVar3;
string asStack_38 [32];
lVar1 = ftell(*(FILE **)this);
if (lVar1 != -1) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
piVar2 = __errno_location();
pcVar3 = strerror(*piVar2);
/* try { // try from 001ac996 to 001ac9a9 has its CatchHandler @ 001ac9f5 */
format_abi_cxx11_((char *)asStack_38,"ftell error: %s",pcVar3);
/* try { // try from 001ac9ad to 001ac9cf has its CatchHandler @ 001ac9d0 */
std::runtime_error::runtime_error(this_00,asStack_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0025cff0,PTR__runtime_error_0025ccf0);
}
|
|
13,709
|
find_typeset
|
eloqsql/mysys/typelib.c
|
my_ulonglong find_typeset(const char *x, TYPELIB *lib, int *err)
{
my_ulonglong result;
int find;
const char *i;
DBUG_ENTER("find_set");
DBUG_PRINT("enter",("x: '%s' lib: %p", x, lib));
if (!lib->count)
{
DBUG_PRINT("exit",("no count"));
DBUG_RETURN(0);
}
result= 0;
*err= 0;
while (*x)
{
(*err)++;
i= x;
while (*x && *x != ',')
x++;
if (x[0] && x[1]) /* skip separator if found */
x++;
if ((find= find_type(i, lib, FIND_TYPE_COMMA_TERM) - 1) < 0)
DBUG_RETURN(0);
result|= (1ULL << find);
}
*err= 0;
DBUG_RETURN(result);
}
|
O3
|
c
|
find_typeset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, (%rsi)
je 0xc9e7b
movq %rdi, %r13
movl $0x0, (%rdx)
cmpb $0x0, (%rdi)
je 0xc9e80
movq %rsi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rdx, -0x30(%rbp)
incl %r12d
movl %r12d, (%rdx)
leaq 0x1(%r13), %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0xc9e3a
cmpl $0x2c, %ecx
je 0xc9e2d
incq %rax
jmp 0xc9e1b
leaq -0x1(%rax), %rbx
cmpb $0x0, (%rax)
cmovneq %rax, %rbx
jmp 0xc9e40
decq %rax
movq %rax, %rbx
movq %r13, -0x38(%rbp)
movq %r13, %rdi
callq 0x2b3b0
addq %rax, %r13
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
movl $0x8, %edx
movq %r13, %rcx
callq 0xc9c39
testl %eax, %eax
jle 0xc9e7b
decb %al
btsq %rax, %r15
cmpb $0x0, (%rbx)
movq %rbx, %r13
movq -0x30(%rbp), %rdx
jne 0xc9e11
jmp 0xc9e83
xorl %r15d, %r15d
jmp 0xc9e89
xorl %r15d, %r15d
movl $0x0, (%rdx)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
find_typeset:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
cmp dword ptr [rsi], 0
jz loc_C9E7B
mov r13, rdi
mov dword ptr [rdx], 0
cmp byte ptr [rdi], 0
jz short loc_C9E80
mov r14, rsi
xor r12d, r12d
xor r15d, r15d
mov [rbp+var_30], rdx
loc_C9E11:
inc r12d
mov [rdx], r12d
lea rax, [r13+1]
loc_C9E1B:
movzx ecx, byte ptr [rax-1]
test ecx, ecx
jz short loc_C9E3A
cmp ecx, 2Ch ; ','
jz short loc_C9E2D
inc rax
jmp short loc_C9E1B
loc_C9E2D:
lea rbx, [rax-1]
cmp byte ptr [rax], 0
cmovnz rbx, rax
jmp short loc_C9E40
loc_C9E3A:
dec rax
mov rbx, rax
loc_C9E40:
mov [rbp+var_38], r13
mov rdi, r13
call _strlen
add r13, rax
lea rdi, [rbp+var_38]
mov rsi, r14
mov edx, 8
mov rcx, r13
call find_type_eol
test eax, eax
jle short loc_C9E7B
dec al
bts r15, rax
cmp byte ptr [rbx], 0
mov r13, rbx
mov rdx, [rbp+var_30]
jnz short loc_C9E11
jmp short loc_C9E83
loc_C9E7B:
xor r15d, r15d
jmp short loc_C9E89
loc_C9E80:
xor r15d, r15d
loc_C9E83:
mov dword ptr [rdx], 0
loc_C9E89:
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long find_typeset(_BYTE *a1, _DWORD *a2, _DWORD *a3)
{
_BYTE *v3; // r13
int v4; // r12d
long long v5; // r15
_BYTE *i; // rax
_BYTE *v7; // rbx
long long v8; // rax
int type_eol; // eax
_BYTE *v11; // [rsp+8h] [rbp-38h] BYREF
_DWORD *v12; // [rsp+10h] [rbp-30h]
if ( !*a2 )
return 0LL;
v3 = a1;
*a3 = 0;
if ( *a1 )
{
v4 = 0;
v5 = 0LL;
v12 = a3;
while ( 1 )
{
*a3 = ++v4;
for ( i = v3 + 1; ; ++i )
{
if ( !*(i - 1) )
{
v7 = i - 1;
goto LABEL_12;
}
if ( *(i - 1) == 44 )
break;
}
v7 = i - 1;
if ( *i )
v7 = i;
LABEL_12:
v11 = v3;
v8 = strlen(v3);
type_eol = find_type_eol(&v11, (long long)a2, 8, &v3[v8]);
if ( type_eol <= 0 )
return 0LL;
v5 |= 1LL << ((unsigned __int8)type_eol - 1);
v3 = v7;
a3 = v12;
if ( !*v7 )
goto LABEL_17;
}
}
v5 = 0LL;
LABEL_17:
*a3 = 0;
return v5;
}
|
find_typeset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
CMP dword ptr [RSI],0x0
JZ 0x001c9e7b
MOV R13,RDI
MOV dword ptr [RDX],0x0
CMP byte ptr [RDI],0x0
JZ 0x001c9e80
MOV R14,RSI
XOR R12D,R12D
XOR R15D,R15D
MOV qword ptr [RBP + -0x30],RDX
LAB_001c9e11:
INC R12D
MOV dword ptr [RDX],R12D
LEA RAX,[R13 + 0x1]
LAB_001c9e1b:
MOVZX ECX,byte ptr [RAX + -0x1]
TEST ECX,ECX
JZ 0x001c9e3a
CMP ECX,0x2c
JZ 0x001c9e2d
INC RAX
JMP 0x001c9e1b
LAB_001c9e2d:
LEA RBX,[RAX + -0x1]
CMP byte ptr [RAX],0x0
CMOVNZ RBX,RAX
JMP 0x001c9e40
LAB_001c9e3a:
DEC RAX
MOV RBX,RAX
LAB_001c9e40:
MOV qword ptr [RBP + -0x38],R13
MOV RDI,R13
CALL 0x0012b3b0
ADD R13,RAX
LEA RDI,[RBP + -0x38]
MOV RSI,R14
MOV EDX,0x8
MOV RCX,R13
CALL 0x001c9c39
TEST EAX,EAX
JLE 0x001c9e7b
DEC AL
BTS R15,RAX
CMP byte ptr [RBX],0x0
MOV R13,RBX
MOV RDX,qword ptr [RBP + -0x30]
JNZ 0x001c9e11
JMP 0x001c9e83
LAB_001c9e7b:
XOR R15D,R15D
JMP 0x001c9e89
LAB_001c9e80:
XOR R15D,R15D
LAB_001c9e83:
MOV dword ptr [RDX],0x0
LAB_001c9e89:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong find_typeset(char *param_1,int *param_2,int *param_3)
{
int iVar1;
char *pcVar2;
size_t sVar3;
char *pcVar4;
int iVar5;
ulong uVar6;
char *local_40;
int *local_38;
if (*param_2 == 0) {
LAB_001c9e7b:
uVar6 = 0;
}
else {
*param_3 = 0;
if (*param_1 == '\0') {
uVar6 = 0;
}
else {
iVar5 = 0;
uVar6 = 0;
local_38 = param_3;
do {
iVar5 = iVar5 + 1;
*local_38 = iVar5;
pcVar2 = param_1;
do {
pcVar4 = pcVar2;
pcVar2 = pcVar4 + 1;
if (*pcVar4 == '\0') goto LAB_001c9e40;
} while (*pcVar4 != ',');
if (*pcVar2 != '\0') {
pcVar4 = pcVar2;
}
LAB_001c9e40:
local_40 = param_1;
sVar3 = strlen(param_1);
iVar1 = find_type_eol(&local_40,param_2,8,param_1 + sVar3);
if (iVar1 < 1) goto LAB_001c9e7b;
uVar6 = uVar6 | 1L << ((ulong)(byte)((char)iVar1 - 1) & 0x3f);
param_3 = local_38;
param_1 = pcVar4;
} while (*pcVar4 != '\0');
}
*param_3 = 0;
}
return uVar6;
}
|
|
13,710
|
js_get_radix
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_get_radix(JSContext *ctx, JSValue val)
{
int radix;
if (JS_ToInt32Sat(ctx, &radix, val))
return -1;
if (radix < 2 || radix > 36) {
JS_ThrowRangeError(ctx, "toString() radix argument must be between 2 and 36");
return -1;
}
return radix;
}
|
O2
|
c
|
js_get_radix:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
callq 0x24eed
pushq $-0x1
popq %rbp
testl %eax, %eax
jne 0x619a5
movl 0x4(%rsp), %eax
leal -0x25(%rax), %ecx
cmpl $-0x24, %ecx
ja 0x619a7
leaq 0x2a012(%rip), %rsi # 0x8b9ad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1e863
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
js_get_radix:
push rbp
push rbx
push rax
mov rcx, rdx
mov rdx, rsi
mov rbx, rdi
lea rsi, [rsp+18h+var_14]
call JS_ToInt32Sat
push 0FFFFFFFFFFFFFFFFh
pop rbp
test eax, eax
jnz short loc_619A5
mov eax, [rsp+18h+var_14]
lea ecx, [rax-25h]
cmp ecx, 0FFFFFFDCh
ja short loc_619A7
lea rsi, aTostringRadixA; "toString() radix argument must be betwe"...
mov rdi, rbx
xor eax, eax
call JS_ThrowRangeError
loc_619A5:
mov eax, ebp
loc_619A7:
add rsp, 8
pop rbx
pop rbp
retn
|
long long js_get_radix(
long long a1,
_DWORD *a2,
unsigned int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rax
long long v12; // rdx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
long long result; // rax
long long v18; // rcx
long long v19; // [rsp-4h] [rbp-18h] BYREF
v19 = v11;
if ( !(unsigned int)JS_ToInt32Sat(a1, (long long)&v19 + 4, a2, a3) )
{
result = HIDWORD(v19);
v18 = (unsigned int)(HIDWORD(v19) - 37);
if ( (unsigned int)v18 > 0xFFFFFFDC )
return result;
JS_ThrowRangeError(
a1,
(long long)"toString() radix argument must be between 2 and 36",
v12,
v18,
v13,
v14,
a4,
a5,
a6,
a7,
v15,
v16,
a10,
a11,
v19);
}
return 0xFFFFFFFFLL;
}
|
js_get_radix:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RCX,RDX
MOV RDX,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x4]
CALL 0x00124eed
PUSH -0x1
POP RBP
TEST EAX,EAX
JNZ 0x001619a5
MOV EAX,dword ptr [RSP + 0x4]
LEA ECX,[RAX + -0x25]
CMP ECX,-0x24
JA 0x001619a7
LEA RSI,[0x18b9ad]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011e863
LAB_001619a5:
MOV EAX,EBP
LAB_001619a7:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int js_get_radix(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 in_RAX;
int local_14;
local_14 = (int)((ulong)in_RAX >> 0x20);
iVar1 = JS_ToInt32Sat(param_1,&local_14,param_2,param_3);
if (iVar1 == 0) {
if (0xffffffdc < local_14 - 0x25U) {
return local_14;
}
JS_ThrowRangeError(param_1,"toString() radix argument must be between 2 and 36");
}
return -1;
}
|
|
13,711
|
ma_ft_parserecord
|
eloqsql/storage/maria/ma_ft_update.c
|
FT_WORD * _ma_ft_parserecord(MARIA_HA *info, uint keynr, const uchar *record,
MEM_ROOT *mem_root)
{
TREE ptree;
MYSQL_FTPARSER_PARAM *param;
DBUG_ENTER("_ma_ft_parserecord");
if (! (param= maria_ftparser_call_initializer(info, keynr, 0)))
DBUG_RETURN(NULL);
bzero((char*) &ptree, sizeof(ptree));
param->flags= 0;
if (_ma_ft_parse(&ptree, info, keynr, record, param, mem_root))
DBUG_RETURN(NULL);
DBUG_RETURN(maria_ft_linearize(&ptree, mem_root));
}
|
O0
|
c
|
ma_ft_parserecord:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x78790
movq %rax, -0x2c8(%rbp)
cmpq $0x0, %rax
jne 0x78db1
jmp 0x78da7
movq $0x0, -0x8(%rbp)
jmp 0x78e1b
leaq -0x2c0(%rbp), %rdi
xorl %esi, %esi
movl $0x298, %edx # imm = 0x298
callq 0x29280
movq -0x2c8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x2c8(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x2c0(%rbp), %rdi
callq 0x78c90
cmpl $0x0, %eax
je 0x78e05
jmp 0x78dfb
movq $0x0, -0x8(%rbp)
jmp 0x78e1b
jmp 0x78e07
movq -0x28(%rbp), %rsi
leaq -0x2c0(%rbp), %rdi
callq 0x77aa0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x2d0, %rsp # imm = 0x2D0
popq %rbp
retq
nopl (%rax,%rax)
|
_ma_ft_parserecord:
push rbp
mov rbp, rsp
sub rsp, 2D0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
xor edx, edx
call maria_ftparser_call_initializer
mov [rbp+var_2C8], rax
cmp rax, 0
jnz short loc_78DB1
jmp short $+2
loc_78DA7:
mov [rbp+var_8], 0
jmp short loc_78E1B
loc_78DB1:
lea rdi, [rbp+var_2C0]
xor esi, esi
mov edx, 298h
call _memset
mov rax, [rbp+var_2C8]
mov dword ptr [rax+34h], 0
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_2C8]
mov r9, [rbp+var_28]
lea rdi, [rbp+var_2C0]
call _ma_ft_parse
cmp eax, 0
jz short loc_78E05
jmp short $+2
loc_78DFB:
mov [rbp+var_8], 0
jmp short loc_78E1B
loc_78E05:
jmp short $+2
loc_78E07:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_2C0]
call maria_ft_linearize
mov [rbp+var_8], rax
loc_78E1B:
mov rax, [rbp+var_8]
add rsp, 2D0h
pop rbp
retn
|
long long ma_ft_parserecord(_QWORD *a1, unsigned int a2, long long a3, long long a4)
{
unsigned long long v5; // [rsp+8h] [rbp-2C8h]
_QWORD v6[83]; // [rsp+10h] [rbp-2C0h] BYREF
long long v7; // [rsp+2A8h] [rbp-28h]
long long v8; // [rsp+2B0h] [rbp-20h]
unsigned int v9; // [rsp+2BCh] [rbp-14h]
_QWORD *v10; // [rsp+2C0h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = a4;
v5 = maria_ftparser_call_initializer(a1, a2, 0);
if ( !v5 )
return 0LL;
memset(v6, 0LL, sizeof(v6));
*(_DWORD *)(v5 + 52) = 0;
if ( (unsigned int)ma_ft_parse(v6, (long long)v10, v9, v8, (_QWORD *)v5, v7) )
return 0LL;
else
return maria_ft_linearize((long long)v6, v7);
}
|
_ma_ft_parserecord:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2d0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
XOR EDX,EDX
CALL 0x00178790
MOV qword ptr [RBP + -0x2c8],RAX
CMP RAX,0x0
JNZ 0x00178db1
JMP 0x00178da7
LAB_00178da7:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00178e1b
LAB_00178db1:
LEA RDI,[RBP + -0x2c0]
XOR ESI,ESI
MOV EDX,0x298
CALL 0x00129280
MOV RAX,qword ptr [RBP + -0x2c8]
MOV dword ptr [RAX + 0x34],0x0
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x2c8]
MOV R9,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x2c0]
CALL 0x00178c90
CMP EAX,0x0
JZ 0x00178e05
JMP 0x00178dfb
LAB_00178dfb:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00178e1b
LAB_00178e05:
JMP 0x00178e07
LAB_00178e07:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x2c0]
CALL 0x00177aa0
MOV qword ptr [RBP + -0x8],RAX
LAB_00178e1b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x2d0
POP RBP
RET
|
int8
_ma_ft_parserecord(int8 param_1,int4 param_2,int8 param_3,int8 param_4)
{
int iVar1;
long lVar2;
int1 local_2c8 [664];
int8 local_30;
int8 local_28;
int4 local_1c;
int8 local_18;
int8 local_10;
local_30 = param_4;
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
lVar2 = maria_ftparser_call_initializer(param_1,param_2,0);
if (lVar2 == 0) {
local_10 = 0;
}
else {
memset(local_2c8,0,0x298);
*(int4 *)(lVar2 + 0x34) = 0;
iVar1 = _ma_ft_parse(local_2c8,local_18,local_1c,local_28,lVar2,local_30);
if (iVar1 == 0) {
local_10 = maria_ft_linearize(local_2c8,local_30);
}
else {
local_10 = 0;
}
}
return local_10;
}
|
|
13,712
|
my_string_repertoire_8bit
|
eloqsql/strings/ctype.c
|
uint
my_string_repertoire_8bit(CHARSET_INFO *cs, const char *str, size_t length)
{
const char *strend;
if ((cs->state & MY_CS_NONASCII) && length > 0)
return MY_REPERTOIRE_UNICODE30;
for (strend= str + length; str < strend; str++)
{
if (((uchar) *str) > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
return MY_REPERTOIRE_ASCII;
}
|
O3
|
c
|
my_string_repertoire_8bit:
movl $0x3, %eax
testq %rdx, %rdx
je 0x5d783
movl $0x2000, %ecx # imm = 0x2000
andl 0xc(%rdi), %ecx
je 0x5d783
retq
testq %rdx, %rdx
jle 0x5d7a3
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
cmpb $0x0, (%rsi)
js 0x5d7a1
incq %rsi
cmpq %rdx, %rsi
jb 0x5d78f
movl $0x1, %eax
popq %rbp
retq
movl $0x1, %eax
retq
|
my_string_repertoire_8bit:
mov eax, 3
test rdx, rdx
jz short loc_5D783
mov ecx, 2000h
and ecx, [rdi+0Ch]
jz short loc_5D783
retn
loc_5D783:
test rdx, rdx
jle short loc_5D7A3
push rbp
mov rbp, rsp
add rdx, rsi
loc_5D78F:
cmp byte ptr [rsi], 0
js short loc_5D7A1
inc rsi
cmp rsi, rdx
jb short loc_5D78F
mov eax, 1
loc_5D7A1:
pop rbp
retn
loc_5D7A3:
mov eax, 1
retn
|
long long my_string_repertoire_8bit(long long a1, char *a2, long long a3)
{
long long result; // rax
char *v4; // rdx
result = 3LL;
if ( !a3 || (*(_DWORD *)(a1 + 12) & 0x2000) == 0 )
{
if ( a3 <= 0 )
{
return 1LL;
}
else
{
v4 = &a2[a3];
while ( *a2 >= 0 )
{
if ( ++a2 >= v4 )
return 1LL;
}
}
}
return result;
}
|
my_string_repertoire_8bit:
MOV EAX,0x3
TEST RDX,RDX
JZ 0x0015d783
MOV ECX,0x2000
AND ECX,dword ptr [RDI + 0xc]
JZ 0x0015d783
RET
LAB_0015d783:
TEST RDX,RDX
JLE 0x0015d7a3
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_0015d78f:
CMP byte ptr [RSI],0x0
JS 0x0015d7a1
INC RSI
CMP RSI,RDX
JC 0x0015d78f
MOV EAX,0x1
LAB_0015d7a1:
POP RBP
RET
LAB_0015d7a3:
MOV EAX,0x1
RET
|
int8 my_string_repertoire_8bit(long param_1,char *param_2,long param_3)
{
char *pcVar1;
if ((param_3 != 0) && ((*(uint *)(param_1 + 0xc) & 0x2000) != 0)) {
return 3;
}
if (param_3 < 1) {
return 1;
}
pcVar1 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return 3;
}
param_2 = param_2 + 1;
} while (param_2 < pcVar1);
return 1;
}
|
|
13,713
|
my_context_yield
|
eloqsql/libmariadb/libmariadb/ma_context.c
|
int
my_context_yield(struct my_context *c)
{
uint64_t *save= &c->save[0];
__asm__ __volatile__
(
"movq (%[save]), %%rax\n\t"
"movq %%rsp, (%[save])\n\t"
"movq %%rax, %%rsp\n\t"
"movq 8(%[save]), %%rax\n\t"
"movq %%rbp, 8(%[save])\n\t"
"movq %%rax, %%rbp\n\t"
"movq 16(%[save]), %%rax\n\t"
"movq %%rbx, 16(%[save])\n\t"
"movq %%rax, %%rbx\n\t"
"movq 24(%[save]), %%rax\n\t"
"movq %%r12, 24(%[save])\n\t"
"movq %%rax, %%r12\n\t"
"movq 32(%[save]), %%rax\n\t"
"movq %%r13, 32(%[save])\n\t"
"movq %%rax, %%r13\n\t"
"movq 40(%[save]), %%rax\n\t"
"movq %%r14, 40(%[save])\n\t"
"movq %%rax, %%r14\n\t"
"movq 48(%[save]), %%rax\n\t"
"movq %%r15, 48(%[save])\n\t"
"movq %%rax, %%r15\n\t"
"movq 64(%[save]), %%rax\n\t"
"leaq 1f(%%rip), %%rcx\n\t"
"movq %%rcx, 64(%[save])\n\t"
"jmpq *%%rax\n"
"1:\n"
: [save] "+D" (save)
:
: "rax", "rcx", "rdx", "rsi", "r8", "r9", "r10", "r11", "memory", "cc"
);
return 0;
}
|
O0
|
c
|
my_context_yield:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq %rsp, (%rdi)
movq %rax, %rsp
movq 0x8(%rdi), %rax
movq %rbp, 0x8(%rdi)
movq %rax, %rbp
movq 0x10(%rdi), %rax
movq %rbx, 0x10(%rdi)
movq %rax, %rbx
movq 0x18(%rdi), %rax
movq %r12, 0x18(%rdi)
movq %rax, %r12
movq 0x20(%rdi), %rax
movq %r13, 0x20(%rdi)
movq %rax, %r13
movq 0x28(%rdi), %rax
movq %r14, 0x28(%rdi)
movq %rax, %r14
movq 0x30(%rdi), %rax
movq %r15, 0x30(%rdi)
movq %rax, %r15
movq 0x40(%rdi), %rax
leaq 0x6(%rip), %rcx # 0xa3f10
movq %rcx, 0x40(%rdi)
jmpq *%rax
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
|
my_context_yield:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rdi, [rbp+var_10]
mov rax, [rdi]
mov [rdi], rsp
mov rsp, rax
mov rax, [rdi+8]
mov [rdi+8], rbp
mov rbp, rax
mov rax, [rdi+10h]
mov [rdi+10h], rbx
mov rbx, rax
mov rax, [rdi+18h]
mov [rdi+18h], r12
mov r12, rax
mov rax, [rdi+20h]
mov [rdi+20h], r13
mov r13, rax
mov rax, [rdi+28h]
mov [rdi+28h], r14
mov r14, rax
mov rax, [rdi+30h]
mov [rdi+30h], r15
mov r15, rax
mov rax, [rdi+40h]
lea rcx, qword_A3F10
mov [rdi+40h], rcx
jmp rax
|
long long my_context_yield(_QWORD *a1)
{
long long v1; // rbx
long long v2; // r12
long long v3; // r13
long long v4; // r14
long long v5; // r15
long long (*v6)(void); // rax
long long savedregs; // [rsp+10h] [rbp+0h] BYREF
*a1 = &savedregs;
a1[1] = &savedregs;
a1[2] = v1;
a1[3] = v2;
a1[4] = v3;
a1[5] = v4;
a1[6] = v5;
v6 = (long long (*)(void))a1[8];
a1[8] = qword_A3F10;
return v6();
}
|
my_context_yield:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RDI]
MOV qword ptr [RDI],RSP
MOV RSP,RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RDI + 0x8],RBP
MOV RBP,RAX
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RDI + 0x10],RBX
MOV RBX,RAX
MOV RAX,qword ptr [RDI + 0x18]
MOV qword ptr [RDI + 0x18],R12
MOV R12,RAX
MOV RAX,qword ptr [RDI + 0x20]
MOV qword ptr [RDI + 0x20],R13
MOV R13,RAX
MOV RAX,qword ptr [RDI + 0x28]
MOV qword ptr [RDI + 0x28],R14
MOV R14,RAX
MOV RAX,qword ptr [RDI + 0x30]
MOV qword ptr [RDI + 0x30],R15
MOV R15,RAX
MOV RAX,qword ptr [RDI + 0x40]
LEA RCX,[0x1a3f10]
MOV qword ptr [RDI + 0x40],RCX
JMP RAX
|
void my_context_yield(long param_1)
{
code *UNRECOVERED_JUMPTABLE;
int8 unaff_RBX;
int8 unaff_R12;
int8 unaff_R13;
int8 unaff_R14;
int8 unaff_R15;
*(int1 **)param_1 = &stack0xfffffffffffffff8;
*(int1 **)(param_1 + 8) = &stack0xfffffffffffffff8;
*(int8 *)(param_1 + 0x10) = unaff_RBX;
*(int8 *)(param_1 + 0x18) = unaff_R12;
*(int8 *)(param_1 + 0x20) = unaff_R13;
*(int8 *)(param_1 + 0x28) = unaff_R14;
*(int8 *)(param_1 + 0x30) = unaff_R15;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x40);
*(int1 **)(param_1 + 0x40) = &LAB_001a3f10;
/* WARNING: Could not recover jumptable at 0x001a3f0e. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)();
return;
}
|
|
13,714
|
get_argument
|
eloqsql/mysys/my_default.c
|
static char *get_argument(const char *keyword, size_t kwlen,
char *ptr, char *name, uint line)
{
char *end;
/* Skip over "include / includedir keyword" and following whitespace */
for (ptr+= kwlen - 1;
my_isspace(&my_charset_latin1, ptr[0]);
ptr++)
{}
/*
Trim trailing whitespace from directory name
The -1 below is for the newline added by fgets()
Note that my_isspace() is true for \r and \n
*/
for (end= ptr + strlen(ptr) - 1;
my_isspace(&my_charset_latin1, *(end - 1));
end--)
{}
end[0]= 0; /* Cut off end space */
/* Print error msg if there is nothing after !include* directive */
if (end <= ptr)
{
fprintf(stderr,
"error: Wrong '!%s' directive in config file: %s at line %d\n",
keyword, name, line);
return 0;
}
return ptr;
}
|
O0
|
c
|
get_argument:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x254f4d(%rip), %rax # 0x27bd00
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x26ddb
jmp 0x26dcd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x26dac
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24120
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
leaq 0x254efb(%rip), %rax # 0x27bd00
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x26e2e
jmp 0x26e20
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x26dfe
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x26e6d
movq 0x1ae19a(%rip), %rax # 0x1d4fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq 0x58bab(%rip), %rsi # 0x7fa07
movb $0x0, %al
callq 0x24430
movq $0x0, -0x8(%rbp)
jmp 0x26e75
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
|
get_argument:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov rax, [rbp+var_18]
sub rax, 1
add rax, [rbp+var_20]
mov [rbp+var_20], rax
loc_26DAC:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_26DDB
jmp short $+2
loc_26DCD:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_26DAC
loc_26DDB:
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_20]
call _strlen
mov rcx, rax
mov rax, [rbp+var_40]
add rax, rcx
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
loc_26DFE:
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_26E2E
jmp short $+2
loc_26E20:
mov rax, [rbp+var_38]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rax
jmp short loc_26DFE
loc_26E2E:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
cmp rax, [rbp+var_20]
ja short loc_26E6D
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_28]
mov r8d, [rbp+var_2C]
lea rsi, aErrorWrongSDir; "error: Wrong '!%s' directive in config "...
mov al, 0
call _fprintf
mov [rbp+var_8], 0
jmp short loc_26E75
loc_26E6D:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_26E75:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
unsigned __int8 * get_argument(const char *a1, long long a2, long long a3, const char *a4, int a5)
{
unsigned __int8 *j; // [rsp+8h] [rbp-38h]
unsigned __int8 *i; // [rsp+20h] [rbp-20h]
for ( i = (unsigned __int8 *)(a3 + a2 - 1); (*(_BYTE *)(*((_QWORD *)&my_charset_latin1 + 8) + *i + 1LL) & 8) != 0; ++i )
;
for ( j = &i[strlen(i) - 1]; (*(_BYTE *)(*((_QWORD *)&my_charset_latin1 + 8) + *(j - 1) + 1LL) & 8) != 0; --j )
;
*j = 0;
if ( j > i )
return i;
fprintf(stderr, "error: Wrong '!%s' directive in config file: %s at line %d\n", a1, a4, a5);
return 0LL;
}
|
get_argument:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
LAB_00126dac:
LEA RAX,[0x37bd00]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00126ddb
JMP 0x00126dcd
LAB_00126dcd:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00126dac
LAB_00126ddb:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00124120
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,RCX
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
LAB_00126dfe:
LEA RAX,[0x37bd00]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00126e2e
JMP 0x00126e20
LAB_00126e20:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00126dfe
LAB_00126e2e:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x00126e6d
MOV RAX,qword ptr [0x002d4fe0]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RBP + -0x2c]
LEA RSI,[0x17fa07]
MOV AL,0x0
CALL 0x00124430
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00126e75
LAB_00126e6d:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_00126e75:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
byte * get_argument(int8 param_1,long param_2,long param_3,int8 param_4,uint param_5)
{
byte *pbVar1;
byte *pbVar2;
size_t sVar3;
byte *local_40;
byte *local_28;
byte *local_10;
local_28 = (byte *)(param_2 + -1 + param_3);
while ((PTR_ctype_latin1_0037bd40[(ulong)*local_28 + 1] & 8) != 0) {
local_28 = local_28 + 1;
}
sVar3 = strlen((char *)local_28);
pbVar2 = local_28 + sVar3;
do {
local_40 = pbVar2 + -1;
pbVar1 = pbVar2 + -2;
pbVar2 = local_40;
} while ((PTR_ctype_latin1_0037bd40[(ulong)*pbVar1 + 1] & 8) != 0);
*local_40 = 0;
if (local_28 < local_40) {
local_10 = local_28;
}
else {
fprintf(*(FILE **)PTR_stderr_002d4fe0,
"error: Wrong \'!%s\' directive in config file: %s at line %d\n",param_1,param_4,
(ulong)param_5);
local_10 = (byte *)0x0;
}
return local_10;
}
|
|
13,715
|
get_argument
|
eloqsql/mysys/my_default.c
|
static char *get_argument(const char *keyword, size_t kwlen,
char *ptr, char *name, uint line)
{
char *end;
/* Skip over "include / includedir keyword" and following whitespace */
for (ptr+= kwlen - 1;
my_isspace(&my_charset_latin1, ptr[0]);
ptr++)
{}
/*
Trim trailing whitespace from directory name
The -1 below is for the newline added by fgets()
Note that my_isspace() is true for \r and \n
*/
for (end= ptr + strlen(ptr) - 1;
my_isspace(&my_charset_latin1, *(end - 1));
end--)
{}
end[0]= 0; /* Cut off end space */
/* Print error msg if there is nothing after !include* directive */
if (end <= ptr)
{
fprintf(stderr,
"error: Wrong '!%s' directive in config file: %s at line %d\n",
keyword, name, line);
return 0;
}
return ptr;
}
|
O3
|
c
|
get_argument:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r12
leaq 0x2f368f(%rip), %rax # 0x319ca0
movq 0x40(%rax), %r13
leaq (%rsi,%rdx), %r15
addq $-0x2, %r15
movzbl 0x1(%r15), %eax
incq %r15
testb $0x8, 0x1(%r13,%rax)
jne 0x2661d
movq %r15, %rdi
callq 0x24120
addq %r15, %rax
movzbl -0x2(%rax), %ecx
decq %rax
testb $0x8, 0x1(%r13,%rcx)
jne 0x26638
movb $0x0, (%rax)
cmpq %r15, %rax
ja 0x26678
movq 0x2cc982(%rip), %rax # 0x2f2fd8
movq (%rax), %rdi
leaq 0x393a7(%rip), %rdx # 0x5fa07
xorl %r15d, %r15d
movl $0x1, %esi
movq %r12, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x245a0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
get_argument:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r14, rcx
mov r12, rdi
lea rax, my_charset_latin1
mov r13, [rax+40h]
lea r15, [rsi+rdx]
add r15, 0FFFFFFFFFFFFFFFEh
loc_2661D:
movzx eax, byte ptr [r15+1]
inc r15
test byte ptr [r13+rax+1], 8
jnz short loc_2661D
mov rdi, r15
call _strlen
add rax, r15
loc_26638:
movzx ecx, byte ptr [rax-2]
dec rax
test byte ptr [r13+rcx+1], 8
jnz short loc_26638
mov byte ptr [rax], 0
cmp rax, r15
ja short loc_26678
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rdx, aErrorWrongSDir; "error: Wrong '!%s' directive in config "...
xor r15d, r15d
mov esi, 1
mov rcx, r12
mov r8, r14
mov r9d, ebx
xor eax, eax
call ___fprintf_chk
loc_26678:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long get_argument(const char *a1, long long a2, long long a3, const char *a4, int a5)
{
long long v7; // r13
unsigned long long v8; // r15
long long v9; // rax
_BYTE *v10; // rax
long long v11; // rcx
v7 = *((_QWORD *)&my_charset_latin1 + 8);
v8 = a2 + a3 - 2;
do
v9 = *(unsigned __int8 *)++v8;
while ( (*(_BYTE *)(v7 + v9 + 1) & 8) != 0 );
v10 = (_BYTE *)(v8 + strlen(v8));
do
{
v11 = (unsigned __int8)*(v10 - 2);
--v10;
}
while ( (*(_BYTE *)(v7 + v11 + 1) & 8) != 0 );
*v10 = 0;
if ( (unsigned long long)v10 <= v8 )
{
v8 = 0LL;
__fprintf_chk(stderr, 1LL, "error: Wrong '!%s' directive in config file: %s at line %d\n", a1, a4, a5);
}
return v8;
}
|
get_argument:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R8D
MOV R14,RCX
MOV R12,RDI
LEA RAX,[0x419ca0]
MOV R13,qword ptr [RAX + 0x40]
LEA R15,[RSI + RDX*0x1]
ADD R15,-0x2
LAB_0012661d:
MOVZX EAX,byte ptr [R15 + 0x1]
INC R15
TEST byte ptr [R13 + RAX*0x1 + 0x1],0x8
JNZ 0x0012661d
MOV RDI,R15
CALL 0x00124120
ADD RAX,R15
LAB_00126638:
MOVZX ECX,byte ptr [RAX + -0x2]
DEC RAX
TEST byte ptr [R13 + RCX*0x1 + 0x1],0x8
JNZ 0x00126638
MOV byte ptr [RAX],0x0
CMP RAX,R15
JA 0x00126678
MOV RAX,qword ptr [0x003f2fd8]
MOV RDI,qword ptr [RAX]
LEA RDX,[0x15fa07]
XOR R15D,R15D
MOV ESI,0x1
MOV RCX,R12
MOV R8,R14
MOV R9D,EBX
XOR EAX,EAX
CALL 0x001245a0
LAB_00126678:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
char * get_argument(int8 param_1,long param_2,long param_3,int8 param_4,
int4 param_5)
{
byte *pbVar1;
int *puVar2;
size_t sVar3;
char *pcVar4;
char *__s;
puVar2 = PTR_ctype_latin1_00419ce0;
__s = (char *)(param_2 + param_3 + -2);
do {
pbVar1 = (byte *)(__s + 1);
__s = __s + 1;
} while ((PTR_ctype_latin1_00419ce0[(ulong)*pbVar1 + 1] & 8) != 0);
sVar3 = strlen(__s);
pcVar4 = __s + sVar3;
do {
pbVar1 = (byte *)(pcVar4 + -2);
pcVar4 = pcVar4 + -1;
} while ((puVar2[(ulong)*pbVar1 + 1] & 8) != 0);
*pcVar4 = '\0';
if (pcVar4 <= __s) {
__s = (char *)0x0;
__fprintf_chk(*(int8 *)PTR_stderr_003f2fd8,1,
"error: Wrong \'!%s\' directive in config file: %s at line %d\n",param_1,param_4,
param_5);
}
return __s;
}
|
|
13,716
|
ma_SHA1Init
|
eloqsql/libmariadb/libmariadb/ma_sha1.c
|
void ma_SHA1Init(_MA_SHA1_CTX * context)
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants.
*/
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
context->state[4] = 0xc3d2e1f0;
}
|
O0
|
c
|
ma_SHA1Init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax) # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax) # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_SHA1Init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov dword ptr [rax+18h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+14h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax], 67452301h
mov rax, [rbp+var_8]
mov dword ptr [rax+4], 0EFCDAB89h
mov rax, [rbp+var_8]
mov dword ptr [rax+8], 98BADCFEh
mov rax, [rbp+var_8]
mov dword ptr [rax+0Ch], 10325476h
mov rax, [rbp+var_8]
mov dword ptr [rax+10h], 0C3D2E1F0h
pop rbp
retn
|
_DWORD * ma_SHA1Init(_DWORD *a1)
{
_DWORD *result; // rax
a1[6] = 0;
a1[5] = 0;
*a1 = 1732584193;
a1[1] = -271733879;
a1[2] = -1732584194;
a1[3] = 271733878;
result = a1;
a1[4] = -1009589776;
return result;
}
|
ma_SHA1Init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x14],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x67452301
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x4],0xefcdab89
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8],0x98badcfe
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xc],0x10325476
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],0xc3d2e1f0
POP RBP
RET
|
void ma_SHA1Init(int4 *param_1)
{
param_1[6] = 0;
param_1[5] = 0;
*param_1 = 0x67452301;
param_1[1] = 0xefcdab89;
param_1[2] = 0x98badcfe;
param_1[3] = 0x10325476;
param_1[4] = 0xc3d2e1f0;
return;
}
|
|
13,717
|
minja::IfNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
for (const auto& branch : cascade) {
auto enter_branch = true;
if (branch.first) {
enter_branch = branch.first->evaluate(context).to_bool();
}
if (enter_branch) {
if (!branch.second) throw std::runtime_error("IfNode.cascade.second is null");
branch.second->render(out, context);
return;
}
}
}
|
O2
|
cpp
|
minja::IfNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rdi), %r12
movq 0x28(%rdi), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x73290
movq (%r12), %rsi
testq %rsi, %rsi
je 0x7327b
movq %r15, %rdi
movq %rbx, %rdx
callq 0x62ea2
movq %r15, %rdi
callq 0x63078
movl %eax, %ebp
movq %r15, %rdi
callq 0x63132
testb %bpl, %bpl
jne 0x7327b
addq $0x20, %r12
jmp 0x73245
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x7329f
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7332e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %rbx
leaq 0x43643(%rip), %rsi # 0xb68f4
movq %rax, %rdi
callq 0x24320
movq 0x8cd30(%rip), %rsi # 0xffff0
movq 0x8cc89(%rip), %rdx # 0xfff50
movq %rbx, %rdi
callq 0x24ee0
movq %rax, %r14
movq %rbx, %rdi
callq 0x24670
jmp 0x732e9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x63132
movq %r14, %rdi
callq 0x24f60
nop
|
_ZNK5minja6IfNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdx
mov r14, rsi
mov r12, [rdi+20h]
mov r13, [rdi+28h]
lea r15, [rsp+88h+var_80]
loc_73245:
cmp r12, r13
jz short loc_73290
mov rsi, [r12]
test rsi, rsi
jz short loc_7327B
mov rdi, r15
mov rdx, rbx
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, r15; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
mov ebp, eax
mov rdi, r15; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jnz short loc_7327B
add r12, 20h ; ' '
jmp short loc_73245
loc_7327B:
mov rdi, [r12+10h]
test rdi, rdi
jz short loc_7329F
mov rsi, r14
mov rdx, rbx
call _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::ostringstream &,std::shared_ptr<minja::Context> const&)
loc_73290:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7329F:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIfnodeCascadeS; "IfNode.cascade.second is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_732E9
mov r14, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_732E9:
mov rdi, r14
call __Unwind_Resume
|
void minja::IfNode::do_render(long long a1, int a2, int a3, int a4, int a5, int a6)
{
long long v7; // r12
long long v8; // r13
char v9; // bp
long long v10; // rdi
std::runtime_error *exception; // rbx
_BYTE v12[128]; // [rsp+8h] [rbp-80h] BYREF
v7 = *(_QWORD *)(a1 + 32);
v8 = *(_QWORD *)(a1 + 40);
while ( v7 != v8 )
{
if ( !*(_QWORD *)v7
|| (minja::Expression::evaluate((long long)v12, *(void (****)(void))v7),
v9 = minja::Value::to_bool((minja::Value *)v12),
minja::Value::~Value((minja::Value *)v12),
v9) )
{
v10 = *(_QWORD *)(v7 + 16);
if ( !v10 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "IfNode.cascade.second is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::TemplateNode::render(v10, a2, a3, a4, a5, a6);
return;
}
v7 += 32LL;
}
}
|
do_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDX
MOV R14,RSI
MOV R12,qword ptr [RDI + 0x20]
MOV R13,qword ptr [RDI + 0x28]
LEA R15,[RSP + 0x8]
LAB_00173245:
CMP R12,R13
JZ 0x00173290
MOV RSI,qword ptr [R12]
TEST RSI,RSI
JZ 0x0017327b
MOV RDI,R15
MOV RDX,RBX
CALL 0x00162ea2
LAB_0017325e:
MOV RDI,R15
CALL 0x00163078
LAB_00173266:
MOV EBP,EAX
MOV RDI,R15
CALL 0x00163132
TEST BPL,BPL
JNZ 0x0017327b
ADD R12,0x20
JMP 0x00173245
LAB_0017327b:
MOV RDI,qword ptr [R12 + 0x10]
TEST RDI,RDI
JZ 0x0017329f
MOV RSI,R14
MOV RDX,RBX
CALL 0x0017332e
LAB_00173290:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017329f:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV RBX,RAX
LAB_001732aa:
LEA RSI,[0x1b68f4]
MOV RDI,RAX
CALL 0x00124320
LAB_001732b9:
MOV RSI,qword ptr [0x001ffff0]
MOV RDX,qword ptr [0x001fff50]
MOV RDI,RBX
CALL 0x00124ee0
|
/* minja::IfNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void minja::IfNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int8 *puVar1;
char cVar2;
runtime_error *this;
int8 *puVar3;
Expression local_80 [80];
puVar3 = *(int8 **)(param_1 + 0x20);
puVar1 = *(int8 **)(param_1 + 0x28);
while( true ) {
if (puVar3 == puVar1) {
return;
}
if ((shared_ptr *)*puVar3 == (shared_ptr *)0x0) break;
Expression::evaluate(local_80,(shared_ptr *)*puVar3);
/* try { // try from 0017325e to 00173265 has its CatchHandler @ 001732dc */
cVar2 = Value::to_bool((Value *)local_80);
Value::~Value((Value *)local_80);
if (cVar2 != '\0') break;
puVar3 = puVar3 + 4;
}
if ((ostringstream *)puVar3[2] != (ostringstream *)0x0) {
TemplateNode::render((ostringstream *)puVar3[2],param_2);
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001732aa to 001732b8 has its CatchHandler @ 001732cf */
std::runtime_error::runtime_error(this,"IfNode.cascade.second is null");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001ffff0,PTR__runtime_error_001fff50);
}
|
|
13,718
|
set_lsn
|
eloqsql/storage/maria/ma_loghandler.c
|
static inline void set_lsn(LSN *lsn, LSN value)
{
DBUG_ENTER("set_lsn");
translog_lock_assert_owner();
*lsn= value;
/* we generate LSN so something is not flushed in log */
log_descriptor.is_everything_flushed= 0;
DBUG_PRINT("info", ("new LSN appeared: " LSN_FMT, LSN_IN_PARTS(value)));
DBUG_VOID_RETURN;
}
|
O0
|
c
|
set_lsn:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, 0xc1ee82(%rip) # 0xc7a290
jmp 0x5b410
jmp 0x5b412
jmp 0x5b414
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
set_lsn:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov cs:byte_C7A290, 0
jmp short $+2
loc_5B410:
jmp short $+2
loc_5B412:
jmp short $+2
loc_5B414:
pop rbp
retn
|
_QWORD * set_lsn(_QWORD *a1, long long a2)
{
_QWORD *result; // rax
result = a1;
*a1 = a2;
byte_C7A290 = 0;
return result;
}
|
set_lsn:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV byte ptr [0x00d7a290],0x0
JMP 0x0015b410
LAB_0015b410:
JMP 0x0015b412
LAB_0015b412:
JMP 0x0015b414
LAB_0015b414:
POP RBP
RET
|
void set_lsn(int8 *param_1,int8 param_2)
{
*param_1 = param_2;
DAT_00d7a290 = 0;
return;
}
|
|
13,719
|
minja::CommentTemplateToken::CommentTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/minja.hpp
|
CommentTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::string& t) : TemplateToken(Type::Comment, location, pre, post), text(t) {}
|
O1
|
cpp
|
minja::CommentTemplateToken::CommentTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbx
movq %rdi, %rbx
leaq 0xa27f3(%rip), %rax # 0xe4180
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x419ac
movq (%rax), %rsi
incq %rsi
callq 0x1a740
leaq 0xa2815(%rip), %rax # 0xe41c8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x419c9
popq %rbx
jmp 0x35448
popq %rbx
retq
nop
|
_ZN5minja20CommentTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja20CommentTemplateTokenE; `vtable for'minja::CommentTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+30h]; void *
lea rax, [rbx+40h]
cmp rdi, rax
jz short loc_419AC
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_419AC:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_419C9
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_419C9:
pop rbx
retn
|
void minja::CommentTemplateToken::~CommentTemplateToken(minja::CommentTemplateToken *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::CommentTemplateToken + 2;
v2 = (char *)*((_QWORD *)this + 6);
if ( v2 != (char *)this + 64 )
operator delete(v2, *((_QWORD *)this + 8) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
|
~CommentTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1e4180]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x30]
LEA RAX,[RBX + 0x40]
CMP RDI,RAX
JZ 0x001419ac
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a740
LAB_001419ac:
LEA RAX,[0x1e41c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001419c9
POP RBX
JMP 0x00135448
LAB_001419c9:
POP RBX
RET
|
/* minja::CommentTemplateToken::~CommentTemplateToken() */
void __thiscall minja::CommentTemplateToken::~CommentTemplateToken(CommentTemplateToken *this)
{
*(int ***)this = &PTR__CommentTemplateToken_001e4190;
if (*(CommentTemplateToken **)(this + 0x30) != this + 0x40) {
operator_delete(*(CommentTemplateToken **)(this + 0x30),*(long *)(this + 0x40) + 1);
}
*(int ***)this = &PTR__TemplateToken_001e41d8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
|
|
13,720
|
nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_msgpack_object(unsigned long)
|
monkey531[P]llama/common/./json.hpp
|
bool get_msgpack_object(const std::size_t len)
{
if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
{
return false;
}
string_t key;
for (std::size_t i = 0; i < len; ++i)
{
get();
if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
{
return false;
}
if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
{
return false;
}
key.clear();
}
return sax->end_object();
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>>>, parse_json(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)::json_error_locator>::get_msgpack_object(unsigned long):
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ef03
jmp 0x18ef0d
movb $0x0, 0x67(%rsp)
jmp 0x18f046
leaq 0x30(%rsp), %rdi
callq 0x504a0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x18f012
movq 0x10(%rsp), %rdi
callq 0x18b910
jmp 0x18ef3c
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x18f100
movb %al, 0xf(%rsp)
jmp 0x18ef51
movb 0xf(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x18ef62
jmp 0x18ef89
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
leaq 0x30(%rsp), %rsi
callq *%rax
movb %al, 0xd(%rsp)
jmp 0x18ef7f
movb 0xd(%rsp), %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18ef97
jmp 0x18efc6
movb $0x0, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x18f03c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x510c0
jmp 0x18f051
movq 0x10(%rsp), %rdi
callq 0x18ab80
movb %al, 0xc(%rsp)
jmp 0x18efd6
movb 0xc(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18efe6
jmp 0x18eff5
movb $0x0, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x18f03c
leaq 0x30(%rsp), %rdi
callq 0x507b0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x18ef20
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movb %al, 0xb(%rsp)
jmp 0x18f02a
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x510c0
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x50940
nopl (%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE18get_msgpack_objectEm:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_58], rax
mov rdi, [rax+28h]
mov rsi, [rsp+68h+var_18]
mov rax, [rdi]
call qword ptr [rax+38h]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EF03
jmp short loc_18EF0D
loc_18EF03:
mov [rsp+68h+var_1], 0
jmp loc_18F046
loc_18EF0D:
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov [rsp+68h+var_40], 0
loc_18EF20:
mov rax, [rsp+68h+var_40]
cmp rax, [rsp+68h+var_18]
jnb loc_18F012
mov rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE3getEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::get(void)
jmp short $+2
loc_18EF3C:
mov rdi, [rsp+68h+var_58]
lea rsi, [rsp+68h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE18get_msgpack_stringERSB_; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::get_msgpack_string(std::string&)
mov [rsp+68h+var_59], al
jmp short $+2
loc_18EF51:
mov cl, [rsp+68h+var_59]
mov al, 1
test cl, 1
mov [rsp+68h+var_5A], al
jnz short loc_18EF62
jmp short loc_18EF89
loc_18EF62:
mov rax, [rsp+68h+var_58]
mov rdi, [rax+28h]
mov rax, [rdi]
mov rax, [rax+40h]
lea rsi, [rsp+68h+var_38]
call rax
mov [rsp+68h+var_5B], al
jmp short $+2
loc_18EF7F:
mov al, [rsp+68h+var_5B]
xor al, 0FFh
mov [rsp+68h+var_5A], al
loc_18EF89:
mov al, [rsp+68h+var_5A]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EF97
jmp short loc_18EFC6
loc_18EF97:
mov [rsp+68h+var_1], 0
mov [rsp+68h+var_50], 1
jmp loc_18F03C
mov rcx, rax
mov eax, edx
mov [rsp+arg_18], rcx
mov [rsp+arg_14], eax
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_18F051
loc_18EFC6:
mov rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_36detail13binary_readerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEZL10parse_jsonRSL_RKSL_RSF_E18json_error_locatorE22parse_msgpack_internalEv; nlohmann::json_abi_v3_11_3::detail::binary_reader<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)::json_error_locator>::parse_msgpack_internal(void)
mov [rsp+68h+var_5C], al
jmp short $+2
loc_18EFD6:
mov al, [rsp+68h+var_5C]
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_18EFE6
jmp short loc_18EFF5
loc_18EFE6:
mov [rsp+68h+var_1], 0
mov [rsp+68h+var_50], 1
jmp short loc_18F03C
loc_18EFF5:
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5clearEv; std::string::clear(void)
mov rax, [rsp+68h+var_40]
add rax, 1
mov [rsp+68h+var_40], rax
jmp loc_18EF20
loc_18F012:
mov rax, [rsp+68h+var_58]
mov rdi, [rax+28h]
mov rax, [rdi]
mov rax, [rax+48h]
call rax
mov [rsp+68h+var_5D], al
jmp short $+2
loc_18F02A:
mov al, [rsp+68h+var_5D]
and al, 1
mov [rsp+68h+var_1], al
mov [rsp+68h+var_50], 1
loc_18F03C:
lea rdi, [rsp+68h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_18F046:
mov al, [rsp+68h+var_1]
and al, 1
add rsp, 68h
retn
loc_18F051:
mov rdi, [rsp+arg_18]
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::get_msgpack_object(
long long a1,
unsigned long long a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
char v7; // [rsp+Eh] [rbp-5Ah]
unsigned long long i; // [rsp+28h] [rbp-40h]
_BYTE v9[32]; // [rsp+30h] [rbp-38h] BYREF
unsigned long long v10; // [rsp+50h] [rbp-18h]
long long v11; // [rsp+58h] [rbp-10h]
char v12; // [rsp+67h] [rbp-1h]
v11 = a1;
v10 = a2;
if ( ((*(long long ( **)(_QWORD, unsigned long long))(**(_QWORD **)(a1 + 40) + 56LL))(*(_QWORD *)(a1 + 40), a2) & 1) != 0 )
{
std::string::basic_string(v9);
for ( i = 0LL; i < v10; ++i )
{
nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::get(a1);
v7 = 1;
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::get_msgpack_string(
a1,
(unsigned int)v9,
v2,
v3,
v4,
v5) & 1) != 0 )
v7 = ~(*(unsigned __int8 ( **)(_QWORD, _BYTE *))(**(_QWORD **)(a1 + 40) + 64LL))(
*(_QWORD *)(a1 + 40),
v9);
if ( (v7 & 1) != 0 )
{
v12 = 0;
goto LABEL_13;
}
if ( (nlohmann::json_abi_v3_11_3::detail::binary_reader<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>>,parse_json(__gnu_cxx::__normal_iterator<char const*,std::string>&,__gnu_cxx::__normal_iterator<char const*,std::string> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&)::json_error_locator>::parse_msgpack_internal(a1) & 1) == 0 )
{
v12 = 0;
goto LABEL_13;
}
std::string::clear(v9);
}
v12 = (*(long long ( **)(_QWORD))(**(_QWORD **)(a1 + 40) + 72LL))(*(_QWORD *)(a1 + 40)) & 1;
LABEL_13:
std::string::~string(v9);
}
else
{
v12 = 0;
}
return v12 & 1;
}
|
__is_null_pointer<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>:
MOV qword ptr [RSP + -0x8],RDI
XOR EAX,EAX
AND AL,0x1
RET
|
/* bool __gnu_cxx::__is_null_pointer<__gnu_cxx::__normal_iterator<char*, std::__cxx11::string >
>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::string >) */
bool __gnu_cxx::__is_null_pointer<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>(void)
{
return false;
}
|
|
13,721
|
my_casedn_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x51ec8
jmp 0x51eca
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x50(%rbp), %rcx
movb %al, -0x61(%rbp)
jae 0x51efb
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x51f04
jmp 0x51f5f
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x553b0
movl -0x44(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
je 0x51f38
jmp 0x51f5f
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x51eca
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
my_casedn_utf16:
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_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_58], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_60], rax
jmp short $+2
loc_51EC8:
jmp short $+2
loc_51ECA:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_50]
mov [rbp+var_61], al
jnb short loc_51EFB
mov rax, [rbp+var_38]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_50]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_44], eax
cmp eax, 0
setnle al
mov [rbp+var_61], al
loc_51EFB:
mov al, [rbp+var_61]
test al, 1
jnz short loc_51F04
jmp short loc_51F5F
loc_51F04:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_30]
call my_tolower_utf16
mov eax, [rbp+var_44]
mov [rbp+var_68], eax
mov rax, [rbp+var_40]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_58]
call rax
mov ecx, eax
mov eax, [rbp+var_68]
cmp eax, ecx
jz short loc_51F38
jmp short loc_51F5F
loc_51F38:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_44]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_51ECA
loc_51F5F:
mov rax, [rbp+var_18]
add rsp, 70h
pop rbp
retn
|
long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
bool v6; // [rsp+Fh] [rbp-61h]
long long v7; // [rsp+10h] [rbp-60h]
long long v8; // [rsp+18h] [rbp-58h]
unsigned long long v9; // [rsp+20h] [rbp-50h]
int v10; // [rsp+2Ch] [rbp-44h]
unsigned int ( *v11)(long long, _QWORD, long long, long long); // [rsp+30h] [rbp-40h]
long long ( *v12)(long long, _QWORD *, unsigned long long, unsigned long long); // [rsp+38h] [rbp-38h]
_QWORD v13[2]; // [rsp+40h] [rbp-30h] BYREF
long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
unsigned long long v16; // [rsp+60h] [rbp-10h]
long long v17; // [rsp+68h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13[1] = a5;
v12 = *(long long ( **)(long long, _QWORD *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v11 = *(unsigned int ( **)(long long, _QWORD, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL);
v9 = a3 + a2;
v8 = a5 + a4;
v7 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v6 = 0;
if ( v16 < v9 )
{
v10 = v12(v17, v13, v16, v9);
v6 = v10 > 0;
}
if ( !v6 )
break;
my_tolower_utf16(v7, v13);
if ( v10 != v11(v17, v13[0], v14, v8) )
break;
v16 += v10;
v14 += v10;
}
return v15;
}
|
my_casedn_utf16:
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 qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00151ec8
LAB_00151ec8:
JMP 0x00151eca
LAB_00151eca:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x61],AL
JNC 0x00151efb
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x61],AL
LAB_00151efb:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x00151f04
JMP 0x00151f5f
LAB_00151f04:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x30]
CALL 0x001553b0
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x68],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,ECX
JZ 0x00151f38
JMP 0x00151f5f
LAB_00151f38:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00151eca
LAB_00151f5f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x70
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
code *pcVar1;
code *pcVar2;
int8 uVar3;
bool bVar4;
int iVar5;
int local_4c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar2 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar3 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar4 = false;
if (local_18 < param_2 + param_3) {
local_4c = (*pcVar1)(local_10,&local_38,local_18,param_2 + param_3);
bVar4 = 0 < local_4c;
}
if (!bVar4) break;
my_tolower_utf16(uVar3,&local_38);
iVar5 = (*pcVar2)(local_10,local_38,local_28,param_4 + param_5);
if (local_4c != iVar5) {
return local_20;
}
local_18 = local_18 + (long)local_4c;
local_28 = local_28 + local_4c;
}
return local_20;
}
|
|
13,722
|
minja::ExpressionTemplateToken::~ExpressionTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
ExpressionTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && e) : TemplateToken(Type::Expression, location, pre, post), expr(std::move(e)) {}
|
O3
|
cpp
|
minja::ExpressionTemplateToken::~ExpressionTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x92e75(%rip), %rax # 0x12faf8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9cc98
callq 0x725dc
leaq 0x92649(%rip), %rax # 0x12f2e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9ccb4
callq 0x725dc
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1b910
|
_ZN5minja23ExpressionTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja23ExpressionTemplateTokenE; `vtable for'minja::ExpressionTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_9CC98
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9CC98:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9CCB4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9CCB4:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::ExpressionTemplateToken::~ExpressionTemplateToken(minja::ExpressionTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
|
~ExpressionTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22faf8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0019cc98
CALL 0x001725dc
LAB_0019cc98:
LEA RAX,[0x22f2e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019ccb4
CALL 0x001725dc
LAB_0019ccb4:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011b910
|
/* minja::ExpressionTemplateToken::~ExpressionTemplateToken() */
void __thiscall
minja::ExpressionTemplateToken::~ExpressionTemplateToken(ExpressionTemplateToken *this)
{
*(int ***)this = &PTR__ExpressionTemplateToken_0022fb08;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022f2f8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
|
|
13,723
|
ggml_compute_forward_argmax_f32
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c
|
static void ggml_compute_forward_argmax_f32(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
if (params->ith != 0) {
return;
}
assert(src0->nb[0] == sizeof(float));
assert(dst->nb[0] == sizeof(float));
const int64_t ne00 = src0->ne[0];
const int64_t ne01 = src0->ne[1];
const size_t nb01 = src0->nb[1];
const size_t nb0 = dst->nb[0];
for (int64_t i1 = 0; i1 < ne01; i1++) {
float * src = (float *) ((char *) src0->data + i1*nb01);
int32_t * dst_ = (int32_t *) ((char *) dst->data + i1*nb0);
int v = 0;
ggml_vec_argmax_f32(ne00, &v, src);
dst_[0] = v;
}
}
|
O0
|
c
|
ggml_compute_forward_argmax_f32:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x266ed
jmp 0x267ee
movq -0x18(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0x266fa
jmp 0x26719
leaq 0x4e13c(%rip), %rdi # 0x7483d
leaq 0x4d45a(%rip), %rsi # 0x73b62
movl $0x1666, %edx # imm = 0x1666
leaq 0x4e39c(%rip), %rcx # 0x74ab0
callq 0xd690
movq -0x10(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0x26726
jmp 0x26745
leaq 0x4e0f4(%rip), %rdi # 0x74821
leaq 0x4d42e(%rip), %rsi # 0x73b62
movl $0x1667, %edx # imm = 0x1667
leaq 0x4e370(%rip), %rcx # 0x74ab0
callq 0xd690
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x267ee
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x40(%rbp), %rcx
imulq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq -0x40(%rbp), %rcx
imulq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x48(%rbp), %rdx
leaq -0x54(%rbp), %rsi
callq 0x26800
movl -0x54(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x2677d
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ggml_compute_forward_argmax_f32:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
cmp dword ptr [rax], 0
jz short loc_266ED
jmp loc_267EE
loc_266ED:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 4
jnz short loc_266FA
jmp short loc_26719
loc_266FA:
lea rdi, aSrc0Nb0SizeofF; "src0->nb[0] == sizeof(float)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1666h
lea rcx, aVoidGgmlComput_12; "void ggml_compute_forward_argmax_f32(co"...
call ___assert_fail
loc_26719:
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 4
jnz short loc_26726
jmp short loc_26745
loc_26726:
lea rdi, aDstNb0SizeofFl; "dst->nb[0] == sizeof(float)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1667h
lea rcx, aVoidGgmlComput_12; "void ggml_compute_forward_argmax_f32(co"...
call ___assert_fail
loc_26745:
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax+30h]
mov [rbp+var_38], rax
mov [rbp+var_40], 0
loc_2677D:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_28]
jge short loc_267EE
mov rax, [rbp+var_18]
mov rax, [rax+0F8h]
mov rcx, [rbp+var_40]
imul rcx, [rbp+var_30]
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
mov rcx, [rbp+var_40]
imul rcx, [rbp+var_38]
add rax, rcx
mov [rbp+var_50], rax
mov [rbp+var_54], 0
mov rax, [rbp+var_20]
mov edi, eax
mov rdx, [rbp+var_48]
lea rsi, [rbp+var_54]
call ggml_vec_argmax_f32
mov ecx, [rbp+var_54]
mov rax, [rbp+var_50]
mov [rax], ecx
mov rax, [rbp+var_40]
add rax, 1
mov [rbp+var_40], rax
jmp short loc_2677D
loc_267EE:
add rsp, 60h
pop rbp
retn
|
_DWORD * ggml_compute_forward_argmax_f32(_DWORD *a1, long long a2)
{
_DWORD *result; // rax
int v3; // [rsp+Ch] [rbp-54h] BYREF
_DWORD *v4; // [rsp+10h] [rbp-50h]
long long v5; // [rsp+18h] [rbp-48h]
long long i; // [rsp+20h] [rbp-40h]
long long v7; // [rsp+28h] [rbp-38h]
long long v8; // [rsp+30h] [rbp-30h]
long long v9; // [rsp+38h] [rbp-28h]
long long v10; // [rsp+40h] [rbp-20h]
_QWORD *v11; // [rsp+48h] [rbp-18h]
long long v12; // [rsp+50h] [rbp-10h]
_DWORD *v13; // [rsp+58h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = *(_QWORD **)(a2 + 152);
result = a1;
if ( !*a1 )
{
if ( v11[6] != 4LL )
__assert_fail(
"src0->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5734LL,
"void ggml_compute_forward_argmax_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
if ( *(_QWORD *)(v12 + 48) != 4LL )
__assert_fail(
"dst->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5735LL,
"void ggml_compute_forward_argmax_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
v10 = v11[2];
v9 = v11[3];
v8 = v11[7];
v7 = *(_QWORD *)(v12 + 48);
for ( i = 0LL; ; ++i )
{
result = (_DWORD *)i;
if ( i >= v9 )
break;
v5 = v8 * i + v11[31];
v4 = (_DWORD *)(v7 * i + *(_QWORD *)(v12 + 248));
v3 = 0;
ggml_vec_argmax_f32((unsigned int)v10, &v3, v5);
*v4 = v3;
}
}
return result;
}
|
ggml_compute_forward_argmax_f32:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX],0x0
JZ 0x001266ed
JMP 0x001267ee
LAB_001266ed:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x001266fa
JMP 0x00126719
LAB_001266fa:
LEA RDI,[0x17483d]
LEA RSI,[0x173b62]
MOV EDX,0x1666
LEA RCX,[0x174ab0]
CALL 0x0010d690
LAB_00126719:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x00126726
JMP 0x00126745
LAB_00126726:
LEA RDI,[0x174821]
LEA RSI,[0x173b62]
MOV EDX,0x1667
LEA RCX,[0x174ab0]
CALL 0x0010d690
LAB_00126745:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x40],0x0
LAB_0012677d:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x28]
JGE 0x001267ee
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RBP + -0x40]
IMUL RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RBP + -0x40]
IMUL RCX,qword ptr [RBP + -0x38]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x54],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,EAX
MOV RDX,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x54]
CALL 0x00126800
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0012677d
LAB_001267ee:
ADD RSP,0x60
POP RBP
RET
|
void ggml_compute_forward_argmax_f32(int *param_1,long param_2)
{
int4 local_5c;
int4 *local_58;
long local_50;
long local_48;
long local_40;
long local_38;
long local_30;
ulong local_28;
long local_20;
long local_18;
int *local_10;
local_20 = *(long *)(param_2 + 0x98);
if (*param_1 == 0) {
local_18 = param_2;
local_10 = param_1;
if (*(long *)(local_20 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("src0->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x1666,
"void ggml_compute_forward_argmax_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
if (*(long *)(param_2 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("dst->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x1667,
"void ggml_compute_forward_argmax_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
local_28 = *(ulong *)(local_20 + 0x10);
local_30 = *(long *)(local_20 + 0x18);
local_38 = *(long *)(local_20 + 0x38);
local_40 = *(long *)(param_2 + 0x30);
for (local_48 = 0; local_48 < local_30; local_48 = local_48 + 1) {
local_50 = *(long *)(local_20 + 0xf8) + local_48 * local_38;
local_58 = (int4 *)(*(long *)(local_18 + 0xf8) + local_48 * local_40);
local_5c = 0;
ggml_vec_argmax_f32(local_28 & 0xffffffff,&local_5c,local_50);
*local_58 = local_5c;
}
}
return;
}
|
|
13,724
|
JS_GetPropertyStr
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_GetPropertyStr(JSContext *ctx, JSValue this_obj,
const char *prop)
{
JSAtom atom;
JSValue ret;
atom = JS_NewAtom(ctx, prop);
ret = JS_GetProperty(ctx, this_obj, atom);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O1
|
c
|
JS_GetPropertyStr:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xe240
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1fdc0
movl %eax, %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movl %ebx, %esi
callq 0x207d8
movq %r14, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
JS_GetPropertyStr:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rcx
call _strlen
mov rdi, r12
mov rsi, rbx
mov rdx, rax
call JS_NewAtomLen
mov ebx, eax
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov ecx, eax
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r15, rdx
mov rdi, r12
mov esi, ebx
call JS_FreeAtom
mov rax, r14
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long JS_GetPropertyStr(long long a1, long long a2, long long a3, unsigned __int8 *a4)
{
unsigned __int8 *v4; // rbx
long long v6; // rax
unsigned long long PropertyInternal2; // r14
v4 = a4;
v6 = strlen(a4);
LODWORD(v4) = JS_NewAtomLen(a1, v4, v6);
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, (unsigned int)v4, a2, a3, 0LL, 0);
JS_FreeAtom(a1, (int)v4);
return PropertyInternal2;
}
|
JS_GetPropertyStr:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
MOV RDI,RCX
CALL 0x0010e240
MOV RDI,R12
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0011fdc0
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
MOV ECX,EAX
MOV R8,R15
MOV R9,R14
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV R14,RAX
MOV R15,RDX
MOV RDI,R12
MOV ESI,EBX
CALL 0x001207d8
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
JS_GetPropertyStr(int8 param_1,int8 param_2,int8 param_3,char *param_4)
{
int4 uVar1;
size_t sVar2;
int1 auVar3 [16];
sVar2 = strlen(param_4);
uVar1 = JS_NewAtomLen(param_1,param_4,sVar2);
auVar3 = JS_GetPropertyInternal2(param_1,param_2,param_3,uVar1,param_2,param_3,0,0);
JS_FreeAtom(param_1,uVar1);
return auVar3;
}
|
|
13,725
|
JS_GetPropertyStr
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_GetPropertyStr(JSContext *ctx, JSValue this_obj,
const char *prop)
{
JSAtom atom;
JSValue ret;
atom = JS_NewAtom(ctx, prop);
ret = JS_GetProperty(ctx, this_obj, atom);
JS_FreeAtom(ctx, atom);
return ret;
}
|
O3
|
c
|
JS_GetPropertyStr:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xe240
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2052b
movl %eax, %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x2384b
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movl %ebx, %esi
callq 0x20f31
movq %r14, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
JS_GetPropertyStr:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rcx
call _strlen
mov rdi, r12
mov rsi, rbx
mov rdx, rax
call JS_NewAtomLen
mov ebx, eax
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov ecx, eax
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r15, rdx
mov rdi, r12
mov esi, ebx
call JS_FreeAtom
mov rax, r14
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long JS_GetPropertyStr(long long a1, long long a2, long long a3, unsigned __int8 *a4)
{
unsigned __int8 *v4; // rbx
long long v6; // rax
unsigned long long PropertyInternal2; // r14
v4 = a4;
v6 = strlen(a4);
LODWORD(v4) = JS_NewAtomLen(a1, v4, v6);
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, (unsigned int)v4, a2, a3, 0LL, 0);
JS_FreeAtom(a1, (int)v4);
return PropertyInternal2;
}
|
JS_GetPropertyStr:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
MOV RDI,RCX
CALL 0x0010e240
MOV RDI,R12
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0012052b
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
MOV ECX,EAX
MOV R8,R15
MOV R9,R14
PUSH 0x0
PUSH 0x0
CALL 0x0012384b
ADD RSP,0x10
MOV R14,RAX
MOV R15,RDX
MOV RDI,R12
MOV ESI,EBX
CALL 0x00120f31
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
JS_GetPropertyStr(int8 param_1,int8 param_2,int8 param_3,char *param_4)
{
int4 uVar1;
size_t sVar2;
int1 auVar3 [16];
sVar2 = strlen(param_4);
uVar1 = JS_NewAtomLen(param_1,param_4,sVar2);
auVar3 = JS_GetPropertyInternal2(param_1,param_2,param_3,uVar1,param_2,param_3,0,0);
JS_FreeAtom(param_1,uVar1);
return auVar3;
}
|
|
13,726
|
coro::event::reverse(coro::event::awaiter*)
|
AlayaLite/build_O3/_deps/libcoro-src/src/event.cpp
|
auto event::reverse(awaiter* curr) -> awaiter*
{
if (curr == nullptr || curr->m_next == nullptr)
{
return curr;
}
awaiter* prev = nullptr;
awaiter* next = nullptr;
while (curr != nullptr)
{
next = curr->m_next;
curr->m_next = prev;
prev = curr;
curr = next;
}
return prev;
}
|
O3
|
cpp
|
coro::event::reverse(coro::event::awaiter*):
testq %rsi, %rsi
je 0x5c52
cmpq $0x0, 0x10(%rsi)
je 0x5c55
xorl %ecx, %ecx
movq %rsi, %rax
movq 0x10(%rsi), %rsi
movq %rcx, 0x10(%rax)
movq %rax, %rcx
testq %rsi, %rsi
jne 0x5c3e
retq
xorl %eax, %eax
retq
movq %rsi, %rax
retq
nop
|
_ZN4coro5event7reverseEPNS0_7awaiterE:
test rsi, rsi
jz short loc_5C52
cmp qword ptr [rsi+10h], 0
jz short loc_5C55
xor ecx, ecx
loc_5C3E:
mov rax, rsi
mov rsi, [rsi+10h]
mov [rax+10h], rcx
mov rcx, rax
test rsi, rsi
jnz short loc_5C3E
retn
loc_5C52:
xor eax, eax
retn
loc_5C55:
mov rax, rsi
retn
|
long long coro::event::reverse(long long a1, long long a2)
{
long long v2; // rcx
long long result; // rax
if ( !a2 )
return 0LL;
if ( !*(_QWORD *)(a2 + 16) )
return a2;
v2 = 0LL;
do
{
result = a2;
a2 = *(_QWORD *)(a2 + 16);
*(_QWORD *)(result + 16) = v2;
v2 = result;
}
while ( a2 );
return result;
}
|
reverse:
TEST RSI,RSI
JZ 0x00105c52
CMP qword ptr [RSI + 0x10],0x0
JZ 0x00105c55
XOR ECX,ECX
LAB_00105c3e:
MOV RAX,RSI
MOV RSI,qword ptr [RSI + 0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,RAX
TEST RSI,RSI
JNZ 0x00105c3e
RET
LAB_00105c52:
XOR EAX,EAX
RET
LAB_00105c55:
MOV RAX,RSI
RET
|
/* coro::event::reverse(coro::event::awaiter*) */
awaiter * __thiscall coro::event::reverse(event *this,awaiter *param_1)
{
awaiter *paVar1;
awaiter *paVar2;
awaiter *paVar3;
if (param_1 == (awaiter *)0x0) {
return (awaiter *)0x0;
}
if (*(long *)(param_1 + 0x10) != 0) {
paVar3 = (awaiter *)0x0;
do {
paVar2 = param_1;
paVar1 = *(awaiter **)(param_1 + 0x10);
*(awaiter **)(param_1 + 0x10) = paVar3;
paVar3 = param_1;
param_1 = paVar1;
} while (paVar1 != (awaiter *)0x0);
return paVar2;
}
return param_1;
}
|
|
13,727
|
reset_partitioned_key_cache_counters
|
eloqsql/mysys/mf_keycache.c
|
static int
reset_partitioned_key_cache_counters(const char *name __attribute__((unused)),
PARTITIONED_KEY_CACHE_CB *keycache)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_reset_key_cache_counters");
for (i = 0; i < partitions; i++)
{
reset_simple_key_cache_counters(name, keycache->partition_array[i]);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
reset_partitioned_key_cache_counters:
movl 0x1c(%rsi), %eax
testq %rax, %rax
je 0xa23f4
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movq 0x8(%rsi), %rdx
movq (%rdx,%rcx,8), %rdx
cmpb $0x0, (%rdx)
je 0xa23eb
movups %xmm0, 0x148(%rdx)
movups %xmm0, 0x138(%rdx)
movq $0x0, 0x158(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0xa23c5
popq %rbp
xorl %eax, %eax
retq
|
reset_partitioned_key_cache_counters:
mov eax, [rsi+1Ch]
test rax, rax
jz short loc_A23F4
push rbp
mov rbp, rsp
xor ecx, ecx
xorps xmm0, xmm0
loc_A23C5:
mov rdx, [rsi+8]
mov rdx, [rdx+rcx*8]
cmp byte ptr [rdx], 0
jz short loc_A23EB
movups xmmword ptr [rdx+148h], xmm0
movups xmmword ptr [rdx+138h], xmm0
mov qword ptr [rdx+158h], 0
loc_A23EB:
inc rcx
cmp rax, rcx
jnz short loc_A23C5
pop rbp
loc_A23F4:
xor eax, eax
retn
|
long long reset_partitioned_key_cache_counters(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // rdx
v2 = *(unsigned int *)(a2 + 28);
if ( *(_DWORD *)(a2 + 28) )
{
v3 = 0LL;
do
{
v4 = *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8 * v3);
if ( *(_BYTE *)v4 )
{
*(_OWORD *)(v4 + 328) = 0LL;
*(_OWORD *)(v4 + 312) = 0LL;
*(_QWORD *)(v4 + 344) = 0LL;
}
++v3;
}
while ( v2 != v3 );
}
return 0LL;
}
|
reset_partitioned_key_cache_counters:
MOV EAX,dword ptr [RSI + 0x1c]
TEST RAX,RAX
JZ 0x001a23f4
PUSH RBP
MOV RBP,RSP
XOR ECX,ECX
XORPS XMM0,XMM0
LAB_001a23c5:
MOV RDX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP byte ptr [RDX],0x0
JZ 0x001a23eb
MOVUPS xmmword ptr [RDX + 0x148],XMM0
MOVUPS xmmword ptr [RDX + 0x138],XMM0
MOV qword ptr [RDX + 0x158],0x0
LAB_001a23eb:
INC RCX
CMP RAX,RCX
JNZ 0x001a23c5
POP RBP
LAB_001a23f4:
XOR EAX,EAX
RET
|
int8 reset_partitioned_key_cache_counters(int8 param_1,long param_2)
{
uint uVar1;
char *pcVar2;
ulong uVar3;
uVar1 = *(uint *)(param_2 + 0x1c);
if ((ulong)uVar1 != 0) {
uVar3 = 0;
do {
pcVar2 = *(char **)(*(long *)(param_2 + 8) + uVar3 * 8);
if (*pcVar2 != '\0') {
pcVar2[0x148] = '\0';
pcVar2[0x149] = '\0';
pcVar2[0x14a] = '\0';
pcVar2[0x14b] = '\0';
pcVar2[0x14c] = '\0';
pcVar2[0x14d] = '\0';
pcVar2[0x14e] = '\0';
pcVar2[0x14f] = '\0';
pcVar2[0x150] = '\0';
pcVar2[0x151] = '\0';
pcVar2[0x152] = '\0';
pcVar2[0x153] = '\0';
pcVar2[0x154] = '\0';
pcVar2[0x155] = '\0';
pcVar2[0x156] = '\0';
pcVar2[0x157] = '\0';
pcVar2[0x138] = '\0';
pcVar2[0x139] = '\0';
pcVar2[0x13a] = '\0';
pcVar2[0x13b] = '\0';
pcVar2[0x13c] = '\0';
pcVar2[0x13d] = '\0';
pcVar2[0x13e] = '\0';
pcVar2[0x13f] = '\0';
pcVar2[0x140] = '\0';
pcVar2[0x141] = '\0';
pcVar2[0x142] = '\0';
pcVar2[0x143] = '\0';
pcVar2[0x144] = '\0';
pcVar2[0x145] = '\0';
pcVar2[0x146] = '\0';
pcVar2[0x147] = '\0';
pcVar2[0x158] = '\0';
pcVar2[0x159] = '\0';
pcVar2[0x15a] = '\0';
pcVar2[0x15b] = '\0';
pcVar2[0x15c] = '\0';
pcVar2[0x15d] = '\0';
pcVar2[0x15e] = '\0';
pcVar2[0x15f] = '\0';
}
uVar3 = uVar3 + 1;
} while (uVar1 != uVar3);
}
return 0;
}
|
|
13,728
|
really_execute_checkpoint
|
eloqsql/storage/maria/ma_checkpoint.c
|
static int really_execute_checkpoint(void)
{
uint i, error= 0;
int error_errno= 0;
/** @brief checkpoint_start_log_horizon will be stored there */
char *ptr;
const char *error_place= 0;
LEX_STRING record_pieces[4]; /**< only malloc-ed pieces */
LSN min_page_rec_lsn, min_trn_rec_lsn, min_first_undo_lsn;
TRANSLOG_ADDRESS checkpoint_start_log_horizon;
char checkpoint_start_log_horizon_char[LSN_STORE_SIZE];
DBUG_ENTER("really_execute_checkpoint");
DBUG_PRINT("enter", ("level: %d", checkpoint_in_progress));
bzero(&record_pieces, sizeof(record_pieces));
/*
STEP 1: record current end-of-log position using log's lock. It is
critical for the correctness of Checkpoint (related to memory visibility
rules, the log's lock is a mutex).
"Horizon" is a lower bound of the LSN of the next log record.
*/
checkpoint_start_log_horizon= translog_get_horizon();
DBUG_PRINT("info",("checkpoint_start_log_horizon " LSN_FMT "",
LSN_IN_PARTS(checkpoint_start_log_horizon)));
lsn_store(checkpoint_start_log_horizon_char, checkpoint_start_log_horizon);
/*
STEP 2: fetch information about transactions.
We must fetch transactions before dirty pages. Indeed, a transaction
first sets its rec_lsn then sets the page's rec_lsn then sets its rec_lsn
to 0. If we fetched pages first, we may see no dirty page yet, then we
fetch transactions but the transaction has already reset its rec_lsn to 0
so we miss rec_lsn again.
For a similar reason (over-allocated bitmap pages) we have to fetch
transactions before flushing bitmap pages.
min_trn_rec_lsn will serve to lower the starting point of the REDO phase
(down from checkpoint_start_log_horizon).
*/
if (unlikely(trnman_collect_transactions(&record_pieces[0],
&record_pieces[1],
&min_trn_rec_lsn,
&min_first_undo_lsn)))
{
error_place= "trnman_collect_transaction";
goto err;
}
/* STEP 3: fetch information about table files */
if (unlikely(collect_tables(&record_pieces[2],
checkpoint_start_log_horizon)))
{
error_place= "collect_tables";
goto err;
}
/* STEP 4: fetch information about dirty pages */
/*
It's better to do it _after_ having flushed some data pages (which
collect_tables() may have done), because those are now non-dirty and so we
have a more up-to-date dirty pages list to put into the checkpoint record,
and thus we will have less work at Recovery.
*/
/* Using default pagecache for now */
if (unlikely(pagecache_collect_changed_blocks_with_lsn(maria_pagecache,
&record_pieces[3],
&min_page_rec_lsn)))
{
error_place= "collect_pages";
goto err;
}
/* LAST STEP: now write the checkpoint log record */
{
LSN lsn;
translog_size_t total_rec_length;
/*
the log handler is allowed to modify "str" and "length" (but not "*str")
of its argument, so we must not pass it record_pieces directly,
otherwise we would later not know what memory pieces to my_free().
*/
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 5];
log_array[TRANSLOG_INTERNAL_PARTS + 0].str=
(uchar*) checkpoint_start_log_horizon_char;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= total_rec_length=
sizeof(checkpoint_start_log_horizon_char);
for (i= 0; i < (sizeof(record_pieces)/sizeof(record_pieces[0])); i++)
{
log_array[TRANSLOG_INTERNAL_PARTS + 1 + i].str= (uchar*)record_pieces[i].str;
log_array[TRANSLOG_INTERNAL_PARTS + 1 + i].length= record_pieces[i].length;
total_rec_length+= (translog_size_t) record_pieces[i].length;
}
if (unlikely(translog_write_record(&lsn, LOGREC_CHECKPOINT,
&dummy_transaction_object, NULL,
total_rec_length,
sizeof(log_array)/sizeof(log_array[0]),
log_array, NULL, NULL) ||
translog_flush(lsn)))
{
error_place= "translog_write_record";
goto err;
}
translog_lock();
/*
This cannot be done as a inwrite_rec_hook of LOGREC_CHECKPOINT, because
such hook would be called before translog_flush (and we must be sure
that log was flushed before we write to the control file).
*/
if (unlikely(ma_control_file_write_and_force(lsn, last_logno,
max_trid_in_control_file,
recovery_failures)))
{
error_place= "ma_control_file_write";
error_errno= my_errno;
translog_unlock();
goto err;
}
translog_unlock();
}
/*
Note that we should not alter memory structures until we have successfully
written the checkpoint record and control file.
*/
/* checkpoint succeeded */
ptr= record_pieces[3].str;
pages_to_flush_before_next_checkpoint= uint4korr(ptr);
DBUG_PRINT("checkpoint",("%u pages to flush before next checkpoint",
pages_to_flush_before_next_checkpoint));
/* compute log's low-water mark */
{
TRANSLOG_ADDRESS log_low_water_mark= min_page_rec_lsn;
set_if_smaller(log_low_water_mark, min_trn_rec_lsn);
set_if_smaller(log_low_water_mark, min_first_undo_lsn);
set_if_smaller(log_low_water_mark, checkpoint_start_log_horizon);
/**
Now purge unneeded logs.
As some systems have an unreliable fsync (drive lying), we could try to
be robust against that: remember a few previous checkpoints in the
control file, and not purge logs immediately... Think about it.
*/
if (translog_purge(log_low_water_mark))
ma_message_no_user(0, "log purging failed");
}
goto end;
err:
error= 1;
my_printf_error(HA_ERR_GENERIC, "Aria engine: checkpoint failed at %s with "
"error %d", MYF(ME_ERROR_LOG),
error_place, (error_errno ? error_errno : my_errno));
/* we were possibly not able to determine what pages to flush */
pages_to_flush_before_next_checkpoint= 0;
end:
for (i= 0; i < (sizeof(record_pieces)/sizeof(record_pieces[0])); i++)
my_free(record_pieces[i].str);
mysql_mutex_lock(&LOCK_checkpoint);
checkpoint_in_progress= CHECKPOINT_NONE;
checkpoints_total++;
checkpoints_ok_total+= !error;
mysql_mutex_unlock(&LOCK_checkpoint);
DBUG_RETURN(error);
}
|
O0
|
c
|
really_execute_checkpoint:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0x9b1d0
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2a2b0
movb $0x0, %al
callq 0x8c810
movq %rax, -0x90(%rbp)
jmp 0x9b1f0
jmp 0x9b1f2
jmp 0x9b1f4
movq -0x90(%rbp), %rax
sarq $0x20, %rax
movb %al, -0xf(%rbp)
movq -0x90(%rbp), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, -0xe(%rbp)
movq -0x90(%rbp), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, -0xd(%rbp)
jmp 0x9b226
leaq -0xf(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x98(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x90(%rbp), %rax
movl %eax, %ecx
movq -0x98(%rbp), %rax
movl %ecx, (%rax)
jmp 0x9b253
leaq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %rsi
addq $0x10, %rsi
leaq -0x80(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x75900
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9b295
leaq 0xc08c0(%rip), %rax # 0x15bb4c
movq %rax, -0x30(%rbp)
jmp 0x9b584
leaq -0x70(%rbp), %rdi
addq $0x20, %rdi
movq -0x90(%rbp), %rsi
callq 0x9bc00
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9b2cc
leaq 0xc08a4(%rip), %rax # 0x15bb67
movq %rax, -0x30(%rbp)
jmp 0x9b584
leaq 0x22d20d(%rip), %rax # 0x2c84e0
movq (%rax), %rdi
leaq -0x70(%rbp), %rsi
addq $0x30, %rsi
leaq -0x78(%rbp), %rdx
callq 0x994b0
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9b30d
leaq 0xc0872(%rip), %rax # 0x15bb76
movq %rax, -0x30(%rbp)
jmp 0x9b584
leaq -0xf(%rbp), %rax
movq %rax, -0x100(%rbp)
movl $0x7, -0xa4(%rbp)
movq $0x7, -0xf8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x4, %rax
jae 0x9b3cd
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq -0x70(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %edx
leaq -0x120(%rbp), %rax
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq -0x70(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %edx
leaq -0x120(%rbp), %rax
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq -0x70(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addl -0xa4(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b334
movl -0xa4(%rbp), %r8d
leaq -0x120(%rbp), %rax
leaq -0xa0(%rbp), %rdi
movl $0x1d, %esi
leaq 0x3e78c2(%rip), %rdx # 0x482cb0
xorl %ecx, %ecx
movl $0x7, %r9d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x8bc40
movsbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x129(%rbp)
jne 0x9b43c
movq -0xa0(%rbp), %rdi
callq 0x8e450
movsbl %al, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x129(%rbp)
movb -0x129(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9b46a
leaq 0xc0723(%rip), %rax # 0x15bb84
movq %rax, -0x30(%rbp)
jmp 0x9b584
movb $0x0, %al
callq 0x87d40
movq -0xa0(%rbp), %rdi
leaq 0x3e7dc1(%rip), %rax # 0x483240
movl (%rax), %esi
leaq 0x3e7dc0(%rip), %rax # 0x483248
movq (%rax), %rdx
leaq 0x3e7dbe(%rip), %rax # 0x483250
movzbl (%rax), %ecx
callq 0x86490
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9b4ce
leaq 0xc06e6(%rip), %rax # 0x15bb9a
movq %rax, -0x30(%rbp)
callq 0xfc990
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, %al
callq 0x87e30
jmp 0x9b584
movb $0x0, %al
callq 0x87e30
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xbea117(%rip) # 0xc85600
jmp 0x9b4eb
movq -0x78(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
cmpq -0x80(%rbp), %rax
jle 0x9b50e
movq -0x80(%rbp), %rax
movq %rax, -0x128(%rbp)
jmp 0x9b510
jmp 0x9b512
movq -0x128(%rbp), %rax
cmpq -0x88(%rbp), %rax
jle 0x9b530
movq -0x88(%rbp), %rax
movq %rax, -0x128(%rbp)
jmp 0x9b532
jmp 0x9b534
movq -0x128(%rbp), %rax
cmpq -0x90(%rbp), %rax
jle 0x9b552
movq -0x90(%rbp), %rax
movq %rax, -0x128(%rbp)
jmp 0x9b554
movq -0x128(%rbp), %rdi
callq 0x8f1d0
cmpb $0x0, %al
je 0x9b582
movl $0xa8, %edi
leaq 0xbf911(%rip), %rsi # 0x15ae81
xorl %eax, %eax
movl %eax, %edx
leaq 0xc0635(%rip), %rcx # 0x15bbb0
movb $0x0, %al
callq 0xf2c30
jmp 0x9b5e4
movl $0x1, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9b5a7
movl -0x1c(%rbp), %eax
movl %eax, -0x13c(%rbp)
jmp 0x9b5b4
callq 0xfc990
movl (%rax), %eax
movl %eax, -0x13c(%rbp)
movq -0x138(%rbp), %rcx
movl -0x13c(%rbp), %r8d
movl $0xa8, %edi
leaq 0xc05f5(%rip), %rsi # 0x15bbc3
movl $0x40, %edx
movb $0x0, %al
callq 0xf2c30
movl $0x0, 0xbea01c(%rip) # 0xc85600
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x4, %rax
jae 0x9b617
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq -0x70(%rbp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0xfa370
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b5eb
leaq 0xbe9f4a(%rip), %rdi # 0xc85568
leaq 0xc049b(%rip), %rsi # 0x15bac0
movl $0x13b, %edx # imm = 0x13B
callq 0x9b060
movl $0x0, 0xbe9f77(%rip) # 0xc855b0
movl 0xbe9fd9(%rip), %eax # 0xc85618
addl $0x1, %eax
movl %eax, 0xbe9fd0(%rip) # 0xc85618
cmpl $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addl 0xbe9fc0(%rip), %eax # 0xc8561c
movl %eax, 0xbe9fba(%rip) # 0xc8561c
leaq 0xbe9eff(%rip), %rdi # 0xc85568
callq 0x9b0d0
movl -0x18(%rbp), %eax
movl %eax, -0x140(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x9b698
movl -0x140(%rbp), %eax
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
callq 0x2a260
nopl (%rax)
|
really_execute_checkpoint:
push rbp
mov rbp, rsp
sub rsp, 160h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
mov [rbp+var_30], 0
jmp short $+2
loc_9B1D0:
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov al, 0
call translog_get_horizon
mov [rbp+var_90], rax
jmp short $+2
loc_9B1F0:
jmp short $+2
loc_9B1F2:
jmp short $+2
loc_9B1F4:
mov rax, [rbp+var_90]
sar rax, 20h
mov [rbp+var_F], al
mov rax, [rbp+var_90]
sar rax, 20h
shr eax, 8
mov [rbp+var_E], al
mov rax, [rbp+var_90]
sar rax, 20h
shr eax, 10h
mov [rbp+var_D], al
jmp short $+2
loc_9B226:
lea rax, [rbp+var_F]
add rax, 3
mov [rbp+var_98], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_90]
mov ecx, eax
mov rax, [rbp+var_98]
mov [rax], ecx
jmp short $+2
loc_9B253:
lea rdi, [rbp+var_70]
lea rsi, [rbp+var_70]
add rsi, 10h
lea rdx, [rbp+var_80]
lea rcx, [rbp+var_88]
call trnman_collect_transactions
movsx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9B295
lea rax, aTrnmanCollectT; "trnman_collect_transaction"
mov [rbp+var_30], rax
jmp loc_9B584
loc_9B295:
lea rdi, [rbp+var_70]
add rdi, 20h ; ' '
mov rsi, [rbp+var_90]
call collect_tables
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9B2CC
lea rax, aCollectTables; "collect_tables"
mov [rbp+var_30], rax
jmp loc_9B584
loc_9B2CC:
lea rax, maria_pagecache
mov rdi, [rax]
lea rsi, [rbp+var_70]
add rsi, 30h ; '0'
lea rdx, [rbp+var_78]
call pagecache_collect_changed_blocks_with_lsn
movsx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9B30D
lea rax, aCollectPages; "collect_pages"
mov [rbp+var_30], rax
jmp loc_9B584
loc_9B30D:
lea rax, [rbp+var_F]
mov [rbp+var_100], rax
mov [rbp+var_A4], 7
mov [rbp+var_F8], 7
mov [rbp+var_14], 0
loc_9B334:
mov eax, [rbp+var_14]
cmp rax, 4
jnb loc_9B3CD
mov eax, [rbp+var_14]
mov ecx, eax
lea rax, [rbp+var_70]
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov eax, [rbp+var_14]
add eax, 3
mov eax, eax
mov edx, eax
lea rax, [rbp+var_120]
shl rdx, 4
add rax, rdx
mov [rax], rcx
mov eax, [rbp+var_14]
mov ecx, eax
lea rax, [rbp+var_70]
shl rcx, 4
add rax, rcx
mov rcx, [rax+8]
mov eax, [rbp+var_14]
add eax, 3
mov eax, eax
mov edx, eax
lea rax, [rbp+var_120]
shl rdx, 4
add rax, rdx
mov [rax+8], rcx
mov eax, [rbp+var_14]
mov ecx, eax
lea rax, [rbp+var_70]
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
add eax, [rbp+var_A4]
mov [rbp+var_A4], eax
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_9B334
loc_9B3CD:
mov r8d, [rbp+var_A4]
lea rax, [rbp+var_120]
lea rdi, [rbp+var_A0]
mov esi, 1Dh
lea rdx, dummy_transaction_object
xor ecx, ecx
mov r9d, 7
mov [rsp+160h+var_160], rax
mov [rsp+160h+var_158], 0
mov [rsp+160h+var_150], 0
call translog_write_record
movsx ecx, al
mov al, 1
cmp ecx, 0
mov [rbp+var_129], al
jnz short loc_9B43C
mov rdi, [rbp+var_A0]
call translog_flush
movsx eax, al
cmp eax, 0
setnz al
mov [rbp+var_129], al
loc_9B43C:
mov al, [rbp+var_129]
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9B46A
lea rax, aTranslogWriteR; "translog_write_record"
mov [rbp+var_30], rax
jmp loc_9B584
loc_9B46A:
mov al, 0
call translog_lock
mov rdi, [rbp+var_A0]
lea rax, last_logno
mov esi, [rax]
lea rax, max_trid_in_control_file
mov rdx, [rax]
lea rax, recovery_failures
movzx ecx, byte ptr [rax]
call ma_control_file_write_and_force
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_9B4CE
lea rax, aMaControlFileW; "ma_control_file_write"
mov [rbp+var_30], rax
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
mov al, 0
call translog_unlock
jmp loc_9B584
loc_9B4CE:
mov al, 0
call translog_unlock
mov rax, [rbp+var_40]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov eax, [rax]
mov cs:pages_to_flush_before_next_checkpoint, eax
jmp short $+2
loc_9B4EB:
mov rax, [rbp+var_78]
mov [rbp+var_128], rax
mov rax, [rbp+var_128]
cmp rax, [rbp+var_80]
jle short loc_9B50E
mov rax, [rbp+var_80]
mov [rbp+var_128], rax
loc_9B50E:
jmp short $+2
loc_9B510:
jmp short $+2
loc_9B512:
mov rax, [rbp+var_128]
cmp rax, [rbp+var_88]
jle short loc_9B530
mov rax, [rbp+var_88]
mov [rbp+var_128], rax
loc_9B530:
jmp short $+2
loc_9B532:
jmp short $+2
loc_9B534:
mov rax, [rbp+var_128]
cmp rax, [rbp+var_90]
jle short loc_9B552
mov rax, [rbp+var_90]
mov [rbp+var_128], rax
loc_9B552:
jmp short $+2
loc_9B554:
mov rdi, [rbp+var_128]
call translog_purge
cmp al, 0
jz short loc_9B582
mov edi, 0A8h
lea rsi, aAriaEngineS; "Aria engine: %s"
xor eax, eax
mov edx, eax
lea rcx, aLogPurgingFail; "log purging failed"
mov al, 0
call my_printf_error
loc_9B582:
jmp short loc_9B5E4
loc_9B584:
mov [rbp+var_18], 1
mov rax, [rbp+var_30]
mov [rbp+var_138], rax
cmp [rbp+var_1C], 0
jz short loc_9B5A7
mov eax, [rbp+var_1C]
mov [rbp+var_13C], eax
jmp short loc_9B5B4
loc_9B5A7:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_13C], eax
loc_9B5B4:
mov rcx, [rbp+var_138]
mov r8d, [rbp+var_13C]
mov edi, 0A8h
lea rsi, aAriaEngineChec; "Aria engine: checkpoint failed at %s wi"...
mov edx, 40h ; '@'
mov al, 0
call my_printf_error
mov cs:pages_to_flush_before_next_checkpoint, 0
loc_9B5E4:
mov [rbp+var_14], 0
loc_9B5EB:
mov eax, [rbp+var_14]
cmp rax, 4
jnb short loc_9B617
mov eax, [rbp+var_14]
mov ecx, eax
lea rax, [rbp+var_70]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
call my_free
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_9B5EB
loc_9B617:
lea rdi, LOCK_checkpoint
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 13Bh
call inline_mysql_mutex_lock_13
mov cs:checkpoint_in_progress, 0
mov eax, cs:checkpoints_total
add eax, 1
mov cs:checkpoints_total, eax
cmp [rbp+var_18], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
add eax, cs:checkpoints_ok_total
mov cs:checkpoints_ok_total, eax
lea rdi, LOCK_checkpoint
call inline_mysql_mutex_unlock_14
mov eax, [rbp+var_18]
mov [rbp+var_140], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_9B698
mov eax, [rbp+var_140]
add rsp, 160h
pop rbp
retn
loc_9B698:
call ___stack_chk_fail
|
long long really_execute_checkpoint()
{
long long *v0; // rdi
long long v1; // rsi
int v2; // r9d
int v3; // r8d
int v4; // r9d
int v5; // r9d
int v7; // [rsp+24h] [rbp-13Ch]
int v8; // [rsp+28h] [rbp-138h]
bool v9; // [rsp+37h] [rbp-129h]
long long v10; // [rsp+38h] [rbp-128h]
_QWORD v11[4]; // [rsp+40h] [rbp-120h] BYREF
__int16 *v12; // [rsp+60h] [rbp-100h]
long long v13; // [rsp+68h] [rbp-F8h]
int v14; // [rsp+BCh] [rbp-A4h]
long long v15[2]; // [rsp+C0h] [rbp-A0h] BYREF
long long horizon; // [rsp+D0h] [rbp-90h]
long long v17; // [rsp+D8h] [rbp-88h] BYREF
long long v18; // [rsp+E0h] [rbp-80h] BYREF
long long v19; // [rsp+E8h] [rbp-78h] BYREF
long long v20[2]; // [rsp+F0h] [rbp-70h] BYREF
_BYTE v21[16]; // [rsp+100h] [rbp-60h] BYREF
_BYTE v22[16]; // [rsp+110h] [rbp-50h] BYREF
long long v23[2]; // [rsp+120h] [rbp-40h] BYREF
const char *v24; // [rsp+130h] [rbp-30h]
long long v25; // [rsp+138h] [rbp-28h]
int v26; // [rsp+144h] [rbp-1Ch]
unsigned int v27; // [rsp+148h] [rbp-18h]
unsigned int i; // [rsp+14Ch] [rbp-14h]
__int16 v29; // [rsp+151h] [rbp-Fh] BYREF
char v30; // [rsp+153h] [rbp-Dh]
int v31; // [rsp+154h] [rbp-Ch] BYREF
unsigned long long v32; // [rsp+158h] [rbp-8h]
v32 = __readfsqword(0x28u);
v27 = 0;
v26 = 0;
v24 = 0LL;
memset(v20, 0LL, 64LL);
horizon = translog_get_horizon();
v29 = WORD2(horizon);
v30 = BYTE6(horizon);
v15[1] = (long long)&v31;
v31 = horizon;
v0 = v20;
v1 = (long long)v21;
if ( trnman_collect_transactions(v20, (long long)v21, &v18, &v17) )
{
v24 = "trnman_collect_transaction";
LABEL_25:
v27 = 1;
v8 = (int)v24;
if ( v26 )
{
my_printf_error(168, (unsigned int)"Aria engine: checkpoint failed at %s with error %d", 64, (_DWORD)v24, v26, v2);
}
else
{
v7 = *(_DWORD *)my_thread_var(v0, (const char *)v1);
my_printf_error(168, (unsigned int)"Aria engine: checkpoint failed at %s with error %d", 64, v8, v7, v5);
}
pages_to_flush_before_next_checkpoint = 0;
goto LABEL_29;
}
v0 = (long long *)v22;
v1 = horizon;
if ( (unsigned int)collect_tables(v22, horizon) )
{
v24 = "collect_tables";
goto LABEL_25;
}
v0 = (long long *)maria_pagecache;
v1 = (long long)v23;
if ( pagecache_collect_changed_blocks_with_lsn((long long)maria_pagecache, v23, &v19) )
{
v24 = "collect_pages";
goto LABEL_25;
}
v12 = &v29;
v14 = 7;
v13 = 7LL;
for ( i = 0; i < 4uLL; ++i )
{
v11[2 * i + 6] = v20[2 * i];
v11[2 * i + 7] = v20[2 * i + 1];
v14 += v20[2 * i + 1];
}
v0 = v15;
v1 = 29LL;
v9 = 1;
if ( !translog_write_record((long long)v15, 0x1Du, (long long)dummy_transaction_object, 0LL, v14, 7u, v11, 0LL, 0LL) )
{
v0 = (long long *)v15[0];
v9 = translog_flush(v15[0]) != 0;
}
if ( v9 )
{
v24 = "translog_write_record";
goto LABEL_25;
}
translog_lock();
v0 = (long long *)v15[0];
v1 = (unsigned int)last_logno;
if ( (unsigned int)ma_control_file_write_and_force(v15[0], last_logno, max_trid_in_control_file, recovery_failures) )
{
v24 = "ma_control_file_write";
v26 = *(_DWORD *)my_thread_var(v0, (const char *)v1);
translog_unlock();
goto LABEL_25;
}
translog_unlock();
v25 = v23[0];
pages_to_flush_before_next_checkpoint = *(_DWORD *)v23[0];
v10 = v19;
if ( v19 > v18 )
v10 = v18;
if ( v10 > v17 )
v10 = v17;
if ( v10 > horizon )
v10 = horizon;
if ( translog_purge(v10) )
my_printf_error(168, (unsigned int)"Aria engine: %s", 0, (unsigned int)"log purging failed", v3, v4);
LABEL_29:
for ( i = 0; i < 4uLL; ++i )
my_free(v20[2 * i]);
inline_mysql_mutex_lock_13(
(long long)&LOCK_checkpoint,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_checkpoint.c",
0x13Bu);
checkpoint_in_progress = 0;
++checkpoints_total;
checkpoints_ok_total += v27 == 0;
inline_mysql_mutex_unlock_14((long long)&LOCK_checkpoint);
return v27;
}
|
really_execute_checkpoint:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
MOV qword ptr [RBP + -0x30],0x0
JMP 0x0019b1d0
LAB_0019b1d0:
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0012a2b0
MOV AL,0x0
CALL 0x0018c810
MOV qword ptr [RBP + -0x90],RAX
JMP 0x0019b1f0
LAB_0019b1f0:
JMP 0x0019b1f2
LAB_0019b1f2:
JMP 0x0019b1f4
LAB_0019b1f4:
MOV RAX,qword ptr [RBP + -0x90]
SAR RAX,0x20
MOV byte ptr [RBP + -0xf],AL
MOV RAX,qword ptr [RBP + -0x90]
SAR RAX,0x20
SHR EAX,0x8
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0x90]
SAR RAX,0x20
SHR EAX,0x10
MOV byte ptr [RBP + -0xd],AL
JMP 0x0019b226
LAB_0019b226:
LEA RAX,[RBP + -0xf]
ADD RAX,0x3
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x90]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x98]
MOV dword ptr [RAX],ECX
JMP 0x0019b253
LAB_0019b253:
LEA RDI,[RBP + -0x70]
LEA RSI,[RBP + -0x70]
ADD RSI,0x10
LEA RDX,[RBP + -0x80]
LEA RCX,[RBP + -0x88]
CALL 0x00175900
MOVSX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019b295
LEA RAX,[0x25bb4c]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0019b584
LAB_0019b295:
LEA RDI,[RBP + -0x70]
ADD RDI,0x20
MOV RSI,qword ptr [RBP + -0x90]
CALL 0x0019bc00
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019b2cc
LEA RAX,[0x25bb67]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0019b584
LAB_0019b2cc:
LEA RAX,[0x3c84e0]
MOV RDI,qword ptr [RAX]
LEA RSI,[RBP + -0x70]
ADD RSI,0x30
LEA RDX,[RBP + -0x78]
CALL 0x001994b0
MOVSX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019b30d
LEA RAX,[0x25bb76]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0019b584
LAB_0019b30d:
LEA RAX,[RBP + -0xf]
MOV qword ptr [RBP + -0x100],RAX
MOV dword ptr [RBP + -0xa4],0x7
MOV qword ptr [RBP + -0xf8],0x7
MOV dword ptr [RBP + -0x14],0x0
LAB_0019b334:
MOV EAX,dword ptr [RBP + -0x14]
CMP RAX,0x4
JNC 0x0019b3cd
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
LEA RAX,[RBP + -0x70]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x3
MOV EAX,EAX
MOV EDX,EAX
LEA RAX,[RBP + -0x120]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
LEA RAX,[RBP + -0x70]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x3
MOV EAX,EAX
MOV EDX,EAX
LEA RAX,[RBP + -0x120]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
LEA RAX,[RBP + -0x70]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
ADD EAX,dword ptr [RBP + -0xa4]
MOV dword ptr [RBP + -0xa4],EAX
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0019b334
LAB_0019b3cd:
MOV R8D,dword ptr [RBP + -0xa4]
LEA RAX,[RBP + -0x120]
LEA RDI,[RBP + -0xa0]
MOV ESI,0x1d
LEA RDX,[0x582cb0]
XOR ECX,ECX
MOV R9D,0x7
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
CALL 0x0018bc40
MOVSX ECX,AL
MOV AL,0x1
CMP ECX,0x0
MOV byte ptr [RBP + -0x129],AL
JNZ 0x0019b43c
MOV RDI,qword ptr [RBP + -0xa0]
CALL 0x0018e450
MOVSX EAX,AL
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x129],AL
LAB_0019b43c:
MOV AL,byte ptr [RBP + -0x129]
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019b46a
LEA RAX,[0x25bb84]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0019b584
LAB_0019b46a:
MOV AL,0x0
CALL 0x00187d40
MOV RDI,qword ptr [RBP + -0xa0]
LEA RAX,[0x583240]
MOV ESI,dword ptr [RAX]
LEA RAX,[0x583248]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x583250]
MOVZX ECX,byte ptr [RAX]
CALL 0x00186490
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0019b4ce
LEA RAX,[0x25bb9a]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001fc990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
MOV AL,0x0
CALL 0x00187e30
JMP 0x0019b584
LAB_0019b4ce:
MOV AL,0x0
CALL 0x00187e30
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [0x00d85600],EAX
JMP 0x0019b4eb
LAB_0019b4eb:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x128],RAX
MOV RAX,qword ptr [RBP + -0x128]
CMP RAX,qword ptr [RBP + -0x80]
JLE 0x0019b50e
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x128],RAX
LAB_0019b50e:
JMP 0x0019b510
LAB_0019b510:
JMP 0x0019b512
LAB_0019b512:
MOV RAX,qword ptr [RBP + -0x128]
CMP RAX,qword ptr [RBP + -0x88]
JLE 0x0019b530
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x128],RAX
LAB_0019b530:
JMP 0x0019b532
LAB_0019b532:
JMP 0x0019b534
LAB_0019b534:
MOV RAX,qword ptr [RBP + -0x128]
CMP RAX,qword ptr [RBP + -0x90]
JLE 0x0019b552
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x128],RAX
LAB_0019b552:
JMP 0x0019b554
LAB_0019b554:
MOV RDI,qword ptr [RBP + -0x128]
CALL 0x0018f1d0
CMP AL,0x0
JZ 0x0019b582
MOV EDI,0xa8
LEA RSI,[0x25ae81]
XOR EAX,EAX
MOV EDX,EAX
LEA RCX,[0x25bbb0]
MOV AL,0x0
CALL 0x001f2c30
LAB_0019b582:
JMP 0x0019b5e4
LAB_0019b584:
MOV dword ptr [RBP + -0x18],0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0019b5a7
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x13c],EAX
JMP 0x0019b5b4
LAB_0019b5a7:
CALL 0x001fc990
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x13c],EAX
LAB_0019b5b4:
MOV RCX,qword ptr [RBP + -0x138]
MOV R8D,dword ptr [RBP + -0x13c]
MOV EDI,0xa8
LEA RSI,[0x25bbc3]
MOV EDX,0x40
MOV AL,0x0
CALL 0x001f2c30
MOV dword ptr [0x00d85600],0x0
LAB_0019b5e4:
MOV dword ptr [RBP + -0x14],0x0
LAB_0019b5eb:
MOV EAX,dword ptr [RBP + -0x14]
CMP RAX,0x4
JNC 0x0019b617
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
LEA RAX,[RBP + -0x70]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
CALL 0x001fa370
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0019b5eb
LAB_0019b617:
LEA RDI,[0xd85568]
LEA RSI,[0x25bac0]
MOV EDX,0x13b
CALL 0x0019b060
MOV dword ptr [0x00d855b0],0x0
MOV EAX,dword ptr [0x00d85618]
ADD EAX,0x1
MOV dword ptr [0x00d85618],EAX
CMP dword ptr [RBP + -0x18],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
ADD EAX,dword ptr [0x00d8561c]
MOV dword ptr [0x00d8561c],EAX
LEA RDI,[0xd85568]
CALL 0x0019b0d0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x140],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0019b698
MOV EAX,dword ptr [RBP + -0x140]
ADD RSP,0x160
POP RBP
RET
LAB_0019b698:
CALL 0x0012a260
|
int really_execute_checkpoint(void)
{
char *pcVar1;
char cVar2;
int iVar3;
int *piVar4;
long in_FS_OFFSET;
bool bVar5;
int local_144;
long local_130;
int1 *local_128 [4];
int1 *local_108;
int8 local_100;
int1 *apuStack_f8 [9];
int local_ac;
int8 local_a8;
int4 *local_a0;
long local_98;
long local_90;
long local_88;
long local_80;
int8 local_78 [2];
int1 auStack_68 [16];
int1 auStack_58 [16];
int4 *local_48 [2];
char *local_38;
int4 *local_30;
int local_24;
int local_20;
uint local_1c;
int1 local_17;
int1 local_16;
int1 local_15;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = 0;
local_24 = 0;
local_38 = (char *)0x0;
memset(local_78,0,0x40);
local_98 = translog_get_horizon();
local_17 = (int1)((ulong)local_98 >> 0x20);
local_16 = (int1)((ulong)local_98 >> 0x28);
local_15 = (int1)((ulong)local_98 >> 0x30);
local_a0 = &local_14;
local_14 = (int4)local_98;
cVar2 = trnman_collect_transactions(local_78,auStack_68,&local_88,&local_90);
if (cVar2 == '\0') {
iVar3 = collect_tables(auStack_58,local_98);
if (iVar3 == 0) {
cVar2 = pagecache_collect_changed_blocks_with_lsn(maria_pagecache,local_48,&local_80);
if (cVar2 == '\0') {
local_108 = &local_17;
local_ac = 7;
local_100 = 7;
for (local_1c = 0; local_1c < 4; local_1c = local_1c + 1) {
local_128[(ulong)(local_1c + 3) * 2] = (int1 *)local_78[(ulong)local_1c * 2];
local_128[(ulong)(local_1c + 3) * 2 + 1] =
*(int1 **)(auStack_68 + (ulong)local_1c * 0x10 + -8);
local_ac = (int)*(int8 *)(auStack_68 + (ulong)local_1c * 0x10 + -8) + local_ac;
}
cVar2 = translog_write_record
(&local_a8,0x1d,dummy_transaction_object,0,local_ac,7,local_128,0,0);
bVar5 = true;
if (cVar2 == '\0') {
cVar2 = translog_flush(local_a8);
bVar5 = cVar2 != '\0';
}
if (bVar5) {
local_38 = "translog_write_record";
}
else {
translog_lock();
iVar3 = ma_control_file_write_and_force
(local_a8,last_logno,max_trid_in_control_file,recovery_failures);
if (iVar3 == 0) {
translog_unlock();
local_30 = local_48[0];
pages_to_flush_before_next_checkpoint = *local_48[0];
local_130 = local_80;
if (local_88 < local_80) {
local_130 = local_88;
}
if (local_90 < local_130) {
local_130 = local_90;
}
if (local_98 < local_130) {
local_130 = local_98;
}
cVar2 = translog_purge(local_130);
if (cVar2 != '\0') {
my_printf_error(0xa8,"Aria engine: %s",0,"log purging failed");
}
goto LAB_0019b5e4;
}
local_38 = "ma_control_file_write";
piVar4 = (int *)_my_thread_var();
local_24 = *piVar4;
translog_unlock();
}
}
else {
local_38 = "collect_pages";
}
}
else {
local_38 = "collect_tables";
}
}
else {
local_38 = "trnman_collect_transaction";
}
pcVar1 = local_38;
local_20 = 1;
if (local_24 == 0) {
piVar4 = (int *)_my_thread_var();
local_144 = *piVar4;
}
else {
local_144 = local_24;
}
my_printf_error(0xa8,"Aria engine: checkpoint failed at %s with error %d",0x40,pcVar1,local_144);
pages_to_flush_before_next_checkpoint = 0;
LAB_0019b5e4:
for (local_1c = 0; local_1c < 4; local_1c = local_1c + 1) {
my_free(local_78[(ulong)local_1c * 2]);
}
inline_mysql_mutex_lock
(LOCK_checkpoint,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_checkpoint.c",0x13b);
checkpoint_in_progress = 0;
checkpoints_total = checkpoints_total + 1;
checkpoints_ok_total = (uint)((local_20 != 0 ^ 0xffU) & 1) + checkpoints_ok_total;
inline_mysql_mutex_unlock(LOCK_checkpoint);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_20;
}
|
|
13,729
|
my_hash_init2
|
eloqsql/mysys/hash.c
|
my_bool
my_hash_init2(PSI_memory_key psi_key, HASH *hash, uint growth_size,
CHARSET_INFO *charset, ulong size, size_t key_offset,
size_t key_length, my_hash_get_key get_key,
my_hash_function hash_function,
void (*free_element)(void*), uint flags)
{
my_bool res;
DBUG_ENTER("my_hash_init2");
DBUG_PRINT("enter",("hash:%p size: %u", hash, (uint) size));
hash->records=0;
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->get_key=get_key;
hash->hash_function= hash_function ? hash_function : my_hash_sort;
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
res= init_dynamic_array2(psi_key, &hash->array, sizeof(HASH_LINK), NULL, size,
growth_size, MYF((flags & HASH_THREAD_SPECIFIC ?
MY_THREAD_SPECIFIC : 0)));
DBUG_RETURN(res);
}
|
O0
|
c
|
my_hash_init2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x62223
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x10(%rax)
movq 0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpq $0x0, 0x20(%rbp)
je 0x6226f
movq 0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x6227c
leaq -0x126(%rip), %rax # 0x62150
movq %rax, -0x40(%rbp)
jmp 0x6227c
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movl 0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rax
movl %eax, %r8d
movl -0x14(%rbp), %r9d
movl 0x30(%rbp), %edx
andl $0x2, %edx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, %eax
movl $0x10, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x57c50
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_hash_init2:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_20]
mov rax, [rbp+arg_18]
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_62223:
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+10h], 1
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_10]
mov [rax+50h], rcx
cmp [rbp+arg_10], 0
jz short loc_6226F
mov rax, [rbp+arg_10]
mov [rbp+var_40], rax
jmp short loc_6227C
loc_6226F:
lea rax, my_hash_sort
mov [rbp+var_40], rax
jmp short $+2
loc_6227C:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+58h], rcx
mov rcx, [rbp+arg_18]
mov rax, [rbp+var_10]
mov [rax+60h], rcx
mov ecx, [rbp+arg_20]
mov rax, [rbp+var_10]
mov [rax+20h], ecx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+68h], rcx
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
add rsi, 28h ; '('
mov rax, [rbp+var_28]
mov r8d, eax
mov r9d, [rbp+var_14]
mov edx, [rbp+arg_20]
and edx, 2
xor eax, eax
mov ecx, 10000h
cmp edx, 0
cmovnz eax, ecx
mov eax, eax
mov edx, 10h
xor ecx, ecx
mov [rsp+50h+var_50], rax
call init_dynamic_array2
mov [rbp+var_31], al
mov al, [rbp+var_31]
mov [rbp+var_41], al
mov al, [rbp+var_41]
add rsp, 50h
pop rbp
retn
|
char my_hash_init2(
unsigned int a1,
long long a2,
int a3,
long long a4,
unsigned int a5,
long long a6,
long long a7,
long long a8,
long long ( *a9)(long long a1, long long a2, long long a3),
long long a10,
int a11)
{
long long v11; // rsi
unsigned int v12; // eax
long long ( *v14)(long long, long long, long long); // [rsp+10h] [rbp-40h]
*(_QWORD *)(a2 + 24) = 0LL;
*(_QWORD *)a2 = a6;
*(_QWORD *)(a2 + 8) = a7;
*(_QWORD *)(a2 + 16) = 1LL;
*(_QWORD *)(a2 + 80) = a8;
if ( a9 )
v14 = a9;
else
v14 = my_hash_sort;
*(_QWORD *)(a2 + 88) = v14;
*(_QWORD *)(a2 + 96) = a10;
*(_DWORD *)(a2 + 32) = a11;
*(_QWORD *)(a2 + 104) = a4;
v11 = a2 + 40;
v12 = 0;
if ( (a11 & 2) != 0 )
v12 = 0x10000;
return init_dynamic_array2(a1, v11, 0x10u, 0LL, a5, a3, v12);
}
|
my_hash_init2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x30]
MOV RAX,qword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x00162223
LAB_00162223:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],0x1
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x50],RCX
CMP qword ptr [RBP + 0x20],0x0
JZ 0x0016226f
MOV RAX,qword ptr [RBP + 0x20]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0016227c
LAB_0016226f:
LEA RAX,[0x162150]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0016227c
LAB_0016227c:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x58],RCX
MOV RCX,qword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],RCX
MOV ECX,dword ptr [RBP + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x20],ECX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],RCX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x28
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + 0x30]
AND EDX,0x2
XOR EAX,EAX
MOV ECX,0x10000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV EAX,EAX
MOV EDX,0x10
XOR ECX,ECX
MOV qword ptr [RSP],RAX
CALL 0x00157c50
MOV byte ptr [RBP + -0x31],AL
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x41],AL
MOV AL,byte ptr [RBP + -0x41]
ADD RSP,0x50
POP RBP
RET
|
int8
my_hash_init2(int4 param_1,int8 *param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6,int8 param_7,int8 param_8,
code *param_9,int8 param_10,uint param_11)
{
int4 uVar1;
int8 uVar2;
code *local_48;
param_2[3] = 0;
*param_2 = param_6;
param_2[1] = param_7;
param_2[2] = 1;
param_2[10] = param_8;
if (param_9 == (code *)0x0) {
local_48 = my_hash_sort;
}
else {
local_48 = param_9;
}
param_2[0xb] = local_48;
param_2[0xc] = param_10;
*(uint *)(param_2 + 4) = param_11;
param_2[0xd] = param_4;
uVar1 = 0;
if ((param_11 & 2) != 0) {
uVar1 = 0x10000;
}
uVar2 = init_dynamic_array2(param_1,param_2 + 5,0x10,0,param_5,param_3,uVar1);
return uVar2;
}
|
|
13,730
|
bitmap_bits_set
|
eloqsql/mysys/my_bitmap.c
|
uint bitmap_bits_set(const MY_BITMAP *map)
{
my_bitmap_map *data_ptr= map->bitmap;
my_bitmap_map *end= map->last_word_ptr;
uint res= 0;
DBUG_ASSERT(map->bitmap);
for (; data_ptr < end; data_ptr++)
res+= my_count_bits_uint32(*data_ptr);
/*Reset last bits to zero*/
res+= my_count_bits_uint32(*map->last_word_ptr & ~map->last_word_mask);
return res;
}
|
O0
|
c
|
bitmap_bits_set:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
jmp 0xeef4c
jmp 0xeef4e
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xeef77
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xeefb0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xeef4e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
xorl $-0x1, %eax
andl %eax, %edi
callq 0xeefb0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
bitmap_bits_set:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
jmp short $+2
loc_EEF4C:
jmp short $+2
loc_EEF4E:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_EEF77
mov rax, [rbp+var_10]
mov edi, [rax]
call my_count_bits_uint32
add eax, [rbp+var_1C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
add rax, 4
mov [rbp+var_10], rax
jmp short loc_EEF4E
loc_EEF77:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov edi, [rax]
mov rax, [rbp+var_8]
mov eax, [rax+18h]
xor eax, 0FFFFFFFFh
and edi, eax
call my_count_bits_uint32
add eax, [rbp+var_1C]
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
add rsp, 20h
pop rbp
retn
|
long long bitmap_bits_set(unsigned int **a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
unsigned long long v3; // [rsp+8h] [rbp-18h]
unsigned int *v4; // [rsp+10h] [rbp-10h]
v4 = *a1;
v3 = (unsigned long long)a1[1];
v2 = 0;
while ( (unsigned long long)v4 < v3 )
v2 += my_count_bits_uint32(*v4++);
return v2 + (unsigned int)my_count_bits_uint32(~*((_DWORD *)a1 + 6) & *a1[1]);
}
|
bitmap_bits_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001eef4c
LAB_001eef4c:
JMP 0x001eef4e
LAB_001eef4e:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x001eef77
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX]
CALL 0x001eefb0
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x4
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001eef4e
LAB_001eef77:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
XOR EAX,0xffffffff
AND EDI,EAX
CALL 0x001eefb0
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSP,0x20
POP RBP
RET
|
int bitmap_bits_set(int8 *param_1)
{
int4 *puVar1;
int iVar2;
int local_24;
int4 *local_18;
local_18 = (int4 *)*param_1;
puVar1 = (int4 *)param_1[1];
local_24 = 0;
for (; local_18 < puVar1; local_18 = local_18 + 1) {
iVar2 = my_count_bits_uint32(*local_18);
local_24 = iVar2 + local_24;
}
iVar2 = my_count_bits_uint32(*(uint *)param_1[1] & (*(uint *)(param_1 + 3) ^ 0xffffffff));
return iVar2 + local_24;
}
|
|
13,731
|
my_mb_wc_utf8mb3_quick
|
eloqsql/strings/ctype-utf8.h
|
static inline int
my_mb_wc_utf8mb3_quick(my_wc_t * pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s+2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s+3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
}
|
O0
|
c
|
my_mb_wc_utf8mb3_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x68796
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x68913
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x687c3
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x68913
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x687da
movl $0x0, -0x4(%rbp)
jmp 0x68913
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x68850
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x687ff
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x68913
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x6881d
movl $0x0, -0x4(%rbp)
jmp 0x68913
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x68913
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x68906
movq -0x18(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jbe 0x68879
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x68913
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x688b7
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x688b7
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x688c0
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x688c0
movl $0x0, -0x4(%rbp)
jmp 0x68913
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x68913
jmp 0x68908
jmp 0x6890a
jmp 0x6890c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
my_mb_wc_utf8mb3_quick_0:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_68796
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_68913
loc_68796:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_687C3
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_68913
loc_687C3:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_687DA
mov [rbp+var_4], 0
jmp loc_68913
loc_687DA:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_68850
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_687FF
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_68913
loc_687FF:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_6881D
mov [rbp+var_4], 0
jmp loc_68913
loc_6881D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_68913
loc_68850:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_68906
mov rax, [rbp+var_18]
add rax, 3
cmp rax, [rbp+var_20]
jbe short loc_68879
mov [rbp+var_4], 0FFFFFF99h
jmp loc_68913
loc_68879:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_688B7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_688B7
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_688C0
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_688C0
loc_688B7:
mov [rbp+var_4], 0
jmp short loc_68913
loc_688C0:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 3
jmp short loc_68913
loc_68906:
jmp short $+2
loc_68908:
jmp short $+2
loc_6890A:
jmp short $+2
loc_6890C:
mov [rbp+var_4], 0
loc_68913:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_utf8mb3_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 3) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 && (a2[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a2[1] >= 0xA0u) )
{
*a1 = a2[2] ^ 0x80u | ((long long)(a2[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 )
{
*a1 = a2[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a1 = v4;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_mb_wc_utf8mb3_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x00168796
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00168913
LAB_00168796:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x001687c3
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00168913
LAB_001687c3:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x001687da
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00168913
LAB_001687da:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x00168850
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001687ff
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00168913
LAB_001687ff:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0016881d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00168913
LAB_0016881d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00168913
LAB_00168850:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x00168906
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x00168879
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x00168913
LAB_00168879:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001688b7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x001688b7
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x001688c0
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x001688c0
LAB_001688b7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00168913
LAB_001688c0:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x00168913
LAB_00168906:
JMP 0x00168908
LAB_00168908:
JMP 0x0016890a
LAB_0016890a:
JMP 0x0016890c
LAB_0016890c:
MOV dword ptr [RBP + -0x4],0x0
LAB_00168913:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb3_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
if (param_2 < param_3) {
bVar1 = *param_2;
if (bVar1 < 0x80) {
*param_1 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2[1] ^ 0x80) < 0x40) {
*param_1 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_2[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
local_c = 0xffffff99;
}
else if ((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_2[1])))) {
*param_1 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_2[1] ^ 0x80) << 6 |
(long)(int)(param_2[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
13,732
|
linenoiseEditFeed
|
ericcurtin[P]linenoise/linenoise.cpp
|
const char * linenoiseEditFeed(struct linenoiseState * l) {
/* Not a TTY, pass control to line reading without character count
* limits. */
if (!isatty(l->ifd)) {
return linenoiseNoTTY();
}
int c;
int nread;
char cbuf[32];
nread = readCode(l->ifd, cbuf, sizeof(cbuf), &c);
if (nread <= 0) {
return NULL;
}
auto esc_type = ESC_NULL;
if (c == ESC) {
esc_type = readEscapeSequence(l);
}
/* Only autocomplete when the callback is set. It returns < 0 when
* there was an error reading from fd. Otherwise it will return the
* character that should be handled next. */
if ((l->in_completion || c == 9) && completionCallback != NULL) {
c = completeLine(l, c, esc_type);
/* Read next character when 0 */
if (c == 0) {
return linenoiseEditMore;
}
}
return processInputCharacter(l, c, cbuf, nread, esc_type);
}
|
O0
|
cpp
|
linenoiseEditFeed:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x23d0
cmpl $0x0, %eax
jne 0x403b
callq 0x40f0
movq %rax, -0x8(%rbp)
jmp 0x40df
movq 0xc226(%rip), %rax # 0x10268
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %edi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
leaq -0x14(%rbp), %rcx
callq *%rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x406b
movq $0x0, -0x8(%rbp)
jmp 0x40df
movl $0x0, -0x44(%rbp)
cmpl $0x1b, -0x14(%rbp)
jne 0x4084
movq -0x10(%rbp), %rdi
callq 0x41f0
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4093
cmpl $0x9, -0x14(%rbp)
jne 0x40c4
cmpq $0x0, 0xc20d(%rip) # 0x102a8
je 0x40c4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x44(%rbp), %edx
callq 0x43a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x40c2
movq 0xc1b4(%rip), %rax # 0x10270
movq %rax, -0x8(%rbp)
jmp 0x40df
jmp 0x40c4
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdx
movl -0x18(%rbp), %ecx
movl -0x44(%rbp), %r8d
callq 0x4580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
linenoiseEditFeed:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov edi, [rax+10h]
call _isatty
cmp eax, 0
jnz short loc_403B
call _ZL14linenoiseNoTTYv; linenoiseNoTTY(void)
mov [rbp+var_8], rax
jmp loc_40DF
loc_403B:
mov rax, cs:_ZL8readCode; readCode
mov rcx, [rbp+var_10]
mov edi, [rcx+10h]; int
lea rsi, [rbp+var_40]; char *
mov edx, 20h ; ' '; unsigned __int64
lea rcx, [rbp+var_14]; int *
call rax ; defaultReadCode(int,char *,ulong,int *); defaultReadCode(int,char *,ulong,int *)
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jg short loc_406B
mov [rbp+var_8], 0
jmp short loc_40DF
loc_406B:
mov [rbp+var_44], 0
cmp [rbp+var_14], 1Bh
jnz short loc_4084
mov rdi, [rbp+var_10]
call _ZL18readEscapeSequenceP14linenoiseState; readEscapeSequence(linenoiseState *)
mov [rbp+var_44], eax
loc_4084:
mov rax, [rbp+var_10]
cmp dword ptr [rax], 0
jnz short loc_4093
cmp [rbp+var_14], 9
jnz short loc_40C4
loc_4093:
cmp cs:_ZL18completionCallback, 0; completionCallback
jz short loc_40C4
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, [rbp+var_44]
call _ZL12completeLineP14linenoiseStatei8ESC_TYPE; completeLine(linenoiseState *,int,ESC_TYPE)
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jnz short loc_40C2
mov rax, cs:linenoiseEditMore
mov [rbp+var_8], rax
jmp short loc_40DF
loc_40C2:
jmp short $+2
loc_40C4:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
lea rdx, [rbp+var_40]
mov ecx, [rbp+var_18]
mov r8d, [rbp+var_44]
call _ZL21processInputCharacterP14linenoiseStateiPcii; processInputCharacter(linenoiseState *,int,char *,int,int)
mov [rbp+var_8], rax
loc_40DF:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
|
char * linenoiseEditFeed(_DWORD *a1)
{
unsigned int EscapeSequence; // [rsp+Ch] [rbp-44h]
char v3[40]; // [rsp+10h] [rbp-40h] BYREF
int v4; // [rsp+38h] [rbp-18h]
int v5; // [rsp+3Ch] [rbp-14h] BYREF
_DWORD *v6; // [rsp+40h] [rbp-10h]
v6 = a1;
if ( !(unsigned int)isatty((unsigned int)a1[4]) )
return (char *)linenoiseNoTTY();
v4 = readCode(v6[4], v3, 0x20uLL, &v5);
if ( v4 <= 0 )
return 0LL;
EscapeSequence = 0;
if ( v5 == 27 )
EscapeSequence = readEscapeSequence(v6);
if ( (*v6 || v5 == 9) && completionCallback && (v5 = completeLine(v6, (unsigned int)v5, EscapeSequence)) == 0 )
return linenoiseEditMore;
else
return (char *)processInputCharacter(v6, (unsigned int)v5, v3, (unsigned int)v4, EscapeSequence);
}
|
linenoiseEditFeed:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x10]
CALL 0x001023d0
CMP EAX,0x0
JNZ 0x0010403b
CALL 0x001040f0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001040df
LAB_0010403b:
MOV RAX,qword ptr [0x00110268]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RCX + 0x10]
LEA RSI,[RBP + -0x40]
MOV EDX,0x20
LEA RCX,[RBP + -0x14]
CALL RAX
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JG 0x0010406b
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001040df
LAB_0010406b:
MOV dword ptr [RBP + -0x44],0x0
CMP dword ptr [RBP + -0x14],0x1b
JNZ 0x00104084
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001041f0
MOV dword ptr [RBP + -0x44],EAX
LAB_00104084:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX],0x0
JNZ 0x00104093
CMP dword ptr [RBP + -0x14],0x9
JNZ 0x001040c4
LAB_00104093:
CMP qword ptr [0x001102a8],0x0
JZ 0x001040c4
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x44]
CALL 0x001043a0
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001040c2
MOV RAX,qword ptr [0x00110270]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001040df
LAB_001040c2:
JMP 0x001040c4
LAB_001040c4:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
LEA RDX,[RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x18]
MOV R8D,dword ptr [RBP + -0x44]
CALL 0x00104580
MOV qword ptr [RBP + -0x8],RAX
LAB_001040df:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
int * linenoiseEditFeed(linenoiseState *param_1)
{
int iVar1;
int local_4c;
char local_48 [40];
int local_20;
int local_1c;
linenoiseState *local_18;
int *local_10;
local_18 = param_1;
iVar1 = isatty(*(int *)(param_1 + 0x10));
if (iVar1 == 0) {
local_10 = (int *)linenoiseNoTTY();
}
else {
local_20 = (*(code *)readCode)(*(int4 *)(local_18 + 0x10),local_48,0x20,&local_1c);
if (local_20 < 1) {
local_10 = (int *)0x0;
}
else {
local_4c = 0;
if (local_1c == 0x1b) {
local_4c = readEscapeSequence(local_18);
}
if ((((*(int *)local_18 == 0) && (local_1c != 9)) || (completionCallback == 0)) ||
(local_1c = completeLine(local_18,local_1c,local_4c), local_1c != 0)) {
local_10 = (int *)processInputCharacter(local_18,local_1c,local_48,local_20,local_4c);
}
else {
local_10 = linenoiseEditMore;
}
}
}
return local_10;
}
|
|
13,733
|
ftxui::TerminalInputParser::ParseCSI()
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/terminal_input_parser.cpp
|
TerminalInputParser::Output TerminalInputParser::ParseCSI() {
bool altered = false;
int argument = 0;
std::vector<int> arguments;
while (true) {
if (!Eat()) {
return UNCOMPLETED;
}
if (Current() == '<') {
altered = true;
continue;
}
if (Current() >= '0' && Current() <= '9') {
argument *= 10; // NOLINT
argument += Current() - '0';
continue;
}
if (Current() == ';') {
arguments.push_back(argument);
argument = 0;
continue;
}
// CSI is terminated by a character in the range 0x40–0x7E
// (ASCII @A–Z[\]^_`a–z{|}~),
if (Current() >= '@' && Current() <= '~' &&
// Note: I don't remember why we exclude '<'
Current() != '<' &&
// To handle F1-F4, we exclude '['.
Current() != '[') {
arguments.push_back(argument);
argument = 0; // NOLINT
switch (Current()) {
case 'M':
return ParseMouse(altered, true, std::move(arguments));
case 'm':
return ParseMouse(altered, false, std::move(arguments));
case 'R':
return ParseCursorReporting(std::move(arguments));
default:
return SPECIAL;
}
}
// Invalid ESC in CSI.
if (Current() == '\x1B') {
return SPECIAL;
}
}
}
|
O0
|
cpp
|
ftxui::TerminalInputParser::ParseCSI():
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2d860
jmp 0x72e4e
movq -0x88(%rbp), %rdi
callq 0x72ab0
testb $0x1, %al
jne 0x72e8b
movq -0x98(%rbp), %rdi
xorl %esi, %esi
callq 0x73b90
jmp 0x72e6e
movl $0x1, -0x38(%rbp)
jmp 0x73207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x73220
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x99(%rbp)
jmp 0x72e9f
movb -0x99(%rbp), %al
movzbl %al, %eax
cmpl $0x3c, %eax
jne 0x72eb3
movb $0x1, -0x9(%rbp)
jmp 0x72e4c
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x9a(%rbp)
jmp 0x72ec7
movb -0x9a(%rbp), %al
movzbl %al, %eax
cmpl $0x30, %eax
jl 0x72f2f
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x9b(%rbp)
jmp 0x72ee9
movb -0x9b(%rbp), %al
movzbl %al, %eax
cmpl $0x39, %eax
jg 0x72f2f
movq -0x88(%rbp), %rdi
movl -0x10(%rbp), %ecx
addl %ecx, %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %eax
movl %eax, -0x10(%rbp)
callq 0x72a80
movb %al, -0x9c(%rbp)
jmp 0x72f18
movb -0x9c(%rbp), %al
movzbl %al, %eax
subl $0x30, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x72e4c
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x9d(%rbp)
jmp 0x72f43
movb -0x9d(%rbp), %al
movzbl %al, %eax
cmpl $0x3b, %eax
jne 0x72f6c
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2d880
jmp 0x72f60
movl $0x0, -0x10(%rbp)
jmp 0x72e4c
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x9e(%rbp)
jmp 0x72f80
movb -0x9e(%rbp), %al
movzbl %al, %eax
cmpl $0x40, %eax
jl 0x731c4
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0x9f(%rbp)
jmp 0x72fa6
movb -0x9f(%rbp), %al
movzbl %al, %eax
cmpl $0x7e, %eax
jg 0x731c4
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0xa0(%rbp)
jmp 0x72fcc
movb -0xa0(%rbp), %al
movzbl %al, %eax
cmpl $0x3c, %eax
je 0x731c4
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0xa1(%rbp)
jmp 0x72ff2
movb -0xa1(%rbp), %al
movzbl %al, %eax
cmpl $0x5b, %eax
je 0x731c4
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2d880
jmp 0x73013
movq -0x88(%rbp), %rdi
movl $0x0, -0x10(%rbp)
callq 0x72a80
movb %al, -0xa2(%rbp)
jmp 0x7302e
movb -0xa2(%rbp), %al
movzbl %al, %ecx
movl %ecx, -0xa8(%rbp)
subb $0x4d, %al
je 0x73064
jmp 0x73043
movl -0xa8(%rbp), %eax
subl $0x52, %eax
je 0x7314f
jmp 0x73054
movl -0xa8(%rbp), %eax
subl $0x6d, %eax
je 0x730db
jmp 0x731a8
movzbl -0x9(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x73c10
movl -0xb4(%rbp), %edx
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0xb0(%rbp), %r8
andl $0x1, %edx
movl $0x1, %ecx
callq 0x732d0
jmp 0x730ac
leaq -0x50(%rbp), %rdi
callq 0x2d4b0
movl $0x1, -0x38(%rbp)
jmp 0x73207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2d4b0
jmp 0x73220
movzbl -0x9(%rbp), %eax
movl %eax, -0xc4(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x73c10
movl -0xc4(%rbp), %edx
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0xc0(%rbp), %r8
andl $0x1, %edx
xorl %ecx, %ecx
callq 0x732d0
jmp 0x73120
leaq -0x68(%rbp), %rdi
callq 0x2d4b0
movl $0x1, -0x38(%rbp)
jmp 0x73207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2d4b0
jmp 0x73220
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x73c10
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0xd0(%rbp), %rdx
callq 0x73400
jmp 0x7317f
leaq -0x80(%rbp), %rdi
callq 0x2d4b0
movl $0x1, -0x38(%rbp)
jmp 0x73207
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2d4b0
jmp 0x73220
movq -0x98(%rbp), %rdi
movl $0x3, %esi
callq 0x73b90
jmp 0x731bb
movl $0x1, -0x38(%rbp)
jmp 0x73207
movq -0x88(%rbp), %rdi
callq 0x72a80
movb %al, -0xd1(%rbp)
jmp 0x731d8
movb -0xd1(%rbp), %al
movzbl %al, %eax
cmpl $0x1b, %eax
jne 0x73202
movq -0x98(%rbp), %rdi
movl $0x3, %esi
callq 0x73b90
jmp 0x731f9
movl $0x1, -0x38(%rbp)
jmp 0x73207
jmp 0x72e4c
leaq -0x28(%rbp), %rdi
callq 0x2d4b0
movq -0x90(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x2d4b0
movq -0x30(%rbp), %rdi
callq 0xda90
nopw %cs:(%rax,%rax)
|
_ZN5ftxui19TerminalInputParser8ParseCSIEv:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov [rbp+var_98], rdi
mov [rbp+var_90], rdi
mov [rbp+var_8], rsi
mov rax, [rbp+var_8]
mov [rbp+var_88], rax
mov [rbp+var_9], 0
mov [rbp+var_10], 0
lea rdi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
loc_72E4C:
jmp short $+2
loc_72E4E:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser3EatEv; ftxui::TerminalInputParser::Eat(void)
test al, 1
jnz short loc_72E8B
mov rdi, [rbp+var_98]
xor esi, esi
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp short $+2
loc_72E6E:
mov [rbp+var_38], 1
jmp loc_73207
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
jmp loc_73220
loc_72E8B:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_99], al
jmp short $+2
loc_72E9F:
mov al, [rbp+var_99]
movzx eax, al
cmp eax, 3Ch ; '<'
jnz short loc_72EB3
mov [rbp+var_9], 1
jmp short loc_72E4C
loc_72EB3:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9A], al
jmp short $+2
loc_72EC7:
mov al, [rbp+var_9A]
movzx eax, al
cmp eax, 30h ; '0'
jl short loc_72F2F
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9B], al
jmp short $+2
loc_72EE9:
mov al, [rbp+var_9B]
movzx eax, al
cmp eax, 39h ; '9'
jg short loc_72F2F
mov rdi, [rbp+var_88]; this
mov ecx, [rbp+var_10]
add ecx, ecx
mov eax, ecx
lea eax, [rax+rax*4]
mov [rbp+var_10], eax
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9C], al
jmp short $+2
loc_72F18:
mov al, [rbp+var_9C]
movzx eax, al
sub eax, 30h ; '0'
add eax, [rbp+var_10]
mov [rbp+var_10], eax
jmp loc_72E4C
loc_72F2F:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9D], al
jmp short $+2
loc_72F43:
mov al, [rbp+var_9D]
movzx eax, al
cmp eax, 3Bh ; ';'
jnz short loc_72F6C
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_10]
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
jmp short $+2
loc_72F60:
mov [rbp+var_10], 0
jmp loc_72E4C
loc_72F6C:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9E], al
jmp short $+2
loc_72F80:
mov al, [rbp+var_9E]
movzx eax, al
cmp eax, 40h ; '@'
jl loc_731C4
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_9F], al
jmp short $+2
loc_72FA6:
mov al, [rbp+var_9F]
movzx eax, al
cmp eax, 7Eh ; '~'
jg loc_731C4
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_A0], al
jmp short $+2
loc_72FCC:
mov al, [rbp+var_A0]
movzx eax, al
cmp eax, 3Ch ; '<'
jz loc_731C4
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_A1], al
jmp short $+2
loc_72FF2:
mov al, [rbp+var_A1]
movzx eax, al
cmp eax, 5Bh ; '['
jz loc_731C4
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_10]
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
jmp short $+2
loc_73013:
mov rdi, [rbp+var_88]; this
mov [rbp+var_10], 0
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_A2], al
jmp short $+2
loc_7302E:
mov al, [rbp+var_A2]
movzx ecx, al
mov [rbp+var_A8], ecx
sub al, 4Dh ; 'M'
jz short loc_73064
jmp short $+2
loc_73043:
mov eax, [rbp+var_A8]
sub eax, 52h ; 'R'
jz loc_7314F
jmp short $+2
loc_73054:
mov eax, [rbp+var_A8]
sub eax, 6Dh ; 'm'
jz short loc_730DB
jmp loc_731A8
loc_73064:
movzx eax, [rbp+var_9]
mov [rbp+var_B4], eax
lea rdi, [rbp+var_50]
mov [rbp+var_B0], rdi
lea rsi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEEC2EOS1_; std::vector<int>::vector(std::vector<int>&&)
mov edx, [rbp+var_B4]
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_88]
mov r8, [rbp+var_B0]
and edx, 1
mov ecx, 1
call _ZN5ftxui19TerminalInputParser10ParseMouseEbbSt6vectorIiSaIiEE; ftxui::TerminalInputParser::ParseMouse(bool,bool,std::vector<int>)
jmp short $+2
loc_730AC:
lea rdi, [rbp+var_50]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov [rbp+var_38], 1
jmp loc_73207
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
lea rdi, [rbp+var_50]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_73220
loc_730DB:
movzx eax, [rbp+var_9]
mov [rbp+var_C4], eax
lea rdi, [rbp+var_68]
mov [rbp+var_C0], rdi
lea rsi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEEC2EOS1_; std::vector<int>::vector(std::vector<int>&&)
mov edx, [rbp+var_C4]
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_88]
mov r8, [rbp+var_C0]
and edx, 1
xor ecx, ecx
call _ZN5ftxui19TerminalInputParser10ParseMouseEbbSt6vectorIiSaIiEE; ftxui::TerminalInputParser::ParseMouse(bool,bool,std::vector<int>)
jmp short $+2
loc_73120:
lea rdi, [rbp+var_68]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov [rbp+var_38], 1
jmp loc_73207
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
lea rdi, [rbp+var_68]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_73220
loc_7314F:
lea rdi, [rbp+var_80]
mov [rbp+var_D0], rdi
lea rsi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEEC2EOS1_; std::vector<int>::vector(std::vector<int>&&)
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_88]
mov rdx, [rbp+var_D0]
call _ZN5ftxui19TerminalInputParser20ParseCursorReportingESt6vectorIiSaIiEE; ftxui::TerminalInputParser::ParseCursorReporting(std::vector<int>)
jmp short $+2
loc_7317F:
lea rdi, [rbp+var_80]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov [rbp+var_38], 1
jmp short loc_73207
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
lea rdi, [rbp+var_80]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_73220
loc_731A8:
mov rdi, [rbp+var_98]
mov esi, 3
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp short $+2
loc_731BB:
mov [rbp+var_38], 1
jmp short loc_73207
loc_731C4:
mov rdi, [rbp+var_88]; this
call _ZN5ftxui19TerminalInputParser7CurrentEv; ftxui::TerminalInputParser::Current(void)
mov [rbp+var_D1], al
jmp short $+2
loc_731D8:
mov al, [rbp+var_D1]
movzx eax, al
cmp eax, 1Bh
jnz short loc_73202
mov rdi, [rbp+var_98]
mov esi, 3
call _ZN5ftxui19TerminalInputParser6OutputC2ENS0_4TypeE; ftxui::TerminalInputParser::Output::Output(ftxui::TerminalInputParser::Type)
jmp short $+2
loc_731F9:
mov [rbp+var_38], 1
jmp short loc_73207
loc_73202:
jmp loc_72E4C
loc_73207:
lea rdi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rbp+var_90]
add rsp, 0E0h
pop rbp
retn
loc_73220:
lea rdi, [rbp+var_28]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, [rbp+var_30]
call __Unwind_Resume
|
ftxui::TerminalInputParser * ftxui::TerminalInputParser::ParseCSI(
ftxui::TerminalInputParser *this,
ftxui::TerminalInputParser *a2)
{
char v3; // [rsp+1Ch] [rbp-C4h]
char v4; // [rsp+2Ch] [rbp-B4h]
char v5; // [rsp+3Eh] [rbp-A2h]
unsigned __int8 v6; // [rsp+44h] [rbp-9Ch]
long long v7[3]; // [rsp+60h] [rbp-80h] BYREF
long long v8[3]; // [rsp+78h] [rbp-68h] BYREF
long long v9[3]; // [rsp+90h] [rbp-50h] BYREF
int v10; // [rsp+A8h] [rbp-38h]
long long v11[3]; // [rsp+B8h] [rbp-28h] BYREF
int v12; // [rsp+D0h] [rbp-10h] BYREF
char v13; // [rsp+D7h] [rbp-9h]
ftxui::TerminalInputParser *v14; // [rsp+D8h] [rbp-8h]
v14 = a2;
v13 = 0;
v12 = 0;
std::vector<int>::vector((long long)v11);
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
if ( !ftxui::TerminalInputParser::Eat(a2) )
{
ftxui::TerminalInputParser::Output::Output(this, 0LL);
v10 = 1;
goto LABEL_26;
}
if ( ftxui::TerminalInputParser::Current(a2) != 60 )
break;
v13 = 1;
}
if ( (unsigned __int8)ftxui::TerminalInputParser::Current(a2) < 0x30u
|| (unsigned __int8)ftxui::TerminalInputParser::Current(a2) > 0x39u )
{
break;
}
v12 *= 10;
v6 = ftxui::TerminalInputParser::Current(a2);
v12 += v6 - 48;
}
if ( ftxui::TerminalInputParser::Current(a2) != 59 )
break;
std::vector<int>::push_back((long long)v11, (long long)&v12);
v12 = 0;
}
if ( (unsigned __int8)ftxui::TerminalInputParser::Current(a2) >= 0x40u
&& (unsigned __int8)ftxui::TerminalInputParser::Current(a2) <= 0x7Eu
&& ftxui::TerminalInputParser::Current(a2) != 60
&& ftxui::TerminalInputParser::Current(a2) != 91 )
{
break;
}
if ( ftxui::TerminalInputParser::Current(a2) == 27 )
{
ftxui::TerminalInputParser::Output::Output(this, 3LL);
v10 = 1;
goto LABEL_26;
}
}
std::vector<int>::push_back((long long)v11, (long long)&v12);
v12 = 0;
v5 = ftxui::TerminalInputParser::Current(a2);
if ( v5 == 77 )
{
v4 = v13;
std::vector<int>::vector(v9, v11);
ftxui::TerminalInputParser::ParseMouse(this, a2, v4 & 1, 1LL, v9);
std::vector<int>::~vector(v9);
v10 = 1;
}
else if ( v5 == 82 )
{
std::vector<int>::vector(v7, v11);
ftxui::TerminalInputParser::ParseCursorReporting(this, a2, v7);
std::vector<int>::~vector(v7);
v10 = 1;
}
else
{
if ( v5 == 109 )
{
v3 = v13;
std::vector<int>::vector(v8, v11);
ftxui::TerminalInputParser::ParseMouse(this, a2, v3 & 1, 0LL, v8);
std::vector<int>::~vector(v8);
}
else
{
ftxui::TerminalInputParser::Output::Output(this, 3LL);
}
v10 = 1;
}
LABEL_26:
std::vector<int>::~vector(v11);
return this;
}
|
ParseCSI:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0x90],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x88],RAX
MOV byte ptr [RBP + -0x9],0x0
MOV dword ptr [RBP + -0x10],0x0
LEA RDI,[RBP + -0x28]
CALL 0x0012d860
LAB_00172e4c:
JMP 0x00172e4e
LAB_00172e4e:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172ab0
TEST AL,0x1
JNZ 0x00172e8b
LAB_00172e5e:
MOV RDI,qword ptr [RBP + -0x98]
XOR ESI,ESI
CALL 0x00173b90
JMP 0x00172e6e
LAB_00172e6e:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_00172e8b:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x99],AL
JMP 0x00172e9f
LAB_00172e9f:
MOV AL,byte ptr [RBP + -0x99]
MOVZX EAX,AL
CMP EAX,0x3c
JNZ 0x00172eb3
MOV byte ptr [RBP + -0x9],0x1
JMP 0x00172e4c
LAB_00172eb3:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9a],AL
JMP 0x00172ec7
LAB_00172ec7:
MOV AL,byte ptr [RBP + -0x9a]
MOVZX EAX,AL
CMP EAX,0x30
JL 0x00172f2f
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9b],AL
JMP 0x00172ee9
LAB_00172ee9:
MOV AL,byte ptr [RBP + -0x9b]
MOVZX EAX,AL
CMP EAX,0x39
JG 0x00172f2f
MOV RDI,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RBP + -0x10]
ADD ECX,ECX
MOV EAX,ECX
LEA EAX,[RAX + RAX*0x4]
MOV dword ptr [RBP + -0x10],EAX
CALL 0x00172a80
MOV byte ptr [RBP + -0x9c],AL
JMP 0x00172f18
LAB_00172f18:
MOV AL,byte ptr [RBP + -0x9c]
MOVZX EAX,AL
SUB EAX,0x30
ADD EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x00172e4c
LAB_00172f2f:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9d],AL
JMP 0x00172f43
LAB_00172f43:
MOV AL,byte ptr [RBP + -0x9d]
MOVZX EAX,AL
CMP EAX,0x3b
JNZ 0x00172f6c
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x10]
CALL 0x0012d880
JMP 0x00172f60
LAB_00172f60:
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00172e4c
LAB_00172f6c:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9e],AL
JMP 0x00172f80
LAB_00172f80:
MOV AL,byte ptr [RBP + -0x9e]
MOVZX EAX,AL
CMP EAX,0x40
JL 0x001731c4
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0x9f],AL
JMP 0x00172fa6
LAB_00172fa6:
MOV AL,byte ptr [RBP + -0x9f]
MOVZX EAX,AL
CMP EAX,0x7e
JG 0x001731c4
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0xa0],AL
JMP 0x00172fcc
LAB_00172fcc:
MOV AL,byte ptr [RBP + -0xa0]
MOVZX EAX,AL
CMP EAX,0x3c
JZ 0x001731c4
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0xa1],AL
JMP 0x00172ff2
LAB_00172ff2:
MOV AL,byte ptr [RBP + -0xa1]
MOVZX EAX,AL
CMP EAX,0x5b
JZ 0x001731c4
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x10]
CALL 0x0012d880
JMP 0x00173013
LAB_00173013:
MOV RDI,qword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x10],0x0
CALL 0x00172a80
MOV byte ptr [RBP + -0xa2],AL
JMP 0x0017302e
LAB_0017302e:
MOV AL,byte ptr [RBP + -0xa2]
MOVZX ECX,AL
MOV dword ptr [RBP + -0xa8],ECX
SUB AL,0x4d
JZ 0x00173064
JMP 0x00173043
LAB_00173043:
MOV EAX,dword ptr [RBP + -0xa8]
SUB EAX,0x52
JZ 0x0017314f
JMP 0x00173054
LAB_00173054:
MOV EAX,dword ptr [RBP + -0xa8]
SUB EAX,0x6d
JZ 0x001730db
JMP 0x001731a8
LAB_00173064:
MOVZX EAX,byte ptr [RBP + -0x9]
MOV dword ptr [RBP + -0xb4],EAX
LEA RDI,[RBP + -0x50]
MOV qword ptr [RBP + -0xb0],RDI
LEA RSI,[RBP + -0x28]
CALL 0x00173c10
MOV EDX,dword ptr [RBP + -0xb4]
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x88]
MOV R8,qword ptr [RBP + -0xb0]
LAB_0017309d:
AND EDX,0x1
MOV ECX,0x1
CALL 0x001732d0
JMP 0x001730ac
LAB_001730ac:
LEA RDI,[RBP + -0x50]
CALL 0x0012d4b0
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_001730db:
MOVZX EAX,byte ptr [RBP + -0x9]
MOV dword ptr [RBP + -0xc4],EAX
LEA RDI,[RBP + -0x68]
MOV qword ptr [RBP + -0xc0],RDI
LEA RSI,[RBP + -0x28]
CALL 0x00173c10
MOV EDX,dword ptr [RBP + -0xc4]
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x88]
MOV R8,qword ptr [RBP + -0xc0]
LAB_00173114:
AND EDX,0x1
XOR ECX,ECX
CALL 0x001732d0
JMP 0x00173120
LAB_00173120:
LEA RDI,[RBP + -0x68]
CALL 0x0012d4b0
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_0017314f:
LEA RDI,[RBP + -0x80]
MOV qword ptr [RBP + -0xd0],RDI
LEA RSI,[RBP + -0x28]
CALL 0x00173c10
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0xd0]
LAB_00173178:
CALL 0x00173400
JMP 0x0017317f
LAB_0017317f:
LEA RDI,[RBP + -0x80]
CALL 0x0012d4b0
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_001731a8:
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,0x3
CALL 0x00173b90
JMP 0x001731bb
LAB_001731bb:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_001731c4:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x00172a80
MOV byte ptr [RBP + -0xd1],AL
JMP 0x001731d8
LAB_001731d8:
MOV AL,byte ptr [RBP + -0xd1]
MOVZX EAX,AL
CMP EAX,0x1b
JNZ 0x00173202
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,0x3
CALL 0x00173b90
LAB_001731f7:
JMP 0x001731f9
LAB_001731f9:
MOV dword ptr [RBP + -0x38],0x1
JMP 0x00173207
LAB_00173202:
JMP 0x00172e4c
LAB_00173207:
LEA RDI,[RBP + -0x28]
CALL 0x0012d4b0
MOV RAX,qword ptr [RBP + -0x90]
ADD RSP,0xe0
POP RBP
RET
|
/* ftxui::TerminalInputParser::ParseCSI() */
Output * ftxui::TerminalInputParser::ParseCSI(void)
{
char cVar1;
byte bVar2;
ulong uVar3;
TerminalInputParser *in_RSI;
Output *in_RDI;
vector<int,std::allocator<int>> local_88 [24];
vector<int,std::allocator<int>> local_70 [24];
vector<int,std::allocator<int>> local_58 [24];
int4 local_40;
vector<int,std::allocator<int>> local_30 [24];
int local_18;
byte local_11;
local_11 = 0;
local_18 = 0;
std::vector<int,std::allocator<int>>::vector(local_30);
while( true ) {
while( true ) {
while( true ) {
while( true ) {
uVar3 = Eat(in_RSI);
if ((uVar3 & 1) == 0) {
/* try { // try from 00172e5e to 00173025 has its CatchHandler @ 00172e7a */
Output::Output(in_RDI,0);
goto LAB_00173207;
}
cVar1 = Current(in_RSI);
if (cVar1 != '<') break;
local_11 = 1;
}
bVar2 = Current(in_RSI);
if ((bVar2 < 0x30) || (bVar2 = Current(in_RSI), 0x39 < bVar2)) break;
local_18 = local_18 * 10;
bVar2 = Current(in_RSI);
local_18 = (bVar2 - 0x30) + local_18;
}
cVar1 = Current(in_RSI);
if (cVar1 != ';') break;
std::vector<int,std::allocator<int>>::push_back(local_30,&local_18);
local_18 = 0;
}
bVar2 = Current(in_RSI);
if ((((0x3f < bVar2) && (bVar2 = Current(in_RSI), bVar2 < 0x7f)) &&
(cVar1 = Current(in_RSI), cVar1 != '<')) && (cVar1 = Current(in_RSI), cVar1 != '[')) break;
cVar1 = Current(in_RSI);
if (cVar1 == '\x1b') {
Output::Output(in_RDI,3);
LAB_00173207:
local_40 = 1;
std::vector<int,std::allocator<int>>::~vector(local_30);
return in_RDI;
}
}
std::vector<int,std::allocator<int>>::push_back(local_30,&local_18);
local_18 = 0;
cVar1 = Current(in_RSI);
bVar2 = local_11;
if (cVar1 == 'M') {
std::vector<int,std::allocator<int>>::vector(local_58,(vector *)local_30);
/* try { // try from 0017309d to 001730a9 has its CatchHandler @ 001730c1 */
ParseMouse(in_RDI,in_RSI,bVar2 & 1,1,local_58);
std::vector<int,std::allocator<int>>::~vector(local_58);
}
else if (cVar1 == 'R') {
std::vector<int,std::allocator<int>>::vector(local_88,(vector *)local_30);
/* try { // try from 00173178 to 0017317c has its CatchHandler @ 00173191 */
ParseCursorReporting(in_RDI,in_RSI,local_88);
std::vector<int,std::allocator<int>>::~vector(local_88);
}
else if (cVar1 == 'm') {
std::vector<int,std::allocator<int>>::vector(local_70,(vector *)local_30);
/* try { // try from 00173114 to 0017311d has its CatchHandler @ 00173135 */
ParseMouse(in_RDI,in_RSI,bVar2 & 1,0,local_70);
std::vector<int,std::allocator<int>>::~vector(local_70);
}
else {
/* try { // try from 001731a8 to 001731f6 has its CatchHandler @ 00172e7a */
Output::Output(in_RDI,3);
}
goto LAB_00173207;
}
|
|
13,734
|
google::protobuf::internal::ExtensionSet::Extension::Clear()
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc
|
void ExtensionSet::Extension::Clear() {
if (is_repeated) {
switch (cpp_type(type)) {
#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
case WireFormatLite::CPPTYPE_##UPPERCASE: \
repeated_##LOWERCASE##_value->Clear(); \
break
HANDLE_TYPE(INT32, int32_t);
HANDLE_TYPE(INT64, int64_t);
HANDLE_TYPE(UINT32, uint32_t);
HANDLE_TYPE(UINT64, uint64_t);
HANDLE_TYPE(FLOAT, float);
HANDLE_TYPE(DOUBLE, double);
HANDLE_TYPE(BOOL, bool);
HANDLE_TYPE(ENUM, enum);
HANDLE_TYPE(STRING, string);
HANDLE_TYPE(MESSAGE, message);
#undef HANDLE_TYPE
}
} else {
if (!is_cleared) {
switch (cpp_type(type)) {
case WireFormatLite::CPPTYPE_STRING:
string_value->clear();
break;
case WireFormatLite::CPPTYPE_MESSAGE:
if (is_lazy) {
lazymessage_value->Clear();
} else {
message_value->Clear();
}
break;
default:
// No need to do anything. Get*() will return the default value
// as long as is_cleared is true and Set*() will overwrite the
// previous value.
break;
}
is_cleared = true;
}
}
}
|
O0
|
cpp
|
google::protobuf::internal::ExtensionSet::Extension::Clear():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x9(%rax)
je 0x469d7e
movq 0x18(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x46a020
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x9, %eax
ja 0x469d79
movq 0x10(%rsp), %rax
leaq 0x18cb73(%rip), %rcx # 0x5f684c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3d7b80
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3dd240
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3da6e0
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3dfd70
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3e28f0
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3e5480
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3d4ef0
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3d7b80
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3e79d0
jmp 0x469d79
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x489e80
jmp 0x469e05
movq 0x18(%rsp), %rax
movb 0xa(%rax), %al
andb $0xf, %al
testb $0x1, %al
jne 0x469e03
movq 0x18(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x46a020
movl %eax, %ecx
movl %ecx, 0xc(%rsp)
subl $0x9, %eax
je 0x469db2
jmp 0x469da7
movl 0xc(%rsp), %eax
subl $0xa, %eax
je 0x469dc1
jmp 0x469df0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1986a0
jmp 0x469df2
movq 0x18(%rsp), %rax
movb 0xa(%rax), %al
shrb $0x4, %al
testb $0x1, %al
je 0x469de0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
jmp 0x469dee
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x469df2
jmp 0x469df2
movq 0x18(%rsp), %rax
movb 0xa(%rax), %cl
andb $-0x10, %cl
orb $0x1, %cl
movb %cl, 0xa(%rax)
jmp 0x469e05
addq $0x28, %rsp
retq
nopw (%rax,%rax)
|
_ZN6google8protobuf8internal12ExtensionSet9Extension5ClearEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_10], rax
test byte ptr [rax+9], 1
jz loc_469D7E
mov rax, [rsp+28h+var_10]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal12_GLOBAL__N_18cpp_typeEh; google::protobuf::internal::`anonymous namespace'::cpp_type(uchar)
dec eax; switch 10 cases
mov ecx, eax
mov [rsp+28h+var_18], rcx
sub eax, 9
ja def_469CE0; jumptable 0000000000469CE0 default case
mov rax, [rsp+28h+var_18]
lea rcx, jpt_469CE0
movsxd rax, ds:(jpt_469CE0 - 5F684Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_469CE2:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 1
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIiE5ClearEv; google::protobuf::RepeatedField<int>::Clear(void)
jmp def_469CE0; jumptable 0000000000469CE0 default case
loc_469CF4:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 2
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIlE5ClearEv; google::protobuf::RepeatedField<long>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D03:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 3
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIjE5ClearEv; google::protobuf::RepeatedField<uint>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D12:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 4
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldImE5ClearEv; google::protobuf::RepeatedField<ulong>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D21:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 6
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIfE5ClearEv; google::protobuf::RepeatedField<float>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D30:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 5
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIdE5ClearEv; google::protobuf::RepeatedField<double>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D3F:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 7
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIbE5ClearEv; google::protobuf::RepeatedField<bool>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D4E:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 8
mov rdi, [rax]
call _ZN6google8protobuf13RepeatedFieldIiE5ClearEv; google::protobuf::RepeatedField<int>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D5D:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 9
mov rdi, [rax]
call _ZN6google8protobuf16RepeatedPtrFieldINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE5ClearEv; google::protobuf::RepeatedPtrField<std::string>::Clear(void)
jmp short def_469CE0; jumptable 0000000000469CE0 default case
loc_469D6C:
mov rax, [rsp+28h+var_10]; jumptable 0000000000469CE0 case 10
mov rdi, [rax]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_11MessageLiteEE5ClearEv; google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::Clear(void)
def_469CE0:
jmp loc_469E05; jumptable 0000000000469CE0 default case
loc_469D7E:
mov rax, [rsp+28h+var_10]
mov al, [rax+0Ah]
and al, 0Fh
test al, 1
jnz short loc_469E03
mov rax, [rsp+28h+var_10]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal12_GLOBAL__N_18cpp_typeEh; google::protobuf::internal::`anonymous namespace'::cpp_type(uchar)
mov ecx, eax
mov [rsp+28h+var_1C], ecx
sub eax, 9
jz short loc_469DB2
jmp short $+2
loc_469DA7:
mov eax, [rsp+28h+var_1C]
sub eax, 0Ah
jz short loc_469DC1
jmp short loc_469DF0
loc_469DB2:
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5clearEv; std::string::clear(void)
jmp short loc_469DF2
loc_469DC1:
mov rax, [rsp+28h+var_10]
mov al, [rax+0Ah]
shr al, 4
test al, 1
jz short loc_469DE0
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+78h]
jmp short loc_469DEE
loc_469DE0:
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
mov rax, [rdi]
call qword ptr [rax+20h]
loc_469DEE:
jmp short loc_469DF2
loc_469DF0:
jmp short $+2
loc_469DF2:
mov rax, [rsp+28h+var_10]
mov cl, [rax+0Ah]
and cl, 0F0h
or cl, 1
mov [rax+0Ah], cl
loc_469E03:
jmp short $+2
loc_469E05:
add rsp, 28h
retn
|
char google::protobuf::internal::ExtensionSet::Extension::Clear(
google::protobuf::internal::ExtensionSet::Extension *this,
unsigned __int8 a2)
{
int v2; // eax
int v3; // eax
if ( (*((_BYTE *)this + 9) & 1) != 0 )
{
v2 = google::protobuf::internal::`anonymous namespace'::cpp_type(
(google::protobuf::internal::_anonymous_namespace_ *)*((unsigned __int8 *)this + 8),
a2)
- 1;
switch ( v2 )
{
case 0:
case 7:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<int>::Clear(*(_DWORD **)this);
break;
case 1:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<long>::Clear(*(_DWORD **)this);
break;
case 2:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<unsigned int>::Clear(*(_DWORD **)this);
break;
case 3:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<unsigned long>::Clear(*(_DWORD **)this);
break;
case 4:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<double>::Clear(*(_DWORD **)this);
break;
case 5:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<float>::Clear(*(_DWORD **)this);
break;
case 6:
LOBYTE(v2) = (unsigned __int8)google::protobuf::RepeatedField<bool>::Clear(*(_DWORD **)this);
break;
case 8:
LOBYTE(v2) = google::protobuf::RepeatedPtrField<std::string>::Clear(*(_QWORD *)this);
break;
case 9:
LOBYTE(v2) = google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::Clear(*(_QWORD *)this);
break;
default:
return v2;
}
}
else
{
LOBYTE(v2) = *((_BYTE *)this + 10) & 0xF;
if ( (*((_BYTE *)this + 10) & 1) == 0 )
{
v3 = google::protobuf::internal::`anonymous namespace'::cpp_type(
(google::protobuf::internal::_anonymous_namespace_ *)*((unsigned __int8 *)this + 8),
a2);
if ( v3 == 9 )
{
std::string::clear(*(_QWORD *)this);
}
else if ( v3 == 10 )
{
if ( (*((_BYTE *)this + 10) & 0x10) != 0 )
(*(void ( **)(_QWORD))(**(_QWORD **)this + 120LL))(*(_QWORD *)this);
else
(*(void ( **)(_QWORD))(**(_QWORD **)this + 32LL))(*(_QWORD *)this);
}
LOBYTE(v2) = (_BYTE)this;
*((_BYTE *)this + 10) = *((_BYTE *)this + 10) & 0xF0 | 1;
}
}
return v2;
}
|
__gthread_yield:
PUSH RAX
CALL 0x002a6000
POP RCX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* __gthread_yield() */
void __gthread_yield(void)
{
sched_yield();
return;
}
|
|
13,735
|
string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&)
|
monkey531[P]llama/common/common.cpp
|
bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides) {
const char * sep = strchr(data, '=');
if (sep == nullptr || sep - data >= 128) {
LOG_ERR("%s: malformed KV override '%s'\n", __func__, data);
return false;
}
llama_model_kv_override kvo;
std::strncpy(kvo.key, data, sep - data);
kvo.key[sep - data] = 0;
sep++;
if (strncmp(sep, "int:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_INT;
kvo.val_i64 = std::atol(sep);
} else if (strncmp(sep, "float:", 6) == 0) {
sep += 6;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_FLOAT;
kvo.val_f64 = std::atof(sep);
} else if (strncmp(sep, "bool:", 5) == 0) {
sep += 5;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_BOOL;
if (std::strcmp(sep, "true") == 0) {
kvo.val_bool = true;
} else if (std::strcmp(sep, "false") == 0) {
kvo.val_bool = false;
} else {
LOG_ERR("%s: invalid boolean value for KV override '%s'\n", __func__, data);
return false;
}
} else if (strncmp(sep, "str:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_STR;
if (strlen(sep) > 127) {
LOG_ERR("%s: malformed KV override '%s', value cannot exceed 127 chars\n", __func__, data);
return false;
}
strncpy(kvo.val_str, sep, 127);
kvo.val_str[127] = '\0';
} else {
LOG_ERR("%s: invalid type for KV override '%s'\n", __func__, data);
return false;
}
overrides.emplace_back(std::move(kvo));
return true;
}
|
O3
|
cpp
|
string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3d, %esi
callq 0x1b330
testq %rax, %rax
je 0x7818c
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
cmpq $0x80, %r12
jl 0x781c8
leaq 0xba3bd(%rip), %rax # 0x132550
cmpl $0x0, (%rax)
js 0x78374
callq 0xd0a6b
leaq 0x7b8da(%rip), %rdx # 0xf3a82
leaq 0x7b8f3(%rip), %rcx # 0xf3aa2
xorl %ebp, %ebp
movq %rax, %rdi
movl $0x4, %esi
movq %rbx, %r8
xorl %eax, %eax
callq 0xd0b08
jmp 0x78376
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1b4b0
movb $0x0, 0xc(%rsp,%r12)
leaq 0x1(%r15), %r12
leaq 0x7b8d2(%rip), %rsi # 0xf3abb
movl $0x4, %edx
movq %r12, %rdi
callq 0x1b470
testl %eax, %eax
je 0x7826b
leaq 0x7b8bf(%rip), %rsi # 0xf3ac0
movl $0x6, %edx
movq %r12, %rdi
callq 0x1b470
testl %eax, %eax
je 0x78289
leaq 0x7b8ae(%rip), %rsi # 0xf3ac7
movl $0x5, %edx
movq %r12, %rdi
callq 0x1b470
testl %eax, %eax
je 0x782e4
leaq 0x7b8c8(%rip), %rsi # 0xf3afd
movl $0x4, %edx
movq %r12, %rdi
callq 0x1b470
testl %eax, %eax
je 0x7833b
leaq 0xba2ff(%rip), %rax # 0x132550
cmpl $0x0, (%rax)
js 0x78374
callq 0xd0a6b
leaq 0x7b8db(%rip), %rdx # 0xf3b41
jmp 0x781a8
addq $0x5, %r15
movl $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x1bad0
movq %rax, 0x90(%rsp)
jmp 0x782a6
addq $0x7, %r15
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x1bb30
movsd %xmm0, 0x90(%rsp)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x782cc
leaq 0x8(%rsp), %rsi
movl $0x108, %edx # imm = 0x108
movq %rax, %rdi
callq 0x1b780
addq $0x108, 0x8(%r14) # imm = 0x108
jmp 0x782dc
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xbdab8
movb $0x1, %bpl
jmp 0x78376
addq $0x6, %r15
movl $0x2, 0x8(%rsp)
leaq 0x736b3(%rip), %rsi # 0xeb9aa
movq %r15, %rdi
callq 0x1bcf0
testl %eax, %eax
je 0x78388
leaq 0x76385(%rip), %rsi # 0xee693
movq %r15, %rdi
callq 0x1bcf0
testl %eax, %eax
je 0x783b6
leaq 0xba22b(%rip), %rax # 0x132550
cmpl $0x0, (%rax)
js 0x78374
callq 0xd0a6b
leaq 0x7b797(%rip), %rdx # 0xf3acd
jmp 0x781a8
addq $0x5, %r15
movl $0x3, 0x8(%rsp)
movq %r15, %rdi
callq 0x1b410
cmpq $0x80, %rax
jb 0x78395
leaq 0xba1f2(%rip), %rax # 0x132550
cmpl $0x0, (%rax)
js 0x78374
callq 0xd0a6b
leaq 0x7b793(%rip), %rdx # 0xf3b02
jmp 0x781a8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x90(%rsp)
jmp 0x782a6
leaq 0x90(%rsp), %rbx
movl $0x7f, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b4b0
movb $0x0, 0x7f(%rbx)
jmp 0x782a6
movb $0x0, 0x90(%rsp)
jmp 0x782a6
|
_Z24string_parse_kv_overridePKcRSt6vectorI23llama_model_kv_overrideSaIS2_EE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
mov esi, 3Dh ; '='
call _strchr
test rax, rax
jz short loc_7818C
mov r15, rax
mov r12, rax
sub r12, rbx
cmp r12, 80h
jl short loc_781C8
loc_7818C:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_78374
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
loc_781A8:
lea rcx, aStringParseKvO; "string_parse_kv_override"
xor ebp, ebp
mov rdi, rax
mov esi, 4
mov r8, rbx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_78376
loc_781C8:
lea rdi, [rsp+138h+var_12C]
mov rsi, rbx
mov rdx, r12
call _strncpy
mov [rsp+r12+138h+var_12C], 0
lea r12, [r15+1]
lea rsi, aInt; "int:"
mov edx, 4
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_7826B
lea rsi, aFloat; "float:"
mov edx, 6
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_78289
lea rsi, aBool; "bool:"
mov edx, 5
mov rdi, r12
call _strncmp
test eax, eax
jz loc_782E4
lea rsi, aStr; "str:"
mov edx, 4
mov rdi, r12
call _strncmp
test eax, eax
jz loc_7833B
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_78374
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
jmp loc_781A8
loc_7826B:
add r15, 5
mov [rsp+138h+var_130], 0
mov rdi, r15
call _atol
mov [rsp+138h+var_A8], rax
jmp short loc_782A6
loc_78289:
add r15, 7
mov [rsp+138h+var_130], 1
mov rdi, r15
call _atof
movsd [rsp+138h+var_A8], xmm0
loc_782A6:
mov rax, [r14+8]
cmp rax, [r14+10h]
jz short loc_782CC
lea rsi, [rsp+138h+var_130]
mov edx, 108h
mov rdi, rax
call _memcpy
add qword ptr [r14+8], 108h
jmp short loc_782DC
loc_782CC:
lea rdx, [rsp+138h+var_130]
mov rdi, r14
mov rsi, rax
call _ZNSt6vectorI23llama_model_kv_overrideSaIS0_EE17_M_realloc_insertIJS0_EEEvN9__gnu_cxx17__normal_iteratorIPS0_S2_EEDpOT_; std::vector<llama_model_kv_override>::_M_realloc_insert<llama_model_kv_override>(__gnu_cxx::__normal_iterator<llama_model_kv_override*,std::vector<llama_model_kv_override>>,llama_model_kv_override &&)
loc_782DC:
mov bpl, 1
jmp loc_78376
loc_782E4:
add r15, 6
mov [rsp+138h+var_130], 2
lea rsi, aTrue; "true"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_78388
lea rsi, aAdvancedOption+0ABh; "false"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_783B6
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_78374
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
jmp loc_781A8
loc_7833B:
add r15, 5
mov [rsp+138h+var_130], 3
mov rdi, r15
call _strlen
cmp rax, 80h
jb short loc_78395
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_78374
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
jmp loc_781A8
loc_78374:
xor ebp, ebp
loc_78376:
mov eax, ebp
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_78388:
mov byte ptr [rsp+138h+var_A8], 1
jmp loc_782A6
loc_78395:
lea rbx, [rsp+138h+var_A8]
mov edx, 7Fh
mov rdi, rbx
mov rsi, r15
call _strncpy
mov byte ptr [rbx+7Fh], 0
jmp loc_782A6
loc_783B6:
mov byte ptr [rsp+138h+var_A8], 0
jmp loc_782A6
|
long long string_parse_kv_override(long long a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // rax
long long v4; // r15
long long v5; // r12
int v6; // eax
int v7; // r9d
const char *v8; // rdx
long long v9; // r15
long long v10; // r15
int v12; // [rsp+8h] [rbp-130h] BYREF
_BYTE v13[132]; // [rsp+Ch] [rbp-12Ch] BYREF
long long v14[15]; // [rsp+90h] [rbp-A8h] BYREF
char v15; // [rsp+10Fh] [rbp-29h]
v3 = strchr(a1, 61LL);
if ( !v3 || (v4 = v3, v5 = v3 - a1, v3 - a1 >= 128) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s'\n";
LABEL_5:
v2 = 0;
common_log_add(v6, 4, (_DWORD)v8, (unsigned int)"string_parse_kv_override", a1, v7);
return v2;
}
return 0;
}
strncpy(v13, a1, v3 - a1);
v13[v5] = 0;
if ( !(unsigned int)strncmp(v4 + 1, "int:", 4LL) )
{
v12 = 0;
v14[0] = atol(v4 + 5);
}
else if ( !(unsigned int)strncmp(v4 + 1, "float:", 6LL) )
{
v12 = 1;
v14[0] = atof(v4 + 7);
}
else if ( !(unsigned int)strncmp(v4 + 1, "bool:", 5LL) )
{
v9 = v4 + 6;
v12 = 2;
if ( !(unsigned int)strcmp(v9, "true") )
{
LOBYTE(v14[0]) = 1;
}
else
{
if ( (unsigned int)strcmp(v9, "false") )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid boolean value for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
LOBYTE(v14[0]) = 0;
}
}
else
{
if ( (unsigned int)strncmp(v4 + 1, "str:", 4LL) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid type for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
v10 = v4 + 5;
v12 = 3;
if ( (unsigned long long)strlen(v10) >= 0x80 )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s', value cannot exceed 127 chars\n";
goto LABEL_5;
}
return 0;
}
strncpy(v14, v10, 127LL);
v15 = 0;
}
if ( *(_QWORD *)(a2 + 8) == *(_QWORD *)(a2 + 16) )
{
std::vector<llama_model_kv_override>::_M_realloc_insert<llama_model_kv_override>(a2, *(_QWORD *)(a2 + 8), &v12);
}
else
{
memcpy(*(_QWORD *)(a2 + 8), &v12, 264LL);
*(_QWORD *)(a2 + 8) += 264LL;
}
LOBYTE(v2) = 1;
return v2;
}
|
string_parse_kv_override:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
MOV ESI,0x3d
CALL 0x0011b330
TEST RAX,RAX
JZ 0x0017818c
MOV R15,RAX
MOV R12,RAX
SUB R12,RBX
CMP R12,0x80
JL 0x001781c8
LAB_0017818c:
LEA RAX,[0x232550]
CMP dword ptr [RAX],0x0
JS 0x00178374
CALL 0x001d0a6b
LEA RDX,[0x1f3a82]
LAB_001781a8:
LEA RCX,[0x1f3aa2]
XOR EBP,EBP
MOV RDI,RAX
MOV ESI,0x4
MOV R8,RBX
XOR EAX,EAX
CALL 0x001d0b08
JMP 0x00178376
LAB_001781c8:
LEA RDI,[RSP + 0xc]
MOV RSI,RBX
MOV RDX,R12
CALL 0x0011b4b0
MOV byte ptr [RSP + R12*0x1 + 0xc],0x0
LEA R12,[R15 + 0x1]
LEA RSI,[0x1f3abb]
MOV EDX,0x4
MOV RDI,R12
CALL 0x0011b470
TEST EAX,EAX
JZ 0x0017826b
LEA RSI,[0x1f3ac0]
MOV EDX,0x6
MOV RDI,R12
CALL 0x0011b470
TEST EAX,EAX
JZ 0x00178289
LEA RSI,[0x1f3ac7]
MOV EDX,0x5
MOV RDI,R12
CALL 0x0011b470
TEST EAX,EAX
JZ 0x001782e4
LEA RSI,[0x1f3afd]
MOV EDX,0x4
MOV RDI,R12
CALL 0x0011b470
TEST EAX,EAX
JZ 0x0017833b
LEA RAX,[0x232550]
CMP dword ptr [RAX],0x0
JS 0x00178374
CALL 0x001d0a6b
LEA RDX,[0x1f3b41]
JMP 0x001781a8
LAB_0017826b:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x0
MOV RDI,R15
CALL 0x0011bad0
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001782a6
LAB_00178289:
ADD R15,0x7
MOV dword ptr [RSP + 0x8],0x1
MOV RDI,R15
CALL 0x0011bb30
MOVSD qword ptr [RSP + 0x90],XMM0
LAB_001782a6:
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [R14 + 0x10]
JZ 0x001782cc
LEA RSI,[RSP + 0x8]
MOV EDX,0x108
MOV RDI,RAX
CALL 0x0011b780
ADD qword ptr [R14 + 0x8],0x108
JMP 0x001782dc
LAB_001782cc:
LEA RDX,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
CALL 0x001bdab8
LAB_001782dc:
MOV BPL,0x1
JMP 0x00178376
LAB_001782e4:
ADD R15,0x6
MOV dword ptr [RSP + 0x8],0x2
LEA RSI,[0x1eb9aa]
MOV RDI,R15
CALL 0x0011bcf0
TEST EAX,EAX
JZ 0x00178388
LEA RSI,[0x1ee693]
MOV RDI,R15
CALL 0x0011bcf0
TEST EAX,EAX
JZ 0x001783b6
LEA RAX,[0x232550]
CMP dword ptr [RAX],0x0
JS 0x00178374
CALL 0x001d0a6b
LEA RDX,[0x1f3acd]
JMP 0x001781a8
LAB_0017833b:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x3
MOV RDI,R15
CALL 0x0011b410
CMP RAX,0x80
JC 0x00178395
LEA RAX,[0x232550]
CMP dword ptr [RAX],0x0
JS 0x00178374
CALL 0x001d0a6b
LEA RDX,[0x1f3b02]
JMP 0x001781a8
LAB_00178374:
XOR EBP,EBP
LAB_00178376:
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00178388:
MOV byte ptr [RSP + 0x90],0x1
JMP 0x001782a6
LAB_00178395:
LEA RBX,[RSP + 0x90]
MOV EDX,0x7f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b4b0
MOV byte ptr [RBX + 0x7f],0x0
JMP 0x001782a6
LAB_001783b6:
MOV byte ptr [RSP + 0x90],0x0
JMP 0x001782a6
|
/* string_parse_kv_override(char const*, std::vector<llama_model_kv_override,
std::allocator<llama_model_kv_override> >&) */
ulong string_parse_kv_override(char *param_1,vector *param_2)
{
char *__s1;
void *__dest;
int iVar1;
char *pcVar2;
int8 uVar3;
int8 unaff_RBP;
ulong uVar4;
size_t sVar5;
int4 local_130;
char local_12c [132];
double local_a8 [15];
int1 local_29;
pcVar2 = strchr(param_1,0x3d);
if ((pcVar2 == (char *)0x0) || (sVar5 = (long)pcVar2 - (long)param_1, 0x7f < (long)sVar5)) {
if (common_log_verbosity_thold < 0) goto LAB_00178374;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\'\n";
goto LAB_001781a8;
}
strncpy(local_12c,param_1,sVar5);
local_12c[sVar5] = '\0';
__s1 = pcVar2 + 1;
iVar1 = strncmp(__s1,"int:",4);
if (iVar1 == 0) {
local_130 = 0;
local_a8[0] = (double)atol(pcVar2 + 5);
}
else {
iVar1 = strncmp(__s1,"float:",6);
if (iVar1 == 0) {
local_130 = 1;
local_a8[0] = atof(pcVar2 + 7);
}
else {
iVar1 = strncmp(__s1,"bool:",5);
if (iVar1 != 0) {
iVar1 = strncmp(__s1,"str:",4);
if (iVar1 == 0) {
local_130 = 3;
sVar5 = strlen(pcVar2 + 5);
if (sVar5 < 0x80) {
strncpy((char *)local_a8,pcVar2 + 5,0x7f);
local_29 = 0;
goto LAB_001782a6;
}
if (common_log_verbosity_thold < 0) goto LAB_00178374;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\', value cannot exceed 127 chars\n";
}
else {
if (common_log_verbosity_thold < 0) {
LAB_00178374:
uVar4 = 0;
goto LAB_00178376;
}
uVar3 = common_log_main();
pcVar2 = "%s: invalid type for KV override \'%s\'\n";
}
LAB_001781a8:
uVar4 = 0;
common_log_add(uVar3,4,pcVar2,"string_parse_kv_override",param_1);
goto LAB_00178376;
}
local_130 = 2;
iVar1 = strcmp(pcVar2 + 6,"true");
if (iVar1 == 0) {
local_a8[0] = (double)CONCAT71(local_a8[0]._1_7_,1);
}
else {
iVar1 = strcmp(pcVar2 + 6,"false");
if (iVar1 != 0) {
if (common_log_verbosity_thold < 0) goto LAB_00178374;
uVar3 = common_log_main();
pcVar2 = "%s: invalid boolean value for KV override \'%s\'\n";
goto LAB_001781a8;
}
local_a8[0] = (double)((ulong)local_a8[0] & 0xffffffffffffff00);
}
}
}
LAB_001782a6:
__dest = *(void **)(param_2 + 8);
if (__dest == *(void **)(param_2 + 0x10)) {
std::vector<llama_model_kv_override,std::allocator<llama_model_kv_override>>::
_M_realloc_insert<llama_model_kv_override>
((vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *)param_2,
__dest,&local_130);
}
else {
memcpy(__dest,&local_130,0x108);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + 0x108;
}
uVar4 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
LAB_00178376:
return uVar4 & 0xffffffff;
}
|
|
13,736
|
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const
|
monkey531[P]llama/common/minja.hpp
|
T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
}
|
O1
|
cpp
|
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x99926
testb %al, %al
je 0xb2882
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x90404
movq %r14, %rdi
movq %rbx, %rsi
callq 0x994ea
movq %rax, %rdi
callq 0x8c378
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x6adae
movq %r14, %rdi
callq 0x70460
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0xb282e
callq 0x33c28
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xb283d
callq 0x33c28
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xb284c
callq 0x33c28
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb2882
movq 0x81723(%rip), %rax # 0x133f80
cmpb $0x0, (%rax)
je 0xb286d
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xb2877
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xb2882
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8c2ec
movq %rbx, %rdi
callq 0x1bff0
|
_ZNK5minja5Value3getIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdx
mov r15, rsi
mov r14, rdi
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz loc_B2882
mov rbx, rsp
mov rdi, rbx
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, rbx; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rax
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov rbx, rax
lea r14, [rsp+68h+var_28]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [r14-8]
test rdi, rdi
jz short loc_B282E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B282E:
mov rdi, [rsp+68h+var_40]
test rdi, rdi
jz short loc_B283D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B283D:
mov rdi, [rsp+68h+var_50]
test rdi, rdi
jz short loc_B284C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_B284C:
mov rdi, [rsp+68h+var_60]
test rdi, rdi
jz short loc_B2882
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_B286D
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_B2877
loc_B286D:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_B2877:
cmp eax, 1
jnz short loc_B2882
mov rax, [rdi]
call qword ptr [rax+18h]
loc_B2882:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Value::get<long>(minja::Value *this, long long a2, long long a3)
{
unsigned long long v4; // rax
long long v5; // rdi
signed __int32 v6; // eax
long long v8; // [rsp+0h] [rbp-68h] BYREF
long long v9; // [rsp+8h] [rbp-60h]
volatile signed __int32 *v10; // [rsp+18h] [rbp-50h]
volatile signed __int32 *v11; // [rsp+28h] [rbp-40h]
volatile signed __int32 *v12; // [rsp+38h] [rbp-30h]
char v13[40]; // [rsp+40h] [rbp-28h] BYREF
if ( minja::Value::contains((long long)this, a2) )
{
minja::Value::Value((long long)&v8, a2);
v4 = minja::Value::at(this, (const minja::Value *)&v8);
a3 = minja::Value::get<long>(v4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
if ( v12 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v12);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v10 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v10);
v5 = v9;
if ( v9 )
{
if ( _libc_single_threaded )
{
v6 = *(_DWORD *)(v9 + 12);
*(_DWORD *)(v9 + 12) = v6 - 1;
}
else
{
v6 = _InterlockedExchangeAdd((volatile signed __int32 *)(v9 + 12), 0xFFFFFFFF);
}
if ( v6 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
return a3;
}
|
get<long>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
CALL 0x00199926
TEST AL,AL
JZ 0x001b2882
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R15
CALL 0x00190404
LAB_001b27f3:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001994ea
MOV RDI,RAX
CALL 0x0018c378
LAB_001b2806:
MOV RBX,RAX
LEA R14,[RSP + 0x40]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0016adae
MOV RDI,R14
CALL 0x00170460
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x001b282e
CALL 0x00133c28
LAB_001b282e:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x001b283d
CALL 0x00133c28
LAB_001b283d:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x001b284c
CALL 0x00133c28
LAB_001b284c:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001b2882
MOV RAX,qword ptr [0x00233f80]
CMP byte ptr [RAX],0x0
JZ 0x001b286d
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001b2877
LAB_001b286d:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001b2877:
CMP EAX,0x1
JNZ 0x001b2882
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001b2882:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* long minja::Value::get<long>(std::__cxx11::string const&, long) const */
long __thiscall minja::Value::get<long>(Value *this,string *param_1,long param_2)
{
int *piVar1;
char cVar2;
int iVar3;
Value *this_00;
Value aVStack_68 [8];
long *local_60;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
data local_28 [16];
cVar2 = contains(this,param_1);
if (cVar2 != '\0') {
Value(aVStack_68,param_1);
/* try { // try from 001b27f3 to 001b2805 has its CatchHandler @ 001b288f */
this_00 = (Value *)at(this,aVStack_68);
param_2 = get<long>(this_00);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_28,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_50);
}
if (local_60 != (long *)0x0) {
if (*PTR___libc_single_threaded_00233f80 == '\0') {
LOCK();
piVar1 = (int *)((long)local_60 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_60 + 0xc);
*(int *)((long)local_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_60 + 0x18))();
}
}
}
return param_2;
}
|
|
13,737
|
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const
|
monkey531[P]llama/common/minja.hpp
|
T get(const std::string & key, T default_value) const {
if (!contains(key)) return default_value;
return at(key).get<T>();
}
|
O2
|
cpp
|
long minja::Value::get<long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x720a0
testb %al, %al
je 0x84e1a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6a9b2
movq %r14, %rdi
movq %r12, %rsi
callq 0x71d52
movq %rbx, %rdi
movq %rax, %rsi
callq 0x685f6
leaq 0x8(%rsp), %rdi
callq 0x679d4
jmp 0x84e25
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24b70
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x679d4
movq %rbx, %rdi
callq 0x24fe0
|
_ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_RKS7_S8_:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r12, rcx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
mov rsi, rdx
call _ZNK5minja5Value8containsERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::contains(std::string const&)
test al, al
jz short loc_84E1A
lea r12, [rsp+78h+var_70]
mov rdi, r12
mov rsi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r14; this
mov rsi, r12; minja::Value *
call _ZN5minja5Value2atERKS0_; minja::Value::at(minja::Value const&)
mov rdi, rbx
mov rsi, rax
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+78h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_84E25
loc_84E1A:
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
loc_84E25:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Value::get<std::string>(long long a1, minja::Value *a2, long long a3, long long a4)
{
minja::Value *v6; // rax
_BYTE v8[112]; // [rsp+8h] [rbp-70h] BYREF
if ( minja::Value::contains((long long)a2) )
{
minja::Value::Value((long long)v8, a3);
v6 = (minja::Value *)minja::Value::at(a2, (const minja::Value *)v8);
minja::Value::get<std::string>(a1, v6);
minja::Value::~Value((minja::Value *)v8);
}
else
{
std::string::basic_string(a1, a4);
}
return a1;
}
|
get<std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12,RCX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
MOV RSI,RDX
CALL 0x001720a0
TEST AL,AL
JZ 0x00184e1a
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R15
CALL 0x0016a9b2
LAB_00184df8:
MOV RDI,R14
MOV RSI,R12
CALL 0x00171d52
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001685f6
LAB_00184e0e:
LEA RDI,[RSP + 0x8]
CALL 0x001679d4
JMP 0x00184e25
LAB_00184e1a:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00124b70
LAB_00184e25:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string minja::Value::get<std::__cxx11::string >(std::__cxx11::string const&,
std::__cxx11::string) const */
string * minja::Value::get<std::__cxx11::string>
(string *param_1,string *param_2,string *param_3,string *param_4)
{
char cVar1;
Value local_70 [80];
cVar1 = contains(param_2);
if (cVar1 == '\0') {
std::__cxx11::string::string(param_1,param_4);
}
else {
Value(local_70,param_3);
/* try { // try from 00184df8 to 00184e0d has its CatchHandler @ 00184e34 */
at((Value *)param_2,local_70);
get<std::__cxx11::string>();
~Value(local_70);
}
return param_1;
}
|
|
13,738
|
release_wrlock
|
eloqsql/storage/maria/ma_pagecache.c
|
static void release_wrlock(PAGECACHE_BLOCK_LINK *block, my_bool read_lock)
{
DBUG_ENTER("release_wrlock");
PCBLOCK_INFO(block);
DBUG_ASSERT(block->wlocks > 0);
DBUG_ASSERT(block->rlocks == 0);
DBUG_ASSERT(block->pins > 0);
if (read_lock)
block->rlocks_queue++;
if (block->wlocks == 1)
{
block->rlocks= block->rlocks_queue;
block->rlocks_queue= 0;
}
block->wlocks--;
if (block->wlocks > 0)
DBUG_VOID_RETURN; /* Multiple write locked */
DBUG_PRINT("info", ("WR lock reset, block %p", block));
/* release all threads waiting for read lock or one waiting for write */
if (block->wqueue[COND_FOR_WRLOCK].last_thread)
wqueue_release_one_locktype_from_queue(&block->wqueue[COND_FOR_WRLOCK]);
PCBLOCK_INFO(block);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
release_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
jmp 0x310f4
jmp 0x310f6
jmp 0x310f8
jmp 0x310fa
jmp 0x310fc
jmp 0x310fe
jmp 0x31100
cmpb $0x0, -0x9(%rbp)
je 0x31113
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x70(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x68(%rax)
jne 0x31136
movq -0x8(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jbe 0x31151
jmp 0x3114f
jmp 0x31179
jmp 0x31153
jmp 0x31155
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x31171
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
addq $0x10, %rdi
callq 0xff7d0
jmp 0x31173
jmp 0x31175
jmp 0x31177
jmp 0x31179
addq $0x10, %rsp
popq %rbp
retq
nop
|
release_wrlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
jmp short $+2
loc_310F4:
jmp short $+2
loc_310F6:
jmp short $+2
loc_310F8:
jmp short $+2
loc_310FA:
jmp short $+2
loc_310FC:
jmp short $+2
loc_310FE:
jmp short $+2
loc_31100:
cmp [rbp+var_9], 0
jz short loc_31113
mov rax, [rbp+var_8]
mov ecx, [rax+70h]
add ecx, 1
mov [rax+70h], ecx
loc_31113:
mov rax, [rbp+var_8]
cmp dword ptr [rax+68h], 1
jnz short loc_31136
mov rax, [rbp+var_8]
mov ecx, [rax+70h]
mov rax, [rbp+var_8]
mov [rax+6Ch], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+70h], 0
loc_31136:
mov rax, [rbp+var_8]
mov ecx, [rax+68h]
add ecx, 0FFFFFFFFh
mov [rax+68h], ecx
mov rax, [rbp+var_8]
cmp dword ptr [rax+68h], 0
jbe short loc_31151
jmp short $+2
loc_3114F:
jmp short loc_31179
loc_31151:
jmp short $+2
loc_31153:
jmp short $+2
loc_31155:
mov rax, [rbp+var_8]
cmp qword ptr [rax+58h], 0
jz short loc_31171
mov rdi, [rbp+var_8]
add rdi, 48h ; 'H'
add rdi, 10h
call wqueue_release_one_locktype_from_queue
loc_31171:
jmp short $+2
loc_31173:
jmp short $+2
loc_31175:
jmp short $+2
loc_31177:
jmp short $+2
loc_31179:
add rsp, 10h
pop rbp
retn
|
long long release_wrlock(long long a1, char a2)
{
long long result; // rax
if ( a2 )
++*(_DWORD *)(a1 + 112);
if ( *(_DWORD *)(a1 + 104) == 1 )
{
*(_DWORD *)(a1 + 108) = *(_DWORD *)(a1 + 112);
*(_DWORD *)(a1 + 112) = 0;
}
--*(_DWORD *)(a1 + 104);
result = a1;
if ( !*(_DWORD *)(a1 + 104) )
{
result = a1;
if ( *(_QWORD *)(a1 + 88) )
return wqueue_release_one_locktype_from_queue(a1 + 88);
}
return result;
}
|
release_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
JMP 0x001310f4
LAB_001310f4:
JMP 0x001310f6
LAB_001310f6:
JMP 0x001310f8
LAB_001310f8:
JMP 0x001310fa
LAB_001310fa:
JMP 0x001310fc
LAB_001310fc:
JMP 0x001310fe
LAB_001310fe:
JMP 0x00131100
LAB_00131100:
CMP byte ptr [RBP + -0x9],0x0
JZ 0x00131113
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x70]
ADD ECX,0x1
MOV dword ptr [RAX + 0x70],ECX
LAB_00131113:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x68],0x1
JNZ 0x00131136
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x70]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x6c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x70],0x0
LAB_00131136:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x68],ECX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x68],0x0
JBE 0x00131151
JMP 0x0013114f
LAB_0013114f:
JMP 0x00131179
LAB_00131151:
JMP 0x00131153
LAB_00131153:
JMP 0x00131155
LAB_00131155:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x00131171
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x48
ADD RDI,0x10
CALL 0x001ff7d0
LAB_00131171:
JMP 0x00131173
LAB_00131173:
JMP 0x00131175
LAB_00131175:
JMP 0x00131177
LAB_00131177:
JMP 0x00131179
LAB_00131179:
ADD RSP,0x10
POP RBP
RET
|
void release_wrlock(long param_1,char param_2)
{
if (param_2 != '\0') {
*(int *)(param_1 + 0x70) = *(int *)(param_1 + 0x70) + 1;
}
if (*(int *)(param_1 + 0x68) == 1) {
*(int4 *)(param_1 + 0x6c) = *(int4 *)(param_1 + 0x70);
*(int4 *)(param_1 + 0x70) = 0;
}
*(int *)(param_1 + 0x68) = *(int *)(param_1 + 0x68) + -1;
if ((*(int *)(param_1 + 0x68) == 0) && (*(long *)(param_1 + 0x58) != 0)) {
wqueue_release_one_locktype_from_queue(param_1 + 0x58);
}
return;
}
|
|
13,739
|
my_hash_delete
|
eloqsql/mysys/hash.c
|
my_bool my_hash_delete(HASH *hash, uchar *record)
{
uint pos2,idx,empty_index;
my_hash_value_type pos_hashnr, lastpos_hashnr;
size_t blength;
HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
DBUG_ENTER("my_hash_delete");
if (!hash->records)
DBUG_RETURN(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,HASH_LINK*);
/* Search after record with key */
pos= data + my_hash_mask(rec_hashnr(hash, record), blength, hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
DBUG_RETURN(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos[0]= empty[0];
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr= lastpos->hash_nr;
/* pos is where lastpos should be */
pos= data + my_hash_mask(lastpos_hashnr, hash->blength, hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr= pos->hash_nr;
/* pos3 is where the pos should be */
pos3= data + my_hash_mask(pos_hashnr, hash->blength, hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= my_hash_mask(lastpos_hashnr, blength, hash->records + 1);
if (pos2 == my_hash_mask(pos_hashnr, blength, hash->records + 1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);
}
|
O0
|
c
|
my_hash_delete:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2dba9
jmp 0x2dba0
movb $0x1, -0x1(%rbp)
jmp 0x2df22
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2df30
movl %eax, %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x2d3b0
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x2dc45
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x2dc2e
jmp 0x2dc25
movb $0x1, -0x1(%rbp)
jmp 0x2df22
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0x2dc04
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x2dc74
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x2dcba
movq -0x58(%rbp), %rax
movl (%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
jmp 0x2dcf5
movq -0x58(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x2dcf3
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2dcf5
movq -0x68(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x2dd04
jmp 0x2def6
movq -0x48(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x2d3b0
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x2dd66
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2def6
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x28(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x2d3b0
movl %eax, %ecx
movq -0x80(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
je 0x2de0c
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x60(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0x2db40
jmp 0x2def6
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0x2d3b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x28(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
addq $0x1, %rdx
callq 0x2d3b0
movl %eax, %ecx
movl -0x84(%rbp), %eax
cmpl %ecx, %eax
jne 0x2debb
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x2dea7
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %esi
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
movl -0x24(%rbp), %ecx
callq 0x2db40
jmp 0x2def6
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, -0x20(%rbp)
jmp 0x2dec2
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x58(%rbp), %rax
movl (%rax), %ecx
callq 0x2db40
movl -0x24(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3bc20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x2df1c
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x2df1e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x90, %rsp
popq %rbp
retq
nop
|
my_hash_delete:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jnz short loc_2DBA9
jmp short $+2
loc_2DBA0:
mov [rbp+var_1], 1
jmp loc_2DF22
loc_2DBA9:
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_70], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rec_hashnr
mov edi, eax
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_70]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov [rbp+var_50], 0
loc_2DC04:
mov rax, [rbp+var_58]
mov rax, [rax+8]
cmp rax, [rbp+var_18]
jz short loc_2DC45
mov rax, [rbp+var_58]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jnz short loc_2DC2E
jmp short $+2
loc_2DC25:
mov [rbp+var_1], 1
jmp loc_2DF22
loc_2DC2E:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
jmp short loc_2DC04
loc_2DC45:
mov rcx, [rbp+var_10]
mov rax, [rcx+18h]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rcx+18h], rax
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
shr rcx, 1
cmp rax, rcx
jnb short loc_2DC74
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
shr rcx, 1
mov [rax+10h], rcx
loc_2DC74:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
shl rcx, 4
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_58]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_24], eax
cmp [rbp+var_50], 0
jz short loc_2DCBA
mov rax, [rbp+var_58]
mov ecx, [rax]
mov rax, [rbp+var_50]
mov [rax], ecx
jmp short loc_2DCF5
loc_2DCBA:
mov rax, [rbp+var_58]
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_2DCF3
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
mov ecx, [rcx]
mov [rbp+var_24], ecx
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_68], rax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_68]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
loc_2DCF3:
jmp short $+2
loc_2DCF5:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_48]
jnz short loc_2DD04
jmp loc_2DEF6
loc_2DD04:
mov rax, [rbp+var_48]
mov eax, [rax+4]
mov [rbp+var_2C], eax
mov rax, [rbp+var_40]
mov [rbp+var_78], rax
mov edi, [rbp+var_2C]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_78]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_68]
jnz short loc_2DD66
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
jmp loc_2DEF6
loc_2DD66:
mov rax, [rbp+var_58]
mov eax, [rax+4]
mov [rbp+var_28], eax
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov edi, [rbp+var_28]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov ecx, eax
mov rax, [rbp+var_80]
mov ecx, ecx
shl rcx, 4
add rax, rcx
mov [rbp+var_60], rax
mov rax, [rbp+var_58]
cmp rax, [rbp+var_60]
jz short loc_2DE0C
mov rax, [rbp+var_68]
mov rcx, [rbp+var_58]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rax, [rbp+var_58]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink
jmp loc_2DEF6
loc_2DE0C:
mov edi, [rbp+var_2C]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov [rbp+var_84], eax
mov edi, [rbp+var_28]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
add rdx, 1
call my_hash_mask
mov ecx, eax
mov eax, [rbp+var_84]
cmp eax, ecx
jnz short loc_2DEBB
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_10]
cmp rax, [rcx+18h]
jz short loc_2DEA7
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov rax, [rbp+var_48]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov esi, eax
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov edx, eax
mov ecx, [rbp+var_24]
call movelink
jmp short loc_2DEF6
loc_2DEA7:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_40]
sub rax, rcx
sar rax, 4
mov [rbp+var_20], eax
jmp short loc_2DEC2
loc_2DEBB:
mov [rbp+var_20], 0FFFFFFFFh
loc_2DEC2:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_48]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rdi, [rbp+var_40]
mov esi, [rbp+var_20]
mov edx, [rbp+var_24]
mov rax, [rbp+var_58]
mov ecx, [rax]
call movelink
mov ecx, [rbp+var_24]
mov rax, [rbp+var_58]
mov [rax], ecx
loc_2DEF6:
mov rdi, [rbp+var_10]
add rdi, 28h ; '('
call pop_dynamic
mov rax, [rbp+var_10]
cmp qword ptr [rax+60h], 0
jz short loc_2DF1C
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov rdi, [rbp+var_18]
call rax
loc_2DF1C:
jmp short $+2
loc_2DF1E:
mov [rbp+var_1], 0
loc_2DF22:
mov al, [rbp+var_1]
add rsp, 90h
pop rbp
retn
|
char my_hash_delete(long long a1, long long a2)
{
unsigned int v2; // eax
unsigned long long v3; // rax
_QWORD *v5; // [rsp+28h] [rbp-68h]
long long v6; // [rsp+30h] [rbp-60h]
unsigned int *v7; // [rsp+38h] [rbp-58h]
long long v8; // [rsp+38h] [rbp-58h]
_DWORD *v9; // [rsp+40h] [rbp-50h]
long long v10; // [rsp+48h] [rbp-48h]
long long v11; // [rsp+50h] [rbp-40h]
unsigned long long v12; // [rsp+58h] [rbp-38h]
unsigned int v13; // [rsp+64h] [rbp-2Ch]
unsigned int v14; // [rsp+68h] [rbp-28h]
unsigned int v15; // [rsp+6Ch] [rbp-24h]
int v16; // [rsp+70h] [rbp-20h]
int v17; // [rsp+74h] [rbp-1Ch]
if ( !*(_QWORD *)(a1 + 24) )
return 1;
v12 = *(_QWORD *)(a1 + 16);
v11 = *(_QWORD *)(a1 + 40);
v2 = rec_hashnr(a1, a2);
v7 = (unsigned int *)(16LL * (unsigned int)my_hash_mask(v2, v12, *(_QWORD *)(a1 + 24)) + v11);
v9 = 0LL;
while ( *((_QWORD *)v7 + 1) != a2 )
{
v9 = v7;
if ( *v7 == -1 )
return 1;
v7 = (unsigned int *)(16LL * *v7 + v11);
}
v3 = *(_QWORD *)(a1 + 24) - 1LL;
*(_QWORD *)(a1 + 24) = v3;
if ( v3 < *(_QWORD *)(a1 + 16) >> 1 )
*(_QWORD *)(a1 + 16) >>= 1;
v10 = 16LL * *(_QWORD *)(a1 + 24) + v11;
v5 = v7;
v15 = ((long long)v7 - v11) >> 4;
if ( v9 )
{
*v9 = *v7;
}
else if ( *v7 != -1 )
{
v15 = *v7;
v5 = (_QWORD *)(16LL * *v7 + v11);
*(_QWORD *)v7 = *v5;
*((_QWORD *)v7 + 1) = v5[1];
}
if ( v5 != (_QWORD *)v10 )
{
v13 = *(_DWORD *)(v10 + 4);
v8 = 16LL * (unsigned int)my_hash_mask(v13, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( (_QWORD *)v8 == v5 )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
}
else
{
v14 = *(_DWORD *)(v8 + 4);
v6 = 16LL * (unsigned int)my_hash_mask(v14, *(_QWORD *)(a1 + 16), *(_QWORD *)(a1 + 24)) + v11;
if ( v8 == v6 )
{
v17 = my_hash_mask(v13, v12, *(_QWORD *)(a1 + 24) + 1LL);
if ( v17 == (unsigned int)my_hash_mask(v14, v12, *(_QWORD *)(a1 + 24) + 1LL) )
{
if ( v17 != *(_QWORD *)(a1 + 24) )
{
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink(v11, (v10 - v11) >> 4, (v8 - v11) >> 4, v15);
goto LABEL_25;
}
v16 = (v8 - v11) >> 4;
}
else
{
v16 = -1;
}
*v5 = *(_QWORD *)v10;
v5[1] = *(_QWORD *)(v10 + 8);
movelink(v11, v16, v15, *(_DWORD *)v8);
*(_DWORD *)v8 = v15;
goto LABEL_25;
}
*v5 = *(_QWORD *)v8;
v5[1] = *(_QWORD *)(v8 + 8);
*(_QWORD *)v8 = *(_QWORD *)v10;
*(_QWORD *)(v8 + 8) = *(_QWORD *)(v10 + 8);
movelink(v11, (v8 - v11) >> 4, (v6 - v11) >> 4, v15);
}
}
LABEL_25:
pop_dynamic(a1 + 40);
if ( *(_QWORD *)(a1 + 96) )
(*(void ( **)(long long))(a1 + 96))(a2);
return 0;
}
|
my_hash_delete:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x0012dba9
JMP 0x0012dba0
LAB_0012dba0:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012df22
LAB_0012dba9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012df30
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x0012d3b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x50],0x0
LAB_0012dc04:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0x8]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x0012dc45
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JNZ 0x0012dc2e
JMP 0x0012dc25
LAB_0012dc25:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012df22
LAB_0012dc2e:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0012dc04
LAB_0012dc45:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RCX + 0x18]
ADD RAX,-0x1
MOV qword ptr [RCX + 0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
SHR RCX,0x1
CMP RAX,RCX
JNC 0x0012dc74
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
SHR RCX,0x1
MOV qword ptr [RAX + 0x10],RCX
LAB_0012dc74:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x24],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x0012dcba
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
JMP 0x0012dcf5
LAB_0012dcba:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX],-0x1
JZ 0x0012dcf3
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RBP + -0x24],ECX
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
LAB_0012dcf3:
JMP 0x0012dcf5
LAB_0012dcf5:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x0012dd04
JMP 0x0012def6
LAB_0012dd04:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x78],RAX
MOV EDI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x0012d3b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x0012dd66
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0012def6
LAB_0012dd66:
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x0012d3b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x60]
JZ 0x0012de0c
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x0012db40
JMP 0x0012def6
LAB_0012de0c:
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x0012d3b0
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x84],EAX
MOV EDI,dword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
ADD RDX,0x1
CALL 0x0012d3b0
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x84]
CMP EAX,ECX
JNZ 0x0012debb
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x18]
JZ 0x0012dea7
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV EDX,EAX
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x0012db40
JMP 0x0012def6
LAB_0012dea7:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x40]
SUB RAX,RCX
SAR RAX,0x4
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0012dec2
LAB_0012debb:
MOV dword ptr [RBP + -0x20],0xffffffff
LAB_0012dec2:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x40]
MOV ESI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX]
CALL 0x0012db40
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX],ECX
LAB_0012def6:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x28
CALL 0x0013bc20
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0012df1c
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
LAB_0012df1c:
JMP 0x0012df1e
LAB_0012df1e:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012df22:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x90
POP RBP
RET
|
int1 my_hash_delete(long param_1,long param_2)
{
int8 uVar1;
long lVar2;
int4 uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uint *puVar8;
uint *puVar9;
uint *puVar10;
uint *local_70;
uint *local_60;
uint *local_58;
uint local_2c;
int4 local_28;
if (*(long *)(param_1 + 0x18) == 0) {
return 1;
}
uVar1 = *(int8 *)(param_1 + 0x10);
lVar2 = *(long *)(param_1 + 0x28);
uVar3 = rec_hashnr(param_1,param_2);
uVar4 = my_hash_mask(uVar3,uVar1,*(int8 *)(param_1 + 0x18));
local_58 = (uint *)0x0;
while (local_60 = (uint *)(lVar2 + (ulong)uVar4 * 0x10), *(long *)(local_60 + 2) != param_2) {
local_58 = local_60;
if (*local_60 == 0xffffffff) {
return 1;
}
uVar4 = *local_60;
}
uVar7 = *(long *)(param_1 + 0x18) - 1;
*(ulong *)(param_1 + 0x18) = uVar7;
if (uVar7 < *(ulong *)(param_1 + 0x10) >> 1) {
*(ulong *)(param_1 + 0x10) = *(ulong *)(param_1 + 0x10) >> 1;
}
puVar8 = (uint *)(lVar2 + *(long *)(param_1 + 0x18) * 0x10);
local_70 = local_60;
local_2c = (uint)((long)local_60 - lVar2 >> 4);
if (local_58 == (uint *)0x0) {
if (*local_60 != 0xffffffff) {
local_2c = *local_60;
local_70 = (uint *)(lVar2 + (ulong)local_2c * 0x10);
*(int8 *)local_60 = *(int8 *)local_70;
*(int8 *)(local_60 + 2) = *(int8 *)(local_70 + 2);
}
}
else {
*local_58 = *local_60;
}
if (local_70 != puVar8) {
uVar4 = puVar8[1];
uVar5 = my_hash_mask(uVar4,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar9 = (uint *)(lVar2 + (ulong)uVar5 * 0x10);
if (puVar9 == local_70) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
}
else {
uVar5 = puVar9[1];
uVar6 = my_hash_mask(uVar5,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18));
puVar10 = (uint *)(lVar2 + (ulong)uVar6 * 0x10);
if (puVar9 == puVar10) {
uVar4 = my_hash_mask(uVar4,uVar1,*(long *)(param_1 + 0x18) + 1);
uVar5 = my_hash_mask(uVar5,uVar1,*(long *)(param_1 + 0x18) + 1);
if (uVar4 == uVar5) {
if ((ulong)uVar4 != *(ulong *)(param_1 + 0x18)) {
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar8 - lVar2 >> 4 & 0xffffffff,
(long)puVar9 - lVar2 >> 4 & 0xffffffff,local_2c);
goto LAB_0012def6;
}
local_28 = (int4)((long)puVar9 - lVar2 >> 4);
}
else {
local_28 = 0xffffffff;
}
*(int8 *)local_70 = *(int8 *)puVar8;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,local_28,local_2c,*puVar9);
*puVar9 = local_2c;
}
else {
*(int8 *)local_70 = *(int8 *)puVar9;
*(int8 *)(local_70 + 2) = *(int8 *)(puVar9 + 2);
*(int8 *)puVar9 = *(int8 *)puVar8;
*(int8 *)(puVar9 + 2) = *(int8 *)(puVar8 + 2);
movelink(lVar2,(long)puVar9 - lVar2 >> 4 & 0xffffffff,
(long)puVar10 - lVar2 >> 4 & 0xffffffff,local_2c);
}
}
}
LAB_0012def6:
pop_dynamic(param_1 + 0x28);
if (*(long *)(param_1 + 0x60) != 0) {
(**(code **)(param_1 + 0x60))(param_2);
}
return 0;
}
|
|
13,740
|
my_hash_delete
|
eloqsql/mysys/hash.c
|
my_bool my_hash_delete(HASH *hash, uchar *record)
{
uint pos2,idx,empty_index;
my_hash_value_type pos_hashnr, lastpos_hashnr;
size_t blength;
HASH_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
DBUG_ENTER("my_hash_delete");
if (!hash->records)
DBUG_RETURN(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,HASH_LINK*);
/* Search after record with key */
pos= data + my_hash_mask(rec_hashnr(hash, record), blength, hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
DBUG_RETURN(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos[0]= empty[0];
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr= lastpos->hash_nr;
/* pos is where lastpos should be */
pos= data + my_hash_mask(lastpos_hashnr, hash->blength, hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr= pos->hash_nr;
/* pos3 is where the pos should be */
pos3= data + my_hash_mask(pos_hashnr, hash->blength, hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= my_hash_mask(lastpos_hashnr, blength, hash->records + 1);
if (pos2 == my_hash_mask(pos_hashnr, blength, hash->records + 1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
(void) pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
DBUG_RETURN(0);
}
|
O3
|
c
|
my_hash_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movb $0x1, %r15b
cmpq $0x0, 0x18(%rdi)
je 0x2a32e
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%rdi), %r13
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2a12f
leaq -0x58(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rsi
movq (%r12), %rdx
jmp 0x2a13d
movq 0x8(%r14), %rdx
movq %rdx, -0x58(%rbp)
movq (%r14), %rsi
addq %rbx, %rsi
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movq 0x68(%r14), %rdi
callq *0x58(%r14)
movq 0x18(%r14), %rcx
movq -0x38(%rbp), %r9
leaq (%r9,%r12), %r10
movl %r10d, %edx
andl %eax, %edx
shrq %r9
decl %r9d
andl %r9d, %eax
cmpq %rcx, %rdx
cmovbl %edx, %eax
movq %rax, %rdx
shlq $0x4, %rdx
leaq (%rdx,%r13), %rsi
cmpq %rbx, 0x8(%r13,%rdx)
je 0x2a19f
movl (%rsi), %eax
cmpq %r12, %rax
je 0x2a32e
movq %rsi, %rdx
movq %rax, %rdi
shlq $0x4, %rdi
leaq (%rdi,%r13), %rsi
cmpq %rbx, 0x8(%r13,%rdi)
jne 0x2a17d
jmp 0x2a1a1
xorl %edx, %edx
decq %rcx
movq %rcx, 0x18(%r14)
movq 0x10(%r14), %rdi
shrq %rdi
cmpq %rdi, %rcx
jae 0x2a1b8
movq %rdi, 0x10(%r14)
movq %rcx, %r8
shlq $0x4, %r8
addq %r13, %r8
movl (%rsi), %edi
testq %rdx, %rdx
je 0x2a1cd
movl %edi, (%rdx)
jmp 0x2a1e8
cmpl $-0x1, %edi
je 0x2a1e8
movq %rdi, %rax
shlq $0x4, %rax
movups (%r13,%rax), %xmm0
movups %xmm0, (%rsi)
leaq (%rax,%r13), %rsi
movl %edi, %eax
leaq 0x28(%r14), %rdi
cmpq %r8, %rsi
je 0x2a318
movq %r10, -0x50(%rbp)
movq %r9, -0x38(%rbp)
movl 0x4(%r8), %r11d
movq 0x10(%r14), %r9
movq 0x18(%r14), %r15
addq %r9, %r12
movl %r12d, %edx
andl %r11d, %edx
shrq %r9
decl %r9d
movl %r9d, %r10d
andl %r11d, %r10d
cmpq %r15, %rdx
cmovbl %edx, %r10d
movq %r10, %rdx
shlq $0x4, %rdx
addq %r13, %rdx
cmpq %rsi, %rdx
je 0x2a2c1
movq %rdi, -0x30(%rbp)
movl 0x4(%rdx), %edi
andl %edi, %r12d
andl %edi, %r9d
cmpq %r15, %r12
cmovbl %r12d, %r9d
cmpl %r9d, %r10d
jne 0x2a2ca
movq %r15, -0x48(%rbp)
leaq 0x1(%r15), %r9
movq %r9, -0x40(%rbp)
movq -0x50(%rbp), %r9
movl %r9d, %r12d
andl %r11d, %r12d
movq -0x38(%rbp), %r15
andl %r15d, %r11d
cmpq -0x40(%rbp), %r12
cmovbl %r12d, %r11d
andl %edi, %r9d
andl %r15d, %edi
cmpq -0x40(%rbp), %r9
cmovbl %r9d, %edi
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
cmpl %edi, %r11d
jne 0x2a29b
movl %r11d, %edi
cmpq %rdi, -0x48(%rbp)
jne 0x2a2f5
movl %r10d, %r9d
movups (%r8), %xmm0
movups %xmm0, (%rsi)
movl (%rdx), %ecx
movl %eax, %edi
movl %edi, %esi
shlq $0x4, %rsi
movl (%r13,%rsi), %edi
cmpl %r9d, %edi
jne 0x2a2a6
addq %rsi, %r13
movl %ecx, (%r13)
movl %eax, (%rdx)
jmp 0x2a314
movups (%r8), %xmm0
movups %xmm0, (%rsi)
jmp 0x2a318
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
movups (%r8), %xmm0
movups %xmm0, (%rdx)
movq -0x30(%rbp), %rdi
movl %r9d, %ecx
shlq $0x4, %rcx
movl (%r13,%rcx), %r9d
cmpl %r10d, %r9d
jne 0x2a2db
addq %rcx, %r13
movl %eax, (%r13)
jmp 0x2a318
movups (%r8), %xmm0
movups %xmm0, (%rsi)
movl %r10d, %edx
shlq $0x4, %rdx
movl (%r13,%rdx), %r10d
cmpl %ecx, %r10d
jne 0x2a2fc
addq %rdx, %r13
movl %eax, (%r13)
movq -0x30(%rbp), %rdi
callq 0x32d5b
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x2a32b
movq %rbx, %rdi
callq *%rax
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_hash_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15b, 1
cmp qword ptr [rdi+18h], 0
jz loc_2A32E
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+10h]
mov [rbp+var_38], rax
mov r13, [rdi+28h]
mov rax, [rdi+50h]
test rax, rax
jz short loc_2A12F
lea r12, [rbp+var_58]
mov rdi, rbx
mov rsi, r12
xor edx, edx
call rax
mov rsi, rax
mov rdx, [r12]
jmp short loc_2A13D
loc_2A12F:
mov rdx, [r14+8]
mov [rbp+var_58], rdx
mov rsi, [r14]
add rsi, rbx
loc_2A13D:
mov r12d, 0FFFFFFFFh
mov rdi, [r14+68h]
call qword ptr [r14+58h]
mov rcx, [r14+18h]
mov r9, [rbp+var_38]
lea r10, [r9+r12]
mov edx, r10d
and edx, eax
shr r9, 1
dec r9d
and eax, r9d
cmp rdx, rcx
cmovb eax, edx
mov rdx, rax
shl rdx, 4
lea rsi, [rdx+r13]
cmp [r13+rdx+8], rbx
jz short loc_2A19F
loc_2A17D:
mov eax, [rsi]
cmp rax, r12
jz loc_2A32E
mov rdx, rsi
mov rdi, rax
shl rdi, 4
lea rsi, [rdi+r13]
cmp [r13+rdi+8], rbx
jnz short loc_2A17D
jmp short loc_2A1A1
loc_2A19F:
xor edx, edx
loc_2A1A1:
dec rcx
mov [r14+18h], rcx
mov rdi, [r14+10h]
shr rdi, 1
cmp rcx, rdi
jnb short loc_2A1B8
mov [r14+10h], rdi
loc_2A1B8:
mov r8, rcx
shl r8, 4
add r8, r13
mov edi, [rsi]
test rdx, rdx
jz short loc_2A1CD
mov [rdx], edi
jmp short loc_2A1E8
loc_2A1CD:
cmp edi, 0FFFFFFFFh
jz short loc_2A1E8
mov rax, rdi
shl rax, 4
movups xmm0, xmmword ptr [r13+rax+0]
movups xmmword ptr [rsi], xmm0
lea rsi, [rax+r13]
mov eax, edi
loc_2A1E8:
lea rdi, [r14+28h]
cmp rsi, r8
jz loc_2A318
mov [rbp+var_50], r10
mov [rbp+var_38], r9
mov r11d, [r8+4]
mov r9, [r14+10h]
mov r15, [r14+18h]
add r12, r9
mov edx, r12d
and edx, r11d
shr r9, 1
dec r9d
mov r10d, r9d
and r10d, r11d
cmp rdx, r15
cmovb r10d, edx
mov rdx, r10
shl rdx, 4
add rdx, r13
cmp rdx, rsi
jz loc_2A2C1
mov [rbp+var_30], rdi
mov edi, [rdx+4]
and r12d, edi
and r9d, edi
cmp r12, r15
cmovb r9d, r12d
cmp r10d, r9d
jnz short loc_2A2CA
mov [rbp+var_48], r15
lea r9, [r15+1]
mov [rbp+var_40], r9
mov r9, [rbp+var_50]
mov r12d, r9d
and r12d, r11d
mov r15, [rbp+var_38]
and r11d, r15d
cmp r12, [rbp+var_40]
cmovb r11d, r12d
and r9d, edi
and edi, r15d
cmp r9, [rbp+var_40]
cmovb edi, r9d
mov r9d, 0FFFFFFFFh
cmp r11d, edi
jnz short loc_2A29B
mov edi, r11d
cmp [rbp+var_48], rdi
jnz short loc_2A2F5
mov r9d, r10d
loc_2A29B:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
mov ecx, [rdx]
mov edi, eax
loc_2A2A6:
mov esi, edi
shl rsi, 4
mov edi, [r13+rsi+0]
cmp edi, r9d
jnz short loc_2A2A6
add r13, rsi
mov [r13+0], ecx
mov [rdx], eax
jmp short loc_2A314
loc_2A2C1:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
jmp short loc_2A318
loc_2A2CA:
movups xmm0, xmmword ptr [rdx]
movups xmmword ptr [rsi], xmm0
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rdx], xmm0
mov rdi, [rbp+var_30]
loc_2A2DB:
mov ecx, r9d
shl rcx, 4
mov r9d, [r13+rcx+0]
cmp r9d, r10d
jnz short loc_2A2DB
add r13, rcx
mov [r13+0], eax
jmp short loc_2A318
loc_2A2F5:
movups xmm0, xmmword ptr [r8]
movups xmmword ptr [rsi], xmm0
loc_2A2FC:
mov edx, r10d
shl rdx, 4
mov r10d, [r13+rdx+0]
cmp r10d, ecx
jnz short loc_2A2FC
add r13, rdx
mov [r13+0], eax
loc_2A314:
mov rdi, [rbp+var_30]
loc_2A318:
call pop_dynamic
mov rax, [r14+60h]
test rax, rax
jz short loc_2A32B
mov rdi, rbx
call rax
loc_2A32B:
xor r15d, r15d
loc_2A32E:
mov eax, r15d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_hash_delete(long long a1, long long a2)
{
unsigned int v2; // r15d
long long v5; // r13
long long ( *v6)(long long, long long *, _QWORD); // rax
long long v7; // rsi
long long v8; // rdx
int v9; // eax
unsigned long long v10; // rcx
unsigned long long v11; // r10
unsigned long long v12; // rdx
unsigned long long v13; // r9
long long v14; // rax
unsigned int *v15; // rsi
unsigned int *v16; // rdx
unsigned long long v17; // rcx
unsigned long long v18; // rdi
unsigned int *v19; // r8
long long v20; // rdi
long long v21; // rdi
unsigned int v22; // r11d
unsigned long long v23; // r9
unsigned long long v24; // r15
int v25; // r12d
unsigned long long v26; // rdx
int v27; // r9d
long long v28; // r10
unsigned int *v29; // rdx
unsigned int v30; // edi
unsigned long long v31; // r12
unsigned int v32; // r9d
unsigned long long v33; // r12
int v34; // r11d
unsigned long long v35; // r9
int v36; // edi
int v37; // r9d
unsigned int v38; // edi
long long v39; // rsi
long long v40; // rcx
long long v41; // rdx
void ( *v42)(long long); // rax
long long v44; // [rsp+8h] [rbp-58h] BYREF
unsigned long long v45; // [rsp+10h] [rbp-50h]
unsigned long long v46; // [rsp+18h] [rbp-48h]
unsigned long long v47; // [rsp+20h] [rbp-40h]
unsigned long long v48; // [rsp+28h] [rbp-38h]
long long v49; // [rsp+30h] [rbp-30h]
LOBYTE(v2) = 1;
if ( !*(_QWORD *)(a1 + 24) )
return v2;
v48 = *(_QWORD *)(a1 + 16);
v5 = *(_QWORD *)(a1 + 40);
v6 = *(long long ( **)(long long, long long *, _QWORD))(a1 + 80);
if ( v6 )
{
v7 = v6(a2, &v44, 0LL);
v8 = v44;
}
else
{
v8 = *(_QWORD *)(a1 + 8);
v44 = v8;
v7 = a2 + *(_QWORD *)a1;
}
v9 = (*(long long ( **)(_QWORD, long long, long long))(a1 + 88))(*(_QWORD *)(a1 + 104), v7, v8);
v10 = *(_QWORD *)(a1 + 24);
v11 = v48 + 0xFFFFFFFF;
v12 = v9 & (unsigned int)(v48 - 1);
v13 = (unsigned int)(v48 >> 1) - 1;
v14 = (unsigned int)v13 & v9;
if ( v12 < v10 )
v14 = (unsigned int)v12;
v15 = (unsigned int *)(16 * v14 + v5);
if ( *((_QWORD *)v15 + 1) == a2 )
{
v16 = 0LL;
LABEL_12:
v17 = v10 - 1;
*(_QWORD *)(a1 + 24) = v17;
v18 = *(_QWORD *)(a1 + 16) >> 1;
if ( v17 < v18 )
*(_QWORD *)(a1 + 16) = v18;
v19 = (unsigned int *)(v5 + 16 * v17);
v20 = *v15;
if ( v16 )
{
*v16 = v20;
}
else if ( (_DWORD)v20 != -1 )
{
*(_OWORD *)v15 = *(_OWORD *)(v5 + 16 * v20);
v15 = (unsigned int *)(16 * v20 + v5);
LODWORD(v14) = v20;
}
v21 = a1 + 40;
if ( v15 == v19 )
goto LABEL_43;
v45 = v11;
v48 = v13;
v22 = v19[1];
v23 = *(_QWORD *)(a1 + 16);
v24 = *(_QWORD *)(a1 + 24);
v25 = v23 - 1;
v26 = v22 & ((_DWORD)v23 - 1);
v27 = (v23 >> 1) - 1;
v28 = v22 & v27;
if ( v26 < v24 )
v28 = (unsigned int)v26;
v29 = (unsigned int *)(v5 + 16 * v28);
if ( v29 == v15 )
{
*(_OWORD *)v15 = *(_OWORD *)v19;
LABEL_43:
pop_dynamic(v21);
v42 = *(void ( **)(long long))(a1 + 96);
if ( v42 )
v42(a2);
return 0;
}
v49 = a1 + 40;
v30 = v29[1];
v31 = v30 & v25;
v32 = v30 & v27;
if ( v31 < v24 )
v32 = v31;
if ( (_DWORD)v28 != v32 )
{
*(_OWORD *)v15 = *(_OWORD *)v29;
*(_OWORD *)v29 = *(_OWORD *)v19;
v21 = v49;
do
{
v40 = 16LL * v32;
v32 = *(_DWORD *)(v5 + v40);
}
while ( v32 != (_DWORD)v28 );
*(_DWORD *)(v40 + v5) = v14;
goto LABEL_43;
}
v46 = v24;
v47 = v24 + 1;
v33 = v22 & (unsigned int)v45;
v34 = v48 & v22;
if ( v33 < v24 + 1 )
v34 = v33;
v35 = v30 & (unsigned int)v45;
v36 = v48 & v30;
if ( v35 < v47 )
v36 = v35;
v37 = -1;
if ( v34 == v36 )
{
if ( v46 != v34 )
{
*(_OWORD *)v15 = *(_OWORD *)v19;
do
{
v41 = 16LL * (unsigned int)v28;
LODWORD(v28) = *(_DWORD *)(v5 + v41);
}
while ( (_DWORD)v28 != (_DWORD)v17 );
*(_DWORD *)(v41 + v5) = v14;
goto LABEL_42;
}
v37 = v28;
}
*(_OWORD *)v15 = *(_OWORD *)v19;
v38 = v14;
do
{
v39 = 16LL * v38;
v38 = *(_DWORD *)(v5 + v39);
}
while ( v38 != v37 );
*(_DWORD *)(v39 + v5) = *v29;
*v29 = v14;
LABEL_42:
v21 = v49;
goto LABEL_43;
}
while ( 1 )
{
v14 = *v15;
if ( v14 == 0xFFFFFFFFLL )
return v2;
v16 = v15;
v15 = (unsigned int *)(16 * v14 + v5);
if ( *((_QWORD *)v15 + 1) == a2 )
goto LABEL_12;
}
}
|
my_hash_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15B,0x1
CMP qword ptr [RDI + 0x18],0x0
JZ 0x0012a32e
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV R13,qword ptr [RDI + 0x28]
MOV RAX,qword ptr [RDI + 0x50]
TEST RAX,RAX
JZ 0x0012a12f
LEA R12,[RBP + -0x58]
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL RAX
MOV RSI,RAX
MOV RDX,qword ptr [R12]
JMP 0x0012a13d
LAB_0012a12f:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x58],RDX
MOV RSI,qword ptr [R14]
ADD RSI,RBX
LAB_0012a13d:
MOV R12D,0xffffffff
MOV RDI,qword ptr [R14 + 0x68]
CALL qword ptr [R14 + 0x58]
MOV RCX,qword ptr [R14 + 0x18]
MOV R9,qword ptr [RBP + -0x38]
LEA R10,[R9 + R12*0x1]
MOV EDX,R10D
AND EDX,EAX
SHR R9,0x1
DEC R9D
AND EAX,R9D
CMP RDX,RCX
CMOVC EAX,EDX
MOV RDX,RAX
SHL RDX,0x4
LEA RSI,[RDX + R13*0x1]
CMP qword ptr [R13 + RDX*0x1 + 0x8],RBX
JZ 0x0012a19f
LAB_0012a17d:
MOV EAX,dword ptr [RSI]
CMP RAX,R12
JZ 0x0012a32e
MOV RDX,RSI
MOV RDI,RAX
SHL RDI,0x4
LEA RSI,[RDI + R13*0x1]
CMP qword ptr [R13 + RDI*0x1 + 0x8],RBX
JNZ 0x0012a17d
JMP 0x0012a1a1
LAB_0012a19f:
XOR EDX,EDX
LAB_0012a1a1:
DEC RCX
MOV qword ptr [R14 + 0x18],RCX
MOV RDI,qword ptr [R14 + 0x10]
SHR RDI,0x1
CMP RCX,RDI
JNC 0x0012a1b8
MOV qword ptr [R14 + 0x10],RDI
LAB_0012a1b8:
MOV R8,RCX
SHL R8,0x4
ADD R8,R13
MOV EDI,dword ptr [RSI]
TEST RDX,RDX
JZ 0x0012a1cd
MOV dword ptr [RDX],EDI
JMP 0x0012a1e8
LAB_0012a1cd:
CMP EDI,-0x1
JZ 0x0012a1e8
MOV RAX,RDI
SHL RAX,0x4
MOVUPS XMM0,xmmword ptr [R13 + RAX*0x1]
MOVUPS xmmword ptr [RSI],XMM0
LEA RSI,[RAX + R13*0x1]
MOV EAX,EDI
LAB_0012a1e8:
LEA RDI,[R14 + 0x28]
CMP RSI,R8
JZ 0x0012a318
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x38],R9
MOV R11D,dword ptr [R8 + 0x4]
MOV R9,qword ptr [R14 + 0x10]
MOV R15,qword ptr [R14 + 0x18]
ADD R12,R9
MOV EDX,R12D
AND EDX,R11D
SHR R9,0x1
DEC R9D
MOV R10D,R9D
AND R10D,R11D
CMP RDX,R15
CMOVC R10D,EDX
MOV RDX,R10
SHL RDX,0x4
ADD RDX,R13
CMP RDX,RSI
JZ 0x0012a2c1
MOV qword ptr [RBP + -0x30],RDI
MOV EDI,dword ptr [RDX + 0x4]
AND R12D,EDI
AND R9D,EDI
CMP R12,R15
CMOVC R9D,R12D
CMP R10D,R9D
JNZ 0x0012a2ca
MOV qword ptr [RBP + -0x48],R15
LEA R9,[R15 + 0x1]
MOV qword ptr [RBP + -0x40],R9
MOV R9,qword ptr [RBP + -0x50]
MOV R12D,R9D
AND R12D,R11D
MOV R15,qword ptr [RBP + -0x38]
AND R11D,R15D
CMP R12,qword ptr [RBP + -0x40]
CMOVC R11D,R12D
AND R9D,EDI
AND EDI,R15D
CMP R9,qword ptr [RBP + -0x40]
CMOVC EDI,R9D
MOV R9D,0xffffffff
CMP R11D,EDI
JNZ 0x0012a29b
MOV EDI,R11D
CMP qword ptr [RBP + -0x48],RDI
JNZ 0x0012a2f5
MOV R9D,R10D
LAB_0012a29b:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
MOV ECX,dword ptr [RDX]
MOV EDI,EAX
LAB_0012a2a6:
MOV ESI,EDI
SHL RSI,0x4
MOV EDI,dword ptr [R13 + RSI*0x1]
CMP EDI,R9D
JNZ 0x0012a2a6
ADD R13,RSI
MOV dword ptr [R13],ECX
MOV dword ptr [RDX],EAX
JMP 0x0012a314
LAB_0012a2c1:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
JMP 0x0012a318
LAB_0012a2ca:
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS xmmword ptr [RSI],XMM0
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RDX],XMM0
MOV RDI,qword ptr [RBP + -0x30]
LAB_0012a2db:
MOV ECX,R9D
SHL RCX,0x4
MOV R9D,dword ptr [R13 + RCX*0x1]
CMP R9D,R10D
JNZ 0x0012a2db
ADD R13,RCX
MOV dword ptr [R13],EAX
JMP 0x0012a318
LAB_0012a2f5:
MOVUPS XMM0,xmmword ptr [R8]
MOVUPS xmmword ptr [RSI],XMM0
LAB_0012a2fc:
MOV EDX,R10D
SHL RDX,0x4
MOV R10D,dword ptr [R13 + RDX*0x1]
CMP R10D,ECX
JNZ 0x0012a2fc
ADD R13,RDX
MOV dword ptr [R13],EAX
LAB_0012a314:
MOV RDI,qword ptr [RBP + -0x30]
LAB_0012a318:
CALL 0x00132d5b
MOV RAX,qword ptr [R14 + 0x60]
TEST RAX,RAX
JZ 0x0012a32b
MOV RDI,RBX
CALL RAX
LAB_0012a32b:
XOR R15D,R15D
LAB_0012a32e:
MOV EAX,R15D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_hash_delete(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
uint uVar3;
int8 uVar4;
uint uVar5;
uint uVar6;
long lVar7;
ulong uVar8;
ulong uVar9;
uint uVar10;
uint uVar11;
uint *puVar12;
uint *puVar13;
uint *puVar14;
uint uVar15;
uint uVar16;
ulong uVar18;
uint uVar19;
ulong uVar20;
int8 unaff_R15;
long local_60;
long local_58;
ulong local_50;
ulong local_48;
ulong local_40;
long *local_38;
ulong uVar17;
uVar9 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if (param_1[3] != 0) {
local_40 = param_1[2];
lVar2 = param_1[5];
if ((code *)param_1[10] == (code *)0x0) {
local_60 = param_1[1];
lVar7 = *param_1 + param_2;
}
else {
lVar7 = (*(code *)param_1[10])(param_2,&local_60,0);
}
uVar5 = (*(code *)param_1[0xb])(param_1[0xd],lVar7,local_60);
lVar7 = local_40 + 0xffffffff;
uVar10 = (uint)lVar7;
uVar15 = (int)(local_40 >> 1) - 1;
uVar17 = (ulong)uVar15;
uVar8 = (ulong)(uVar5 & uVar15);
if ((ulong)(uVar10 & uVar5) < (ulong)param_1[3]) {
uVar8 = (ulong)(uVar10 & uVar5);
}
puVar13 = (uint *)(uVar8 * 0x10 + lVar2);
if (*(long *)(lVar2 + 8 + uVar8 * 0x10) == param_2) {
puVar12 = (uint *)0x0;
}
else {
do {
puVar12 = puVar13;
uVar8 = (ulong)*puVar12;
if (uVar8 == 0xffffffff) goto LAB_0012a32e;
puVar13 = (uint *)(uVar8 * 0x10 + lVar2);
} while (*(long *)(lVar2 + 8 + uVar8 * 0x10) != param_2);
}
uVar9 = param_1[3] - 1;
param_1[3] = uVar9;
if (uVar9 < (ulong)param_1[2] >> 1) {
param_1[2] = (ulong)param_1[2] >> 1;
}
puVar14 = (uint *)(uVar9 * 0x10 + lVar2);
uVar5 = *puVar13;
uVar6 = (uint)uVar8;
if (puVar12 == (uint *)0x0) {
if (uVar5 != 0xffffffff) {
puVar12 = (uint *)(lVar2 + (ulong)uVar5 * 0x10);
uVar6 = puVar12[1];
uVar3 = puVar12[2];
uVar11 = puVar12[3];
*puVar13 = *puVar12;
puVar13[1] = uVar6;
puVar13[2] = uVar3;
puVar13[3] = uVar11;
puVar13 = (uint *)((ulong)uVar5 * 0x10 + lVar2);
uVar6 = uVar5;
}
}
else {
*puVar12 = uVar5;
}
plVar1 = param_1 + 5;
if (puVar13 != puVar14) {
uVar5 = puVar14[1];
uVar8 = param_1[3];
uVar19 = (int)param_1[2] - 1;
uVar11 = uVar19 & uVar5;
uVar16 = (int)((ulong)param_1[2] >> 1) - 1;
uVar3 = uVar16 & uVar5;
if (uVar11 < uVar8) {
uVar3 = uVar11;
}
uVar18 = (ulong)uVar3;
puVar12 = (uint *)(uVar18 * 0x10 + lVar2);
local_58 = lVar7;
local_40 = uVar17;
if (puVar12 == puVar13) {
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar10;
puVar13[3] = uVar15;
}
else {
uVar11 = puVar12[1];
uVar20 = (ulong)(uVar19 & uVar11);
uVar17 = (ulong)(uVar16 & uVar11);
if (uVar20 < uVar8) {
uVar17 = uVar20;
}
local_38 = plVar1;
if (uVar3 == (uint)uVar17) {
local_48 = uVar8 + 1;
uVar16 = uVar5 & uVar15;
if ((uVar10 & uVar5) < local_48) {
uVar16 = uVar10 & uVar5;
}
uVar5 = uVar11 & uVar15;
if ((uVar10 & uVar11) < local_48) {
uVar5 = uVar10 & uVar11;
}
uVar10 = 0xffffffff;
local_50 = uVar8;
if ((uVar16 == uVar5) && (uVar10 = uVar3, uVar8 != uVar16)) {
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar10;
puVar13[3] = uVar15;
do {
lVar7 = uVar18 * 0x10;
uVar5 = *(uint *)(lVar2 + lVar7);
uVar18 = (ulong)uVar5;
} while (uVar5 != (uint)uVar9);
*(uint *)(lVar2 + lVar7) = uVar6;
}
else {
uVar5 = puVar14[1];
uVar15 = puVar14[2];
uVar3 = puVar14[3];
*puVar13 = *puVar14;
puVar13[1] = uVar5;
puVar13[2] = uVar15;
puVar13[3] = uVar3;
uVar5 = uVar6;
do {
uVar9 = (ulong)uVar5;
uVar5 = *(uint *)(lVar2 + uVar9 * 0x10);
} while (uVar5 != uVar10);
*(uint *)(lVar2 + uVar9 * 0x10) = *puVar12;
*puVar12 = uVar6;
}
}
else {
uVar4 = *(int8 *)(puVar12 + 2);
*(int8 *)puVar13 = *(int8 *)puVar12;
*(int8 *)(puVar13 + 2) = uVar4;
uVar5 = puVar14[1];
uVar10 = puVar14[2];
uVar15 = puVar14[3];
*puVar12 = *puVar14;
puVar12[1] = uVar5;
puVar12[2] = uVar10;
puVar12[3] = uVar15;
do {
lVar7 = uVar17 * 0x10;
uVar5 = *(uint *)(lVar2 + lVar7);
uVar17 = (ulong)uVar5;
} while (uVar5 != uVar3);
*(uint *)(lVar2 + lVar7) = uVar6;
}
}
}
pop_dynamic(plVar1);
if ((code *)param_1[0xc] != (code *)0x0) {
(*(code *)param_1[0xc])(param_2);
}
uVar9 = 0;
}
LAB_0012a32e:
return uVar9 & 0xffffffff;
}
|
|
13,741
|
js_array_toSpliced
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_toSpliced(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue arr, obj, ret, *arrp, *pval, *last;
JSObject *p;
int64_t i, j, len, newlen, start, add, del;
uint32_t count32;
pval = NULL;
last = NULL;
ret = JS_EXCEPTION;
arr = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
start = 0;
if (argc > 0)
if (JS_ToInt64Clamp(ctx, &start, argv[0], 0, len, len))
goto exception;
del = 0;
if (argc > 0)
del = len - start;
if (argc > 1)
if (JS_ToInt64Clamp(ctx, &del, argv[1], 0, del, 0))
goto exception;
add = 0;
if (argc > 2)
add = argc - 2;
newlen = len + add - del;
if (newlen > UINT32_MAX) {
// Per spec: TypeError if newlen >= 2**53, RangeError below
if (newlen > MAX_SAFE_INTEGER) {
JS_ThrowTypeError(ctx, "invalid array length");
} else {
JS_ThrowRangeError(ctx, "invalid array length");
}
goto exception;
}
arr = JS_NewArray(ctx);
if (JS_IsException(arr))
goto exception;
if (newlen <= 0)
goto done;
p = JS_VALUE_GET_OBJ(arr);
if (expand_fast_array(ctx, p, newlen) < 0)
goto exception;
p->u.array.count = newlen;
pval = &p->u.array.u.values[0];
last = &p->u.array.u.values[newlen];
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
for (i = 0; i < start; i++, pval++)
*pval = js_dup(arrp[i]);
for (j = 0; j < add; j++, pval++)
*pval = js_dup(argv[2 + j]);
for (i += del; i < len; i++, pval++)
*pval = js_dup(arrp[i]);
} else {
for (i = 0; i < start; i++, pval++)
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
goto exception;
for (j = 0; j < add; j++, pval++)
*pval = js_dup(argv[2 + j]);
for (i += del; i < len; i++, pval++)
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
goto exception;
}
assert(pval == last);
if (JS_SetProperty(ctx, arr, JS_ATOM_length, js_int64(newlen)) < 0)
goto exception;
done:
ret = arr;
arr = JS_UNDEFINED;
exception:
while (pval != last)
*pval++ = JS_UNDEFINED;
JS_FreeValue(ctx, arr);
JS_FreeValue(ctx, obj);
return ret;
}
|
O1
|
c
|
js_array_toSpliced:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r13
movl %ecx, %r12d
movq %rdi, %rbx
movl $0x0, 0x40(%rsp)
callq 0x261c9
movq %rdx, %r15
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %rax, 0x50(%rsp)
movq %rax, %rdx
movq %r15, %rcx
callq 0x21ec8
movl $0x3, %edx
xorl %r14d, %r14d
testl %eax, %eax
je 0x76991
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x6, %r13d
jmp 0x76a92
movq $0x0, 0x70(%rsp)
testl %r12d, %r12d
jle 0x769e1
movq 0x80(%rsp), %rbp
movq (%r13), %rdx
movq 0x8(%r13), %rcx
movq %rbp, (%rsp)
xorl %r14d, %r14d
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
movq %rbp, %r9
callq 0x26c44
testl %eax, %eax
jne 0x76a82
movq $0x0, 0x68(%rsp)
subq 0x70(%rsp), %rbp
jmp 0x769e3
xorl %ebp, %ebp
movq %rbp, 0x68(%rsp)
cmpl $0x2, %r12d
jl 0x76a21
leaq 0x68(%rsp), %rsi
movq (%rsi), %r9
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movq $0x0, (%rsp)
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x26c44
movl $0x3, %edx
testl %eax, %eax
jne 0x76981
leal -0x2(%r12), %eax
xorl %esi, %esi
cmpl $0x3, %r12d
cmovgel %eax, %esi
movq 0x80(%rsp), %rcx
leaq (%rcx,%rsi), %r12
movq 0x68(%rsp), %rdx
subq %rdx, %r12
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, %r12
jl 0x76aec
movabsq $0x20000000000000, %rax # imm = 0x20000000000000
leaq 0x2702f(%rip), %rsi # 0x9da96
xorl %r14d, %r14d
movq %rbx, %rdi
cmpq %rax, %r12
jl 0x76a7b
xorl %eax, %eax
callq 0x21953
jmp 0x76a82
xorl %eax, %eax
callq 0x1fec9
xorl %r12d, %r12d
xorl %ebp, %ebp
movl $0x6, %r13d
movl $0x3, %edx
cmpq %r14, %r12
je 0x76ab5
movl $0x0, (%r12)
movq $0x3, 0x8(%r12)
leaq 0x10(%r12), %rax
movq %rax, %r12
cmpq %r14, %rax
jne 0x76a97
movq 0x40(%rsp), %rsi
movq 0x18(%rbx), %rdi
callq 0x1ccb2
movq 0x18(%rbx), %rdi
movq 0x50(%rsp), %rsi
movq %r15, %rdx
callq 0x1ccb2
movq %rbp, %rax
movq %r13, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, 0x58(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x38(%rbx), %rsi
incl (%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0xf48d
movq %rax, 0x40(%rsp)
xorl %r14d, %r14d
cmpl $0x6, %edx
je 0x76981
movq %rax, %rbp
movq %rdx, 0x38(%rsp)
testq %r12, %r12
jle 0x76b92
movq %r12, %r14
movq 0x40(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3cfa4
testl %eax, %eax
js 0x76ba2
movl %r14d, 0x40(%r12)
movq 0x38(%r12), %r12
movq %r14, 0x88(%rsp)
shlq $0x4, %r14
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $-0x1, %r15d
jne 0x76bb2
movq 0x28(%rsp), %rax
cmpw $0x2, 0x6(%rax)
movq 0x48(%rsp), %r9
movq 0x58(%rsp), %r10
jne 0x76b8c
testb $0x8, 0x5(%rax)
jne 0x76dff
xorl %esi, %esi
xorl %edx, %edx
jmp 0x76bc0
xorl %r14d, %r14d
xorl %r12d, %r12d
movq 0x38(%rsp), %r13
jmp 0x76de8
xorl %r14d, %r14d
xorl %r12d, %r12d
movq 0x38(%rsp), %rdx
jmp 0x76984
xorl %esi, %esi
xorl %edx, %edx
movq 0x48(%rsp), %r9
movq 0x58(%rsp), %r10
addq %r12, %r14
movq 0x70(%rsp), %rcx
testb %dl, %dl
je 0x76c15
cmpq %rsi, %r9
jne 0x76c15
testq %rcx, %rcx
jle 0x76cf6
leaq 0x8(%rax), %r11
movq %rcx, %rdx
movq -0x8(%r11), %rsi
movq (%r11), %rdi
movq %rsi, 0x28(%rsp)
cmpl $-0x9, %edi
jb 0x76bfa
movq 0x28(%rsp), %r8
incl (%r8)
movq %rsi, (%r12)
movq %rdi, 0x8(%r12)
addq $0x10, %r12
addq $0x10, %r11
decq %rdx
jne 0x76be1
jmp 0x76cf8
testq %rcx, %rcx
jle 0x76c6d
xorl %eax, %eax
movq %rcx, 0x60(%rsp)
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %r15, %rdx
movq %rax, 0x90(%rsp)
movq %rax, %rcx
movq %r12, %r8
callq 0x4cabd
cmpl $-0x1, %eax
je 0x76ba8
movq 0x90(%rsp), %rax
incq %rax
addq $0x10, %r12
movq 0x60(%rsp), %rcx
cmpq %rax, %rcx
jne 0x76c21
movq 0x48(%rsp), %r9
movq 0x58(%rsp), %r10
jmp 0x76c6f
xorl %ecx, %ecx
testq %r10, %r10
je 0x76caa
shlq $0x4, %r10
xorl %eax, %eax
movq 0x20(%r13,%rax), %rdi
movq 0x28(%r13,%rax), %rdx
movq %rdi, 0x28(%rsp)
cmpl $-0x9, %edx
jb 0x76c95
movq 0x28(%rsp), %rsi
incl (%rsi)
movq %rdi, (%r12,%rax)
movq %rdx, 0x8(%r12,%rax)
addq $0x10, %rax
cmpq %rax, %r10
jne 0x76c7a
addq %rax, %r12
addq 0x78(%rsp), %rcx
cmpq %r9, %rcx
movq 0x38(%rsp), %r13
jge 0x76d82
movq %rcx, 0x60(%rsp)
movq %rbx, %rdi
movq 0x50(%rsp), %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0x4cabd
cmpl $-0x1, %eax
je 0x76e0d
movq 0x60(%rsp), %rcx
incq %rcx
addq $0x10, %r12
cmpq 0x48(%rsp), %rcx
jl 0x76cbd
jmp 0x76d82
xorl %ecx, %ecx
testq %r10, %r10
je 0x76d34
shlq $0x4, %r10
xorl %r8d, %r8d
movq 0x20(%r13,%r8), %rdx
movq 0x28(%r13,%r8), %rsi
movq %rdx, 0x28(%rsp)
cmpl $-0x9, %esi
jb 0x76d1f
movq 0x28(%rsp), %rdi
incl (%rdi)
movq %rdx, (%r12,%r8)
movq %rsi, 0x8(%r12,%r8)
addq $0x10, %r8
cmpq %r8, %r10
jne 0x76d04
addq %r8, %r12
addq 0x78(%rsp), %rcx
cmpq %r9, %rcx
movq 0x38(%rsp), %r13
jge 0x76d82
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x8, %rax
movq -0x8(%rax), %rdi
movq (%rax), %rdx
movq %rdi, 0x28(%rsp)
cmpl $-0x9, %edx
jb 0x76d69
movq 0x28(%rsp), %rsi
incl (%rsi)
movq %rdi, (%r12)
movq %rdx, 0x8(%r12)
incq %rcx
addq $0x10, %r12
addq $0x10, %rax
cmpq %r9, %rcx
jl 0x76d51
movq 0x88(%rsp), %rcx
movq %rcx, %rax
shrq $0x1f, %rax
cvtsi2sd %rcx, %xmm0
movl %ecx, %ecx
movq %xmm0, %r8
cmoveq %rcx, %r8
movl $0x7, %r9d
cmoveq %rax, %r9
movq 0x40(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq %r13, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %rbx, %rdi
movq %r13, %rdx
movl $0x32, %ecx
callq 0x23774
testl %eax, %eax
js 0x76df5
movl $0x0, 0x40(%rsp)
jmp 0x76a8d
xorl %ebp, %ebp
movq %r13, %rdx
jmp 0x76986
movl 0x40(%rax), %esi
movq 0x38(%rax), %rax
movb $0x1, %dl
jmp 0x76bc0
movq %r13, %rdx
jmp 0x76984
|
js_array_toSpliced:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r13, r8
mov r12d, ecx
mov rbx, rdi
mov dword ptr [rsp+0C8h+var_88], 0
call JS_ToObject
mov r15, rdx
lea rsi, [rsp+0C8h+var_48]
mov rdi, rbx
mov [rsp+0C8h+var_78], rax
mov rdx, rax
mov rcx, r15
call js_get_length64
mov edx, 3
xor r14d, r14d
test eax, eax
jz short loc_76991
loc_76981:
xor r12d, r12d
loc_76984:
xor ebp, ebp
loc_76986:
mov r13d, 6
jmp loc_76A92
loc_76991:
mov [rsp+0C8h+var_58], 0
test r12d, r12d
jle short loc_769E1
mov rbp, [rsp+0C8h+var_48]
mov rdx, [r13+0]
mov rcx, [r13+8]
mov qword ptr [rsp+0C8h+var_C8], rbp
xor r14d, r14d
lea rsi, [rsp+0C8h+var_58]
mov rdi, rbx
xor r8d, r8d
mov r9, rbp
call JS_ToInt64Clamp
test eax, eax
jnz loc_76A82
mov [rsp+0C8h+var_60], 0
sub rbp, [rsp+0C8h+var_58]
jmp short loc_769E3
loc_769E1:
xor ebp, ebp
loc_769E3:
mov [rsp+0C8h+var_60], rbp
cmp r12d, 2
jl short loc_76A21
lea rsi, [rsp+0C8h+var_60]
mov r9, [rsi]
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov qword ptr [rsp+0C8h+var_C8], 0
xor r14d, r14d
mov rdi, rbx
xor r8d, r8d
call JS_ToInt64Clamp
mov edx, 3
test eax, eax
jnz loc_76981
loc_76A21:
lea eax, [r12-2]
xor esi, esi
cmp r12d, 3
cmovge esi, eax
mov rcx, [rsp+0C8h+var_48]
lea r12, [rcx+rsi]
mov rdx, [rsp+0C8h+var_60]
sub r12, rdx
mov rax, 100000000h
cmp r12, rax
jl loc_76AEC
mov rax, 20000000000000h
lea rsi, aInvalidArrayLe; "invalid array length"
xor r14d, r14d
mov rdi, rbx
cmp r12, rax
jl short loc_76A7B
xor eax, eax
call JS_ThrowTypeError
jmp short loc_76A82
loc_76A7B:
xor eax, eax
call JS_ThrowRangeError
loc_76A82:
xor r12d, r12d
xor ebp, ebp
mov r13d, 6
loc_76A8D:
mov edx, 3
loc_76A92:
cmp r12, r14
jz short loc_76AB5
loc_76A97:
mov dword ptr [r12], 0
mov qword ptr [r12+8], 3
lea rax, [r12+10h]
mov r12, rax
cmp rax, r14
jnz short loc_76A97
loc_76AB5:
mov rsi, [rsp+0C8h+var_88]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, [rsp+0C8h+var_78]
mov rdx, r15
call JS_FreeValueRT
mov rax, rbp
mov rdx, r13
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_76AEC:
mov [rsp+0C8h+var_70], rsi
mov [rsp+0C8h+var_50], rdx
mov [rsp+0C8h+var_80], rcx
mov rsi, [rbx+38h]
inc dword ptr [rsi]
mov rdi, rbx
mov edx, 2
call JS_NewObjectFromShape
mov [rsp+0C8h+var_88], rax
xor r14d, r14d
cmp edx, 6
jz loc_76981
mov rbp, rax
mov [rsp+0C8h+var_90], rdx
test r12, r12
jle short loc_76B92
mov r14, r12
mov r12, [rsp+0C8h+var_88]
mov rdi, rbx
mov rsi, r12
mov edx, r14d
call expand_fast_array
test eax, eax
js short loc_76BA2
mov [r12+40h], r14d
mov r12, [r12+38h]
mov [rsp+0C8h+var_40], r14
shl r14, 4
mov rax, [rsp+0C8h+var_78]
mov qword ptr [rsp+0C8h+var_A0], rax
cmp r15d, 0FFFFFFFFh
jnz short loc_76BB2
mov rax, qword ptr [rsp+0C8h+var_A0]
cmp word ptr [rax+6], 2
mov r9, [rsp+0C8h+var_80]
mov r10, [rsp+0C8h+var_70]
jnz short loc_76B8C
test byte ptr [rax+5], 8
jnz loc_76DFF
loc_76B8C:
xor esi, esi
xor edx, edx
jmp short loc_76BC0
loc_76B92:
xor r14d, r14d
xor r12d, r12d
mov r13, [rsp+0C8h+var_90]
jmp loc_76DE8
loc_76BA2:
xor r14d, r14d
xor r12d, r12d
loc_76BA8:
mov rdx, [rsp+0C8h+var_90]
jmp loc_76984
loc_76BB2:
xor esi, esi
xor edx, edx
mov r9, [rsp+0C8h+var_80]
mov r10, [rsp+0C8h+var_70]
loc_76BC0:
add r14, r12
mov rcx, [rsp+0C8h+var_58]
test dl, dl
jz short loc_76C15
cmp r9, rsi
jnz short loc_76C15
test rcx, rcx
jle loc_76CF6
lea r11, [rax+8]
mov rdx, rcx
loc_76BE1:
mov rsi, [r11-8]
mov rdi, [r11]
mov qword ptr [rsp+0C8h+var_A0], rsi
cmp edi, 0FFFFFFF7h
jb short loc_76BFA
mov r8, qword ptr [rsp+0C8h+var_A0]
inc dword ptr [r8]
loc_76BFA:
mov [r12], rsi
mov [r12+8], rdi
add r12, 10h
add r11, 10h
dec rdx
jnz short loc_76BE1
jmp loc_76CF8
loc_76C15:
test rcx, rcx
jle short loc_76C6D
xor eax, eax
mov [rsp+0C8h+var_68], rcx
loc_76C21:
mov rdi, rbx
mov rsi, [rsp+0C8h+var_78]
mov rdx, r15
mov [rsp+0C8h+var_38], rax
mov rcx, rax
mov r8, r12
call JS_TryGetPropertyInt64
cmp eax, 0FFFFFFFFh
jz loc_76BA8
mov rax, [rsp+0C8h+var_38]
inc rax
add r12, 10h
mov rcx, [rsp+0C8h+var_68]
cmp rcx, rax
jnz short loc_76C21
mov r9, [rsp+0C8h+var_80]
mov r10, [rsp+0C8h+var_70]
jmp short loc_76C6F
loc_76C6D:
xor ecx, ecx
loc_76C6F:
test r10, r10
jz short loc_76CAA
shl r10, 4
xor eax, eax
loc_76C7A:
mov rdi, [r13+rax+20h]
mov rdx, [r13+rax+28h]
mov qword ptr [rsp+0C8h+var_A0], rdi
cmp edx, 0FFFFFFF7h
jb short loc_76C95
mov rsi, qword ptr [rsp+0C8h+var_A0]
inc dword ptr [rsi]
loc_76C95:
mov [r12+rax], rdi
mov [r12+rax+8], rdx
add rax, 10h
cmp r10, rax
jnz short loc_76C7A
add r12, rax
loc_76CAA:
add rcx, [rsp+0C8h+var_50]
cmp rcx, r9
mov r13, [rsp+0C8h+var_90]
jge loc_76D82
loc_76CBD:
mov [rsp+0C8h+var_68], rcx
mov rdi, rbx
mov rsi, [rsp+0C8h+var_78]
mov rdx, r15
mov r8, r12
call JS_TryGetPropertyInt64
cmp eax, 0FFFFFFFFh
jz loc_76E0D
mov rcx, [rsp+0C8h+var_68]
inc rcx
add r12, 10h
cmp rcx, [rsp+0C8h+var_80]
jl short loc_76CBD
jmp loc_76D82
loc_76CF6:
xor ecx, ecx
loc_76CF8:
test r10, r10
jz short loc_76D34
shl r10, 4
xor r8d, r8d
loc_76D04:
mov rdx, [r13+r8+20h]
mov rsi, [r13+r8+28h]
mov qword ptr [rsp+0C8h+var_A0], rdx
cmp esi, 0FFFFFFF7h
jb short loc_76D1F
mov rdi, qword ptr [rsp+0C8h+var_A0]
inc dword ptr [rdi]
loc_76D1F:
mov [r12+r8], rdx
mov [r12+r8+8], rsi
add r8, 10h
cmp r10, r8
jnz short loc_76D04
add r12, r8
loc_76D34:
add rcx, [rsp+0C8h+var_50]
cmp rcx, r9
mov r13, [rsp+0C8h+var_90]
jge short loc_76D82
mov rdx, rcx
shl rdx, 4
add rax, rdx
add rax, 8
loc_76D51:
mov rdi, [rax-8]
mov rdx, [rax]
mov qword ptr [rsp+0C8h+var_A0], rdi
cmp edx, 0FFFFFFF7h
jb short loc_76D69
mov rsi, qword ptr [rsp+0C8h+var_A0]
inc dword ptr [rsi]
loc_76D69:
mov [r12], rdi
mov [r12+8], rdx
inc rcx
add r12, 10h
add rax, 10h
cmp rcx, r9
jl short loc_76D51
loc_76D82:
mov rcx, [rsp+0C8h+var_40]
mov rax, rcx
shr rax, 1Fh
cvtsi2sd xmm0, rcx
mov ecx, ecx
movq r8, xmm0
cmovz r8, rcx
mov r9d, 7
cmovz r9, rax
mov rsi, [rsp+0C8h+var_88]
mov qword ptr [rsp+0C8h+var_A0], rsi
mov qword ptr [rsp+0C8h+var_A0+8], r13
movups xmm0, [rsp+0C8h+var_A0]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B0], 0
mov [rsp+0C8h+var_B8], 4000h
mov rdi, rbx
mov rdx, r13
mov ecx, 32h ; '2'
call JS_SetPropertyInternal2
test eax, eax
js short loc_76DF5
loc_76DE8:
mov dword ptr [rsp+0C8h+var_88], 0
jmp loc_76A8D
loc_76DF5:
xor ebp, ebp
mov rdx, r13
jmp loc_76986
loc_76DFF:
mov esi, [rax+40h]
mov rax, [rax+38h]
mov dl, 1
jmp loc_76BC0
loc_76E0D:
mov rdx, r13
jmp loc_76984
|
long long js_array_toSpliced(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v15; // r12d
_DWORD *v17; // rax
long long v18; // rdx
long long v19; // r15
int length64; // eax
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rdx
_QWORD *v26; // r14
_QWORD *v27; // r12
long long v28; // rbp
long long v29; // rbp
signed long long v30; // rbp
int v31; // eax
long long v32; // rsi
long long v33; // r12
_DWORD *v35; // rsi
long long v36; // rax
long long v37; // r14
double v38; // xmm4_8
double v39; // xmm5_8
long long v40; // r14
long long v41; // rax
signed long long v42; // r9
long long v43; // r10
long long v44; // rsi
char v45; // dl
long long v46; // rcx
long long *v47; // r11
long long v48; // rdx
long long v49; // rsi
long long v50; // rdi
unsigned long long v51; // rax
long long v52; // rcx
long long v53; // r10
unsigned long long v54; // rax
long long v55; // rdi
long long v56; // rdx
signed long long v57; // rcx
unsigned long long v58; // r13
long long v59; // r10
unsigned long long v60; // r8
long long v61; // rdx
long long v62; // rsi
signed long long v63; // rcx
long long *v64; // rax
long long v65; // rdi
long long v66; // rdx
double v67; // r8
long long v68; // r9
char v69; // [rsp+0h] [rbp-C8h]
__m128 v70; // [rsp+28h] [rbp-A0h]
long long v71; // [rsp+38h] [rbp-90h]
long long v72; // [rsp+40h] [rbp-88h]
long long v73; // [rsp+48h] [rbp-80h]
long long v74; // [rsp+50h] [rbp-78h]
long long v75; // [rsp+58h] [rbp-70h]
long long v76; // [rsp+60h] [rbp-68h]
signed long long v77; // [rsp+60h] [rbp-68h]
signed long long v78; // [rsp+68h] [rbp-60h] BYREF
long long v79; // [rsp+70h] [rbp-58h] BYREF
signed long long v80; // [rsp+78h] [rbp-50h]
long long v81; // [rsp+80h] [rbp-48h] BYREF
unsigned long long v82; // [rsp+88h] [rbp-40h]
unsigned long long v83; // [rsp+90h] [rbp-38h]
v15 = a4;
LODWORD(v72) = 0;
v17 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
v74 = (long long)v17;
length64 = js_get_length64(a1, &v81, (int)v17, v18);
v25 = 3LL;
v26 = 0LL;
if ( length64 )
goto LABEL_2;
v79 = 0LL;
if ( v15 <= 0 )
{
v30 = 0LL;
}
else
{
v29 = v81;
v26 = 0LL;
if ( (unsigned int)JS_ToInt64Clamp(a1, (unsigned long long *)&v79, *(_DWORD **)a5, *(_QWORD *)(a5 + 8), 0LL, v81, v81) )
{
LABEL_16:
v27 = 0LL;
v28 = 0LL;
LABEL_17:
v25 = 3LL;
goto LABEL_18;
}
v78 = 0LL;
v30 = v29 - v79;
}
v78 = v30;
if ( v15 >= 2 )
{
v26 = 0LL;
v31 = JS_ToInt64Clamp(a1, (unsigned long long *)&v78, *(_DWORD **)(a5 + 16), *(_QWORD *)(a5 + 24), 0LL, v78, 0LL);
v25 = 3LL;
if ( v31 )
goto LABEL_2;
}
v32 = 0LL;
if ( v15 >= 3 )
v32 = (unsigned int)(v15 - 2);
v33 = v81 + v32 - v78;
if ( v33 >= 0x100000000LL )
{
v26 = 0LL;
if ( v33 < 0x20000000000000LL )
JS_ThrowRangeError(
a1,
(long long)"invalid array length",
v78,
v81,
v21,
v22,
a7,
a8,
a9,
a10,
v23,
v24,
a13,
a14,
v69);
else
JS_ThrowTypeError(
a1,
(long long)"invalid array length",
v78,
v81,
v21,
v22,
a7,
a8,
a9,
a10,
v23,
v24,
a13,
a14,
v69);
goto LABEL_16;
}
v75 = v32;
v80 = v78;
v73 = v81;
v35 = *(_DWORD **)(a1 + 56);
++*v35;
v36 = JS_NewObjectFromShape(a1, v35, 2u);
v72 = v36;
v26 = 0LL;
if ( (_DWORD)v25 == 6 )
{
LABEL_2:
v27 = 0LL;
LABEL_3:
v28 = 0LL;
goto LABEL_18;
}
v28 = v36;
v71 = v25;
if ( v33 <= 0 )
{
v26 = 0LL;
v27 = 0LL;
LABEL_73:
LODWORD(v72) = 0;
goto LABEL_17;
}
v37 = v33;
if ( (int)expand_fast_array(a1, v36, v33) < 0 )
{
v26 = 0LL;
v27 = 0LL;
LABEL_30:
v25 = v71;
goto LABEL_3;
}
*(_DWORD *)(v72 + 64) = v33;
v27 = *(_QWORD **)(v72 + 56);
v82 = v37;
v40 = 2 * v37;
v41 = v74;
if ( (_DWORD)v19 == -1 )
{
v41 = v74;
v42 = v73;
v43 = v75;
if ( *(_WORD *)(v74 + 6) == 2 && (*(_BYTE *)(v74 + 5) & 8) != 0 )
{
v44 = *(unsigned int *)(v74 + 64);
v41 = *(_QWORD *)(v74 + 56);
v45 = 1;
}
else
{
v44 = 0LL;
v45 = 0;
}
}
else
{
v44 = 0LL;
v45 = 0;
v42 = v73;
v43 = v75;
}
v26 = &v27[v40];
v46 = v79;
if ( v45 && v42 == v44 )
{
if ( v79 <= 0 )
{
v46 = 0LL;
}
else
{
v47 = (long long *)(v41 + 8);
v48 = v79;
do
{
v49 = *(v47 - 1);
v50 = *v47;
if ( (unsigned int)*v47 >= 0xFFFFFFF7 )
++*(_DWORD *)*(v47 - 1);
*v27 = v49;
v27[1] = v50;
v27 += 2;
v47 += 2;
--v48;
}
while ( v48 );
}
if ( v43 )
{
v59 = 16 * v43;
v60 = 0LL;
do
{
v61 = *(_QWORD *)(a5 + v60 + 32);
v62 = *(_QWORD *)(a5 + v60 + 40);
if ( (unsigned int)v62 >= 0xFFFFFFF7 )
++**(_DWORD **)(a5 + v60 + 32);
v27[v60 / 8] = v61;
v27[v60 / 8 + 1] = v62;
v60 += 16LL;
}
while ( v59 != v60 );
v27 = (_QWORD *)((char *)v27 + v60);
}
v63 = v80 + v46;
v58 = v71;
if ( v63 < v42 )
{
v64 = (long long *)(16 * v63 + v41 + 8);
do
{
v65 = *(v64 - 1);
v66 = *v64;
if ( (unsigned int)*v64 >= 0xFFFFFFF7 )
++*(_DWORD *)*(v64 - 1);
*v27 = v65;
v27[1] = v66;
++v63;
v27 += 2;
v64 += 2;
}
while ( v63 < v42 );
}
goto LABEL_68;
}
if ( v79 > 0 )
{
v51 = 0LL;
v76 = v79;
while ( 1 )
{
v83 = v51;
if ( (unsigned int)JS_TryGetPropertyInt64(a1, v74, v19, v51, (long long)v27) == -1 )
goto LABEL_30;
v51 = v83 + 1;
v27 += 2;
v52 = v76;
if ( v76 == v83 + 1 )
{
v42 = v73;
v43 = v75;
goto LABEL_46;
}
}
}
v52 = 0LL;
LABEL_46:
if ( v43 )
{
v53 = 16 * v43;
v54 = 0LL;
do
{
v55 = *(_QWORD *)(a5 + v54 + 32);
v56 = *(_QWORD *)(a5 + v54 + 40);
if ( (unsigned int)v56 >= 0xFFFFFFF7 )
++**(_DWORD **)(a5 + v54 + 32);
v27[v54 / 8] = v55;
v27[v54 / 8 + 1] = v56;
v54 += 16LL;
}
while ( v53 != v54 );
v27 = (_QWORD *)((char *)v27 + v54);
}
v57 = v80 + v52;
v58 = v71;
if ( v57 < v42 )
{
while ( 1 )
{
v77 = v57;
if ( (unsigned int)JS_TryGetPropertyInt64(a1, v74, v19, v57, (long long)v27) == -1 )
break;
v57 = v77 + 1;
v27 += 2;
if ( v77 + 1 >= v73 )
goto LABEL_68;
}
v25 = v71;
goto LABEL_3;
}
LABEL_68:
v67 = (double)(int)v82;
if ( !(v82 >> 31) )
*(_QWORD *)&v67 = (unsigned int)v82;
v68 = 7LL;
if ( !(v82 >> 31) )
v68 = v82 >> 31;
v70.m128_u64[0] = v72;
v70.m128_u64[1] = v58;
if ( (int)JS_SetPropertyInternal2(
a1,
v72,
v58,
0x32u,
*(_DWORD **)&v67,
v68,
v70,
a8,
a9,
a10,
v38,
v39,
a13,
a14,
v72,
v58,
0x4000u,
0LL) >= 0 )
goto LABEL_73;
v28 = 0LL;
v25 = v58;
LABEL_18:
while ( v27 != v26 )
{
*(_DWORD *)v27 = 0;
v27[1] = 3LL;
v27 += 2;
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v72, v25);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v74, v19);
return v28;
}
|
js_array_toSpliced:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R13,R8
MOV R12D,ECX
MOV RBX,RDI
MOV dword ptr [RSP + 0x40],0x0
CALL 0x001261c9
MOV R15,RDX
LEA RSI,[RSP + 0x80]
MOV RDI,RBX
MOV qword ptr [RSP + 0x50],RAX
MOV RDX,RAX
MOV RCX,R15
CALL 0x00121ec8
MOV EDX,0x3
XOR R14D,R14D
TEST EAX,EAX
JZ 0x00176991
LAB_00176981:
XOR R12D,R12D
LAB_00176984:
XOR EBP,EBP
LAB_00176986:
MOV R13D,0x6
JMP 0x00176a92
LAB_00176991:
MOV qword ptr [RSP + 0x70],0x0
TEST R12D,R12D
JLE 0x001769e1
MOV RBP,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
MOV qword ptr [RSP],RBP
XOR R14D,R14D
LEA RSI,[RSP + 0x70]
MOV RDI,RBX
XOR R8D,R8D
MOV R9,RBP
CALL 0x00126c44
TEST EAX,EAX
JNZ 0x00176a82
MOV qword ptr [RSP + 0x68],0x0
SUB RBP,qword ptr [RSP + 0x70]
JMP 0x001769e3
LAB_001769e1:
XOR EBP,EBP
LAB_001769e3:
MOV qword ptr [RSP + 0x68],RBP
CMP R12D,0x2
JL 0x00176a21
LEA RSI,[RSP + 0x68]
MOV R9,qword ptr [RSI]
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP],0x0
XOR R14D,R14D
MOV RDI,RBX
XOR R8D,R8D
CALL 0x00126c44
MOV EDX,0x3
TEST EAX,EAX
JNZ 0x00176981
LAB_00176a21:
LEA EAX,[R12 + -0x2]
XOR ESI,ESI
CMP R12D,0x3
CMOVGE ESI,EAX
MOV RCX,qword ptr [RSP + 0x80]
LEA R12,[RCX + RSI*0x1]
MOV RDX,qword ptr [RSP + 0x68]
SUB R12,RDX
MOV RAX,0x100000000
CMP R12,RAX
JL 0x00176aec
MOV RAX,0x20000000000000
LEA RSI,[0x19da96]
XOR R14D,R14D
MOV RDI,RBX
CMP R12,RAX
JL 0x00176a7b
XOR EAX,EAX
CALL 0x00121953
JMP 0x00176a82
LAB_00176a7b:
XOR EAX,EAX
CALL 0x0011fec9
LAB_00176a82:
XOR R12D,R12D
XOR EBP,EBP
MOV R13D,0x6
LAB_00176a8d:
MOV EDX,0x3
LAB_00176a92:
CMP R12,R14
JZ 0x00176ab5
LAB_00176a97:
MOV dword ptr [R12],0x0
MOV qword ptr [R12 + 0x8],0x3
LEA RAX,[R12 + 0x10]
MOV R12,RAX
CMP RAX,R14
JNZ 0x00176a97
LAB_00176ab5:
MOV RSI,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x0011ccb2
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,R15
CALL 0x0011ccb2
MOV RAX,RBP
MOV RDX,R13
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00176aec:
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x78],RDX
MOV qword ptr [RSP + 0x48],RCX
MOV RSI,qword ptr [RBX + 0x38]
INC dword ptr [RSI]
MOV RDI,RBX
MOV EDX,0x2
CALL 0x0010f48d
MOV qword ptr [RSP + 0x40],RAX
XOR R14D,R14D
CMP EDX,0x6
JZ 0x00176981
MOV RBP,RAX
MOV qword ptr [RSP + 0x38],RDX
TEST R12,R12
JLE 0x00176b92
MOV R14,R12
MOV R12,qword ptr [RSP + 0x40]
MOV RDI,RBX
MOV RSI,R12
MOV EDX,R14D
CALL 0x0013cfa4
TEST EAX,EAX
JS 0x00176ba2
MOV dword ptr [R12 + 0x40],R14D
MOV R12,qword ptr [R12 + 0x38]
MOV qword ptr [RSP + 0x88],R14
SHL R14,0x4
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x28],RAX
CMP R15D,-0x1
JNZ 0x00176bb2
MOV RAX,qword ptr [RSP + 0x28]
CMP word ptr [RAX + 0x6],0x2
MOV R9,qword ptr [RSP + 0x48]
MOV R10,qword ptr [RSP + 0x58]
JNZ 0x00176b8c
TEST byte ptr [RAX + 0x5],0x8
JNZ 0x00176dff
LAB_00176b8c:
XOR ESI,ESI
XOR EDX,EDX
JMP 0x00176bc0
LAB_00176b92:
XOR R14D,R14D
XOR R12D,R12D
MOV R13,qword ptr [RSP + 0x38]
JMP 0x00176de8
LAB_00176ba2:
XOR R14D,R14D
XOR R12D,R12D
LAB_00176ba8:
MOV RDX,qword ptr [RSP + 0x38]
JMP 0x00176984
LAB_00176bb2:
XOR ESI,ESI
XOR EDX,EDX
MOV R9,qword ptr [RSP + 0x48]
MOV R10,qword ptr [RSP + 0x58]
LAB_00176bc0:
ADD R14,R12
MOV RCX,qword ptr [RSP + 0x70]
TEST DL,DL
JZ 0x00176c15
CMP R9,RSI
JNZ 0x00176c15
TEST RCX,RCX
JLE 0x00176cf6
LEA R11,[RAX + 0x8]
MOV RDX,RCX
LAB_00176be1:
MOV RSI,qword ptr [R11 + -0x8]
MOV RDI,qword ptr [R11]
MOV qword ptr [RSP + 0x28],RSI
CMP EDI,-0x9
JC 0x00176bfa
MOV R8,qword ptr [RSP + 0x28]
INC dword ptr [R8]
LAB_00176bfa:
MOV qword ptr [R12],RSI
MOV qword ptr [R12 + 0x8],RDI
ADD R12,0x10
ADD R11,0x10
DEC RDX
JNZ 0x00176be1
JMP 0x00176cf8
LAB_00176c15:
TEST RCX,RCX
JLE 0x00176c6d
XOR EAX,EAX
MOV qword ptr [RSP + 0x60],RCX
LAB_00176c21:
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,R15
MOV qword ptr [RSP + 0x90],RAX
MOV RCX,RAX
MOV R8,R12
CALL 0x0014cabd
CMP EAX,-0x1
JZ 0x00176ba8
MOV RAX,qword ptr [RSP + 0x90]
INC RAX
ADD R12,0x10
MOV RCX,qword ptr [RSP + 0x60]
CMP RCX,RAX
JNZ 0x00176c21
MOV R9,qword ptr [RSP + 0x48]
MOV R10,qword ptr [RSP + 0x58]
JMP 0x00176c6f
LAB_00176c6d:
XOR ECX,ECX
LAB_00176c6f:
TEST R10,R10
JZ 0x00176caa
SHL R10,0x4
XOR EAX,EAX
LAB_00176c7a:
MOV RDI,qword ptr [R13 + RAX*0x1 + 0x20]
MOV RDX,qword ptr [R13 + RAX*0x1 + 0x28]
MOV qword ptr [RSP + 0x28],RDI
CMP EDX,-0x9
JC 0x00176c95
MOV RSI,qword ptr [RSP + 0x28]
INC dword ptr [RSI]
LAB_00176c95:
MOV qword ptr [R12 + RAX*0x1],RDI
MOV qword ptr [R12 + RAX*0x1 + 0x8],RDX
ADD RAX,0x10
CMP R10,RAX
JNZ 0x00176c7a
ADD R12,RAX
LAB_00176caa:
ADD RCX,qword ptr [RSP + 0x78]
CMP RCX,R9
MOV R13,qword ptr [RSP + 0x38]
JGE 0x00176d82
LAB_00176cbd:
MOV qword ptr [RSP + 0x60],RCX
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,R15
MOV R8,R12
CALL 0x0014cabd
CMP EAX,-0x1
JZ 0x00176e0d
MOV RCX,qword ptr [RSP + 0x60]
INC RCX
ADD R12,0x10
CMP RCX,qword ptr [RSP + 0x48]
JL 0x00176cbd
JMP 0x00176d82
LAB_00176cf6:
XOR ECX,ECX
LAB_00176cf8:
TEST R10,R10
JZ 0x00176d34
SHL R10,0x4
XOR R8D,R8D
LAB_00176d04:
MOV RDX,qword ptr [R13 + R8*0x1 + 0x20]
MOV RSI,qword ptr [R13 + R8*0x1 + 0x28]
MOV qword ptr [RSP + 0x28],RDX
CMP ESI,-0x9
JC 0x00176d1f
MOV RDI,qword ptr [RSP + 0x28]
INC dword ptr [RDI]
LAB_00176d1f:
MOV qword ptr [R12 + R8*0x1],RDX
MOV qword ptr [R12 + R8*0x1 + 0x8],RSI
ADD R8,0x10
CMP R10,R8
JNZ 0x00176d04
ADD R12,R8
LAB_00176d34:
ADD RCX,qword ptr [RSP + 0x78]
CMP RCX,R9
MOV R13,qword ptr [RSP + 0x38]
JGE 0x00176d82
MOV RDX,RCX
SHL RDX,0x4
ADD RAX,RDX
ADD RAX,0x8
LAB_00176d51:
MOV RDI,qword ptr [RAX + -0x8]
MOV RDX,qword ptr [RAX]
MOV qword ptr [RSP + 0x28],RDI
CMP EDX,-0x9
JC 0x00176d69
MOV RSI,qword ptr [RSP + 0x28]
INC dword ptr [RSI]
LAB_00176d69:
MOV qword ptr [R12],RDI
MOV qword ptr [R12 + 0x8],RDX
INC RCX
ADD R12,0x10
ADD RAX,0x10
CMP RCX,R9
JL 0x00176d51
LAB_00176d82:
MOV RCX,qword ptr [RSP + 0x88]
MOV RAX,RCX
SHR RAX,0x1f
CVTSI2SD XMM0,RCX
MOV ECX,ECX
MOVQ R8,XMM0
CMOVZ R8,RCX
MOV R9D,0x7
CMOVZ R9,RAX
MOV RSI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],R13
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,RBX
MOV RDX,R13
MOV ECX,0x32
CALL 0x00123774
TEST EAX,EAX
JS 0x00176df5
LAB_00176de8:
MOV dword ptr [RSP + 0x40],0x0
JMP 0x00176a8d
LAB_00176df5:
XOR EBP,EBP
MOV RDX,R13
JMP 0x00176986
LAB_00176dff:
MOV ESI,dword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x38]
MOV DL,0x1
JMP 0x00176bc0
LAB_00176e0d:
MOV RDX,R13
JMP 0x00176984
|
int1 [16]
js_array_toSpliced(long param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int *piVar1;
bool bVar2;
int iVar3;
long lVar4;
long lVar6;
int8 *puVar7;
long lVar8;
int8 uVar9;
long lVar10;
ulong uVar11;
ulong uVar12;
double dVar13;
int8 uVar14;
ulong uVar15;
int8 *puVar16;
int8 *puVar17;
int1 auVar18 [16];
int1 auVar19 [16];
ulong local_88;
long local_60;
long local_58;
long local_50;
ulong local_48;
ulong local_40;
long local_38;
ulong uVar5;
local_88 = local_88 & 0xffffffff00000000;
auVar18 = JS_ToObject();
uVar9 = auVar18._8_8_;
lVar4 = auVar18._0_8_;
iVar3 = js_get_length64(param_1,&local_48,lVar4,uVar9);
uVar11 = local_48;
auVar19._8_8_ = 3;
auVar19._0_8_ = local_88;
if (iVar3 != 0) {
LAB_00176981:
puVar17 = (int8 *)0x0;
puVar16 = (int8 *)0x0;
goto LAB_00176986;
}
local_58 = 0;
if (param_4 < 1) {
local_60 = 0;
LAB_001769e3:
if (1 < param_4) {
iVar3 = JS_ToInt64Clamp(param_1,&local_60,param_5[2],param_5[3],0,local_60,0);
auVar19._8_8_ = 3;
if (iVar3 != 0) goto LAB_00176981;
}
uVar11 = 0;
if (2 < param_4) {
uVar11 = (ulong)(param_4 - 2);
}
uVar15 = (local_48 + uVar11) - local_60;
if (0xffffffff < (long)uVar15) {
if ((long)uVar15 < 0x20000000000000) {
JS_ThrowRangeError(param_1,"invalid array length");
}
else {
JS_ThrowTypeError();
}
goto LAB_00176a82;
}
local_50 = local_60;
piVar1 = *(int **)(param_1 + 0x38);
*piVar1 = *piVar1 + 1;
auVar19 = JS_NewObjectFromShape(param_1,piVar1,2);
uVar5 = auVar19._0_8_;
if (auVar19._8_4_ == 6) goto LAB_00176981;
if (0 < (long)uVar15) {
iVar3 = expand_fast_array(param_1,uVar5,uVar15 & 0xffffffff);
lVar8 = local_58;
if (iVar3 < 0) {
puVar17 = (int8 *)0x0;
puVar16 = (int8 *)0x0;
}
else {
*(int *)(uVar5 + 0x40) = (int)uVar15;
puVar16 = *(int8 **)(uVar5 + 0x38);
lVar6 = lVar4;
if (auVar18._8_4_ == -1) {
if ((*(short *)(lVar4 + 6) == 2) && ((*(byte *)(lVar4 + 5) & 8) != 0)) {
uVar12 = (ulong)*(uint *)(lVar4 + 0x40);
bVar2 = true;
lVar6 = *(long *)(lVar4 + 0x38);
}
else {
uVar12 = 0;
bVar2 = false;
}
}
else {
uVar12 = 0;
bVar2 = false;
}
puVar17 = puVar16 + uVar15 * 2;
local_40 = uVar15;
if ((bVar2) && (local_48 == uVar12)) {
if (local_58 < 1) {
lVar8 = 0;
}
else {
puVar7 = (int8 *)(lVar6 + 8);
lVar10 = local_58;
do {
piVar1 = (int *)puVar7[-1];
uVar14 = *puVar7;
if (0xfffffff6 < (uint)uVar14) {
*piVar1 = *piVar1 + 1;
}
*puVar16 = piVar1;
puVar16[1] = uVar14;
puVar16 = puVar16 + 2;
puVar7 = puVar7 + 2;
lVar10 = lVar10 + -1;
} while (lVar10 != 0);
}
if (uVar11 != 0) {
lVar10 = 0;
do {
piVar1 = *(int **)((long)param_5 + lVar10 + 0x20);
uVar14 = *(int8 *)((long)param_5 + lVar10 + 0x28);
if (0xfffffff6 < (uint)uVar14) {
*piVar1 = *piVar1 + 1;
}
*(int **)((long)puVar16 + lVar10) = piVar1;
*(int8 *)((long)puVar16 + lVar10 + 8) = uVar14;
lVar10 = lVar10 + 0x10;
} while (uVar11 * 0x10 != lVar10);
puVar16 = (int8 *)((long)puVar16 + lVar10);
}
lVar8 = lVar8 + local_50;
if (lVar8 < (long)local_48) {
puVar7 = (int8 *)(lVar6 + lVar8 * 0x10 + 8);
do {
piVar1 = (int *)puVar7[-1];
uVar14 = *puVar7;
if (0xfffffff6 < (uint)uVar14) {
*piVar1 = *piVar1 + 1;
}
*puVar16 = piVar1;
puVar16[1] = uVar14;
lVar8 = lVar8 + 1;
puVar16 = puVar16 + 2;
puVar7 = puVar7 + 2;
} while (lVar8 < (long)local_48);
}
}
else {
if (local_58 < 1) {
lVar8 = 0;
}
else {
lVar6 = 0;
do {
local_38 = lVar6;
iVar3 = JS_TryGetPropertyInt64(param_1,lVar4,uVar9,lVar6,puVar16);
if (iVar3 == -1) goto LAB_00176986;
lVar6 = local_38 + 1;
puVar16 = puVar16 + 2;
} while (lVar8 != lVar6);
}
if (uVar11 != 0) {
lVar6 = 0;
do {
piVar1 = *(int **)((long)param_5 + lVar6 + 0x20);
uVar14 = *(int8 *)((long)param_5 + lVar6 + 0x28);
if (0xfffffff6 < (uint)uVar14) {
*piVar1 = *piVar1 + 1;
}
*(int **)((long)puVar16 + lVar6) = piVar1;
*(int8 *)((long)puVar16 + lVar6 + 8) = uVar14;
lVar6 = lVar6 + 0x10;
} while (uVar11 * 0x10 != lVar6);
puVar16 = (int8 *)((long)puVar16 + lVar6);
}
for (lVar8 = lVar8 + local_50; lVar8 < (long)local_48; lVar8 = lVar8 + 1) {
iVar3 = JS_TryGetPropertyInt64(param_1,lVar4,uVar9,lVar8,puVar16);
if (iVar3 == -1) goto LAB_00176986;
puVar16 = puVar16 + 2;
}
}
bVar2 = local_40 >> 0x1f == 0;
dVar13 = (double)(long)local_40;
if (bVar2) {
dVar13 = (double)(local_40 & 0xffffffff);
}
uVar14 = 7;
if (bVar2) {
uVar14 = 0;
}
iVar3 = JS_SetPropertyInternal2
(param_1,uVar5,auVar19._8_8_,0x32,dVar13,uVar14,uVar5,auVar19._8_4_,0x4000
,0);
if (-1 < iVar3) goto LAB_00176de8;
}
LAB_00176986:
auVar18 = ZEXT816(6) << 0x40;
goto joined_r0x00176a95;
}
puVar17 = (int8 *)0x0;
puVar16 = (int8 *)0x0;
LAB_00176de8:
local_88 = uVar5 & 0xffffffff00000000;
auVar18 = auVar19;
}
else {
iVar3 = JS_ToInt64Clamp(param_1,&local_58,*param_5,param_5[1],0,local_48,local_48);
if (iVar3 == 0) {
local_60 = uVar11 - local_58;
goto LAB_001769e3;
}
LAB_00176a82:
puVar17 = (int8 *)0x0;
puVar16 = (int8 *)0x0;
auVar18 = ZEXT816(6) << 0x40;
}
auVar19._8_8_ = 3;
auVar19._0_8_ = local_88;
joined_r0x00176a95:
while( true ) {
local_88 = auVar19._0_8_;
if (puVar16 == puVar17) break;
*(int4 *)puVar16 = 0;
puVar16[1] = 3;
puVar16 = puVar16 + 2;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_88,auVar19._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar4,uVar9);
return auVar18;
}
|
|
13,742
|
js_array_toSpliced
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_toSpliced(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue arr, obj, ret, *arrp, *pval, *last;
JSObject *p;
int64_t i, j, len, newlen, start, add, del;
uint32_t count32;
pval = NULL;
last = NULL;
ret = JS_EXCEPTION;
arr = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
start = 0;
if (argc > 0)
if (JS_ToInt64Clamp(ctx, &start, argv[0], 0, len, len))
goto exception;
del = 0;
if (argc > 0)
del = len - start;
if (argc > 1)
if (JS_ToInt64Clamp(ctx, &del, argv[1], 0, del, 0))
goto exception;
add = 0;
if (argc > 2)
add = argc - 2;
newlen = len + add - del;
if (newlen > UINT32_MAX) {
// Per spec: TypeError if newlen >= 2**53, RangeError below
if (newlen > MAX_SAFE_INTEGER) {
JS_ThrowTypeError(ctx, "invalid array length");
} else {
JS_ThrowRangeError(ctx, "invalid array length");
}
goto exception;
}
arr = JS_NewArray(ctx);
if (JS_IsException(arr))
goto exception;
if (newlen <= 0)
goto done;
p = JS_VALUE_GET_OBJ(arr);
if (expand_fast_array(ctx, p, newlen) < 0)
goto exception;
p->u.array.count = newlen;
pval = &p->u.array.u.values[0];
last = &p->u.array.u.values[newlen];
if (js_get_fast_array(ctx, obj, &arrp, &count32) && count32 == len) {
for (i = 0; i < start; i++, pval++)
*pval = js_dup(arrp[i]);
for (j = 0; j < add; j++, pval++)
*pval = js_dup(argv[2 + j]);
for (i += del; i < len; i++, pval++)
*pval = js_dup(arrp[i]);
} else {
for (i = 0; i < start; i++, pval++)
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
goto exception;
for (j = 0; j < add; j++, pval++)
*pval = js_dup(argv[2 + j]);
for (i += del; i < len; i++, pval++)
if (-1 == JS_TryGetPropertyInt64(ctx, obj, i, pval))
goto exception;
}
assert(pval == last);
if (JS_SetProperty(ctx, arr, JS_ATOM_length, js_int64(newlen)) < 0)
goto exception;
done:
ret = arr;
arr = JS_UNDEFINED;
exception:
while (pval != last)
*pval++ = JS_UNDEFINED;
JS_FreeValue(ctx, arr);
JS_FreeValue(ctx, obj);
return ret;
}
|
O3
|
c
|
js_array_toSpliced:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r13
movl %ecx, %r12d
movq %rdi, %r15
callq 0x268d8
movq %rax, %rbx
movq %rdx, %r14
leaq 0x80(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x226df
testl %eax, %eax
je 0x79272
addq $0x18, %r15
movl $0x6, %r12d
xorl %ebp, %ebp
movq (%r15), %rdi
cmpl $-0x9, %r14d
jb 0x7925a
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x7925a
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
movq %rbp, %rax
movq %r12, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, 0x78(%rsp)
xorl %esi, %esi
movq 0x80(%rsp), %rbp
testl %r12d, %r12d
jle 0x792fe
movq (%r13), %rdx
movq 0x8(%r13), %rcx
movq %rbp, (%rsp)
leaq 0x78(%rsp), %rsi
movq %r15, %rdi
xorl %r8d, %r8d
movq %rbp, %r9
callq 0x272da
testl %eax, %eax
jne 0x7922e
movq 0x78(%rsp), %rcx
movq %rbp, %r9
subq %rcx, %r9
movq %r9, 0x70(%rsp)
cmpl $0x1, %r12d
je 0x792fa
movq %rcx, 0x28(%rsp)
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movq $0x0, (%rsp)
leaq 0x70(%rsp), %rsi
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x272da
testl %eax, %eax
jne 0x7922e
movq 0x70(%rsp), %r9
movq 0x28(%rsp), %rcx
xorl %esi, %esi
jmp 0x79303
xorl %ecx, %ecx
xorl %r9d, %r9d
leal -0x2(%r12), %eax
cmpl $0x3, %r12d
cmovgel %eax, %esi
leaq (%rsi,%rbp), %rdx
subq %r9, %rdx
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, %rdx
jl 0x7934b
leaq 0x2773a(%rip), %rsi # 0xa0a66
movq %r15, %rdi
xorl %eax, %eax
shrq $0x35, %rdx
je 0x79341
callq 0x2214f
jmp 0x7922e
callq 0x205f0
jmp 0x7922e
movq %r9, 0x50(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%r15), %rsi
incl (%rsi)
movq %r15, %rdi
movl $0x2, %edx
callq 0xf4c7
movl $0x6, %r12d
xorl %esi, %esi
cmpl $0x6, %edx
jne 0x79388
movl %eax, %esi
xorl %ebp, %ebp
jmp 0x795f5
movl $0x3, %edi
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
jle 0x7942f
movq %rdx, 0x48(%rsp)
movq %r15, %rdi
movq %rax, %rsi
movl %ecx, %edx
movq %rax, 0x30(%rsp)
callq 0x3e5ce
testl %eax, %eax
js 0x7948b
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %rax
movl %eax, 0x40(%rcx)
movq 0x38(%rcx), %r8
shlq $0x4, %rax
addq %r8, %rax
movq %rax, 0x40(%rsp)
cmpl $-0x1, %r14d
jne 0x7943d
cmpw $0x2, 0x6(%rbx)
jne 0x7943d
testb $0x8, 0x5(%rbx)
je 0x7943d
movl 0x40(%rbx), %eax
cmpq %rax, %rbp
jne 0x7943d
movq 0x38(%rbx), %rax
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
jle 0x7964a
leaq 0x8(%rax), %rcx
movq -0x8(%rcx), %rsi
movq (%rcx), %rdi
cmpl $-0x9, %edi
jb 0x79416
incl (%rsi)
movq %rsi, (%r8)
movq %rdi, 0x8(%r8)
addq $0x10, %r8
addq $0x10, %rcx
decq %rdx
jne 0x79408
jmp 0x79653
xorl %r8d, %r8d
xorl %r13d, %r13d
movq %rax, %rbp
jmp 0x795ce
cmpq $0x0, 0x28(%rsp)
movq %rbp, 0x68(%rsp)
jle 0x7949e
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %r8, 0x38(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x4e98a
cmpl $-0x1, %eax
je 0x795a3
incq %r12
movq 0x38(%rsp), %r8
addq $0x10, %r8
movq 0x28(%rsp), %rcx
cmpq %r12, %rcx
jne 0x7944f
movq 0x68(%rsp), %rbp
jmp 0x794a0
xorl %ebp, %ebp
movq 0x30(%rsp), %rax
movl %eax, %esi
movq 0x48(%rsp), %rdx
jmp 0x795f5
xorl %ecx, %ecx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
movq 0x50(%rsp), %r9
je 0x794db
shlq $0x4, %rdi
xorl %eax, %eax
movq 0x20(%r13,%rax), %rsi
movq 0x28(%r13,%rax), %rdx
cmpl $-0x9, %edx
jb 0x794c6
incl (%rsi)
movq %rsi, (%r8,%rax)
movq %rdx, 0x8(%r8,%rax)
addq $0x10, %rax
cmpq %rax, %rdi
jne 0x794b5
addq %rax, %r8
addq %r9, %rcx
cmpq %rbp, %rcx
jge 0x79516
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r8, %r13
movq %rcx, %r12
callq 0x4e98a
cmpl $-0x1, %eax
je 0x79632
incq %r12
addq $0x10, %r13
cmpq 0x68(%rsp), %r12
movq %r13, %r8
movq %r12, %rcx
jl 0x794e5
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rdx
movq %rdx, %rax
shrq $0x1f, %rax
movl %edx, %ecx
cvtsi2sd %rdx, %xmm0
movq %xmm0, %r8
cmoveq %rcx, %r8
movl $0x7, %r9d
cmoveq %rax, %r9
movq 0x30(%rsp), %r13
movq %r13, 0x88(%rsp)
movq 0x48(%rsp), %r12
movq %r12, 0x90(%rsp)
movups 0x88(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x32, %ecx
callq 0x23d7f
xorl %ebp, %ebp
testl %eax, %eax
js 0x795b6
xorl %esi, %esi
movq %r13, %rbp
movq %r12, %rdx
movq %r13, %rax
movl $0x3, %edi
jmp 0x795c4
movq 0x30(%rsp), %rax
movl %eax, %esi
movq 0x48(%rsp), %rdi
movl $0x6, %edx
jmp 0x795c4
movl %r13d, %esi
movq %r12, %rdi
movl $0x6, %edx
movq %r13, %rax
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r13
cmpq %r8, %r13
je 0x795ef
movl $0x0, (%r13)
movq $0x3, 0x8(%r13)
leaq 0x10(%r13), %rcx
movq %rcx, %r13
cmpq %r8, %rcx
jne 0x795d3
movq %rdx, %r12
movq %rdi, %rdx
movq 0x18(%r15), %rdi
cmpl $-0x9, %edx
jb 0x7923d
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
movl %esi, %esi
orq %rax, %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x7923d
addq $0x18, %r15
callq 0x20d90
jmp 0x7923a
movq 0x30(%rsp), %rax
movl %eax, %esi
movq 0x48(%rsp), %rdi
movl $0x6, %edx
movq 0x40(%rsp), %r8
jmp 0x795ce
movq $0x0, 0x28(%rsp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x79689
shlq $0x4, %rdi
xorl %ecx, %ecx
movq 0x20(%r13,%rcx), %rdx
movq 0x28(%r13,%rcx), %rsi
cmpl $-0x9, %esi
jb 0x79674
incl (%rdx)
movq %rdx, (%r8,%rcx)
movq %rsi, 0x8(%r8,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rdi
jne 0x79663
addq %rcx, %r8
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rcx
addq %rcx, %rdi
cmpq %rbp, %rdi
jge 0x79516
movq %rbp, %rsi
movq %rdi, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq -0x8(%rax), %rcx
movq (%rax), %rdx
cmpl $-0x9, %edx
jb 0x796be
incl (%rcx)
movq %rcx, (%r8)
movq %rdx, 0x8(%r8)
incq %rdi
addq $0x10, %r8
addq $0x10, %rax
cmpq %rsi, %rdi
jl 0x796b0
jmp 0x79516
|
js_array_toSpliced:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r13, r8
mov r12d, ecx
mov r15, rdi
call JS_ToObject
mov rbx, rax
mov r14, rdx
lea rsi, [rsp+0C8h+var_48]
mov rdi, r15
mov rdx, rax
mov rcx, r14
call js_get_length64
test eax, eax
jz short loc_79272
loc_7922E:
add r15, 18h
mov r12d, 6
xor ebp, ebp
loc_7923A:
mov rdi, [r15]
loc_7923D:
cmp r14d, 0FFFFFFF7h
jb short loc_7925A
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_7925A
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_7925A:
mov rax, rbp
mov rdx, r12
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_79272:
mov [rsp+0C8h+var_50], 0
xor esi, esi
mov rbp, [rsp+0C8h+var_48]
test r12d, r12d
jle short loc_792FE
mov rdx, [r13+0]
mov rcx, [r13+8]
mov qword ptr [rsp+0C8h+var_C8], rbp
lea rsi, [rsp+0C8h+var_50]
mov rdi, r15
xor r8d, r8d
mov r9, rbp
call JS_ToInt64Clamp
test eax, eax
jnz short loc_7922E
mov rcx, [rsp+0C8h+var_50]
mov r9, rbp
sub r9, rcx
mov [rsp+0C8h+var_58], r9
cmp r12d, 1
jz short loc_792FA
mov [rsp+0C8h+var_A0], rcx
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov qword ptr [rsp+0C8h+var_C8], 0
lea rsi, [rsp+0C8h+var_58]
mov rdi, r15
xor r8d, r8d
call JS_ToInt64Clamp
test eax, eax
jnz loc_7922E
mov r9, [rsp+0C8h+var_58]
mov rcx, [rsp+0C8h+var_A0]
loc_792FA:
xor esi, esi
jmp short loc_79303
loc_792FE:
xor ecx, ecx
xor r9d, r9d
loc_79303:
lea eax, [r12-2]
cmp r12d, 3
cmovge esi, eax
lea rdx, [rsi+rbp]
sub rdx, r9
mov rax, 100000000h
cmp rdx, rax
jl short loc_7934B
lea rsi, aInvalidArrayLe; "invalid array length"
mov rdi, r15
xor eax, eax
shr rdx, 35h
jz short loc_79341
call JS_ThrowTypeError
jmp loc_7922E
loc_79341:
call JS_ThrowRangeError
jmp loc_7922E
loc_7934B:
mov [rsp+0C8h+var_78], r9
mov [rsp+0C8h+var_68], rsi
mov [rsp+0C8h+var_70], rdx
mov [rsp+0C8h+var_A0], rcx
mov rsi, [r15+38h]
inc dword ptr [rsi]
mov rdi, r15
mov edx, 2
call JS_NewObjectFromShape
mov r12d, 6
xor esi, esi
cmp edx, 6
jnz short loc_79388
mov esi, eax
xor ebp, ebp
jmp loc_795F5
loc_79388:
mov edi, 3
mov rcx, [rsp+0C8h+var_70]
test rcx, rcx
jle loc_7942F
mov [rsp+0C8h+var_80], rdx
mov rdi, r15
mov rsi, rax
mov edx, ecx
mov [rsp+0C8h+var_98], rax
call expand_fast_array
test eax, eax
js loc_7948B
mov rcx, [rsp+0C8h+var_98]
mov rax, [rsp+0C8h+var_70]
mov [rcx+40h], eax
mov r8, [rcx+38h]
shl rax, 4
add rax, r8
mov [rsp+0C8h+var_88], rax
cmp r14d, 0FFFFFFFFh
jnz short loc_7943D
cmp word ptr [rbx+6], 2
jnz short loc_7943D
test byte ptr [rbx+5], 8
jz short loc_7943D
mov eax, [rbx+40h]
cmp rbp, rax
jnz short loc_7943D
mov rax, [rbx+38h]
mov rdx, [rsp+0C8h+var_A0]
test rdx, rdx
jle loc_7964A
lea rcx, [rax+8]
loc_79408:
mov rsi, [rcx-8]
mov rdi, [rcx]
cmp edi, 0FFFFFFF7h
jb short loc_79416
inc dword ptr [rsi]
loc_79416:
mov [r8], rsi
mov [r8+8], rdi
add r8, 10h
add rcx, 10h
dec rdx
jnz short loc_79408
jmp loc_79653
loc_7942F:
xor r8d, r8d
xor r13d, r13d
mov rbp, rax
jmp loc_795CE
loc_7943D:
cmp [rsp+0C8h+var_A0], 0
mov [rsp+0C8h+var_60], rbp
jle short loc_7949E
xor ebp, ebp
xor r12d, r12d
loc_7944F:
mov [rsp+0C8h+var_90], r8
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov rcx, r12
call JS_TryGetPropertyInt64
cmp eax, 0FFFFFFFFh
jz loc_795A3
inc r12
mov r8, [rsp+0C8h+var_90]
add r8, 10h
mov rcx, [rsp+0C8h+var_A0]
cmp rcx, r12
jnz short loc_7944F
mov rbp, [rsp+0C8h+var_60]
jmp short loc_794A0
loc_7948B:
xor ebp, ebp
mov rax, [rsp+0C8h+var_98]
mov esi, eax
mov rdx, [rsp+0C8h+var_80]
jmp loc_795F5
loc_7949E:
xor ecx, ecx
loc_794A0:
mov rdi, [rsp+0C8h+var_68]
test rdi, rdi
mov r9, [rsp+0C8h+var_78]
jz short loc_794DB
shl rdi, 4
xor eax, eax
loc_794B5:
mov rsi, [r13+rax+20h]
mov rdx, [r13+rax+28h]
cmp edx, 0FFFFFFF7h
jb short loc_794C6
inc dword ptr [rsi]
loc_794C6:
mov [r8+rax], rsi
mov [r8+rax+8], rdx
add rax, 10h
cmp rdi, rax
jnz short loc_794B5
add r8, rax
loc_794DB:
add rcx, r9
cmp rcx, rbp
jge short loc_79516
xor ebp, ebp
loc_794E5:
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov r13, r8
mov r12, rcx
call JS_TryGetPropertyInt64
cmp eax, 0FFFFFFFFh
jz loc_79632
inc r12
add r13, 10h
cmp r12, [rsp+0C8h+var_60]
mov r8, r13
mov rcx, r12
jl short loc_794E5
loc_79516:
mov [rsp+0C8h+var_90], r8
mov rdx, [rsp+0C8h+var_70]
mov rax, rdx
shr rax, 1Fh
mov ecx, edx
cvtsi2sd xmm0, rdx
movq r8, xmm0
cmovz r8, rcx
mov r9d, 7
cmovz r9, rax
mov r13, [rsp+0C8h+var_98]
mov qword ptr [rsp+0C8h+var_40], r13
mov r12, [rsp+0C8h+var_80]
mov qword ptr [rsp+0C8h+var_40+8], r12
movups xmm0, [rsp+0C8h+var_40]
movups [rsp+0C8h+var_C8], xmm0
mov [rsp+0C8h+var_B0], 0
mov [rsp+0C8h+var_B8], 4000h
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov ecx, 32h ; '2'
call JS_SetPropertyInternal2
xor ebp, ebp
test eax, eax
js short loc_795B6
xor esi, esi
mov rbp, r13
mov rdx, r12
mov rax, r13
mov edi, 3
jmp short loc_795C4
loc_795A3:
mov rax, [rsp+0C8h+var_98]
mov esi, eax
mov rdi, [rsp+0C8h+var_80]
mov edx, 6
jmp short loc_795C4
loc_795B6:
mov esi, r13d
mov rdi, r12
mov edx, 6
mov rax, r13
loc_795C4:
mov r8, [rsp+0C8h+var_88]
mov r13, [rsp+0C8h+var_90]
loc_795CE:
cmp r13, r8
jz short loc_795EF
loc_795D3:
mov dword ptr [r13+0], 0
mov qword ptr [r13+8], 3
lea rcx, [r13+10h]
mov r13, rcx
cmp rcx, r8
jnz short loc_795D3
loc_795EF:
mov r12, rdx
mov rdx, rdi
loc_795F5:
mov rdi, [r15+18h]
cmp edx, 0FFFFFFF7h
jb loc_7923D
mov rcx, 0FFFFFFFF00000000h
and rax, rcx
mov esi, esi
or rsi, rax
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg loc_7923D
add r15, 18h
call js_free_value_rt
jmp loc_7923A
loc_79632:
mov rax, [rsp+0C8h+var_98]
mov esi, eax
mov rdi, [rsp+0C8h+var_80]
mov edx, 6
mov r8, [rsp+0C8h+var_88]
jmp short loc_795CE
loc_7964A:
mov [rsp+0C8h+var_A0], 0
loc_79653:
mov rdi, [rsp+0C8h+var_68]
test rdi, rdi
jz short loc_79689
shl rdi, 4
xor ecx, ecx
loc_79663:
mov rdx, [r13+rcx+20h]
mov rsi, [r13+rcx+28h]
cmp esi, 0FFFFFFF7h
jb short loc_79674
inc dword ptr [rdx]
loc_79674:
mov [r8+rcx], rdx
mov [r8+rcx+8], rsi
add rcx, 10h
cmp rdi, rcx
jnz short loc_79663
add r8, rcx
loc_79689:
mov rdi, [rsp+0C8h+var_A0]
mov rcx, [rsp+0C8h+var_78]
add rdi, rcx
cmp rdi, rbp
jge loc_79516
mov rsi, rbp
mov rcx, rdi
shl rcx, 4
add rax, rcx
add rax, 8
loc_796B0:
mov rcx, [rax-8]
mov rdx, [rax]
cmp edx, 0FFFFFFF7h
jb short loc_796BE
inc dword ptr [rcx]
loc_796BE:
mov [r8], rcx
mov [r8+8], rdx
inc rdi
add r8, 10h
add rax, 10h
cmp rdi, rsi
jl short loc_796B0
jmp loc_79516
|
long long js_array_toSpliced(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v15; // r12d
long long v17; // rbx
long long v18; // rdx
long long v19; // r14
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long *v24; // r15
long long v25; // rbp
long long v26; // rdi
int v27; // eax
long long v28; // rcx
long long v30; // rsi
long long v31; // rbp
long long v32; // rcx
signed long long v33; // r9
long long v34; // rdx
long long v35; // rdx
_DWORD *v36; // rsi
long long v37; // rax
long long v38; // rdx
unsigned int v39; // esi
long long v40; // rdi
double v41; // xmm4_8
double v42; // xmm5_8
_QWORD *v43; // r8
long long v44; // rax
long long v45; // rdx
long long *v46; // rcx
_DWORD *v47; // rsi
long long v48; // rdi
_QWORD *v49; // r13
unsigned long long v50; // r12
long long v51; // rcx
long long v52; // rax
_DWORD *v53; // rsi
long long v54; // rdx
signed long long v55; // rcx
signed long long v56; // r12
double v57; // r8
long long v58; // r9
_QWORD *v59; // rsi
int v60; // eax
long long v61; // rcx
long long v62; // rcx
_DWORD *v63; // rdx
long long v64; // rsi
long long v65; // rdi
long long *v66; // rax
_DWORD *v67; // rcx
long long v68; // rdx
char v69; // [rsp+0h] [rbp-C8h]
unsigned long long v70; // [rsp+28h] [rbp-A0h]
long long v71; // [rsp+28h] [rbp-A0h]
long long v72; // [rsp+30h] [rbp-98h]
_QWORD *v73; // [rsp+38h] [rbp-90h]
_QWORD *v74; // [rsp+40h] [rbp-88h]
long long v75; // [rsp+48h] [rbp-80h]
signed long long v76; // [rsp+50h] [rbp-78h]
unsigned long long v77; // [rsp+58h] [rbp-70h]
long long v78; // [rsp+60h] [rbp-68h]
long long v79; // [rsp+68h] [rbp-60h]
signed long long v80; // [rsp+70h] [rbp-58h] BYREF
unsigned long long v81; // [rsp+78h] [rbp-50h] BYREF
long long v82; // [rsp+80h] [rbp-48h] BYREF
__m128 v83; // [rsp+88h] [rbp-40h]
v15 = a4;
v17 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
if ( (unsigned int)js_get_length64(a1, &v82, v17, v18) )
goto LABEL_2;
v81 = 0LL;
v30 = 0LL;
v31 = v82;
if ( v15 > 0 )
{
if ( !(unsigned int)JS_ToInt64Clamp(a1, &v81, *(_DWORD **)a5, *(_QWORD *)(a5 + 8), 0LL, v82, v82) )
{
v32 = v81;
v33 = v31 - v81;
v80 = v31 - v81;
if ( v15 == 1 )
{
LABEL_13:
v30 = 0LL;
goto LABEL_15;
}
v70 = v81;
if ( !(unsigned int)JS_ToInt64Clamp(
a1,
(unsigned long long *)&v80,
*(_DWORD **)(a5 + 16),
*(_QWORD *)(a5 + 24),
0LL,
v33,
0LL) )
{
v33 = v80;
v32 = v70;
goto LABEL_13;
}
}
LABEL_2:
v24 = (long long *)(a1 + 24);
v25 = 0LL;
LABEL_3:
v26 = *v24;
goto LABEL_4;
}
v32 = 0LL;
v33 = 0LL;
LABEL_15:
if ( v15 >= 3 )
v30 = (unsigned int)(v15 - 2);
v34 = v30 + v31 - v33;
if ( v34 >= 0x100000000LL )
{
v35 = (unsigned long long)v34 >> 53;
if ( v35 )
JS_ThrowTypeError(
a1,
(long long)"invalid array length",
v35,
v32,
v20,
v33,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v69);
else
JS_ThrowRangeError(
a1,
(long long)"invalid array length",
0LL,
v32,
v20,
v33,
a7,
a8,
a9,
a10,
v22,
v23,
a13,
a14,
v69);
goto LABEL_2;
}
v76 = v33;
v78 = v30;
v77 = v30 + v31 - v33;
v71 = v32;
v36 = *(_DWORD **)(a1 + 56);
++*v36;
v37 = JS_NewObjectFromShape(a1, v36, 2u);
v39 = 0;
if ( (_DWORD)v38 == 6 )
{
v39 = v37;
v25 = 0LL;
goto LABEL_65;
}
v40 = 3LL;
if ( (long long)v77 > 0 )
{
v75 = v38;
v72 = v37;
if ( (int)expand_fast_array(a1, v37, v77) < 0 )
{
v25 = 0LL;
v37 = v72;
v39 = v72;
v38 = v75;
goto LABEL_65;
}
*(_DWORD *)(v72 + 64) = v77;
v43 = *(_QWORD **)(v72 + 56);
v74 = &v43[2 * v77];
if ( (_DWORD)v19 == -1 && *(_WORD *)(v17 + 6) == 2 && (*(_BYTE *)(v17 + 5) & 8) != 0 && v31 == *(_DWORD *)(v17 + 64) )
{
v44 = *(_QWORD *)(v17 + 56);
v45 = v71;
if ( v71 <= 0 )
{
v71 = 0LL;
}
else
{
v46 = (long long *)(v44 + 8);
do
{
v47 = (_DWORD *)*(v46 - 1);
v48 = *v46;
if ( (unsigned int)*v46 >= 0xFFFFFFF7 )
++*v47;
*v43 = v47;
v43[1] = v48;
v43 += 2;
v46 += 2;
--v45;
}
while ( v45 );
}
if ( v78 )
{
v62 = 0LL;
do
{
v63 = *(_DWORD **)(a5 + v62 * 8 + 32);
v64 = *(_QWORD *)(a5 + v62 * 8 + 40);
if ( (unsigned int)v64 >= 0xFFFFFFF7 )
++*v63;
v43[v62] = v63;
v43[v62 + 1] = v64;
v62 += 2LL;
}
while ( 2 * v78 != v62 );
v43 = (_QWORD *)((char *)v43 + v62 * 8);
}
v65 = v76 + v71;
if ( v76 + v71 < v31 )
{
v66 = (long long *)(16 * v65 + v44 + 8);
do
{
v67 = (_DWORD *)*(v66 - 1);
v68 = *v66;
if ( (unsigned int)*v66 >= 0xFFFFFFF7 )
++*v67;
*v43 = v67;
v43[1] = v68;
++v65;
v43 += 2;
v66 += 2;
}
while ( v65 < v31 );
}
}
else
{
v79 = v31;
if ( v71 > 0 )
{
v25 = 0LL;
v50 = 0LL;
while ( 1 )
{
v73 = v43;
if ( (unsigned int)JS_TryGetPropertyInt64(a1, v17, v19, v50, (long long)v43) == -1 )
break;
++v50;
v43 = v73 + 2;
v51 = v71;
if ( v71 == v50 )
{
v31 = v79;
goto LABEL_43;
}
}
v37 = v72;
v39 = v72;
v40 = v75;
goto LABEL_61;
}
v51 = 0LL;
LABEL_43:
if ( v78 )
{
v52 = 0LL;
do
{
v53 = *(_DWORD **)(a5 + v52 * 8 + 32);
v54 = *(_QWORD *)(a5 + v52 * 8 + 40);
if ( (unsigned int)v54 >= 0xFFFFFFF7 )
++*v53;
v43[v52] = v53;
v43[v52 + 1] = v54;
v52 += 2LL;
}
while ( 2 * v78 != v52 );
v43 = (_QWORD *)((char *)v43 + v52 * 8);
}
v55 = v76 + v51;
if ( v55 < v31 )
{
v25 = 0LL;
while ( 1 )
{
v49 = v43;
v56 = v55;
if ( (unsigned int)JS_TryGetPropertyInt64(a1, v17, v19, v55, (long long)v43) == -1 )
break;
v43 = v49 + 2;
v55 = v56 + 1;
if ( v56 + 1 >= v79 )
goto LABEL_53;
}
v37 = v72;
v39 = v72;
v40 = v75;
v20 = (long long)v74;
goto LABEL_62;
}
}
LABEL_53:
v73 = v43;
v57 = (double)(int)v77;
if ( !(v77 >> 31) )
*(_QWORD *)&v57 = (unsigned int)v77;
v58 = 7LL;
if ( !(v77 >> 31) )
v58 = v77 >> 31;
v83.m128_u64[0] = v72;
v83.m128_u64[1] = v75;
v25 = 0LL;
if ( (int)JS_SetPropertyInternal2(
a1,
v72,
v75,
0x32u,
*(long long *)&v57,
v58,
v83,
a8,
a9,
a10,
v41,
v42,
a13,
a14,
v72,
v75,
0x4000u,
0LL) < 0 )
{
v39 = v72;
v40 = v75;
v37 = v72;
}
else
{
v39 = 0;
v25 = v72;
v37 = v72;
v40 = 3LL;
}
LABEL_61:
v20 = (long long)v74;
v49 = v73;
goto LABEL_62;
}
v20 = 0LL;
v49 = 0LL;
v25 = v37;
LABEL_62:
while ( v49 != (_QWORD *)v20 )
{
*(_DWORD *)v49 = 0;
v49[1] = 3LL;
v49 += 2;
}
v38 = v40;
LABEL_65:
v26 = *(_QWORD *)(a1 + 24);
if ( (unsigned int)v38 >= 0xFFFFFFF7 )
{
v59 = (_QWORD *)(v37 & 0xFFFFFFFF00000000LL | v39);
v60 = *(_DWORD *)v59;
v61 = (unsigned int)(*(_DWORD *)v59 - 1);
*(_DWORD *)v59 = v61;
if ( v60 <= 1 )
{
v24 = (long long *)(a1 + 24);
js_free_value_rt(v26, v59, v38, v61, v20, v21);
goto LABEL_3;
}
}
LABEL_4:
if ( (unsigned int)v19 >= 0xFFFFFFF7 )
{
v27 = *(_DWORD *)v17;
v28 = (unsigned int)(*(_DWORD *)v17 - 1);
*(_DWORD *)v17 = v28;
if ( v27 <= 1 )
js_free_value_rt(v26, (_QWORD *)v17, v19, v28, v20, v21);
}
return v25;
}
|
js_array_toSpliced:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R13,R8
MOV R12D,ECX
MOV R15,RDI
CALL 0x001268d8
MOV RBX,RAX
MOV R14,RDX
LEA RSI,[RSP + 0x80]
MOV RDI,R15
MOV RDX,RAX
MOV RCX,R14
CALL 0x001226df
TEST EAX,EAX
JZ 0x00179272
LAB_0017922e:
ADD R15,0x18
MOV R12D,0x6
XOR EBP,EBP
LAB_0017923a:
MOV RDI,qword ptr [R15]
LAB_0017923d:
CMP R14D,-0x9
JC 0x0017925a
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x0017925a
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
LAB_0017925a:
MOV RAX,RBP
MOV RDX,R12
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00179272:
MOV qword ptr [RSP + 0x78],0x0
XOR ESI,ESI
MOV RBP,qword ptr [RSP + 0x80]
TEST R12D,R12D
JLE 0x001792fe
MOV RDX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
MOV qword ptr [RSP],RBP
LEA RSI,[RSP + 0x78]
MOV RDI,R15
XOR R8D,R8D
MOV R9,RBP
CALL 0x001272da
TEST EAX,EAX
JNZ 0x0017922e
MOV RCX,qword ptr [RSP + 0x78]
MOV R9,RBP
SUB R9,RCX
MOV qword ptr [RSP + 0x70],R9
CMP R12D,0x1
JZ 0x001792fa
MOV qword ptr [RSP + 0x28],RCX
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP],0x0
LEA RSI,[RSP + 0x70]
MOV RDI,R15
XOR R8D,R8D
CALL 0x001272da
TEST EAX,EAX
JNZ 0x0017922e
MOV R9,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x28]
LAB_001792fa:
XOR ESI,ESI
JMP 0x00179303
LAB_001792fe:
XOR ECX,ECX
XOR R9D,R9D
LAB_00179303:
LEA EAX,[R12 + -0x2]
CMP R12D,0x3
CMOVGE ESI,EAX
LEA RDX,[RSI + RBP*0x1]
SUB RDX,R9
MOV RAX,0x100000000
CMP RDX,RAX
JL 0x0017934b
LEA RSI,[0x1a0a66]
MOV RDI,R15
XOR EAX,EAX
SHR RDX,0x35
JZ 0x00179341
CALL 0x0012214f
JMP 0x0017922e
LAB_00179341:
CALL 0x001205f0
JMP 0x0017922e
LAB_0017934b:
MOV qword ptr [RSP + 0x50],R9
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x28],RCX
MOV RSI,qword ptr [R15 + 0x38]
INC dword ptr [RSI]
MOV RDI,R15
MOV EDX,0x2
CALL 0x0010f4c7
MOV R12D,0x6
XOR ESI,ESI
CMP EDX,0x6
JNZ 0x00179388
MOV ESI,EAX
XOR EBP,EBP
JMP 0x001795f5
LAB_00179388:
MOV EDI,0x3
MOV RCX,qword ptr [RSP + 0x58]
TEST RCX,RCX
JLE 0x0017942f
MOV qword ptr [RSP + 0x48],RDX
MOV RDI,R15
MOV RSI,RAX
MOV EDX,ECX
MOV qword ptr [RSP + 0x30],RAX
CALL 0x0013e5ce
TEST EAX,EAX
JS 0x0017948b
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x58]
MOV dword ptr [RCX + 0x40],EAX
MOV R8,qword ptr [RCX + 0x38]
SHL RAX,0x4
ADD RAX,R8
MOV qword ptr [RSP + 0x40],RAX
CMP R14D,-0x1
JNZ 0x0017943d
CMP word ptr [RBX + 0x6],0x2
JNZ 0x0017943d
TEST byte ptr [RBX + 0x5],0x8
JZ 0x0017943d
MOV EAX,dword ptr [RBX + 0x40]
CMP RBP,RAX
JNZ 0x0017943d
MOV RAX,qword ptr [RBX + 0x38]
MOV RDX,qword ptr [RSP + 0x28]
TEST RDX,RDX
JLE 0x0017964a
LEA RCX,[RAX + 0x8]
LAB_00179408:
MOV RSI,qword ptr [RCX + -0x8]
MOV RDI,qword ptr [RCX]
CMP EDI,-0x9
JC 0x00179416
INC dword ptr [RSI]
LAB_00179416:
MOV qword ptr [R8],RSI
MOV qword ptr [R8 + 0x8],RDI
ADD R8,0x10
ADD RCX,0x10
DEC RDX
JNZ 0x00179408
JMP 0x00179653
LAB_0017942f:
XOR R8D,R8D
XOR R13D,R13D
MOV RBP,RAX
JMP 0x001795ce
LAB_0017943d:
CMP qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x68],RBP
JLE 0x0017949e
XOR EBP,EBP
XOR R12D,R12D
LAB_0017944f:
MOV qword ptr [RSP + 0x38],R8
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R12
CALL 0x0014e98a
CMP EAX,-0x1
JZ 0x001795a3
INC R12
MOV R8,qword ptr [RSP + 0x38]
ADD R8,0x10
MOV RCX,qword ptr [RSP + 0x28]
CMP RCX,R12
JNZ 0x0017944f
MOV RBP,qword ptr [RSP + 0x68]
JMP 0x001794a0
LAB_0017948b:
XOR EBP,EBP
MOV RAX,qword ptr [RSP + 0x30]
MOV ESI,EAX
MOV RDX,qword ptr [RSP + 0x48]
JMP 0x001795f5
LAB_0017949e:
XOR ECX,ECX
LAB_001794a0:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
MOV R9,qword ptr [RSP + 0x50]
JZ 0x001794db
SHL RDI,0x4
XOR EAX,EAX
LAB_001794b5:
MOV RSI,qword ptr [R13 + RAX*0x1 + 0x20]
MOV RDX,qword ptr [R13 + RAX*0x1 + 0x28]
CMP EDX,-0x9
JC 0x001794c6
INC dword ptr [RSI]
LAB_001794c6:
MOV qword ptr [R8 + RAX*0x1],RSI
MOV qword ptr [R8 + RAX*0x1 + 0x8],RDX
ADD RAX,0x10
CMP RDI,RAX
JNZ 0x001794b5
ADD R8,RAX
LAB_001794db:
ADD RCX,R9
CMP RCX,RBP
JGE 0x00179516
XOR EBP,EBP
LAB_001794e5:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV R13,R8
MOV R12,RCX
CALL 0x0014e98a
CMP EAX,-0x1
JZ 0x00179632
INC R12
ADD R13,0x10
CMP R12,qword ptr [RSP + 0x68]
MOV R8,R13
MOV RCX,R12
JL 0x001794e5
LAB_00179516:
MOV qword ptr [RSP + 0x38],R8
MOV RDX,qword ptr [RSP + 0x58]
MOV RAX,RDX
SHR RAX,0x1f
MOV ECX,EDX
CVTSI2SD XMM0,RDX
MOVQ R8,XMM0
CMOVZ R8,RCX
MOV R9D,0x7
CMOVZ R9,RAX
MOV R13,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x88],R13
MOV R12,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],R12
MOVUPS XMM0,xmmword ptr [RSP + 0x88]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x32
CALL 0x00123d7f
XOR EBP,EBP
TEST EAX,EAX
JS 0x001795b6
XOR ESI,ESI
MOV RBP,R13
MOV RDX,R12
MOV RAX,R13
MOV EDI,0x3
JMP 0x001795c4
LAB_001795a3:
MOV RAX,qword ptr [RSP + 0x30]
MOV ESI,EAX
MOV RDI,qword ptr [RSP + 0x48]
MOV EDX,0x6
JMP 0x001795c4
LAB_001795b6:
MOV ESI,R13D
MOV RDI,R12
MOV EDX,0x6
MOV RAX,R13
LAB_001795c4:
MOV R8,qword ptr [RSP + 0x40]
MOV R13,qword ptr [RSP + 0x38]
LAB_001795ce:
CMP R13,R8
JZ 0x001795ef
LAB_001795d3:
MOV dword ptr [R13],0x0
MOV qword ptr [R13 + 0x8],0x3
LEA RCX,[R13 + 0x10]
MOV R13,RCX
CMP RCX,R8
JNZ 0x001795d3
LAB_001795ef:
MOV R12,RDX
MOV RDX,RDI
LAB_001795f5:
MOV RDI,qword ptr [R15 + 0x18]
CMP EDX,-0x9
JC 0x0017923d
MOV RCX,-0x100000000
AND RAX,RCX
MOV ESI,ESI
OR RSI,RAX
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0017923d
ADD R15,0x18
CALL 0x00120d90
JMP 0x0017923a
LAB_00179632:
MOV RAX,qword ptr [RSP + 0x30]
MOV ESI,EAX
MOV RDI,qword ptr [RSP + 0x48]
MOV EDX,0x6
MOV R8,qword ptr [RSP + 0x40]
JMP 0x001795ce
LAB_0017964a:
MOV qword ptr [RSP + 0x28],0x0
LAB_00179653:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00179689
SHL RDI,0x4
XOR ECX,ECX
LAB_00179663:
MOV RDX,qword ptr [R13 + RCX*0x1 + 0x20]
MOV RSI,qword ptr [R13 + RCX*0x1 + 0x28]
CMP ESI,-0x9
JC 0x00179674
INC dword ptr [RDX]
LAB_00179674:
MOV qword ptr [R8 + RCX*0x1],RDX
MOV qword ptr [R8 + RCX*0x1 + 0x8],RSI
ADD RCX,0x10
CMP RDI,RCX
JNZ 0x00179663
ADD R8,RCX
LAB_00179689:
MOV RDI,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x50]
ADD RDI,RCX
CMP RDI,RBP
JGE 0x00179516
MOV RSI,RBP
MOV RCX,RDI
SHL RCX,0x4
ADD RAX,RCX
ADD RAX,0x8
LAB_001796b0:
MOV RCX,qword ptr [RAX + -0x8]
MOV RDX,qword ptr [RAX]
CMP EDX,-0x9
JC 0x001796be
INC dword ptr [RCX]
LAB_001796be:
MOV qword ptr [R8],RCX
MOV qword ptr [R8 + 0x8],RDX
INC RDI
ADD R8,0x10
ADD RAX,0x10
CMP RDI,RSI
JL 0x001796b0
JMP 0x00179516
|
int1 [16]
js_array_toSpliced(long param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
bool bVar1;
int iVar2;
int *piVar3;
ulong uVar4;
int8 *puVar5;
int8 uVar6;
ulong uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
int *piVar11;
int8 uVar12;
int8 *puVar13;
double dVar14;
int8 *puVar15;
long lVar16;
int8 uVar17;
long lVar18;
int1 auVar19 [16];
int1 auVar20 [16];
long local_a0;
long local_58;
long local_50;
ulong local_48;
int1 local_40 [16];
auVar19 = JS_ToObject();
uVar6 = auVar19._8_8_;
piVar3 = auVar19._0_8_;
iVar2 = js_get_length64(param_1,&local_48,piVar3);
if (iVar2 == 0) {
local_50 = 0;
if (param_4 < 1) {
local_a0 = 0;
lVar16 = 0;
}
else {
iVar2 = JS_ToInt64Clamp(param_1,&local_50,*param_5,param_5[1],0,local_48,local_48);
local_a0 = local_50;
if ((iVar2 != 0) ||
((local_58 = local_48 - local_50, lVar16 = local_58, param_4 != 1 &&
(iVar2 = JS_ToInt64Clamp(param_1,&local_58,param_5[2],param_5[3],0,local_58,0),
lVar16 = local_58, iVar2 != 0)))) goto LAB_0017922e;
}
uVar10 = 0;
if (2 < param_4) {
uVar10 = (ulong)(param_4 - 2);
}
uVar7 = (uVar10 + local_48) - lVar16;
if (0xffffffff < (long)uVar7) {
if (uVar7 >> 0x35 == 0) {
JS_ThrowRangeError(param_1,"invalid array length");
}
else {
JS_ThrowTypeError();
}
goto LAB_0017922e;
}
piVar11 = *(int **)(param_1 + 0x38);
*piVar11 = *piVar11 + 1;
auVar20 = JS_NewObjectFromShape(param_1,piVar11,2);
uVar12 = auVar20._8_8_;
uVar4 = auVar20._0_8_;
uVar9 = auVar20._0_4_;
if (auVar20._8_4_ == 6) {
auVar20 = ZEXT816(6) << 0x40;
}
else {
if ((long)uVar7 < 1) {
puVar13 = (int8 *)0x0;
puVar15 = (int8 *)0x0;
uVar9 = 0;
uVar12 = 3;
}
else {
iVar2 = expand_fast_array(param_1,uVar4,uVar7 & 0xffffffff);
if (iVar2 < 0) {
auVar20 = ZEXT816(6) << 0x40;
goto LAB_001795f5;
}
*(int *)(uVar4 + 0x40) = (int)uVar7;
puVar15 = *(int8 **)(uVar4 + 0x38);
puVar13 = puVar15 + uVar7 * 2;
if ((((auVar19._8_4_ == 0xffffffff) && (*(short *)((long)piVar3 + 6) == 2)) &&
((*(byte *)((long)piVar3 + 5) & 8) != 0)) && (local_48 == (uint)piVar3[0x10])) {
lVar18 = *(long *)(piVar3 + 0xe);
if (local_a0 < 1) {
local_a0 = 0;
}
else {
puVar5 = (int8 *)(lVar18 + 8);
lVar8 = local_a0;
do {
piVar11 = (int *)puVar5[-1];
uVar17 = *puVar5;
if (0xfffffff6 < (uint)uVar17) {
*piVar11 = *piVar11 + 1;
}
*puVar15 = piVar11;
puVar15[1] = uVar17;
puVar15 = puVar15 + 2;
puVar5 = puVar5 + 2;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
if (uVar10 != 0) {
lVar8 = 0;
do {
piVar11 = *(int **)((long)param_5 + lVar8 + 0x20);
uVar17 = *(int8 *)((long)param_5 + lVar8 + 0x28);
if (0xfffffff6 < (uint)uVar17) {
*piVar11 = *piVar11 + 1;
}
*(int **)((long)puVar15 + lVar8) = piVar11;
*(int8 *)((long)puVar15 + lVar8 + 8) = uVar17;
lVar8 = lVar8 + 0x10;
} while (uVar10 << 4 != lVar8);
puVar15 = (int8 *)((long)puVar15 + lVar8);
}
local_a0 = local_a0 + lVar16;
if (local_a0 < (long)local_48) {
puVar5 = (int8 *)(lVar18 + local_a0 * 0x10 + 8);
do {
piVar11 = (int *)puVar5[-1];
uVar17 = *puVar5;
if (0xfffffff6 < (uint)uVar17) {
*piVar11 = *piVar11 + 1;
}
*puVar15 = piVar11;
puVar15[1] = uVar17;
local_a0 = local_a0 + 1;
puVar15 = puVar15 + 2;
puVar5 = puVar5 + 2;
} while (local_a0 < (long)local_48);
}
}
else {
if (local_a0 < 1) {
local_a0 = 0;
}
else {
lVar18 = 0;
do {
iVar2 = JS_TryGetPropertyInt64(param_1,piVar3,uVar6,lVar18);
if (iVar2 == -1) {
auVar20 = ZEXT816(6) << 0x40;
goto joined_r0x001795d1;
}
lVar18 = lVar18 + 1;
puVar15 = puVar15 + 2;
} while (local_a0 != lVar18);
}
if (uVar10 != 0) {
lVar18 = 0;
do {
piVar11 = *(int **)((long)param_5 + lVar18 + 0x20);
uVar17 = *(int8 *)((long)param_5 + lVar18 + 0x28);
if (0xfffffff6 < (uint)uVar17) {
*piVar11 = *piVar11 + 1;
}
*(int **)((long)puVar15 + lVar18) = piVar11;
*(int8 *)((long)puVar15 + lVar18 + 8) = uVar17;
lVar18 = lVar18 + 0x10;
} while (uVar10 << 4 != lVar18);
puVar15 = (int8 *)((long)puVar15 + lVar18);
}
for (local_a0 = local_a0 + lVar16; local_a0 < (long)local_48; local_a0 = local_a0 + 1) {
iVar2 = JS_TryGetPropertyInt64(param_1,piVar3,uVar6);
if (iVar2 == -1) {
auVar20 = ZEXT816(6) << 0x40;
goto joined_r0x001795d1;
}
puVar15 = puVar15 + 2;
}
}
bVar1 = uVar7 >> 0x1f == 0;
dVar14 = (double)(long)uVar7;
if (bVar1) {
dVar14 = (double)(uVar7 & 0xffffffff);
}
uVar17 = 7;
if (bVar1) {
uVar17 = 0;
}
local_40 = auVar20;
iVar2 = JS_SetPropertyInternal2
(param_1,uVar4,uVar12,0x32,dVar14,uVar17,uVar4,auVar20._8_4_,0x4000,0);
if (iVar2 < 0) {
auVar20 = ZEXT816(6) << 0x40;
}
else {
uVar9 = 0;
uVar12 = 3;
}
}
joined_r0x001795d1:
for (; puVar15 != puVar13; puVar15 = puVar15 + 2) {
*(int4 *)puVar15 = 0;
puVar15[1] = 3;
}
}
LAB_001795f5:
uVar17 = *(int8 *)(param_1 + 0x18);
if (((uint)uVar12 < 0xfffffff7) ||
(piVar11 = (int *)((ulong)uVar9 | uVar4 & 0xffffffff00000000), iVar2 = *piVar11,
*piVar11 = iVar2 + -1, 1 < iVar2)) goto LAB_0017923d;
js_free_value_rt(uVar17);
}
else {
LAB_0017922e:
auVar20 = ZEXT816(6) << 0x40;
}
uVar17 = *(int8 *)(param_1 + 0x18);
LAB_0017923d:
if ((0xfffffff6 < auVar19._8_4_) && (iVar2 = *piVar3, *piVar3 = iVar2 + -1, iVar2 < 2)) {
js_free_value_rt(uVar17,piVar3,uVar6);
}
return auVar20;
}
|
|
13,743
|
get_charset_number
|
eloqsql/mysys/charset.c
|
uint get_charset_number(const char *charset_name, uint cs_flags, myf flags)
{
uint id;
const char *new_charset_name= flags & MY_UTF8_IS_UTF8MB3 ? "utf8mb3" :
"utf8mb4";
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_charset_number_internal(charset_name, cs_flags)))
return id;
if ((charset_name= !my_strcasecmp(&my_charset_latin1, charset_name, "utf8") ?
new_charset_name : NULL))
return get_charset_number_internal(charset_name, cs_flags);
return 0;
}
|
O0
|
c
|
get_charset_number:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
andq $0x400, %rdx # imm = 0x400
leaq 0x4fa2c(%rip), %rax # 0x798b1
leaq 0x4fa1d(%rip), %rcx # 0x798a9
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0x364845(%rip), %rdi # 0x38e6e4
leaq -0x306(%rip), %rsi # 0x29ba0
callq 0x242a0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x29f40
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x29ec7
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29f2a
leaq 0x24a972(%rip), %rax # 0x274840
movq 0xc0(%rax), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rsi
leaq 0x24a95c(%rip), %rdi # 0x274840
leaq 0x4f9ce(%rip), %rdx # 0x798b9
callq *%rax
cmpl $0x0, %eax
jne 0x29efc
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x29f04
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x29f04
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x29f23
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x29f40
movl %eax, -0x4(%rbp)
jmp 0x29f2a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
get_charset_number:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov rdx, [rbp+var_20]
and rdx, 400h
lea rax, aUtf8mb4; "utf8mb4"
lea rcx, aUtf8mb3; "utf8mb3"
cmp rdx, 0
cmovnz rax, rcx
mov [rbp+var_30], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_29EC7
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_29F2A
loc_29EC7:
lea rax, my_charset_latin1
mov rax, [rax+0C0h]
mov rax, [rax+40h]
mov rsi, [rbp+var_10]
lea rdi, my_charset_latin1
lea rdx, aUtf8; "utf8"
call rax
cmp eax, 0
jnz short loc_29EFC
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
jmp short loc_29F04
loc_29EFC:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_29F04:
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_29F23
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
call get_charset_number_internal
mov [rbp+var_4], eax
jmp short loc_29F2A
loc_29F23:
mov [rbp+var_4], 0
loc_29F2A:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long get_charset_number(long long a1, unsigned int a2, __int16 a3)
{
const char *v3; // rax
const char *v5; // [rsp+8h] [rbp-38h]
const char *v6; // [rsp+10h] [rbp-30h]
unsigned int charset_number_internal; // [rsp+1Ch] [rbp-24h]
v3 = "utf8mb4";
if ( (a3 & 0x400) != 0 )
v3 = "utf8mb3";
v6 = v3;
pthread_once(&charsets_initialized, init_available_charsets);
charset_number_internal = get_charset_number_internal(a1, a2);
if ( charset_number_internal )
{
return charset_number_internal;
}
else
{
if ( (*(unsigned int ( **)(void *, long long, const char *))(*((_QWORD *)&my_charset_latin1 + 24) + 64LL))(
&my_charset_latin1,
a1,
"utf8") )
{
v5 = 0LL;
}
else
{
v5 = v6;
}
if ( v5 )
return (unsigned int)get_charset_number_internal(v5, a2);
else
return 0;
}
}
|
get_charset_number:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV RDX,qword ptr [RBP + -0x20]
AND RDX,0x400
LEA RAX,[0x1798b1]
LEA RCX,[0x1798a9]
CMP RDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[0x48e6e4]
LEA RSI,[0x129ba0]
CALL 0x001242a0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00129f40
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x00129ec7
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00129f2a
LAB_00129ec7:
LEA RAX,[0x374840]
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDI,[0x374840]
LEA RDX,[0x1798b9]
CALL RAX
CMP EAX,0x0
JNZ 0x00129efc
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00129f04
LAB_00129efc:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00129f04
LAB_00129f04:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00129f23
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x00129f40
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00129f2a
LAB_00129f23:
MOV dword ptr [RBP + -0x4],0x0
LAB_00129f2a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int get_charset_number(int8 param_1,int4 param_2,ulong param_3)
{
int iVar1;
char *local_40;
int local_c;
local_40 = "utf8mb4";
if ((param_3 & 0x400) != 0) {
local_40 = "utf8mb3";
}
pthread_once(&charsets_initialized,init_available_charsets);
local_c = get_charset_number_internal(param_1,param_2);
if (local_c == 0) {
iVar1 = (**(code **)(PTR_my_collation_8bit_simple_ci_handler_00374900 + 0x40))
(&my_charset_latin1,param_1,&DAT_001798b9);
if (iVar1 != 0) {
local_40 = (char *)0x0;
}
if (local_40 == (char *)0x0) {
local_c = 0;
}
else {
local_c = get_charset_number_internal(local_40,param_2);
}
}
return local_c;
}
|
|
13,744
|
my_xml_error_pos
|
eloqsql/strings/xml.c
|
size_t my_xml_error_pos(MY_XML_PARSER *p)
{
const char *beg=p->beg;
const char *s;
for ( s=p->beg ; s<p->cur; s++)
{
if (s[0] == '\n')
beg=s;
}
return (size_t) (p->cur-beg);
}
|
O3
|
c
|
my_xml_error_pos:
movq 0x128(%rdi), %rcx
movq 0x130(%rdi), %rax
cmpq %rax, %rcx
jae 0xd7f12
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rdx
cmpb $0xa, (%rcx)
cmoveq %rcx, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0xd7f00
popq %rbp
jmp 0xd7f15
movq %rcx, %rdx
subq %rdx, %rax
retq
|
my_xml_error_pos:
mov rcx, [rdi+128h]
mov rax, [rdi+130h]
cmp rcx, rax
jnb short loc_D7F12
push rbp
mov rbp, rsp
mov rdx, rcx
loc_D7F00:
cmp byte ptr [rcx], 0Ah
cmovz rdx, rcx
inc rcx
cmp rcx, rax
jnz short loc_D7F00
pop rbp
jmp short loc_D7F15
loc_D7F12:
mov rdx, rcx
loc_D7F15:
sub rax, rdx
retn
|
long long my_xml_error_pos(long long a1)
{
_BYTE *v1; // rcx
_BYTE *v2; // rax
_BYTE *v3; // rdx
v1 = *(_BYTE **)(a1 + 296);
v2 = *(_BYTE **)(a1 + 304);
if ( v1 >= v2 )
{
v3 = *(_BYTE **)(a1 + 296);
}
else
{
v3 = *(_BYTE **)(a1 + 296);
do
{
if ( *v1 == 10 )
v3 = v1;
++v1;
}
while ( v1 != v2 );
}
return v2 - v3;
}
|
my_xml_error_pos:
MOV RCX,qword ptr [RDI + 0x128]
MOV RAX,qword ptr [RDI + 0x130]
CMP RCX,RAX
JNC 0x001d7f12
PUSH RBP
MOV RBP,RSP
MOV RDX,RCX
LAB_001d7f00:
CMP byte ptr [RCX],0xa
CMOVZ RDX,RCX
INC RCX
CMP RCX,RAX
JNZ 0x001d7f00
POP RBP
JMP 0x001d7f15
LAB_001d7f12:
MOV RDX,RCX
LAB_001d7f15:
SUB RAX,RDX
RET
|
long my_xml_error_pos(long param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
pcVar2 = *(char **)(param_1 + 0x128);
pcVar1 = *(char **)(param_1 + 0x130);
pcVar3 = pcVar2;
if (pcVar2 < pcVar1) {
do {
if (*pcVar2 == '\n') {
pcVar3 = pcVar2;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar1);
}
return (long)pcVar1 - (long)pcVar3;
}
|
|
13,745
|
my_charset_is_ascii_compatible
|
eloqsql/strings/ctype-simple.c
|
static my_bool
my_charset_is_ascii_compatible(CHARSET_INFO *cs)
{
uint i;
if (!cs->tab_to_uni)
return 1;
for (i= 0; i < 128; i++)
{
if (cs->tab_to_uni[i] != i)
return 0;
}
return 1;
}
|
O0
|
c
|
my_charset_is_ascii_compatible:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0xa4329
movb $0x1, -0x1(%rbp)
jmp 0xa4364
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0xa4360
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
je 0xa4353
movb $0x0, -0x1(%rbp)
jmp 0xa4364
jmp 0xa4355
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa4330
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
|
my_charset_is_ascii_compatible:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_A4329
mov [rbp+var_1], 1
jmp short loc_A4364
loc_A4329:
mov [rbp+var_14], 0
loc_A4330:
cmp [rbp+var_14], 80h
jnb short loc_A4360
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov ecx, [rbp+var_14]
movzx eax, word ptr [rax+rcx*2]
cmp eax, [rbp+var_14]
jz short loc_A4353
mov [rbp+var_1], 0
jmp short loc_A4364
loc_A4353:
jmp short $+2
loc_A4355:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_A4330
loc_A4360:
mov [rbp+var_1], 1
loc_A4364:
mov al, [rbp+var_1]
pop rbp
retn
|
char my_charset_is_ascii_compatible(long long a1)
{
unsigned int i; // [rsp+0h] [rbp-14h]
if ( !*(_QWORD *)(a1 + 104) )
return 1;
for ( i = 0; i < 0x80; ++i )
{
if ( *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 2LL * i) != i )
return 0;
}
return 1;
}
|
my_charset_is_ascii_compatible:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x001a4329
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001a4364
LAB_001a4329:
MOV dword ptr [RBP + -0x14],0x0
LAB_001a4330:
CMP dword ptr [RBP + -0x14],0x80
JNC 0x001a4360
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX EAX,word ptr [RAX + RCX*0x2]
CMP EAX,dword ptr [RBP + -0x14]
JZ 0x001a4353
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001a4364
LAB_001a4353:
JMP 0x001a4355
LAB_001a4355:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001a4330
LAB_001a4360:
MOV byte ptr [RBP + -0x1],0x1
LAB_001a4364:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 my_charset_is_ascii_compatible(long param_1)
{
uint local_1c;
if (*(long *)(param_1 + 0x68) != 0) {
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
if (*(ushort *)(*(long *)(param_1 + 0x68) + (ulong)local_1c * 2) != local_1c) {
return 0;
}
}
}
return 1;
}
|
|
13,746
|
File::CreateEmptyFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Dolphin-anty/Source/Core/Common/FileUtil.cpp
|
bool CreateEmptyFile(const std::string& filename)
{
DEBUG_LOG_FMT(COMMON, "CreateEmptyFile: {}", filename);
if (!File::IOFile(filename, "wb"))
{
ERROR_LOG_FMT(COMMON, "CreateEmptyFile: failed {}: {}", filename, Common::LastStrerrorString());
return false;
}
return true;
}
|
O3
|
cpp
|
File::CreateEmptyFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r15
leaq 0x233f2(%rip), %rdx # 0x3dd4e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1e428
cmpq $0x0, (%r14)
setne %bl
andb 0x8(%r14), %bl
movq %r14, %rdi
callq 0x1e480
testb %bl, %bl
jne 0x1a9fc
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x1e639
movups (%r15), %xmm0
movups (%r12), %xmm1
movaps %xmm0, 0x10(%rsp)
movaps %xmm1, 0x20(%rsp)
leaq 0x58(%rsp), %rax
movq $0xdd, (%rax)
movq %r14, 0x8(%rax)
movq %rax, (%rsp)
leaq 0x232f4(%rip), %rdx # 0x3dcb4
leaq 0x2377e(%rip), %r8 # 0x3e145
movl $0x1e, %r9d
movl $0x2, %edi
movl $0x6, %esi
movl $0x184, %ecx # imm = 0x184
callq 0xc12c
movq (%r12), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1a9fc
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x7560
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN4File15CreateEmptyFileERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r15, rdi
lea rdx, aWb; "wb"
lea r14, [rsp+88h+var_78]
mov rdi, r14
mov rsi, r15
xor ecx, ecx
call _ZN4File6IOFileC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcNS_12SharedAccessE; File::IOFile::IOFile(std::string const&,char const*,File::SharedAccess)
cmp qword ptr [r14], 0
setnz bl
and bl, [r14+8]
mov rdi, r14; this
call _ZN4File6IOFileD2Ev; File::IOFile::~IOFile()
test bl, bl
jnz short loc_1A9FC
lea r12, [rsp+88h+var_50]
mov rdi, r12
call _ZN6Common18LastStrerrorStringB5cxx11Ev; Common::LastStrerrorString(void)
movups xmm0, xmmword ptr [r15]
movups xmm1, xmmword ptr [r12]
movaps [rsp+88h+var_78], xmm0
movaps [rsp+88h+var_68], xmm1
lea rax, [rsp+88h+var_30]
mov qword ptr [rax], 0DDh
mov [rax+8], r14
mov [rsp+88h+var_88], rax
lea rdx, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/Dolphi"...
lea r8, aCreateemptyfil; "CreateEmptyFile: failed {}: {}"
mov r9d, 1Eh
mov edi, 2
mov esi, 6
mov ecx, 184h
call _ZN6Common3Log17GenericLogFmtImplENS0_8LogLevelENS0_7LogTypeEPKciN3fmt3v1017basic_string_viewIcEERKNS6_17basic_format_argsINS6_20basic_format_contextINS6_8appenderEcEEEE; Common::Log::GenericLogFmtImpl(Common::Log::LogLevel,Common::Log::LogType,char const*,int,fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>> const&)
mov rdi, [r12]; void *
lea rax, [rsp+88h+var_40]
cmp rdi, rax
jz short loc_1A9FC
mov rsi, [rsp+88h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1A9FC:
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long File::CreateEmptyFile(_OWORD *a1)
{
unsigned int v1; // ebx
_OWORD v3[2]; // [rsp+10h] [rbp-78h] BYREF
__int128 v4; // [rsp+38h] [rbp-50h] BYREF
long long v5; // [rsp+48h] [rbp-40h] BYREF
_QWORD v6[6]; // [rsp+58h] [rbp-30h] BYREF
File::IOFile::IOFile(v3, a1, "wb", 0LL);
LOBYTE(v1) = BYTE8(v3[0]) & (*(_QWORD *)&v3[0] != 0LL);
File::IOFile::~IOFile((File::IOFile *)v3);
if ( !(_BYTE)v1 )
{
Common::LastStrerrorString[abi:cxx11](&v4);
v3[0] = *a1;
v3[1] = v4;
v6[0] = 221LL;
v6[1] = v3;
Common::Log::GenericLogFmtImpl(
2u,
6u,
(long long)"/workspace/llm4binary/github2025/Dolphin-anty/Source/Core/Common/FileUtil.cpp",
0x184u,
(long long)"CreateEmptyFile: failed {}: {}",
30LL,
v6);
if ( (long long *)v4 != &v5 )
operator delete((void *)v4, v5 + 1);
}
return v1;
}
|
CreateEmptyFile:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R15,RDI
LEA RDX,[0x13dd4e]
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV RSI,R15
XOR ECX,ECX
CALL 0x0011e428
CMP qword ptr [R14],0x0
SETNZ BL
AND BL,byte ptr [R14 + 0x8]
MOV RDI,R14
CALL 0x0011e480
TEST BL,BL
JNZ 0x0011a9fc
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x0011e639
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS XMM1,xmmword ptr [R12]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM1
LEA RAX,[RSP + 0x58]
MOV qword ptr [RAX],0xdd
MOV qword ptr [RAX + 0x8],R14
MOV qword ptr [RSP],RAX
LEA RDX,[0x13dcb4]
LEA R8,[0x13e145]
MOV R9D,0x1e
MOV EDI,0x2
MOV ESI,0x6
MOV ECX,0x184
CALL 0x0010c12c
MOV RDI,qword ptr [R12]
LEA RAX,[RSP + 0x48]
CMP RDI,RAX
JZ 0x0011a9fc
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x00107560
LAB_0011a9fc:
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
|
/* File::CreateEmptyFile(std::__cxx11::string const&) */
ulong File::CreateEmptyFile(string *param_1)
{
byte bVar1;
int8 unaff_RBX;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
int4 local_50;
int4 uStack_4c;
int4 uStack_48;
int4 uStack_44;
long local_40 [2];
int8 local_30;
IOFile *local_28;
IOFile::IOFile((IOFile *)&local_78,param_1,&DAT_0013dd4e,0);
bVar1 = CONCAT44(uStack_74,local_78) != 0 & (byte)uStack_70;
IOFile::~IOFile((IOFile *)&local_78);
if (bVar1 == 0) {
Common::LastStrerrorString_abi_cxx11_((Common *)&local_50);
local_78 = *(int4 *)param_1;
uStack_74 = *(int4 *)(param_1 + 4);
uStack_70 = *(int4 *)(param_1 + 8);
uStack_6c = *(int4 *)(param_1 + 0xc);
local_68 = local_50;
uStack_64 = uStack_4c;
uStack_60 = uStack_48;
uStack_5c = uStack_44;
local_30 = 0xdd;
local_28 = (IOFile *)&local_78;
Common::Log::GenericLogFmtImpl
((Log *)0x2,6,
"/workspace/llm4binary/github2025/Dolphin-anty/Source/Core/Common/FileUtil.cpp",0x184
,"CreateEmptyFile: failed {}: {}",0x1e,&local_30);
if ((long *)CONCAT44(uStack_4c,local_50) != local_40) {
operator_delete((long *)CONCAT44(uStack_4c,local_50),local_40[0] + 1);
}
}
return CONCAT71((int7)((ulong)unaff_RBX >> 8),bVar1) & 0xffffffff;
}
|
|
13,747
|
stbi__shiftsigned(unsigned int, int, int)
|
SDL3Lite/dependencies/stb_image.h
|
static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
static unsigned int mul_table[9] = {
0,
0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
};
static unsigned int shift_table[9] = {
0, 0,0,1,0,2,4,6,0,
};
if (shift < 0)
v <<= -shift;
else
v >>= shift;
STBI_ASSERT(v < 256);
v >>= (8-bits);
STBI_ASSERT(bits >= 0 && bits <= 8);
return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
}
|
O0
|
c
|
stbi__shiftsigned(unsigned int, int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x32276
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shll %cl, %eax
movl %eax, -0x4(%rbp)
jmp 0x32281
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp) # imm = 0x100
jae 0x3228c
jmp 0x322ab
leaq 0x9500(%rip), %rdi # 0x3b793
leaq 0x93d5(%rip), %rsi # 0x3b66f
movl $0x1521, %edx # imm = 0x1521
leaq 0x94f5(%rip), %rcx # 0x3b79b
callq 0x21600
movl $0x8, %ecx
subl -0xc(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jl 0x322d0
cmpl $0x8, -0xc(%rbp)
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x322d9
jmp 0x322db
jmp 0x322fa
leaq 0x94e7(%rip), %rdi # 0x3b7c9
leaq 0x9386(%rip), %rsi # 0x3b66f
movl $0x1523, %edx # imm = 0x1523
leaq 0x94a6(%rip), %rcx # 0x3b79b
callq 0x21600
movl -0x4(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x13818(%rip), %rcx # 0x45b20
imull (%rcx,%rdx,4), %eax
movslq -0xc(%rbp), %rdx
leaq 0x13839(%rip), %rcx # 0x45b50
movl (%rcx,%rdx,4), %ecx
sarl %cl, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZL17stbi__shiftsignedjii:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov [rbp+var_C], edx
cmp [rbp+var_8], 0
jge short loc_32276
xor ecx, ecx
sub ecx, [rbp+var_8]
mov eax, [rbp+var_4]
shl eax, cl
mov [rbp+var_4], eax
jmp short loc_32281
loc_32276:
mov ecx, [rbp+var_8]
mov eax, [rbp+var_4]
shr eax, cl
mov [rbp+var_4], eax
loc_32281:
cmp [rbp+var_4], 100h
jnb short loc_3228C
jmp short loc_322AB
loc_3228C:
lea rdi, aV256; "v < 256"
lea rsi, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/SDL3Li"...
mov edx, 1521h
lea rcx, aIntStbiShiftsi; "int stbi__shiftsigned(unsigned int, int"...
call ___assert_fail
loc_322AB:
mov ecx, 8
sub ecx, [rbp+var_C]
mov eax, [rbp+var_4]
shr eax, cl
mov [rbp+var_4], eax
xor eax, eax
cmp [rbp+var_C], 0
mov [rbp+var_D], al
jl short loc_322D0
cmp [rbp+var_C], 8
setle al
mov [rbp+var_D], al
loc_322D0:
mov al, [rbp+var_D]
test al, 1
jnz short loc_322D9
jmp short loc_322DB
loc_322D9:
jmp short loc_322FA
loc_322DB:
lea rdi, aBits0Bits8; "bits >= 0 && bits <= 8"
lea rsi, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/SDL3Li"...
mov edx, 1523h
lea rcx, aIntStbiShiftsi; "int stbi__shiftsigned(unsigned int, int"...
call ___assert_fail
loc_322FA:
mov eax, [rbp+var_4]
movsxd rdx, [rbp+var_C]
lea rcx, _ZZL17stbi__shiftsignedjiiE9mul_table; stbi__shiftsigned(uint,int,int)::mul_table
imul eax, [rcx+rdx*4]
movsxd rdx, [rbp+var_C]
lea rcx, _ZZL17stbi__shiftsignedjiiE11shift_table; stbi__shiftsigned(uint,int,int)::shift_table
mov ecx, [rcx+rdx*4]
sar eax, cl
add rsp, 10h
pop rbp
retn
|
long long stbi__shiftsigned(unsigned int a1, int a2, int a3)
{
bool v4; // [rsp+3h] [rbp-Dh]
unsigned int v5; // [rsp+Ch] [rbp-4h]
unsigned int v6; // [rsp+Ch] [rbp-4h]
if ( a2 >= 0 )
v5 = a1 >> a2;
else
v5 = a1 << -(char)a2;
if ( v5 >= 0x100 )
__assert_fail(
"v < 256",
"/workspace/llm4binary/github2025/SDL3Lite/dependencies/stb_image.h",
5409LL,
"int stbi__shiftsigned(unsigned int, int, int)");
v6 = v5 >> (8 - a3);
v4 = 0;
if ( a3 >= 0 )
v4 = a3 <= 8;
if ( !v4 )
__assert_fail(
"bits >= 0 && bits <= 8",
"/workspace/llm4binary/github2025/SDL3Lite/dependencies/stb_image.h",
5411LL,
"int stbi__shiftsigned(unsigned int, int, int)");
return (unsigned int)((int)(stbi__shiftsigned(unsigned int,int,int)::mul_table[a3] * v6) >> stbi__shiftsigned(unsigned int,int,int)::shift_table[a3]);
}
|
stbi__shiftsigned:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV dword ptr [RBP + -0xc],EDX
CMP dword ptr [RBP + -0x8],0x0
JGE 0x00132276
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x4]
SHL EAX,CL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00132281
LAB_00132276:
MOV ECX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,CL
MOV dword ptr [RBP + -0x4],EAX
LAB_00132281:
CMP dword ptr [RBP + -0x4],0x100
JNC 0x0013228c
JMP 0x001322ab
LAB_0013228c:
LEA RDI,[0x13b793]
LEA RSI,[0x13b66f]
MOV EDX,0x1521
LEA RCX,[0x13b79b]
CALL 0x00121600
LAB_001322ab:
MOV ECX,0x8
SUB ECX,dword ptr [RBP + -0xc]
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,CL
MOV dword ptr [RBP + -0x4],EAX
XOR EAX,EAX
CMP dword ptr [RBP + -0xc],0x0
MOV byte ptr [RBP + -0xd],AL
JL 0x001322d0
CMP dword ptr [RBP + -0xc],0x8
SETLE AL
MOV byte ptr [RBP + -0xd],AL
LAB_001322d0:
MOV AL,byte ptr [RBP + -0xd]
TEST AL,0x1
JNZ 0x001322d9
JMP 0x001322db
LAB_001322d9:
JMP 0x001322fa
LAB_001322db:
LEA RDI,[0x13b7c9]
LEA RSI,[0x13b66f]
MOV EDX,0x1523
LEA RCX,[0x13b79b]
CALL 0x00121600
LAB_001322fa:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,dword ptr [RBP + -0xc]
LEA RCX,[0x145b20]
IMUL EAX,dword ptr [RCX + RDX*0x4]
MOVSXD RDX,dword ptr [RBP + -0xc]
LEA RCX,[0x145b50]
MOV ECX,dword ptr [RCX + RDX*0x4]
SAR EAX,CL
ADD RSP,0x10
POP RBP
RET
|
/* stbi__shiftsigned(unsigned int, int, int) */
int stbi__shiftsigned(uint param_1,int param_2,int param_3)
{
bool local_15;
uint local_c;
if (param_2 < 0) {
local_c = param_1 << (-(byte)param_2 & 0x1f);
}
else {
local_c = param_1 >> ((byte)param_2 & 0x1f);
}
if (0xff < local_c) {
/* WARNING: Subroutine does not return */
__assert_fail("v < 256","/workspace/llm4binary/github2025/SDL3Lite/dependencies/stb_image.h",
0x1521,"int stbi__shiftsigned(unsigned int, int, int)");
}
local_15 = 8 < (uint)param_3;
if (local_15) {
/* WARNING: Subroutine does not return */
__assert_fail("bits >= 0 && bits <= 8",
"/workspace/llm4binary/github2025/SDL3Lite/dependencies/stb_image.h",0x1523,
"int stbi__shiftsigned(unsigned int, int, int)");
}
return (int)((local_c >> (8U - (char)param_3 & 0x1f)) *
*(int *)(stbi__shiftsigned(unsigned_int,int,int)::mul_table + (long)param_3 * 4)) >>
((byte)*(int4 *)
(stbi__shiftsigned(unsigned_int,int,int)::shift_table + (long)param_3 * 4) & 0x1f);
}
|
|
13,748
|
copy_uca_collation
|
eloqsql/mysys/charset.c
|
static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
}
|
O0
|
c
|
copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movzbl 0xb2(%rax), %eax
cmpl $0x1, %eax
jle 0x7e1d6
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e1e3
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
movq -0x10(%rbp), %rax
movb 0x94(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x94(%rax)
movq -0x10(%rbp), %rax
movb 0x95(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x95(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2c8, %ecx # imm = 0x2C8
movl %ecx, 0xc(%rax)
popq %rbp
retq
nop
|
copy_uca_collation:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov rcx, [rax+0B8h]
mov rax, [rbp+var_8]
mov [rax+0B8h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0C0h]
mov rax, [rbp+var_8]
mov [rax+0C0h], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+0B2h]
cmp eax, 1
jle short loc_7E1D6
mov eax, 4
mov [rbp+var_1C], eax
jmp short loc_7E1E3
loc_7E1D6:
mov rax, [rbp+var_10]
mov eax, [rax+90h]
mov [rbp+var_1C], eax
loc_7E1E3:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_8]
mov [rax+90h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+0A0h]
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0A8h]
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+98h]
mov rax, [rbp+var_8]
mov [rax+98h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+9Ch]
mov rax, [rbp+var_8]
mov [rax+9Ch], ecx
mov rax, [rbp+var_10]
mov cl, [rax+94h]
mov rax, [rbp+var_8]
mov [rax+94h], cl
mov rax, [rbp+var_10]
mov cl, [rax+95h]
mov rax, [rbp+var_8]
mov [rax+95h], cl
mov rax, [rbp+var_8]
mov ecx, [rax+0Ch]
or ecx, 2C8h
mov [rax+0Ch], ecx
pop rbp
retn
|
long long copy_uca_collation(long long a1, long long a2, long long a3)
{
long long result; // rax
int v4; // [rsp+0h] [rbp-1Ch]
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
if ( *(unsigned __int8 *)(a3 + 178) <= 1u )
v4 = *(_DWORD *)(a2 + 144);
else
v4 = 4;
*(_DWORD *)(a1 + 144) = v4;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
*(_BYTE *)(a1 + 149) = *(_BYTE *)(a2 + 149);
result = a1;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
|
copy_uca_collation:
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 + -0x10]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xc0],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0xb2]
CMP EAX,0x1
JLE 0x0017e1d6
MOV EAX,0x4
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0017e1e3
LAB_0017e1d6:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0017e1e3:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x98],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x9c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x9c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x94]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x94],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x95]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x95],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x2c8
MOV dword ptr [RAX + 0xc],ECX
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 local_24;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
if (*(byte *)(param_3 + 0xb2) < 2) {
local_24 = *(int4 *)(param_2 + 0x90);
}
else {
local_24 = 4;
}
*(int4 *)(param_1 + 0x90) = local_24;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
|
|
13,749
|
strxnmov
|
eloqsql/strings/strxnmov.c
|
char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
}
|
O0
|
c
|
strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
testb %al, %al
je 0x7d43b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x7d547
jmp 0x7d499
movq -0x8(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x7d4a8
jmp 0x7d549
jmp 0x7d4aa
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x7d499
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x7d517
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x7d534
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7d48c
jmp 0x7d549
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
|
strxnmov:
push rbp
mov rbp, rsp
sub rsp, 90h
test al, al
jz short loc_7D43B
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_7D43B:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_D8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
lea rax, [rbp+var_30]
lea rcx, [rbp+var_F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
loc_7D48C:
cmp [rbp+var_18], 0
jz loc_7D547
jmp short $+2
loc_7D499:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_38]
jnz short loc_7D4A8
jmp loc_7D549
loc_7D4A8:
jmp short $+2
loc_7D4AA:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_8]
mov rdx, rcx
add rdx, 1
mov [rbp+var_8], rdx
mov [rcx], al
cmp al, 0
jnz short loc_7D499
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
lea rax, [rbp+var_30]
mov [rbp+var_100], rax
mov eax, [rbp+var_30]
mov [rbp+var_F4], eax
cmp eax, 28h ; '('
ja short loc_7D517
mov rcx, [rbp+var_100]
mov edx, [rbp+var_F4]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_108], rax
jmp short loc_7D534
loc_7D517:
mov rcx, [rbp+var_100]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_108], rax
loc_7D534:
mov rax, [rbp+var_108]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_7D48C
loc_7D547:
jmp short $+2
loc_7D549:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
|
_BYTE * strxnmov(
_BYTE *a1,
long long a2,
_BYTE *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)
{
_BYTE *v15; // rax
_BYTE *v16; // rcx
char *v17; // rax
char v19; // [rsp+18h] [rbp-F0h] BYREF
long long v20; // [rsp+30h] [rbp-D8h]
long long v21; // [rsp+38h] [rbp-D0h]
long long v22; // [rsp+40h] [rbp-C8h]
__m128 v23; // [rsp+48h] [rbp-C0h]
__m128 v24; // [rsp+58h] [rbp-B0h]
__m128 v25; // [rsp+68h] [rbp-A0h]
__m128 v26; // [rsp+78h] [rbp-90h]
__m128 v27; // [rsp+88h] [rbp-80h]
__m128 v28; // [rsp+98h] [rbp-70h]
__m128 v29; // [rsp+A8h] [rbp-60h]
__m128 v30; // [rsp+B8h] [rbp-50h]
_BYTE *v31; // [rsp+D0h] [rbp-38h]
int v32; // [rsp+D8h] [rbp-30h]
int v33; // [rsp+DCh] [rbp-2Ch]
char *v34; // [rsp+E0h] [rbp-28h]
char *v35; // [rsp+E8h] [rbp-20h]
_BYTE *v36; // [rsp+F0h] [rbp-18h]
long long v37; // [rsp+F8h] [rbp-10h]
_BYTE *v38; // [rsp+100h] [rbp-8h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v21 = a5;
v20 = a4;
v38 = a1;
v37 = a2;
v36 = a3;
v31 = &a1[a2];
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 24;
LABEL_2:
if ( v36 )
{
while ( v38 != v31 )
{
v15 = v36++;
LOBYTE(v15) = *v15;
v16 = v38++;
*v16 = (_BYTE)v15;
if ( !(_BYTE)v15 )
{
--v38;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
v36 = *(_BYTE **)v17;
goto LABEL_2;
}
}
}
*v38 = 0;
return v38;
}
|
strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
TEST AL,AL
JZ 0x0017d43b
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_0017d43b:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xf0]
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],0x18
LAB_0017d48c:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0017d547
JMP 0x0017d499
LAB_0017d499:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x0017d4a8
JMP 0x0017d549
LAB_0017d4a8:
JMP 0x0017d4aa
LAB_0017d4aa:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x0017d499
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x100],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xf4],EAX
CMP EAX,0x28
JA 0x0017d517
MOV RCX,qword ptr [RBP + -0x100]
MOV EDX,dword ptr [RBP + -0xf4]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x108],RAX
JMP 0x0017d534
LAB_0017d517:
MOV RCX,qword ptr [RBP + -0x100]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x108],RAX
LAB_0017d534:
MOV RAX,qword ptr [RBP + -0x108]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0017d48c
LAB_0017d547:
JMP 0x0017d549
LAB_0017d549:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
char * strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
int8 *local_110;
int8 local_f8 [24];
uint local_38;
int8 *local_30;
char *local_20;
char *local_10;
local_30 = (int8 *)&stack0x00000008;
local_38 = 0x18;
local_20 = param_3;
local_10 = param_1;
while (pcVar2 = local_10, local_20 != (char *)0x0) {
do {
local_10 = pcVar2;
if (local_10 == param_1 + param_2) goto LAB_0017d549;
cVar1 = *local_20;
*local_10 = cVar1;
local_20 = local_20 + 1;
pcVar2 = local_10 + 1;
} while (cVar1 != '\0');
if (local_38 < 0x29) {
local_110 = (int8 *)((long)local_f8 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_110 = local_30;
local_30 = local_30 + 1;
}
local_20 = (char *)*local_110;
}
LAB_0017d549:
*local_10 = '\0';
return local_10;
}
|
|
13,750
|
nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type)
|
llama.cpp/common/./json.hpp
|
static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type):
cmpl $0x10, %edi
ja 0x32af8
movl %edi, %eax
leaq 0x96b88(%rip), %rcx # 0xc9678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x9456a(%rip), %rax # 0xc7069
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_32AF8
mov eax, edi
lea rcx, unk_C9678
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_32AF8:
lea rax, aUnknownToken; "unknown token"
retn
|
const char * nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_C9678 + dword_C9678[a1];
}
|
token_type_name:
CMP EDI,0x10
JA 0x00132af8
MOV EAX,EDI
LEA RCX,[0x1c9678]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00132af8:
LEA RAX,[0x1c7069]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<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>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<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>>
::token_type_name(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001c9678 + *(int *)(&DAT_001c9678 + (ulong)param_1 * 4);
}
return "unknown token";
}
|
|
13,751
|
stbi__readval(stbi__context*, int, unsigned char*)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
}
|
O0
|
c
|
stbi__readval(stbi__context*, int, unsigned char*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x80, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x4, (%rsp)
jge 0x1ed90
movl 0x14(%rsp), %eax
andl 0x4(%rsp), %eax
cmpl $0x0, %eax
je 0x1ed79
movq 0x18(%rsp), %rdi
callq 0x1e690
cmpl $0x0, %eax
je 0x1ed61
leaq 0x15ffa8(%rip), %rdi # 0x17ecf2
callq 0xddd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x20(%rsp)
jmp 0x1ed9a
movq 0x18(%rsp), %rdi
callq 0x17f50
movb %al, %dl
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1ed7b
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
sarl %eax
movl %eax, 0x4(%rsp)
jmp 0x1ed21
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZL13stbi__readvalP13stbi__contextiPh:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov [rsp+28h+var_20], rdx
mov [rsp+28h+var_24], 80h
mov [rsp+28h+var_28], 0
loc_1ED21:
cmp [rsp+28h+var_28], 4
jge short loc_1ED90
mov eax, [rsp+28h+var_14]
and eax, [rsp+28h+var_24]
cmp eax, 0
jz short loc_1ED79
mov rdi, [rsp+28h+var_10]
call _ZL12stbi__at_eofP13stbi__context; stbi__at_eof(stbi__context *)
cmp eax, 0
jz short loc_1ED61
lea rdi, aBadFile; "bad file"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
mov [rsp+28h+var_8], rax
jmp short loc_1ED9A
loc_1ED61:
mov rdi, [rsp+28h+var_10]
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
mov dl, al
mov rax, [rsp+28h+var_20]
movsxd rcx, [rsp+28h+var_28]
mov [rax+rcx], dl
loc_1ED79:
jmp short $+2
loc_1ED7B:
mov eax, [rsp+28h+var_28]
add eax, 1
mov [rsp+28h+var_28], eax
mov eax, [rsp+28h+var_24]
sar eax, 1
mov [rsp+28h+var_24], eax
jmp short loc_1ED21
loc_1ED90:
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
loc_1ED9A:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long stbi__readval(long long a1, int a2, long long a3)
{
int i; // [rsp+0h] [rbp-28h]
int v5; // [rsp+4h] [rbp-24h]
v5 = 128;
for ( i = 0; i < 4; ++i )
{
if ( (v5 & a2) != 0 )
{
if ( stbi__at_eof(a1) )
{
stbi__err("bad file");
return 0LL;
}
*(_BYTE *)(a3 + i) = stbi__get8(a1);
}
v5 >>= 1;
}
return a3;
}
|
stbi__readval:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV qword ptr [RSP + 0x8],RDX
MOV dword ptr [RSP + 0x4],0x80
MOV dword ptr [RSP],0x0
LAB_0011ed21:
CMP dword ptr [RSP],0x4
JGE 0x0011ed90
MOV EAX,dword ptr [RSP + 0x14]
AND EAX,dword ptr [RSP + 0x4]
CMP EAX,0x0
JZ 0x0011ed79
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0011e690
CMP EAX,0x0
JZ 0x0011ed61
LEA RDI,[0x27ecf2]
CALL 0x0010ddd0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0011ed9a
LAB_0011ed61:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00117f50
MOV DL,AL
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RCX,dword ptr [RSP]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0011ed79:
JMP 0x0011ed7b
LAB_0011ed7b:
MOV EAX,dword ptr [RSP]
ADD EAX,0x1
MOV dword ptr [RSP],EAX
MOV EAX,dword ptr [RSP + 0x4]
SAR EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x0011ed21
LAB_0011ed90:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_0011ed9a:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
/* stbi__readval(stbi__context*, int, unsigned char*) */
uchar * stbi__readval(stbi__context *param_1,int param_2,uchar *param_3)
{
uchar uVar1;
int iVar2;
int local_28;
uint local_24;
local_24 = 0x80;
local_28 = 0;
do {
if (3 < local_28) {
return param_3;
}
if ((param_2 & local_24) != 0) {
iVar2 = stbi__at_eof(param_1);
if (iVar2 != 0) {
stbi__err("bad file");
return (uchar *)0x0;
}
uVar1 = stbi__get8(param_1);
param_3[local_28] = uVar1;
}
local_28 = local_28 + 1;
local_24 = (int)local_24 >> 1;
} while( true );
}
|
|
13,752
|
stbi__readval(stbi__context*, int, unsigned char*)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
}
|
O2
|
c
|
stbi__readval(stbi__context*, int, unsigned char*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x80, %r15d
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x1731e
testl %ebp, %r15d
je 0x17304
movq %r14, %rdi
callq 0x1728e
testl %eax, %eax
jne 0x1730c
movq %r14, %rdi
callq 0x14342
movb %al, (%rbx,%r12)
incq %r12
shrl %r15d
jmp 0x172e1
leaq 0x815aa(%rip), %rax # 0x988bd
movq %rax, %fs:-0x20
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ZL13stbi__readvalP13stbi__contextiPh:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov ebp, esi
mov r14, rdi
mov r15d, 80h
xor r12d, r12d
loc_172E1:
cmp r12, 4
jz short loc_1731E
test r15d, ebp
jz short loc_17304
mov rdi, r14
call _ZL12stbi__at_eofP13stbi__context; stbi__at_eof(stbi__context *)
test eax, eax
jnz short loc_1730C
mov rdi, r14
call _ZL10stbi__get8P13stbi__context; stbi__get8(stbi__context *)
mov [rbx+r12], al
loc_17304:
inc r12
shr r15d, 1
jmp short loc_172E1
loc_1730C:
lea rax, aBadFile; "bad file"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor ebx, ebx
loc_1731E:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long stbi__readval(long long a1, int a2, long long a3)
{
unsigned int v4; // r15d
long long i; // r12
v4 = 128;
for ( i = 0LL; i != 4; ++i )
{
if ( (a2 & v4) != 0 )
{
if ( (unsigned int)stbi__at_eof(a1) )
{
__writefsqword(0xFFFFFFE0, (unsigned long long)"bad file");
return 0LL;
}
*(_BYTE *)(a3 + i) = stbi__get8(a1);
}
v4 >>= 1;
}
return a3;
}
|
stbi__readval:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV EBP,ESI
MOV R14,RDI
MOV R15D,0x80
XOR R12D,R12D
LAB_001172e1:
CMP R12,0x4
JZ 0x0011731e
TEST R15D,EBP
JZ 0x00117304
MOV RDI,R14
CALL 0x0011728e
TEST EAX,EAX
JNZ 0x0011730c
MOV RDI,R14
CALL 0x00114342
MOV byte ptr [RBX + R12*0x1],AL
LAB_00117304:
INC R12
SHR R15D,0x1
JMP 0x001172e1
LAB_0011730c:
LEA RAX,[0x1988bd]
MOV qword ptr FS:[-0x20],RAX
XOR EBX,EBX
LAB_0011731e:
MOV RAX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* stbi__readval(stbi__context*, int, unsigned char*) */
uchar * stbi__readval(stbi__context *param_1,int param_2,uchar *param_3)
{
uchar uVar1;
int iVar2;
long lVar3;
uint uVar4;
long in_FS_OFFSET;
uVar4 = 0x80;
lVar3 = 0;
do {
if (lVar3 == 4) {
return param_3;
}
if ((uVar4 & param_2) != 0) {
iVar2 = stbi__at_eof(param_1);
if (iVar2 != 0) {
*(char **)(in_FS_OFFSET + -0x20) = "bad file";
return (uchar *)0x0;
}
uVar1 = stbi__get8(param_1);
param_3[lVar3] = uVar1;
}
lVar3 = lVar3 + 1;
uVar4 = uVar4 >> 1;
} while( true );
}
|
|
13,753
|
stbi__readval(stbi__context*, int, unsigned char*)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
}
|
O3
|
c
|
stbi__readval(stbi__context*, int, unsigned char*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x80, %r15d
xorl %r12d, %r12d
testl %ebp, %r15d
je 0x29de5
cmpq $0x0, 0x10(%r14)
je 0x29d96
movq 0x28(%r14), %rdi
callq *0x20(%r14)
testl %eax, %eax
je 0x29dab
cmpl $0x0, 0x30(%r14)
je 0x29df7
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rcx
cmpq %rcx, %rax
jb 0x29db9
jmp 0x29df7
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rcx
cmpq %rcx, %rax
jb 0x29dd4
cmpl $0x0, 0x30(%r14)
je 0x29df3
movq %r14, %rdi
callq 0x2620e
movq 0xc0(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%r14)
movb (%rax), %al
movb %al, (%rbx,%r12)
incq %r12
shrl %r15d
cmpq $0x4, %r12
jne 0x29d77
jmp 0x29e09
xorl %eax, %eax
jmp 0x29de1
leaq 0x91b8f(%rip), %rax # 0xbb98d
movq %rax, %fs:-0x20
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
_ZL13stbi__readvalP13stbi__contextiPh:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov ebp, esi
mov r14, rdi
mov r15d, 80h
xor r12d, r12d
loc_29D77:
test r15d, ebp
jz short loc_29DE5
cmp qword ptr [r14+10h], 0
jz short loc_29D96
mov rdi, [r14+28h]
call qword ptr [r14+20h]
test eax, eax
jz short loc_29DAB
cmp dword ptr [r14+30h], 0
jz short loc_29DF7
loc_29D96:
mov rax, [r14+0C0h]
mov rcx, [r14+0C8h]
cmp rax, rcx
jb short loc_29DB9
jmp short loc_29DF7
loc_29DAB:
mov rax, [r14+0C0h]
mov rcx, [r14+0C8h]
loc_29DB9:
cmp rax, rcx
jb short loc_29DD4
cmp dword ptr [r14+30h], 0
jz short loc_29DF3
mov rdi, r14
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [r14+0C0h]
loc_29DD4:
lea rcx, [rax+1]
mov [r14+0C0h], rcx
mov al, [rax]
loc_29DE1:
mov [rbx+r12], al
loc_29DE5:
inc r12
shr r15d, 1
cmp r12, 4
jnz short loc_29D77
jmp short loc_29E09
loc_29DF3:
xor eax, eax
jmp short loc_29DE1
loc_29DF7:
lea rax, aBadFile; "bad file"
mov fs:0FFFFFFFFFFFFFFE0h, rax
xor ebx, ebx
loc_29E09:
mov rax, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long stbi__readval(long long a1, int a2, long long a3)
{
unsigned int v4; // r15d
long long v5; // r12
char *v6; // rax
unsigned long long v7; // rcx
char v8; // al
v4 = 128;
v5 = 0LL;
while ( (a2 & v4) == 0 )
{
LABEL_14:
++v5;
v4 >>= 1;
if ( v5 == 4 )
return a3;
}
if ( *(_QWORD *)(a1 + 16) )
{
if ( !(*(unsigned int ( **)(_QWORD))(a1 + 32))(*(_QWORD *)(a1 + 40)) )
{
v6 = *(char **)(a1 + 192);
v7 = *(_QWORD *)(a1 + 200);
LABEL_9:
if ( (unsigned long long)v6 >= v7 )
{
if ( !*(_DWORD *)(a1 + 48) )
{
v8 = 0;
goto LABEL_13;
}
stbi__refill_buffer(a1);
v6 = *(char **)(a1 + 192);
}
*(_QWORD *)(a1 + 192) = v6 + 1;
v8 = *v6;
LABEL_13:
*(_BYTE *)(a3 + v5) = v8;
goto LABEL_14;
}
if ( !*(_DWORD *)(a1 + 48) )
goto LABEL_17;
}
v6 = *(char **)(a1 + 192);
v7 = *(_QWORD *)(a1 + 200);
if ( (unsigned long long)v6 < v7 )
goto LABEL_9;
LABEL_17:
__writefsqword(0xFFFFFFE0, (unsigned long long)"bad file");
return 0LL;
}
| |||
13,754
|
THD::find_and_use_tmp_table(TABLE_LIST const*, TABLE**)
|
eloqsql/sql/temporary_tables.cc
|
bool THD::find_and_use_tmp_table(const TABLE_LIST *tl, TABLE **out_table)
{
DBUG_ENTER("THD::find_and_use_tmp_table");
char key[MAX_DBKEY_LENGTH];
uint key_length;
bool result;
key_length= create_tmp_table_def_key(key, tl->get_db_name(),
tl->get_table_name());
result= use_temporary_table(find_temporary_table(key, key_length,
TMP_TABLE_NOT_IN_USE),
out_table);
DBUG_RETURN(result);
}
|
O0
|
cpp
|
THD::find_and_use_tmp_table(TABLE_LIST const*, TABLE**):
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1a8(%rbp)
movq %rsi, -0x1b0(%rbp)
movq %rdx, -0x1b8(%rbp)
movq -0x1a8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x856b10
movq %rax, -0x1d0(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x856b50
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdx
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
callq 0xb37870
movq -0x1c8(%rbp), %rdi
movl %eax, -0x1bc(%rbp)
leaq -0x1a0(%rbp), %rsi
movl -0x1bc(%rbp), %edx
movl $0x1, %ecx
callq 0xb379a0
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
movq -0x1b8(%rbp), %rdx
callq 0xb39350
andb $0x1, %al
movb %al, -0x1bd(%rbp)
movb -0x1bd(%rbp), %al
movb %al, -0x1d9(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb38266
movb -0x1d9(%rbp), %al
andb $0x1, %al
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
callq 0x758480
nopl (%rax,%rax)
|
_ZN3THD22find_and_use_tmp_tableEPK10TABLE_LISTPP5TABLE:
push rbp
mov rbp, rsp
sub rsp, 1E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1A8], rdi
mov [rbp+var_1B0], rsi
mov [rbp+var_1B8], rdx
mov rax, [rbp+var_1A8]
mov [rbp+var_1C8], rax
lea rax, [rbp+var_1A0]
mov [rbp+var_1D8], rax
mov rdi, [rbp+var_1B0]; this
call _ZNK10TABLE_LIST11get_db_nameEv; TABLE_LIST::get_db_name(void)
mov [rbp+var_1D0], rax
mov rdi, [rbp+var_1B0]; this
call _ZNK10TABLE_LIST14get_table_nameEv; TABLE_LIST::get_table_name(void)
mov rsi, [rbp+var_1D8]; char *
mov rdx, [rbp+var_1D0]; char *
mov rdi, [rbp+var_1C8]; this
mov rcx, rax; char *
call _ZN3THD24create_tmp_table_def_keyEPcPKcS2_; THD::create_tmp_table_def_key(char *,char const*,char const*)
mov rdi, [rbp+var_1C8]
mov [rbp+var_1BC], eax
lea rsi, [rbp+var_1A0]
mov edx, [rbp+var_1BC]
mov ecx, 1
call _ZN3THD20find_temporary_tableEPKcjNS_21Temporary_table_stateE; THD::find_temporary_table(char const*,uint,THD::Temporary_table_state)
mov rdi, [rbp+var_1C8]; this
mov rsi, rax; TABLE *
mov rdx, [rbp+var_1B8]; TABLE **
call _ZN3THD19use_temporary_tableEP5TABLEPS1_; THD::use_temporary_table(TABLE *,TABLE **)
and al, 1
mov [rbp+var_1BD], al
mov al, [rbp+var_1BD]
mov [rbp+var_1D9], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B38266
mov al, [rbp+var_1D9]
and al, 1
add rsp, 1E0h
pop rbp
retn
loc_B38266:
call ___stack_chk_fail
|
char THD::find_and_use_tmp_table(THD *this, const TABLE_LIST *a2, TABLE **a3)
{
const char *table_name; // rax
TABLE *temporary_table; // rax
char *db_name; // [rsp+10h] [rbp-1D0h]
unsigned int tmp_table_def_key; // [rsp+24h] [rbp-1BCh]
char v9[408]; // [rsp+40h] [rbp-1A0h] BYREF
unsigned long long v10; // [rsp+1D8h] [rbp-8h]
v10 = __readfsqword(0x28u);
db_name = (char *)TABLE_LIST::get_db_name(a2);
table_name = (const char *)TABLE_LIST::get_table_name(a2);
tmp_table_def_key = THD::create_tmp_table_def_key(this, v9, db_name, table_name);
temporary_table = (TABLE *)THD::find_temporary_table(this, (long long)v9, tmp_table_def_key, 1);
return THD::use_temporary_table(this, temporary_table, a3) & 1;
}
|
init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RCX,qword ptr [RBP + -0x8]
LEA RAX,[0x1e014f0]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
/* Event_worker_thread::init(Event_db_repository*) */
void Event_worker_thread::init(Event_db_repository *param_1)
{
db_repository = param_1;
return;
}
|
|
13,755
|
lshift
|
eloqsql/strings/dtoa.c
|
static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
}
|
O3
|
c
|
lshift:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r12d
shrl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%r14), %eax
movl 0x14(%r14), %ebx
addl %r12d, %ebx
cmpl %eax, %ebx
jl 0xda195
incl %edi
addl %eax, %eax
jmp 0xda18b
movq %rdx, -0x38(%rbp)
movq %rdx, %rsi
callq 0xd9d38
movq (%rax), %r13
cmpl $0x20, %r15d
jb 0xda1cc
decl %r12d
leaq 0x4(,%r12,4), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %rax, -0x30(%rbp)
callq 0x2a290
movq -0x30(%rbp), %rax
leaq 0x4(%r13,%r12,4), %r13
movq (%r14), %rdx
movslq 0x14(%r14), %rcx
leaq (%rdx,%rcx,4), %rsi
andl $0x1f, %r15d
je 0xda218
movl $0x20, %r9d
subl %r15d, %r9d
xorl %edi, %edi
movl (%rdx), %r8d
movl %r15d, %ecx
shll %cl, %r8d
orl %edi, %r8d
movl %r8d, (%r13)
addq $0x4, %r13
movl (%rdx), %edi
addq $0x4, %rdx
movl %r9d, %ecx
shrl %cl, %edi
cmpq %rsi, %rdx
jb 0xda1e8
movl %edi, (%r13)
cmpl $0x1, %edi
sbbl $-0x1, %ebx
jmp 0xda22b
movl (%rdx), %ecx
addq $0x4, %rdx
movl %ecx, (%r13)
addq $0x4, %r13
cmpq %rsi, %rdx
jb 0xda218
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rbx
callq 0xda131
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
lshift:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, esi
mov r14, rdi
mov r12d, esi
shr r12d, 5
mov edi, [rdi+8]
mov eax, [r14+0Ch]
mov ebx, [r14+14h]
add ebx, r12d
loc_DA18B:
cmp ebx, eax
jl short loc_DA195
inc edi
add eax, eax
jmp short loc_DA18B
loc_DA195:
mov [rbp+var_38], rdx
mov rsi, rdx
call Balloc
mov r13, [rax]
cmp r15d, 20h ; ' '
jb short loc_DA1CC
dec r12d
lea rdx, ds:4[r12*4]
mov rdi, r13
xor esi, esi
mov [rbp+var_30], rax
call _memset
mov rax, [rbp+var_30]
lea r13, [r13+r12*4+4]
loc_DA1CC:
mov rdx, [r14]
movsxd rcx, dword ptr [r14+14h]
lea rsi, [rdx+rcx*4]
and r15d, 1Fh
jz short loc_DA218
mov r9d, 20h ; ' '
sub r9d, r15d
xor edi, edi
loc_DA1E8:
mov r8d, [rdx]
mov ecx, r15d
shl r8d, cl
or r8d, edi
mov [r13+0], r8d
add r13, 4
mov edi, [rdx]
add rdx, 4
mov ecx, r9d
shr edi, cl
cmp rdx, rsi
jb short loc_DA1E8
mov [r13+0], edi
cmp edi, 1
sbb ebx, 0FFFFFFFFh
jmp short loc_DA22B
loc_DA218:
mov ecx, [rdx]
add rdx, 4
mov [r13+0], ecx
add r13, 4
cmp rdx, rsi
jb short loc_DA218
loc_DA22B:
mov [rax+14h], ebx
mov rdi, r14
mov rsi, [rbp+var_38]
mov rbx, rax
call Bfree
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long lshift(unsigned long long a1, unsigned int a2, unsigned long long *a3)
{
char v3; // r15
int v5; // edi
int v6; // eax
int v7; // ebx
long long v8; // rax
int *v9; // r13
long long v10; // r12
int *v11; // rdx
unsigned long long v12; // rsi
int v13; // r15d
int v14; // edi
unsigned int v15; // edi
int v16; // ecx
long long v17; // rbx
long long v20; // [rsp+10h] [rbp-30h]
v3 = a2;
v5 = *(_DWORD *)(a1 + 8);
v6 = *(_DWORD *)(a1 + 12);
v7 = (a2 >> 5) + *(_DWORD *)(a1 + 20);
while ( v7 >= v6 )
{
++v5;
v6 *= 2;
}
v8 = Balloc(v5, (long long)a3);
v9 = *(int **)v8;
if ( a2 >= 0x20 )
{
v10 = (a2 >> 5) - 1;
v20 = v8;
memset(*(_QWORD *)v8, 0LL, 4 * v10 + 4);
v8 = v20;
v9 += v10 + 1;
}
v11 = *(int **)a1;
v12 = *(_QWORD *)a1 + 4LL * *(int *)(a1 + 20);
v13 = v3 & 0x1F;
if ( v13 )
{
v14 = 0;
do
{
*v9++ = v14 | (*v11 << v13);
v15 = *v11++;
v14 = v15 >> (32 - v13);
}
while ( (unsigned long long)v11 < v12 );
*v9 = v14;
v7 -= (v14 == 0) - 1;
}
else
{
do
{
v16 = *v11++;
*v9++ = v16;
}
while ( (unsigned long long)v11 < v12 );
}
*(_DWORD *)(v8 + 20) = v7;
v17 = v8;
Bfree(a1, a3);
return v17;
}
|
lshift:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ESI
MOV R14,RDI
MOV R12D,ESI
SHR R12D,0x5
MOV EDI,dword ptr [RDI + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
MOV EBX,dword ptr [R14 + 0x14]
ADD EBX,R12D
LAB_001da18b:
CMP EBX,EAX
JL 0x001da195
INC EDI
ADD EAX,EAX
JMP 0x001da18b
LAB_001da195:
MOV qword ptr [RBP + -0x38],RDX
MOV RSI,RDX
CALL 0x001d9d38
MOV R13,qword ptr [RAX]
CMP R15D,0x20
JC 0x001da1cc
DEC R12D
LEA RDX,[0x4 + R12*0x4]
MOV RDI,R13
XOR ESI,ESI
MOV qword ptr [RBP + -0x30],RAX
CALL 0x0012a290
MOV RAX,qword ptr [RBP + -0x30]
LEA R13,[R13 + R12*0x4 + 0x4]
LAB_001da1cc:
MOV RDX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0x14]
LEA RSI,[RDX + RCX*0x4]
AND R15D,0x1f
JZ 0x001da218
MOV R9D,0x20
SUB R9D,R15D
XOR EDI,EDI
LAB_001da1e8:
MOV R8D,dword ptr [RDX]
MOV ECX,R15D
SHL R8D,CL
OR R8D,EDI
MOV dword ptr [R13],R8D
ADD R13,0x4
MOV EDI,dword ptr [RDX]
ADD RDX,0x4
MOV ECX,R9D
SHR EDI,CL
CMP RDX,RSI
JC 0x001da1e8
MOV dword ptr [R13],EDI
CMP EDI,0x1
SBB EBX,-0x1
JMP 0x001da22b
LAB_001da218:
MOV ECX,dword ptr [RDX]
ADD RDX,0x4
MOV dword ptr [R13],ECX
ADD R13,0x4
CMP RDX,RSI
JC 0x001da218
LAB_001da22b:
MOV dword ptr [RAX + 0x14],EBX
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RBX,RAX
CALL 0x001da131
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
uint *puVar1;
sbyte sVar2;
int iVar3;
int8 *puVar4;
uint *puVar5;
int iVar6;
uint uVar7;
ulong uVar8;
uint *__s;
iVar6 = *(int *)((long)param_1 + 0x14) + (param_2 >> 5);
for (iVar3 = *(int *)((long)param_1 + 0xc); iVar3 <= iVar6; iVar3 = iVar3 * 2) {
}
puVar4 = (int8 *)Balloc();
__s = (uint *)*puVar4;
if (0x1f < param_2) {
uVar8 = (ulong)((param_2 >> 5) - 1);
memset(__s,0,uVar8 * 4 + 4);
__s = __s + uVar8 + 1;
}
puVar5 = (uint *)*param_1;
puVar1 = puVar5 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
*__s = uVar7;
__s = __s + 1;
} while (puVar5 < puVar1);
}
else {
sVar2 = (sbyte)(param_2 & 0x1f);
uVar7 = 0;
do {
*__s = *puVar5 << sVar2 | uVar7;
__s = __s + 1;
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
uVar7 = uVar7 >> (0x20U - sVar2 & 0x1f);
} while (puVar5 < puVar1);
*__s = uVar7;
iVar6 = (iVar6 + 1) - (uint)(uVar7 == 0);
}
*(int *)((long)puVar4 + 0x14) = iVar6;
Bfree(param_1,param_3);
return puVar4;
}
|
|
13,756
|
translog_get_file_max_lsn_stored
|
eloqsql/storage/maria/ma_loghandler.c
|
LSN translog_get_file_max_lsn_stored(uint32 file)
{
uint32 limit= FILENO_IMPOSSIBLE;
DBUG_ENTER("translog_get_file_max_lsn_stored");
DBUG_PRINT("enter", ("file: %lu", (ulong)file));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
mysql_mutex_lock(&log_descriptor.unfinished_files_lock);
/* find file with minimum file number "in progress" */
if (log_descriptor.unfinished_files.elements > 0)
{
struct st_file_counter *fc_ptr;
fc_ptr= dynamic_element(&log_descriptor.unfinished_files,
0, struct st_file_counter *);
limit= fc_ptr->file; /* minimal file number "in progress" */
}
mysql_mutex_unlock(&log_descriptor.unfinished_files_lock);
/*
if there is no "in progress file" then unfinished file is in progress
for sure
*/
if (limit == FILENO_IMPOSSIBLE)
{
TRANSLOG_ADDRESS horizon= translog_get_horizon();
limit= LSN_FILE_NO(horizon);
}
if (file >= limit)
{
DBUG_PRINT("info", ("The file in in progress"));
DBUG_RETURN(LSN_IMPOSSIBLE);
}
{
LOGHANDLER_FILE_INFO info;
File fd;
fd= open_logfile_by_number_no_cache(file);
if(fd < 0)
{
DBUG_PRINT("error", ("Can't open file"));
DBUG_RETURN(LSN_ERROR);
}
if (translog_read_file_header(&info, fd))
{
DBUG_PRINT("error", ("Can't read file header"));
info.max_lsn= LSN_ERROR;
}
if (mysql_file_close(fd, MYF(MY_WME)))
{
DBUG_PRINT("error", ("Can't close file"));
info.max_lsn= LSN_ERROR;
}
DBUG_PRINT("info", ("Max lsn: " LSN_FMT, LSN_IN_PARTS(info.max_lsn)));
DBUG_RETURN(info.max_lsn);
}
}
|
O0
|
c
|
translog_get_file_max_lsn_stored:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
jmp 0x87864
jmp 0x87866
jmp 0x87868
leaq 0x3fcc21(%rip), %rdi # 0x484490
addq $0x800e08, %rdi # imm = 0x800E08
leaq 0xd3738(%rip), %rsi # 0x15afb5
movl $0x5b7, %edx # imm = 0x5B7
callq 0x87970
cmpl $0x0, 0xbfda5a(%rip) # 0xc852e8
jbe 0x878a4
movq 0xbfda49(%rip), %rax # 0xc852e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq 0x3fcbe5(%rip), %rdi # 0x484490
addq $0x800e08, %rdi # imm = 0x800E08
callq 0x879e0
cmpl $0x0, -0x10(%rbp)
jne 0x878d1
callq 0x8c810
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
sarq $0x20, %rax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jb 0x878e9
jmp 0x878db
jmp 0x878dd
jmp 0x878df
movq $0x0, -0x8(%rbp)
jmp 0x8795e
movl -0xc(%rbp), %edi
callq 0x87a40
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jge 0x8790a
jmp 0x878fc
jmp 0x878fe
jmp 0x87900
movq $0x1, -0x8(%rbp)
jmp 0x8795e
movl -0x5c(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x87640
cmpb $0x0, %al
je 0x87926
jmp 0x8791c
jmp 0x8791e
movq $0x1, -0x58(%rbp)
movl -0x5c(%rbp), %edx
leaq 0xd3685(%rip), %rdi # 0x15afb5
movl $0x5e4, %esi # imm = 0x5E4
movl $0x10, %ecx
callq 0x87b10
cmpl $0x0, %eax
je 0x87950
jmp 0x87946
jmp 0x87948
movq $0x1, -0x58(%rbp)
jmp 0x87952
jmp 0x87954
jmp 0x87956
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
translog_get_file_max_lsn_stored:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_C], edi
mov [rbp+var_10], 0
jmp short $+2
loc_87864:
jmp short $+2
loc_87866:
jmp short $+2
loc_87868:
lea rdi, log_descriptor
add rdi, 800E08h
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 5B7h
call inline_mysql_mutex_lock_11
cmp cs:dword_C852E8, 0
jbe short loc_878A4
mov rax, cs:qword_C852E0
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_10], eax
loc_878A4:
lea rdi, log_descriptor
add rdi, 800E08h
call inline_mysql_mutex_unlock_12
cmp [rbp+var_10], 0
jnz short loc_878D1
call translog_get_horizon
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
sar rax, 20h
mov [rbp+var_10], eax
loc_878D1:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jb short loc_878E9
jmp short $+2
loc_878DB:
jmp short $+2
loc_878DD:
jmp short $+2
loc_878DF:
mov [rbp+var_8], 0
jmp short loc_8795E
loc_878E9:
mov edi, [rbp+var_C]
call open_logfile_by_number_no_cache
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jge short loc_8790A
jmp short $+2
loc_878FC:
jmp short $+2
loc_878FE:
jmp short $+2
loc_87900:
mov [rbp+var_8], 1
jmp short loc_8795E
loc_8790A:
mov esi, [rbp+var_5C]
lea rdi, [rbp+var_58]
call translog_read_file_header
cmp al, 0
jz short loc_87926
jmp short $+2
loc_8791C:
jmp short $+2
loc_8791E:
mov [rbp+var_58], 1
loc_87926:
mov edx, [rbp+var_5C]
lea rdi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 5E4h
mov ecx, 10h
call inline_mysql_file_close_4
cmp eax, 0
jz short loc_87950
jmp short $+2
loc_87946:
jmp short $+2
loc_87948:
mov [rbp+var_58], 1
loc_87950:
jmp short $+2
loc_87952:
jmp short $+2
loc_87954:
jmp short $+2
loc_87956:
mov rax, [rbp+var_58]
mov [rbp+var_8], rax
loc_8795E:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
unsigned long long translog_get_file_max_lsn_stored(unsigned int a1)
{
int v2; // [rsp+4h] [rbp-5Ch]
unsigned long long v3[7]; // [rsp+8h] [rbp-58h] BYREF
long long horizon; // [rsp+40h] [rbp-20h]
long long v5; // [rsp+48h] [rbp-18h]
unsigned int v6; // [rsp+50h] [rbp-10h]
unsigned int v7; // [rsp+54h] [rbp-Ch]
v7 = a1;
v6 = 0;
inline_mysql_mutex_lock_11(
&log_descriptor + 1049025,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
1463LL);
if ( dword_C852E8 )
{
v5 = qword_C852E0;
v6 = *(_DWORD *)qword_C852E0;
}
inline_mysql_mutex_unlock_12(&log_descriptor + 1049025);
if ( !v6 )
{
horizon = translog_get_horizon();
v6 = HIDWORD(horizon);
}
if ( v7 >= v6 )
return 0LL;
v2 = open_logfile_by_number_no_cache(v7);
if ( v2 < 0 )
return 1LL;
if ( translog_read_file_header(v3, v2) )
v3[0] = 1LL;
if ( (unsigned int)inline_mysql_file_close_4(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
1508LL,
(unsigned int)v2,
16LL) )
v3[0] = 1LL;
return v3[0];
}
|
translog_get_file_max_lsn_stored:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0xc],EDI
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00187864
LAB_00187864:
JMP 0x00187866
LAB_00187866:
JMP 0x00187868
LAB_00187868:
LEA RDI,[0x584490]
ADD RDI,0x800e08
LEA RSI,[0x25afb5]
MOV EDX,0x5b7
CALL 0x00187970
CMP dword ptr [0x00d852e8],0x0
JBE 0x001878a4
MOV RAX,qword ptr [0x00d852e0]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_001878a4:
LEA RDI,[0x584490]
ADD RDI,0x800e08
CALL 0x001879e0
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x001878d1
CALL 0x0018c810
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
SAR RAX,0x20
MOV dword ptr [RBP + -0x10],EAX
LAB_001878d1:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JC 0x001878e9
JMP 0x001878db
LAB_001878db:
JMP 0x001878dd
LAB_001878dd:
JMP 0x001878df
LAB_001878df:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0018795e
LAB_001878e9:
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x00187a40
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JGE 0x0018790a
JMP 0x001878fc
LAB_001878fc:
JMP 0x001878fe
LAB_001878fe:
JMP 0x00187900
LAB_00187900:
MOV qword ptr [RBP + -0x8],0x1
JMP 0x0018795e
LAB_0018790a:
MOV ESI,dword ptr [RBP + -0x5c]
LEA RDI,[RBP + -0x58]
CALL 0x00187640
CMP AL,0x0
JZ 0x00187926
JMP 0x0018791c
LAB_0018791c:
JMP 0x0018791e
LAB_0018791e:
MOV qword ptr [RBP + -0x58],0x1
LAB_00187926:
MOV EDX,dword ptr [RBP + -0x5c]
LEA RDI,[0x25afb5]
MOV ESI,0x5e4
MOV ECX,0x10
CALL 0x00187b10
CMP EAX,0x0
JZ 0x00187950
JMP 0x00187946
LAB_00187946:
JMP 0x00187948
LAB_00187948:
MOV qword ptr [RBP + -0x58],0x1
LAB_00187950:
JMP 0x00187952
LAB_00187952:
JMP 0x00187954
LAB_00187954:
JMP 0x00187956
LAB_00187956:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x8],RAX
LAB_0018795e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
int8 translog_get_file_max_lsn_stored(uint param_1)
{
char cVar1;
int iVar2;
int8 local_60 [7];
int8 local_28;
uint *local_20;
uint local_18;
uint local_14;
int8 local_10;
local_18 = 0;
local_14 = param_1;
inline_mysql_mutex_lock
(&DAT_00d85298,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x5b7);
if (DAT_00d852e8 != 0) {
local_20 = DAT_00d852e0;
local_18 = *DAT_00d852e0;
}
inline_mysql_mutex_unlock(&DAT_00d85298);
if (local_18 == 0) {
local_28 = translog_get_horizon();
local_18 = (uint)((ulong)local_28 >> 0x20);
}
if (local_14 < local_18) {
iVar2 = open_logfile_by_number_no_cache(local_14);
if (iVar2 < 0) {
local_10 = 1;
}
else {
cVar1 = translog_read_file_header(local_60,iVar2);
if (cVar1 != '\0') {
local_60[0] = 1;
}
iVar2 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x5e4,iVar2,0x10);
if (iVar2 != 0) {
local_60[0] = 1;
}
local_10 = local_60[0];
}
}
else {
local_10 = 0;
}
return local_10;
}
|
|
13,757
|
ext(LefDefParser::defrCallbackType_e, char const*, void*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/defdiff/diffDefRW.cpp
|
int ext(defrCallbackType_e t, const char* c, defiUserData ud) {
char* name;
checkType(t);
if (ud != userData) dataError();
switch (t) {
case defrNetExtCbkType : name = address("net"); break;
case defrComponentExtCbkType : name = address("component"); break;
case defrPinExtCbkType : name = address("pin"); break;
case defrViaExtCbkType : name = address("via"); break;
case defrNetConnectionExtCbkType : name = address("net connection"); break;
case defrGroupExtCbkType : name = address("group"); break;
case defrScanChainExtCbkType : name = address("scanchain"); break;
case defrIoTimingsExtCbkType : name = address("io timing"); break;
case defrPartitionsExtCbkType : name = address("partition"); break;
default: name = address("BOGUS"); return 1;
}
fprintf(fout, "EXTENSION %s %s\n", name, c);
return 0;
}
|
O3
|
cpp
|
ext(LefDefParser::defrCallbackType_e, char const*, void*):
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x68, %edi
jb 0xf2c5
movq 0x53fa1(%rip), %rcx # 0x63250
leaq 0x2f1d9(%rip), %rdi # 0x3e48f
movl $0x27, %esi
movl $0x1, %edx
callq 0x6350
cmpq %r14, 0x53f8c(%rip) # 0x63258
je 0xf2eb
movq 0x53f7b(%rip), %rcx # 0x63250
leaq 0x2f188(%rip), %rdi # 0x3e464
movl $0x2a, %esi
movl $0x1, %edx
callq 0x6350
addl $-0x18, %ebp
movl $0x1, %r14d
cmpl $0x8, %ebp
ja 0xf324
movl %ebp, %eax
leaq 0x2f13e(%rip), %rcx # 0x3e440
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
movq 0x53f40(%rip), %rdi # 0x63250
leaq 0x3046b(%rip), %rsi # 0x3f782
xorl %r14d, %r14d
movq %rbx, %rcx
xorl %eax, %eax
callq 0x6290
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
_Z3extN12LefDefParser18defrCallbackType_eEPKcPv:
push rbp
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov ebp, edi
cmp edi, 68h ; 'h'
jb short loc_F2C5
mov rcx, cs:fout
lea rdi, aErrorCallbackT; "ERROR: callback type is out of bounds!"...
mov esi, 27h ; '''
mov edx, 1
call _fwrite
loc_F2C5:
cmp cs:userData, r14
jz short loc_F2EB
mov rcx, cs:fout
lea rdi, aErrorReturnedU; "ERROR: returned user data is not correc"...
mov esi, 2Ah ; '*'
mov edx, 1
call _fwrite
loc_F2EB:
add ebp, 0FFFFFFE8h
mov r14d, 1
cmp ebp, 8
ja short loc_F324
mov eax, ebp
lea rcx, unk_3E440
movsxd rdx, dword ptr [rcx+rax*4]
add rdx, rcx
mov rdi, cs:fout
lea rsi, aExtensionSS; "EXTENSION %s %s\n"
xor r14d, r14d
mov rcx, rbx
xor eax, eax
call _fprintf
loc_F324:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long ext(unsigned int a1, const char *a2, long long a3)
{
unsigned int v4; // r14d
if ( a1 >= 0x68 )
fwrite("ERROR: callback type is out of bounds!\n", 39LL, 1LL, fout);
if ( userData != a3 )
fwrite("ERROR: returned user data is not correct!\n", 42LL, 1LL, fout);
v4 = 1;
if ( a1 - 24 <= 8 )
{
v4 = 0;
fprintf(fout, "EXTENSION %s %s\n", (const char *)&unk_3E440 + *((int *)&unk_3E440 + a1 - 24), a2);
}
return v4;
}
|
ext:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV EBP,EDI
CMP EDI,0x68
JC 0x0010f2c5
MOV RCX,qword ptr [0x00163250]
LEA RDI,[0x13e48f]
MOV ESI,0x27
MOV EDX,0x1
CALL 0x00106350
LAB_0010f2c5:
CMP qword ptr [0x00163258],R14
JZ 0x0010f2eb
MOV RCX,qword ptr [0x00163250]
LEA RDI,[0x13e464]
MOV ESI,0x2a
MOV EDX,0x1
CALL 0x00106350
LAB_0010f2eb:
ADD EBP,-0x18
MOV R14D,0x1
CMP EBP,0x8
JA 0x0010f324
MOV EAX,EBP
LEA RCX,[0x13e440]
MOVSXD RDX,dword ptr [RCX + RAX*0x4]
ADD RDX,RCX
MOV RDI,qword ptr [0x00163250]
LEA RSI,[0x13f782]
XOR R14D,R14D
MOV RCX,RBX
XOR EAX,EAX
CALL 0x00106290
LAB_0010f324:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
/* ext(LefDefParser::defrCallbackType_e, char const*, void*) */
bool ext(uint param_1,int8 param_2,long param_3)
{
if (0x67 < param_1) {
fwrite("ERROR: callback type is out of bounds!\n",0x27,1,fout);
}
if (userData != param_3) {
fwrite("ERROR: returned user data is not correct!\n",0x2a,1,fout);
}
param_1 = param_1 - 0x18;
if (8 >= param_1) {
fprintf(fout,"EXTENSION %s %s\n",&DAT_0013e440 + *(int *)(&DAT_0013e440 + (ulong)param_1 * 4),
param_2);
}
return 8 < param_1;
}
|
|
13,758
|
mysql_get_timeout_value
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
unsigned int STDCALL
mysql_get_timeout_value(const MYSQL *mysql)
{
unsigned int timeout= 0;
if (mysql->options.extension && mysql->options.extension->async_context)
timeout= mysql->options.extension->async_context->timeout_value;
/* Avoid overflow. */
if (timeout > UINT_MAX - 999)
return (timeout - 1)/1000 + 1;
else
return (timeout+999)/1000;
}
|
O0
|
c
|
mysql_get_timeout_value:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x44be4
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x44be4
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xfffffc18, -0x14(%rbp) # imm = 0xFFFFFC18
jbe 0x44c04
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x44c18
movl -0x14(%rbp), %eax
addl $0x3e7, %eax # imm = 0x3E7
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
mysql_get_timeout_value:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_44BE4
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp qword ptr [rax+28h], 0
jz short loc_44BE4
mov rax, [rbp+var_10]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov eax, [rax+10h]
mov [rbp+var_14], eax
loc_44BE4:
cmp [rbp+var_14], 0FFFFFC18h
jbe short loc_44C04
mov eax, [rbp+var_14]
sub eax, 1
mov ecx, 3E8h
xor edx, edx
div ecx
add eax, 1
mov [rbp+var_4], eax
jmp short loc_44C18
loc_44C04:
mov eax, [rbp+var_14]
add eax, 3E7h
mov ecx, 3E8h
xor edx, edx
div ecx
mov [rbp+var_4], eax
loc_44C18:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long mysql_get_timeout_value(long long a1)
{
unsigned int v2; // [rsp+0h] [rbp-14h]
v2 = 0;
if ( *(_QWORD *)(a1 + 1152) && *(_QWORD *)(*(_QWORD *)(a1 + 1152) + 40LL) )
v2 = *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 1152) + 40LL) + 16LL);
if ( v2 <= 0xFFFFFC18 )
return (v2 + 999) / 0x3E8;
else
return (v2 - 1) / 0x3E8 + 1;
}
|
mysql_get_timeout_value:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x00144be4
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x00144be4
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x14],EAX
LAB_00144be4:
CMP dword ptr [RBP + -0x14],0xfffffc18
JBE 0x00144c04
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV ECX,0x3e8
XOR EDX,EDX
DIV ECX
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00144c18
LAB_00144c04:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x3e7
MOV ECX,0x3e8
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_00144c18:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint mysql_get_timeout_value(long param_1)
{
int4 local_1c;
int4 local_c;
local_1c = 0;
if ((*(long *)(param_1 + 0x480) != 0) && (*(long *)(*(long *)(param_1 + 0x480) + 0x28) != 0)) {
local_1c = *(uint *)(*(long *)(*(long *)(param_1 + 0x480) + 0x28) + 0x10);
}
if (local_1c < 0xfffffc19) {
local_c = (local_1c + 999) / 1000;
}
else {
local_c = (local_1c - 1) / 1000 + 1;
}
return local_c;
}
|
|
13,759
|
ftxui::window(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>)
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/border.cpp
|
Element window(Element title, Element content) {
return std::make_shared<Border>(unpack(std::move(content), std::move(title)),
ROUNDED);
}
|
O1
|
cpp
|
ftxui::window(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rdx), %rcx
leaq 0x28(%rsp), %rax
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x8(%rdx), %rdi
movq %rcx, 0x8(%rdx)
movq %rdi, 0x8(%rax)
movq %rcx, (%rdx)
movq (%rsi), %rdi
leaq 0x18(%rsp), %rdx
movq %rdi, (%rdx)
movq %rcx, 0x8(%rdx)
movq 0x8(%rsi), %rdi
movq %rcx, 0x8(%rsi)
movq %rdi, 0x8(%rdx)
movq %rcx, (%rsi)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x15298
movl $0x80, %edi
callq 0xb3e0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x36408(%rip), %rax # 0x580a0
movq %rax, (%r14)
movq %r14, %r15
addq $0x10, %r15
movq (%rsp), %rax
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x21dd2
leaq 0x38(%rsp), %rdi
callq 0x151c0
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %rsp, %rdi
callq 0x151c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x21cfe
callq 0x14c7c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x21d0d
callq 0x14c7c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x151c0
movl $0x80, %esi
movq %r14, %rdi
callq 0xb400
jmp 0x21d39
movq %rax, %rbx
movq %rsp, %rdi
callq 0x151c0
jmp 0x21d46
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x21d55
callq 0x14c7c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x21d64
callq 0x14c7c
movq %rbx, %rdi
callq 0xb780
|
_ZN5ftxui6windowESt10shared_ptrINS_4NodeEES2_:
push r15
push r14
push rbx
sub rsp, 50h
mov rbx, rdi
mov rcx, [rdx]
lea rax, [rsp+68h+var_40]
mov [rax], rcx
xor ecx, ecx
mov [rax+8], rcx
mov rdi, [rdx+8]
mov [rdx+8], rcx
mov [rax+8], rdi
mov [rdx], rcx
mov rdi, [rsi]
lea rdx, [rsp+68h+var_50]
mov [rdx], rdi
mov [rdx+8], rcx
mov rdi, [rsi+8]
mov [rsi+8], rcx
mov [rdx+8], rdi
mov [rsi], rcx
mov rdi, rsp
mov rsi, rax
call _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEES3_EEESt6vectorIS3_SaIS3_EEDpT_; ftxui::unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>)
mov edi, 80h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_580A0
mov [r14], rax
mov r15, r14
add r15, 10h
mov rax, qword ptr [rsp+68h+var_68]
lea rsi, [rsp+68h+var_30]
mov [rsi], rax
movups xmm0, [rsp+68h+var_68+8]
movups xmmword ptr [rsi+8], xmm0
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rdi, r15
mov edx, 4
xor ecx, ecx
call _ZN5ftxui12_GLOBAL__N_16BorderC2ESt6vectorISt10shared_ptrINS_4NodeEESaIS5_EENS_11BorderStyleESt8optionalINS_5ColorEE; ftxui::`anonymous namespace'::Border::Border(std::vector<std::shared_ptr<ftxui::Node>>,ftxui::BorderStyle,std::optional<ftxui::Color>)
lea rdi, [rsp+68h+var_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov [rbx], r15
mov [rbx+8], r14
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, [rsp+68h+var_48]
test rdi, rdi
jz short loc_21CFE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_21CFE:
mov rdi, [rsp+68h+var_38]
test rdi, rdi
jz short loc_21D0D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_21D0D:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov esi, 80h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_21D39
mov rbx, rax
loc_21D39:
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
jmp short loc_21D46
mov rbx, rax
loc_21D46:
mov rdi, [rsp+arg_18]
test rdi, rdi
jz short loc_21D55
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_21D55:
mov rdi, [rsp+arg_28]
test rdi, rdi
jz short loc_21D64
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_21D64:
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * ftxui::window(_QWORD *a1, long long *a2, long long *a3)
{
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
_QWORD *v6; // r14
int v7; // r8d
int v8; // r9d
void *v10; // [rsp+0h] [rbp-68h] BYREF
__int128 v11; // [rsp+8h] [rbp-60h]
long long v12; // [rsp+18h] [rbp-50h] BYREF
volatile signed __int32 *v13; // [rsp+20h] [rbp-48h]
long long v14; // [rsp+28h] [rbp-40h] BYREF
volatile signed __int32 *v15; // [rsp+30h] [rbp-38h]
void *v16; // [rsp+38h] [rbp-30h] BYREF
__int128 v17; // [rsp+40h] [rbp-28h]
v14 = *a3;
v15 = 0LL;
v4 = (volatile signed __int32 *)a3[1];
a3[1] = 0LL;
v15 = v4;
*a3 = 0LL;
v12 = *a2;
v13 = 0LL;
v5 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v13 = v5;
*a2 = 0LL;
ftxui::unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>((long long)&v10, &v14, &v12);
v6 = (_QWORD *)operator new(0x80uLL);
v6[1] = 0x100000001LL;
*v6 = off_580A0;
v16 = v10;
v17 = v11;
ftxui::`anonymous namespace'::Border::Border((_DWORD)v6 + 16, (unsigned int)&v16, 4, 0, v7, v8, 0LL, 0LL, 0LL);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v16);
*a1 = v6 + 2;
a1[1] = v6;
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v10);
if ( v13 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v13);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
return a1;
}
|
window:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV RCX,qword ptr [RDX]
LEA RAX,[RSP + 0x28]
MOV qword ptr [RAX],RCX
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RDX + 0x8]
MOV qword ptr [RDX + 0x8],RCX
MOV qword ptr [RAX + 0x8],RDI
MOV qword ptr [RDX],RCX
MOV RDI,qword ptr [RSI]
LEA RDX,[RSP + 0x18]
MOV qword ptr [RDX],RDI
MOV qword ptr [RDX + 0x8],RCX
MOV RDI,qword ptr [RSI + 0x8]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RDX + 0x8],RDI
MOV qword ptr [RSI],RCX
LAB_00121c6b:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00115298
LAB_00121c76:
MOV EDI,0x80
CALL 0x0010b3e0
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x1580a0]
MOV qword ptr [R14],RAX
MOV R15,R14
ADD R15,0x10
MOV RAX,qword ptr [RSP]
LEA RSI,[RSP + 0x38]
MOV qword ptr [RSI],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RSI + 0x8],XMM0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_00121cc7:
MOV RDI,R15
MOV EDX,0x4
XOR ECX,ECX
CALL 0x00121dd2
LAB_00121cd6:
LEA RDI,[RSP + 0x38]
CALL 0x001151c0
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
MOV RDI,RSP
CALL 0x001151c0
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00121cfe
CALL 0x00114c7c
LAB_00121cfe:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x00121d0d
CALL 0x00114c7c
LAB_00121d0d:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* ftxui::window(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::window(ftxui *this,int8 *param_2,int8 *param_3)
{
int8 *puVar1;
int8 local_68;
int8 uStack_60;
int8 uStack_58;
int8 local_50;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
local_40 = *param_3;
local_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
param_3[1] = 0;
*param_3 = 0;
local_50 = *param_2;
local_48 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 00121c6b to 00121c75 has its CatchHandler @ 00121d43 */
unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>((ftxui *)&local_68,&local_40);
/* try { // try from 00121c76 to 00121c7f has its CatchHandler @ 00121d36 */
puVar1 = (int8 *)operator_new(0x80);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_001580a0;
local_30 = local_68;
local_28 = uStack_60;
uStack_20 = uStack_58;
local_68 = 0;
uStack_60 = 0;
uStack_58 = 0;
/* try { // try from 00121cc7 to 00121cd5 has its CatchHandler @ 00121d1a */
(anonymous_namespace)::Border::Border((Border *)(puVar1 + 2),&local_30,4,0);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_30);
*(Border **)this = (Border *)(puVar1 + 2);
*(int8 **)(this + 8) = puVar1;
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_68);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
return this;
}
|
|
13,760
|
MemoryManager::getLong(unsigned int, unsigned int*)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp
|
uint64_t MemoryManager::getLong(uint32_t addr, uint32_t *cycles) {
uint64_t b1 = this->getByte(addr, cycles);
uint64_t b2 = this->getByte(addr + 1);
uint64_t b3 = this->getByte(addr + 2);
uint64_t b4 = this->getByte(addr + 3);
uint64_t b5 = this->getByte(addr + 4);
uint64_t b6 = this->getByte(addr + 5);
uint64_t b7 = this->getByte(addr + 6);
uint64_t b8 = this->getByte(addr + 7);
return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24) + (b5 << 32) + (b6 << 40) +
(b7 << 48) + (b8 << 56);
}
|
O0
|
cpp
|
MemoryManager::getLong(unsigned int, unsigned int*):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x5c(%rsp), %esi
movq 0x50(%rsp), %rdx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x48(%rsp)
movl 0x5c(%rsp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x40(%rsp)
movl 0x5c(%rsp), %esi
addl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x38(%rsp)
movl 0x5c(%rsp), %esi
addl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x30(%rsp)
movl 0x5c(%rsp), %esi
addl $0x4, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x28(%rsp)
movl 0x5c(%rsp), %esi
addl $0x5, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x20(%rsp)
movl 0x5c(%rsp), %esi
addl $0x6, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movq 0x8(%rsp), %rdi
movzbl %al, %eax
movq %rax, 0x18(%rsp)
movl 0x5c(%rsp), %esi
addl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3730
movzbl %al, %eax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq 0x38(%rsp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
movq 0x30(%rsp), %rcx
shlq $0x18, %rcx
addq %rcx, %rax
movq 0x28(%rsp), %rcx
shlq $0x20, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
shlq $0x28, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
shlq $0x30, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
shlq $0x38, %rcx
addq %rcx, %rax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
|
_ZN13MemoryManager7getLongEjPj:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_C], esi
mov [rsp+68h+var_18], rdx
mov rdi, [rsp+68h+var_8]; this
mov [rsp+68h+var_60], rdi
mov esi, [rsp+68h+var_C]; unsigned int
mov rdx, [rsp+68h+var_18]; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_20], rax
mov esi, [rsp+68h+var_C]
add esi, 1; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_28], rax
mov esi, [rsp+68h+var_C]
add esi, 2; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_30], rax
mov esi, [rsp+68h+var_C]
add esi, 3; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_38], rax
mov esi, [rsp+68h+var_C]
add esi, 4; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_40], rax
mov esi, [rsp+68h+var_C]
add esi, 5; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_48], rax
mov esi, [rsp+68h+var_C]
add esi, 6; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov rdi, [rsp+68h+var_60]; this
movzx eax, al
mov [rsp+68h+var_50], rax
mov esi, [rsp+68h+var_C]
add esi, 7; unsigned int
xor eax, eax
mov edx, eax; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx eax, al
mov [rsp+68h+var_58], rax
mov rax, [rsp+68h+var_20]
mov rcx, [rsp+68h+var_28]
shl rcx, 8
add rax, rcx
mov rcx, [rsp+68h+var_30]
shl rcx, 10h
add rax, rcx
mov rcx, [rsp+68h+var_38]
shl rcx, 18h
add rax, rcx
mov rcx, [rsp+68h+var_40]
shl rcx, 20h
add rax, rcx
mov rcx, [rsp+68h+var_48]
shl rcx, 28h
add rax, rcx
mov rcx, [rsp+68h+var_50]
shl rcx, 30h
add rax, rcx
mov rcx, [rsp+68h+var_58]
shl rcx, 38h
add rax, rcx
add rsp, 68h
retn
|
unsigned long long MemoryManager::getLong(Cache **this, unsigned int a2, unsigned int *a3)
{
long long v4; // [rsp+18h] [rbp-50h]
long long v5; // [rsp+20h] [rbp-48h]
long long v6; // [rsp+28h] [rbp-40h]
long long v7; // [rsp+30h] [rbp-38h]
long long v8; // [rsp+38h] [rbp-30h]
long long v9; // [rsp+40h] [rbp-28h]
long long Byte; // [rsp+48h] [rbp-20h]
Byte = (unsigned __int8)MemoryManager::getByte(this, a2, a3);
v9 = (unsigned __int8)MemoryManager::getByte(this, a2 + 1, 0LL);
v8 = (unsigned __int8)MemoryManager::getByte(this, a2 + 2, 0LL);
v7 = (unsigned __int8)MemoryManager::getByte(this, a2 + 3, 0LL);
v6 = (unsigned __int8)MemoryManager::getByte(this, a2 + 4, 0LL);
v5 = (unsigned __int8)MemoryManager::getByte(this, a2 + 5, 0LL);
v4 = (unsigned __int8)MemoryManager::getByte(this, a2 + 6, 0LL);
return ((unsigned long long)(unsigned __int8)MemoryManager::getByte(this, a2 + 7, 0LL) << 56)
+ (v4 << 48)
+ (v5 << 40)
+ (v6 << 32)
+ (v7 << 24)
+ (v8 << 16)
+ (v9 << 8)
+ Byte;
}
|
getLong:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],ESI
MOV qword ptr [RSP + 0x50],RDX
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RDI
MOV ESI,dword ptr [RSP + 0x5c]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x48],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x1
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x40],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x2
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x38],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x3
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x30],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x4
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x28],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x5
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x20],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x6
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOV RDI,qword ptr [RSP + 0x8]
MOVZX EAX,AL
MOV qword ptr [RSP + 0x18],RAX
MOV ESI,dword ptr [RSP + 0x5c]
ADD ESI,0x7
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00103730
MOVZX EAX,AL
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RCX,qword ptr [RSP + 0x40]
SHL RCX,0x8
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x38]
SHL RCX,0x10
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x30]
SHL RCX,0x18
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x28]
SHL RCX,0x20
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x20]
SHL RCX,0x28
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x18]
SHL RCX,0x30
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x10]
SHL RCX,0x38
ADD RAX,RCX
ADD RSP,0x68
RET
|
/* MemoryManager::getLong(unsigned int, unsigned int*) */
long __thiscall MemoryManager::getLong(MemoryManager *this,uint param_1,uint *param_2)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
byte bVar7;
byte bVar8;
bVar1 = getByte(this,param_1,param_2);
bVar2 = getByte(this,param_1 + 1,(uint *)0x0);
bVar3 = getByte(this,param_1 + 2,(uint *)0x0);
bVar4 = getByte(this,param_1 + 3,(uint *)0x0);
bVar5 = getByte(this,param_1 + 4,(uint *)0x0);
bVar6 = getByte(this,param_1 + 5,(uint *)0x0);
bVar7 = getByte(this,param_1 + 6,(uint *)0x0);
bVar8 = getByte(this,param_1 + 7,(uint *)0x0);
return (ulong)bVar1 + (ulong)bVar2 * 0x100 + (ulong)bVar3 * 0x10000 + (ulong)bVar4 * 0x1000000 +
((ulong)bVar5 << 0x20) + ((ulong)bVar6 << 0x28) + ((ulong)bVar7 << 0x30) +
((ulong)bVar8 << 0x38);
}
|
|
13,761
|
MemoryManager::getLong(unsigned int, unsigned int*)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp
|
uint64_t MemoryManager::getLong(uint32_t addr, uint32_t *cycles) {
uint64_t b1 = this->getByte(addr, cycles);
uint64_t b2 = this->getByte(addr + 1);
uint64_t b3 = this->getByte(addr + 2);
uint64_t b4 = this->getByte(addr + 3);
uint64_t b5 = this->getByte(addr + 4);
uint64_t b6 = this->getByte(addr + 5);
uint64_t b7 = this->getByte(addr + 6);
uint64_t b8 = this->getByte(addr + 7);
return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24) + (b5 << 32) + (b6 << 40) +
(b7 << 48) + (b8 << 56);
}
|
O1
|
cpp
|
MemoryManager::getLong(unsigned int, unsigned int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x2ff6
movzbl %al, %eax
movq %rax, 0x10(%rsp)
leal 0x1(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movb %al, 0xf(%rsp)
leal 0x2(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movb %al, 0xe(%rsp)
leal 0x3(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movl %eax, %r12d
leal 0x4(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movzbl %al, %r13d
leal 0x5(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movzbl %al, %ebp
leal 0x6(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2ff6
movzbl %al, %r15d
addl $0x7, %ebx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2ff6
movzbl %al, %eax
movzbl 0xf(%rsp), %ecx
shll $0x8, %ecx
addq 0x10(%rsp), %rcx
movzbl 0xe(%rsp), %edx
shll $0x10, %edx
orq %rcx, %rdx
movzbl %r12b, %ecx
shll $0x18, %ecx
orq %rdx, %rcx
shlq $0x20, %r13
orq %rcx, %r13
shlq $0x28, %rbp
orq %r13, %rbp
shlq $0x30, %r15
orq %rbp, %r15
shlq $0x38, %rax
addq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN13MemoryManager7getLongEjPj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebx, esi
mov r14, rdi
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx eax, al
mov [rsp+48h+var_38], rax
lea esi, [rbx+1]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov [rsp+48h+var_39], al
lea esi, [rbx+2]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov [rsp+48h+var_3A], al
lea esi, [rbx+3]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov r12d, eax
lea esi, [rbx+4]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx r13d, al
lea esi, [rbx+5]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx ebp, al
lea esi, [rbx+6]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx r15d, al
add ebx, 7
mov rdi, r14; this
mov esi, ebx; unsigned int
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx eax, al
movzx ecx, [rsp+48h+var_39]
shl ecx, 8
add rcx, [rsp+48h+var_38]
movzx edx, [rsp+48h+var_3A]
shl edx, 10h
or rdx, rcx
movzx ecx, r12b
shl ecx, 18h
or rcx, rdx
shl r13, 20h
or r13, rcx
shl rbp, 28h
or rbp, r13
shl r15, 30h
or r15, rbp
shl rax, 38h
add rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long MemoryManager::getLong(
MemoryManager *this,
long long a2,
unsigned int *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
unsigned __int8 v29; // r12
long long v30; // rcx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
long long v35; // r13
long long v36; // rcx
long long v37; // r8
long long v38; // r9
__m128 v39; // xmm4
__m128 v40; // xmm5
long long v41; // rbp
long long v42; // rcx
long long v43; // r8
long long v44; // r9
__m128 v45; // xmm4
__m128 v46; // xmm5
long long v47; // r15
long long v48; // rcx
long long v49; // r8
long long v50; // r9
__m128 v51; // xmm4
__m128 v52; // xmm5
unsigned __int8 v54; // [rsp+Eh] [rbp-3Ah]
unsigned __int8 v55; // [rsp+Fh] [rbp-39h]
long long Byte; // [rsp+10h] [rbp-38h]
Byte = (unsigned __int8)MemoryManager::getByte(this, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v55 = MemoryManager::getByte(this, (unsigned int)(a2 + 1), 0LL, v14, v15, v16, a7, a8, a9, a10, v17, v18, a13, a14);
v54 = MemoryManager::getByte(this, (unsigned int)(a2 + 2), 0LL, v19, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14);
v29 = MemoryManager::getByte(this, (unsigned int)(a2 + 3), 0LL, v24, v25, v26, a7, a8, a9, a10, v27, v28, a13, a14);
v35 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 4),
0LL,
v30,
v31,
v32,
a7,
a8,
a9,
a10,
v33,
v34,
a13,
a14);
v41 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 5),
0LL,
v36,
v37,
v38,
a7,
a8,
a9,
a10,
v39,
v40,
a13,
a14);
v47 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 6),
0LL,
v42,
v43,
v44,
a7,
a8,
a9,
a10,
v45,
v46,
a13,
a14);
return ((Byte + (v55 << 8)) | (v54 << 16) | (v29 << 24) | (v35 << 32) | (v41 << 40) | (v47 << 48))
+ ((unsigned long long)(unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 7),
0LL,
v48,
v49,
v50,
a7,
a8,
a9,
a10,
v51,
v52,
a13,
a14) << 56);
}
|
getLong:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBX,ESI
MOV R14,RDI
CALL 0x00102ff6
MOVZX EAX,AL
MOV qword ptr [RSP + 0x10],RAX
LEA ESI,[RBX + 0x1]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOV byte ptr [RSP + 0xf],AL
LEA ESI,[RBX + 0x2]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOV byte ptr [RSP + 0xe],AL
LEA ESI,[RBX + 0x3]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOV R12D,EAX
LEA ESI,[RBX + 0x4]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOVZX R13D,AL
LEA ESI,[RBX + 0x5]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOVZX EBP,AL
LEA ESI,[RBX + 0x6]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102ff6
MOVZX R15D,AL
ADD EBX,0x7
MOV RDI,R14
MOV ESI,EBX
XOR EDX,EDX
CALL 0x00102ff6
MOVZX EAX,AL
MOVZX ECX,byte ptr [RSP + 0xf]
SHL ECX,0x8
ADD RCX,qword ptr [RSP + 0x10]
MOVZX EDX,byte ptr [RSP + 0xe]
SHL EDX,0x10
OR RDX,RCX
MOVZX ECX,R12B
SHL ECX,0x18
OR RCX,RDX
SHL R13,0x20
OR R13,RCX
SHL RBP,0x28
OR RBP,R13
SHL R15,0x30
OR R15,RBP
SHL RAX,0x38
ADD RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MemoryManager::getLong(unsigned int, unsigned int*) */
long __thiscall MemoryManager::getLong(MemoryManager *this,uint param_1,uint *param_2)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
byte bVar7;
int iVar8;
bVar1 = getByte(this,param_1,param_2);
bVar2 = getByte(this,param_1 + 1,(uint *)0x0);
bVar3 = getByte(this,param_1 + 2,(uint *)0x0);
iVar8 = getByte(this,param_1 + 3,(uint *)0x0);
bVar4 = getByte(this,param_1 + 4,(uint *)0x0);
bVar5 = getByte(this,param_1 + 5,(uint *)0x0);
bVar6 = getByte(this,param_1 + 6,(uint *)0x0);
bVar7 = getByte(this,param_1 + 7,(uint *)0x0);
return ((ulong)bVar7 << 0x38) +
((ulong)bVar6 << 0x30 |
(ulong)bVar5 << 0x28 |
(ulong)bVar4 << 0x20 |
(ulong)(uint)(iVar8 << 0x18) | (ulong)bVar3 << 0x10 | (ulong)bVar2 * 0x100 + (ulong)bVar1);
}
|
|
13,762
|
MemoryManager::getLong(unsigned int, unsigned int*)
|
DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp
|
uint64_t MemoryManager::getLong(uint32_t addr, uint32_t *cycles) {
uint64_t b1 = this->getByte(addr, cycles);
uint64_t b2 = this->getByte(addr + 1);
uint64_t b3 = this->getByte(addr + 2);
uint64_t b4 = this->getByte(addr + 3);
uint64_t b5 = this->getByte(addr + 4);
uint64_t b6 = this->getByte(addr + 5);
uint64_t b7 = this->getByte(addr + 6);
uint64_t b8 = this->getByte(addr + 7);
return b1 + (b2 << 8) + (b3 << 16) + (b4 << 24) + (b5 << 32) + (b6 << 40) +
(b7 << 48) + (b8 << 56);
}
|
O3
|
cpp
|
MemoryManager::getLong(unsigned int, unsigned int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x2fe0
movzbl %al, %eax
movq %rax, 0x10(%rsp)
leal 0x1(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movb %al, 0xf(%rsp)
leal 0x2(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movb %al, 0xe(%rsp)
leal 0x3(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movl %eax, %r12d
leal 0x4(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movzbl %al, %r13d
leal 0x5(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movzbl %al, %ebp
leal 0x6(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2fe0
movzbl %al, %r15d
addl $0x7, %ebx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x2fe0
movzbl %al, %eax
movzbl 0xf(%rsp), %ecx
shll $0x8, %ecx
addq 0x10(%rsp), %rcx
movzbl 0xe(%rsp), %edx
shll $0x10, %edx
orq %rcx, %rdx
movzbl %r12b, %ecx
shll $0x18, %ecx
orq %rdx, %rcx
shlq $0x20, %r13
orq %rcx, %r13
shlq $0x28, %rbp
orq %r13, %rbp
shlq $0x30, %r15
orq %rbp, %r15
shlq $0x38, %rax
addq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN13MemoryManager7getLongEjPj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebx, esi
mov r14, rdi
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx eax, al
mov [rsp+48h+var_38], rax
lea esi, [rbx+1]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov [rsp+48h+var_39], al
lea esi, [rbx+2]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov [rsp+48h+var_3A], al
lea esi, [rbx+3]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
mov r12d, eax
lea esi, [rbx+4]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx r13d, al
lea esi, [rbx+5]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx ebp, al
lea esi, [rbx+6]; unsigned int
mov rdi, r14; this
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx r15d, al
add ebx, 7
mov rdi, r14; this
mov esi, ebx; unsigned int
xor edx, edx; unsigned int *
call _ZN13MemoryManager7getByteEjPj; MemoryManager::getByte(uint,uint *)
movzx eax, al
movzx ecx, [rsp+48h+var_39]
shl ecx, 8
add rcx, [rsp+48h+var_38]
movzx edx, [rsp+48h+var_3A]
shl edx, 10h
or rdx, rcx
movzx ecx, r12b
shl ecx, 18h
or rcx, rdx
shl r13, 20h
or r13, rcx
shl rbp, 28h
or rbp, r13
shl r15, 30h
or r15, rbp
shl rax, 38h
add rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long MemoryManager::getLong(
MemoryManager *this,
long long a2,
unsigned int *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
unsigned __int8 v29; // r12
long long v30; // rcx
long long v31; // r8
long long v32; // r9
__m128 v33; // xmm4
__m128 v34; // xmm5
long long v35; // r13
long long v36; // rcx
long long v37; // r8
long long v38; // r9
__m128 v39; // xmm4
__m128 v40; // xmm5
long long v41; // rbp
long long v42; // rcx
long long v43; // r8
long long v44; // r9
__m128 v45; // xmm4
__m128 v46; // xmm5
long long v47; // r15
long long v48; // rcx
long long v49; // r8
long long v50; // r9
__m128 v51; // xmm4
__m128 v52; // xmm5
unsigned __int8 v54; // [rsp+Eh] [rbp-3Ah]
unsigned __int8 v55; // [rsp+Fh] [rbp-39h]
long long Byte; // [rsp+10h] [rbp-38h]
Byte = (unsigned __int8)MemoryManager::getByte(this, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v55 = MemoryManager::getByte(this, (unsigned int)(a2 + 1), 0LL, v14, v15, v16, a7, a8, a9, a10, v17, v18, a13, a14);
v54 = MemoryManager::getByte(this, (unsigned int)(a2 + 2), 0LL, v19, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14);
v29 = MemoryManager::getByte(this, (unsigned int)(a2 + 3), 0LL, v24, v25, v26, a7, a8, a9, a10, v27, v28, a13, a14);
v35 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 4),
0LL,
v30,
v31,
v32,
a7,
a8,
a9,
a10,
v33,
v34,
a13,
a14);
v41 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 5),
0LL,
v36,
v37,
v38,
a7,
a8,
a9,
a10,
v39,
v40,
a13,
a14);
v47 = (unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 6),
0LL,
v42,
v43,
v44,
a7,
a8,
a9,
a10,
v45,
v46,
a13,
a14);
return ((Byte + (v55 << 8)) | (v54 << 16) | (v29 << 24) | (v35 << 32) | (v41 << 40) | (v47 << 48))
+ ((unsigned long long)(unsigned __int8)MemoryManager::getByte(
this,
(unsigned int)(a2 + 7),
0LL,
v48,
v49,
v50,
a7,
a8,
a9,
a10,
v51,
v52,
a13,
a14) << 56);
}
|
getLong:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBX,ESI
MOV R14,RDI
CALL 0x00102fe0
MOVZX EAX,AL
MOV qword ptr [RSP + 0x10],RAX
LEA ESI,[RBX + 0x1]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOV byte ptr [RSP + 0xf],AL
LEA ESI,[RBX + 0x2]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOV byte ptr [RSP + 0xe],AL
LEA ESI,[RBX + 0x3]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOV R12D,EAX
LEA ESI,[RBX + 0x4]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOVZX R13D,AL
LEA ESI,[RBX + 0x5]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOVZX EBP,AL
LEA ESI,[RBX + 0x6]
MOV RDI,R14
XOR EDX,EDX
CALL 0x00102fe0
MOVZX R15D,AL
ADD EBX,0x7
MOV RDI,R14
MOV ESI,EBX
XOR EDX,EDX
CALL 0x00102fe0
MOVZX EAX,AL
MOVZX ECX,byte ptr [RSP + 0xf]
SHL ECX,0x8
ADD RCX,qword ptr [RSP + 0x10]
MOVZX EDX,byte ptr [RSP + 0xe]
SHL EDX,0x10
OR RDX,RCX
MOVZX ECX,R12B
SHL ECX,0x18
OR RCX,RDX
SHL R13,0x20
OR R13,RCX
SHL RBP,0x28
OR RBP,R13
SHL R15,0x30
OR R15,RBP
SHL RAX,0x38
ADD RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MemoryManager::getLong(unsigned int, unsigned int*) */
long __thiscall MemoryManager::getLong(MemoryManager *this,uint param_1,uint *param_2)
{
byte bVar1;
byte bVar2;
byte bVar3;
byte bVar4;
byte bVar5;
byte bVar6;
byte bVar7;
int iVar8;
bVar1 = getByte(this,param_1,param_2);
bVar2 = getByte(this,param_1 + 1,(uint *)0x0);
bVar3 = getByte(this,param_1 + 2,(uint *)0x0);
iVar8 = getByte(this,param_1 + 3,(uint *)0x0);
bVar4 = getByte(this,param_1 + 4,(uint *)0x0);
bVar5 = getByte(this,param_1 + 5,(uint *)0x0);
bVar6 = getByte(this,param_1 + 6,(uint *)0x0);
bVar7 = getByte(this,param_1 + 7,(uint *)0x0);
return ((ulong)bVar7 << 0x38) +
((ulong)bVar6 << 0x30 |
(ulong)bVar5 << 0x28 |
(ulong)bVar4 << 0x20 |
(ulong)(uint)(iVar8 << 0x18) | (ulong)bVar3 << 0x10 | (ulong)bVar2 * 0x100 + (ulong)bVar1);
}
|
|
13,763
|
unlink_deleted_block
|
eloqsql/storage/maria/ma_dynrec.c
|
static my_bool unlink_deleted_block(MARIA_HA *info,
MARIA_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MARIA_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_ma_get_block_info(info, &tmp, info->dfile.file,
block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_ma_get_block_info(info, &tmp, info->dfile.file,
block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(maria_rrnd() or maria_scan(), then ensure that we skip over this block
when doing next maria_rrnd() or maria_scan().
*/
if (info->cur_row.nextpos == block_info->filepos)
info->cur_row.nextpos+= block_info->block_len;
DBUG_RETURN(0);
}
|
O0
|
c
|
unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x70(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0xc8(%rcx), %rax
jne 0x4df63
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xc8(%rax)
jmp 0x4e1af
movl $0x0, -0x10(%rbp)
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x480(%rax), %edx
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rcx
leaq -0x60(%rbp), %rsi
callq 0x4d4e0
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4df9c
jmp 0x4df93
movb $0x1, -0x61(%rbp)
jmp 0x4e22c
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rax
shrq $0x20, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movb %al, -0x59(%rbp)
movq -0x90(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x5a(%rbp)
movq -0x90(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x5b(%rbp)
movq -0x90(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x5c(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movb %al, -0x55(%rbp)
movq -0x98(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x56(%rbp)
movq -0x98(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x57(%rbp)
movq -0x98(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x6e8(%rax), %rax
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0x4, %rsi
movq -0x78(%rbp), %rcx
movq 0x48(%rcx), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0x4e080
jmp 0x4e077
movb $0x1, -0x61(%rbp)
jmp 0x4e22c
movq -0x78(%rbp), %rax
cmpq $-0x1, 0x40(%rax)
je 0x4e1ad
movq -0x70(%rbp), %rdi
movq -0x70(%rbp), %rax
movl 0x480(%rax), %edx
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rcx
leaq -0x60(%rbp), %rsi
callq 0x4d4e0
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4e0c1
jmp 0x4e0b8
movb $0x1, -0x61(%rbp)
jmp 0x4e22c
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x20, %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movb %al, -0x51(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x52(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x53(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x54(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movb %al, -0x4d(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x8, %rax
movb %al, -0x4e(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x10, %rax
movb %al, -0x4f(%rbp)
movq -0xb8(%rbp), %rax
shrq $0x18, %rax
movb %al, -0x50(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0x6e8(%rax), %rax
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
addq $0xc, %rsi
movq -0x78(%rbp), %rcx
movq 0x40(%rcx), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0x4e1ab
jmp 0x4e1a2
movb $0x1, -0x61(%rbp)
jmp 0x4e22c
jmp 0x4e1ad
jmp 0x4e1af
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x70(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq 0xc0(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xc0(%rax)
movq -0x70(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x78(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x4e226
movq -0x78(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x70(%rbp), %rax
addq 0xa0(%rax), %rcx
movq %rcx, 0xa0(%rax)
jmp 0x4e228
movb $0x0, -0x61(%rbp)
movb -0x61(%rbp), %al
movb %al, -0xb9(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4e256
movb -0xb9(%rbp), %al
addq $0xc0, %rsp
popq %rbp
retq
callq 0x29230
nopl (%rax,%rax)
|
unlink_deleted_block:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov rax, [rbp+var_78]
mov rax, [rax+38h]
mov rcx, [rbp+var_70]
mov rcx, [rcx]
cmp rax, [rcx+0C8h]
jnz short loc_4DF63
mov rax, [rbp+var_78]
mov rcx, [rax+40h]
mov rax, [rbp+var_70]
mov rax, [rax]
mov [rax+0C8h], rcx
jmp loc_4E1AF
loc_4DF63:
mov [rbp+var_10], 0
mov rdi, [rbp+var_70]
mov rax, [rbp+var_70]
mov edx, [rax+480h]
mov rax, [rbp+var_78]
mov rcx, [rax+48h]
lea rsi, [rbp+var_60]
call _ma_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_4DF9C
jmp short $+2
loc_4DF93:
mov [rbp+var_61], 1
jmp loc_4E22C
loc_4DF9C:
mov rax, [rbp+var_78]
mov rax, [rax+40h]
mov [rbp+var_80], rax
mov rax, [rbp+var_78]
mov rax, [rax+40h]
shr rax, 20h
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov [rbp+var_90], rax
mov rax, [rbp+var_90]
mov [rbp+var_59], al
mov rax, [rbp+var_90]
shr rax, 8
mov [rbp+var_5A], al
mov rax, [rbp+var_90]
shr rax, 10h
mov [rbp+var_5B], al
mov rax, [rbp+var_90]
shr rax, 18h
mov [rbp+var_5C], al
mov rax, [rbp+var_80]
mov [rbp+var_98], rax
mov rax, [rbp+var_98]
mov [rbp+var_55], al
mov rax, [rbp+var_98]
shr rax, 8
mov [rbp+var_56], al
mov rax, [rbp+var_98]
shr rax, 10h
mov [rbp+var_57], al
mov rax, [rbp+var_98]
shr rax, 18h
mov [rbp+var_58], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+6E8h]
mov rdi, [rbp+var_70]
lea rsi, [rbp+var_60]
add rsi, 4
mov rcx, [rbp+var_78]
mov rcx, [rcx+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
call rax
cmp rax, 0
jz short loc_4E080
jmp short $+2
loc_4E077:
mov [rbp+var_61], 1
jmp loc_4E22C
loc_4E080:
mov rax, [rbp+var_78]
cmp qword ptr [rax+40h], 0FFFFFFFFFFFFFFFFh
jz loc_4E1AD
mov rdi, [rbp+var_70]
mov rax, [rbp+var_70]
mov edx, [rax+480h]
mov rax, [rbp+var_78]
mov rcx, [rax+40h]
lea rsi, [rbp+var_60]
call _ma_get_block_info
and eax, 4
cmp eax, 0
jnz short loc_4E0C1
jmp short $+2
loc_4E0B8:
mov [rbp+var_61], 1
jmp loc_4E22C
loc_4E0C1:
mov rax, [rbp+var_78]
mov rax, [rax+48h]
mov [rbp+var_A0], rax
mov rax, [rbp+var_78]
mov rax, [rax+48h]
shr rax, 20h
mov [rbp+var_A8], rax
mov rax, [rbp+var_A8]
mov [rbp+var_B0], rax
mov rax, [rbp+var_B0]
mov [rbp+var_51], al
mov rax, [rbp+var_B0]
shr rax, 8
mov [rbp+var_52], al
mov rax, [rbp+var_B0]
shr rax, 10h
mov [rbp+var_53], al
mov rax, [rbp+var_B0]
shr rax, 18h
mov [rbp+var_54], al
mov rax, [rbp+var_A0]
mov [rbp+var_B8], rax
mov rax, [rbp+var_B8]
mov [rbp+var_4D], al
mov rax, [rbp+var_B8]
shr rax, 8
mov [rbp+var_4E], al
mov rax, [rbp+var_B8]
shr rax, 10h
mov [rbp+var_4F], al
mov rax, [rbp+var_B8]
shr rax, 18h
mov [rbp+var_50], al
mov rax, [rbp+var_70]
mov rax, [rax]
mov rax, [rax+6E8h]
mov rdi, [rbp+var_70]
lea rsi, [rbp+var_60]
add rsi, 0Ch
mov rcx, [rbp+var_78]
mov rcx, [rcx+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
call rax
cmp rax, 0
jz short loc_4E1AB
jmp short $+2
loc_4E1A2:
mov [rbp+var_61], 1
jmp loc_4E22C
loc_4E1AB:
jmp short $+2
loc_4E1AD:
jmp short $+2
loc_4E1AF:
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rcx, [rax+8]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+8], rcx
mov rax, [rbp+var_78]
mov rdx, [rax+28h]
mov rax, [rbp+var_70]
mov rax, [rax+20h]
mov rcx, [rax+10h]
sub rcx, rdx
mov [rax+10h], rcx
mov rax, [rbp+var_70]
mov rax, [rax]
mov rcx, [rax+0C0h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+0C0h], rcx
mov rax, [rbp+var_70]
mov rax, [rax+0A0h]
mov rcx, [rbp+var_78]
cmp rax, [rcx+38h]
jnz short loc_4E226
mov rax, [rbp+var_78]
mov rcx, [rax+28h]
mov rax, [rbp+var_70]
add rcx, [rax+0A0h]
mov [rax+0A0h], rcx
loc_4E226:
jmp short $+2
loc_4E228:
mov [rbp+var_61], 0
loc_4E22C:
mov al, [rbp+var_61]
mov [rbp+var_B9], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4E256
mov al, [rbp+var_B9]
add rsp, 0C0h
pop rbp
retn
loc_4E256:
call ___stack_chk_fail
|
char unlink_deleted_block(_QWORD *a1, _QWORD *a2, long long a3, long long a4, long long a5, int a6)
{
long long v6; // r8
int v7; // r9d
long long v9; // [rsp+20h] [rbp-A0h]
long long v10; // [rsp+40h] [rbp-80h]
unsigned __int8 v12[4]; // [rsp+60h] [rbp-60h] BYREF
_BYTE v13[8]; // [rsp+64h] [rbp-5Ch] BYREF
_BYTE v14[68]; // [rsp+6Ch] [rbp-54h] BYREF
int v15; // [rsp+B0h] [rbp-10h]
unsigned long long v16; // [rsp+B8h] [rbp-8h]
v16 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 200LL) )
{
*(_QWORD *)(*a1 + 200LL) = a2[8];
}
else
{
v15 = 0;
if ( (ma_get_block_info((long long)a1, v12, *((unsigned int *)a1 + 288), a2[9], a5, a6) & 4) == 0 )
return 1;
v10 = a2[8];
v13[2] = BYTE5(v10);
v13[3] = BYTE4(v10);
v13[0] = HIBYTE(v10);
v13[1] = BYTE6(v10);
v13[6] = BYTE1(v10);
v13[7] = v10;
v13[4] = BYTE3(v10);
v13[5] = BYTE2(v10);
if ( (*(long long ( **)(_QWORD *, _BYTE *, long long, long long, long long))(*a1 + 1768LL))(
a1,
v13,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
if ( a2[8] != -1LL )
{
if ( (ma_get_block_info((long long)a1, v12, *((unsigned int *)a1 + 288), a2[8], v6, v7) & 4) == 0 )
return 1;
v9 = a2[9];
v14[2] = BYTE5(v9);
v14[3] = BYTE4(v9);
v14[0] = HIBYTE(v9);
v14[1] = BYTE6(v9);
v14[6] = BYTE1(v9);
v14[7] = v9;
v14[4] = BYTE3(v9);
v14[5] = BYTE2(v9);
if ( (*(long long ( **)(_QWORD *, _BYTE *, long long, long long, long long))(*a1 + 1768LL))(
a1,
v14,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[4] + 8LL);
*(_QWORD *)(a1[4] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 192LL);
if ( a1[20] == a2[7] )
a1[20] += a2[5];
return 0;
}
|
unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0xc8]
JNZ 0x0014df63
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0xc8],RCX
JMP 0x0014e1af
LAB_0014df63:
MOV dword ptr [RBP + -0x10],0x0
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RAX + 0x480]
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x48]
LEA RSI,[RBP + -0x60]
CALL 0x0014d4e0
AND EAX,0x4
CMP EAX,0x0
JNZ 0x0014df9c
JMP 0x0014df93
LAB_0014df93:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x0014e22c
LAB_0014df9c:
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x40]
SHR RAX,0x20
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x90],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0x59],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x8
MOV byte ptr [RBP + -0x5a],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x10
MOV byte ptr [RBP + -0x5b],AL
MOV RAX,qword ptr [RBP + -0x90]
SHR RAX,0x18
MOV byte ptr [RBP + -0x5c],AL
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV byte ptr [RBP + -0x55],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x8
MOV byte ptr [RBP + -0x56],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x10
MOV byte ptr [RBP + -0x57],AL
MOV RAX,qword ptr [RBP + -0x98]
SHR RAX,0x18
MOV byte ptr [RBP + -0x58],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x6e8]
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[RBP + -0x60]
ADD RSI,0x4
MOV RCX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RCX + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x0014e080
JMP 0x0014e077
LAB_0014e077:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x0014e22c
LAB_0014e080:
MOV RAX,qword ptr [RBP + -0x78]
CMP qword ptr [RAX + 0x40],-0x1
JZ 0x0014e1ad
MOV RDI,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x70]
MOV EDX,dword ptr [RAX + 0x480]
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x40]
LEA RSI,[RBP + -0x60]
CALL 0x0014d4e0
AND EAX,0x4
CMP EAX,0x0
JNZ 0x0014e0c1
JMP 0x0014e0b8
LAB_0014e0b8:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x0014e22c
LAB_0014e0c1:
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RAX,qword ptr [RAX + 0x48]
SHR RAX,0x20
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0xb0]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x8
MOV byte ptr [RBP + -0x52],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x10
MOV byte ptr [RBP + -0x53],AL
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x18
MOV byte ptr [RBP + -0x54],AL
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV byte ptr [RBP + -0x4d],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x8
MOV byte ptr [RBP + -0x4e],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x10
MOV byte ptr [RBP + -0x4f],AL
MOV RAX,qword ptr [RBP + -0xb8]
SHR RAX,0x18
MOV byte ptr [RBP + -0x50],AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x6e8]
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[RBP + -0x60]
ADD RSI,0xc
MOV RCX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RCX + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x0014e1ab
JMP 0x0014e1a2
LAB_0014e1a2:
MOV byte ptr [RBP + -0x61],0x1
JMP 0x0014e22c
LAB_0014e1ab:
JMP 0x0014e1ad
LAB_0014e1ad:
JMP 0x0014e1af
LAB_0014e1af:
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x10]
SUB RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0xc0]
ADD RCX,-0x1
MOV qword ptr [RAX + 0xc0],RCX
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RCX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RCX + 0x38]
JNZ 0x0014e226
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RAX + 0x28]
MOV RAX,qword ptr [RBP + -0x70]
ADD RCX,qword ptr [RAX + 0xa0]
MOV qword ptr [RAX + 0xa0],RCX
LAB_0014e226:
JMP 0x0014e228
LAB_0014e228:
MOV byte ptr [RBP + -0x61],0x0
LAB_0014e22c:
MOV AL,byte ptr [RBP + -0x61]
MOV byte ptr [RBP + -0xb9],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014e256
MOV AL,byte ptr [RBP + -0xb9]
ADD RSP,0xc0
POP RBP
RET
LAB_0014e256:
CALL 0x00129230
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
int8 uVar1;
int8 uVar2;
uint uVar3;
long lVar4;
long in_FS_OFFSET;
int1 local_69;
int1 local_68 [4];
int1 local_64;
int1 local_63;
int1 local_62;
int1 local_61;
int1 local_60;
int1 local_5f;
int1 local_5e;
int1 local_5d;
int1 local_5c;
int1 local_5b;
int1 local_5a;
int1 local_59;
int1 local_58;
int1 local_57;
int1 local_56;
int1 local_55;
int4 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 200)) {
*(int8 *)(*param_1 + 200) = *(int8 *)(param_2 + 0x40);
}
else {
local_18 = 0;
uVar3 = _ma_get_block_info(param_1,local_68,(int)param_1[0x90],*(int8 *)(param_2 + 0x48));
if ((uVar3 & 4) == 0) {
local_69 = 1;
goto LAB_0014e22c;
}
uVar1 = *(int8 *)(param_2 + 0x40);
uVar2 = *(int8 *)(param_2 + 0x40);
local_61 = (int1)((ulong)uVar2 >> 0x20);
local_62 = (int1)((ulong)uVar2 >> 0x28);
local_63 = (int1)((ulong)uVar2 >> 0x30);
local_64 = (int1)((ulong)uVar2 >> 0x38);
local_5d = (int1)uVar1;
local_5e = (int1)((ulong)uVar1 >> 8);
local_5f = (int1)((ulong)uVar1 >> 0x10);
local_60 = (int1)((ulong)uVar1 >> 0x18);
lVar4 = (**(code **)(*param_1 + 0x6e8))(param_1,&local_64,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar4 != 0) {
local_69 = 1;
goto LAB_0014e22c;
}
if (*(long *)(param_2 + 0x40) != -1) {
uVar3 = _ma_get_block_info(param_1,local_68,(int)param_1[0x90],*(int8 *)(param_2 + 0x40)
);
if ((uVar3 & 4) == 0) {
local_69 = 1;
goto LAB_0014e22c;
}
uVar1 = *(int8 *)(param_2 + 0x48);
uVar2 = *(int8 *)(param_2 + 0x48);
local_59 = (int1)((ulong)uVar2 >> 0x20);
local_5a = (int1)((ulong)uVar2 >> 0x28);
local_5b = (int1)((ulong)uVar2 >> 0x30);
local_5c = (int1)((ulong)uVar2 >> 0x38);
local_55 = (int1)uVar1;
local_56 = (int1)((ulong)uVar1 >> 8);
local_57 = (int1)((ulong)uVar1 >> 0x10);
local_58 = (int1)((ulong)uVar1 >> 0x18);
lVar4 = (**(code **)(*param_1 + 0x6e8))(param_1,&local_5c,8,*(long *)(param_2 + 0x40) + 0xc,4)
;
if (lVar4 != 0) {
local_69 = 1;
goto LAB_0014e22c;
}
}
}
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + -1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0xc0) = *(long *)(*param_1 + 0xc0) + -1;
if (param_1[0x14] == *(long *)(param_2 + 0x38)) {
param_1[0x14] = *(long *)(param_2 + 0x28) + param_1[0x14];
}
local_69 = 0;
LAB_0014e22c:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_69);
}
|
|
13,764
|
unlink_deleted_block
|
eloqsql/storage/maria/ma_dynrec.c
|
static my_bool unlink_deleted_block(MARIA_HA *info,
MARIA_BLOCK_INFO *block_info)
{
DBUG_ENTER("unlink_deleted_block");
if (block_info->filepos == info->s->state.dellink)
{
/* First deleted block; We can just use this ! */
info->s->state.dellink=block_info->next_filepos;
}
else
{
MARIA_BLOCK_INFO tmp;
tmp.second_read=0;
/* Unlink block from the previous block */
if (!(_ma_get_block_info(info, &tmp, info->dfile.file,
block_info->prev_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+4,block_info->next_filepos);
if (info->s->file_write(info, tmp.header+4,8,
block_info->prev_filepos+4, MYF(MY_NABP)))
DBUG_RETURN(1);
/* Unlink block from next block */
if (block_info->next_filepos != HA_OFFSET_ERROR)
{
if (!(_ma_get_block_info(info, &tmp, info->dfile.file,
block_info->next_filepos)
& BLOCK_DELETED))
DBUG_RETURN(1); /* Something is wrong */
mi_sizestore(tmp.header+12,block_info->prev_filepos);
if (info->s->file_write(info, tmp.header+12,8,
block_info->next_filepos+12,
MYF(MY_NABP)))
DBUG_RETURN(1);
}
}
/* We now have one less deleted block */
info->state->del--;
info->state->empty-= block_info->block_len;
info->s->state.split--;
/*
If this was a block that we where accessing through table scan
(maria_rrnd() or maria_scan(), then ensure that we skip over this block
when doing next maria_rrnd() or maria_scan().
*/
if (info->cur_row.nextpos == block_info->filepos)
info->cur_row.nextpos+= block_info->block_len;
DBUG_RETURN(0);
}
|
O3
|
c
|
unlink_deleted_block:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rsi), %rcx
movq (%rdi), %rax
cmpq 0xc8(%rax), %rcx
jne 0x44e0e
movq 0x40(%r14), %rcx
movq %rcx, 0xc8(%rax)
movq 0x20(%rbx), %rax
decq 0x8(%rax)
movq 0x28(%r14), %rax
movq 0x20(%rbx), %rcx
subq %rax, 0x10(%rcx)
movq (%rbx), %rax
decq 0xc0(%rax)
movq 0xa0(%rbx), %rax
cmpq 0x38(%r14), %rax
jne 0x44e0a
addq 0x28(%r14), %rax
movq %rax, 0xa0(%rbx)
xorl %eax, %eax
jmp 0x44e63
leaq -0x70(%rbp), %rsi
movl $0x0, 0x50(%rsi)
movl 0x480(%rbx), %edx
movq 0x48(%r14), %rcx
movq %rbx, %rdi
callq 0x4498c
testb $0x4, %al
je 0x44e61
movq 0x40(%r14), %rax
leaq -0x6c(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x48(%r14), %rcx
addq $0x4, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x6e8(%rax)
testq %rax, %rax
je 0x44e7b
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x44ed6
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rcx
cmpq $-0x1, %rcx
je 0x44dd4
movl 0x480(%rbx), %edx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x4498c
testb $0x4, %al
je 0x44e61
movq 0x48(%r14), %rax
leaq -0x64(%rbp), %rsi
bswapq %rax
movq %rax, (%rsi)
movq (%rbx), %rax
movq 0x40(%r14), %rcx
addq $0xc, %rcx
movl $0x8, %edx
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x6e8(%rax)
testq %rax, %rax
jne 0x44e61
jmp 0x44dd4
callq 0x29220
|
unlink_deleted_block:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 60h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
mov rcx, [rsi+38h]
mov rax, [rdi]
cmp rcx, [rax+0C8h]
jnz short loc_44E0E
mov rcx, [r14+40h]
mov [rax+0C8h], rcx
loc_44DD4:
mov rax, [rbx+20h]
dec qword ptr [rax+8]
mov rax, [r14+28h]
mov rcx, [rbx+20h]
sub [rcx+10h], rax
mov rax, [rbx]
dec qword ptr [rax+0C0h]
mov rax, [rbx+0A0h]
cmp rax, [r14+38h]
jnz short loc_44E0A
add rax, [r14+28h]
mov [rbx+0A0h], rax
loc_44E0A:
xor eax, eax
jmp short loc_44E63
loc_44E0E:
lea rsi, [rbp+var_70]
mov dword ptr [rsi+50h], 0
mov edx, [rbx+480h]
mov rcx, [r14+48h]
mov rdi, rbx
call _ma_get_block_info
test al, 4
jz short loc_44E61
mov rax, [r14+40h]
lea rsi, [rbp+var_6C]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+48h]
add rcx, 4
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+6E8h]
test rax, rax
jz short loc_44E7B
loc_44E61:
mov al, 1
loc_44E63:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_44ED6
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
loc_44E7B:
mov rcx, [r14+40h]
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz loc_44DD4
mov edx, [rbx+480h]
lea rsi, [rbp+var_70]
mov rdi, rbx
call _ma_get_block_info
test al, 4
jz short loc_44E61
mov rax, [r14+48h]
lea rsi, [rbp+var_64]
bswap rax
mov [rsi], rax
mov rax, [rbx]
mov rcx, [r14+40h]
add rcx, 0Ch
mov edx, 8
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+6E8h]
test rax, rax
jnz short loc_44E61
jmp loc_44DD4
loc_44ED6:
call ___stack_chk_fail
|
char unlink_deleted_block(_QWORD *a1, _QWORD *a2, long long a3, long long a4, long long a5, int a6)
{
long long v6; // rax
long long v8; // r8
int v9; // r9d
long long v10; // rcx
unsigned __int8 v11[4]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v12; // [rsp+4h] [rbp-6Ch] BYREF
unsigned long long v13[8]; // [rsp+Ch] [rbp-64h] BYREF
int v14; // [rsp+50h] [rbp-20h]
unsigned long long v15; // [rsp+58h] [rbp-18h]
v15 = __readfsqword(0x28u);
if ( a2[7] == *(_QWORD *)(*a1 + 200LL) )
{
*(_QWORD *)(*a1 + 200LL) = a2[8];
}
else
{
v14 = 0;
if ( (ma_get_block_info((long long)a1, v11, *((unsigned int *)a1 + 288), a2[9], a5, a6) & 4) == 0 )
return 1;
v12 = _byteswap_uint64(a2[8]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 1768LL))(
a1,
&v12,
8LL,
a2[9] + 4LL,
4LL) )
{
return 1;
}
v10 = a2[8];
if ( v10 != -1 )
{
if ( (ma_get_block_info((long long)a1, v11, *((unsigned int *)a1 + 288), v10, v8, v9) & 4) == 0 )
return 1;
v13[0] = _byteswap_uint64(a2[9]);
if ( (*(long long ( **)(_QWORD *, unsigned long long *, long long, long long, long long))(*a1 + 1768LL))(
a1,
v13,
8LL,
a2[8] + 12LL,
4LL) )
{
return 1;
}
}
}
--*(_QWORD *)(a1[4] + 8LL);
*(_QWORD *)(a1[4] + 16LL) -= a2[5];
--*(_QWORD *)(*a1 + 192LL);
v6 = a1[20];
if ( v6 == a2[7] )
a1[20] = a2[5] + v6;
return 0;
}
|
unlink_deleted_block:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RSI + 0x38]
MOV RAX,qword ptr [RDI]
CMP RCX,qword ptr [RAX + 0xc8]
JNZ 0x00144e0e
MOV RCX,qword ptr [R14 + 0x40]
MOV qword ptr [RAX + 0xc8],RCX
LAB_00144dd4:
MOV RAX,qword ptr [RBX + 0x20]
DEC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x28]
MOV RCX,qword ptr [RBX + 0x20]
SUB qword ptr [RCX + 0x10],RAX
MOV RAX,qword ptr [RBX]
DEC qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBX + 0xa0]
CMP RAX,qword ptr [R14 + 0x38]
JNZ 0x00144e0a
ADD RAX,qword ptr [R14 + 0x28]
MOV qword ptr [RBX + 0xa0],RAX
LAB_00144e0a:
XOR EAX,EAX
JMP 0x00144e63
LAB_00144e0e:
LEA RSI,[RBP + -0x70]
MOV dword ptr [RSI + 0x50],0x0
MOV EDX,dword ptr [RBX + 0x480]
MOV RCX,qword ptr [R14 + 0x48]
MOV RDI,RBX
CALL 0x0014498c
TEST AL,0x4
JZ 0x00144e61
MOV RAX,qword ptr [R14 + 0x40]
LEA RSI,[RBP + -0x6c]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x48]
ADD RCX,0x4
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x6e8]
TEST RAX,RAX
JZ 0x00144e7b
LAB_00144e61:
MOV AL,0x1
LAB_00144e63:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x00144ed6
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
LAB_00144e7b:
MOV RCX,qword ptr [R14 + 0x40]
CMP RCX,-0x1
JZ 0x00144dd4
MOV EDX,dword ptr [RBX + 0x480]
LEA RSI,[RBP + -0x70]
MOV RDI,RBX
CALL 0x0014498c
TEST AL,0x4
JZ 0x00144e61
MOV RAX,qword ptr [R14 + 0x48]
LEA RSI,[RBP + -0x64]
BSWAP RAX
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [R14 + 0x40]
ADD RCX,0xc
MOV EDX,0x8
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x6e8]
TEST RAX,RAX
JNZ 0x00144e61
JMP 0x00144dd4
LAB_00144ed6:
CALL 0x00129220
|
int8 unlink_deleted_block(long *param_1,long param_2)
{
ulong uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int1 local_78 [4];
ulong local_74;
ulong local_6c [8];
int4 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (*(long *)(param_2 + 0x38) == *(long *)(*param_1 + 200)) {
*(int8 *)(*param_1 + 200) = *(int8 *)(param_2 + 0x40);
goto LAB_00144dd4;
}
local_28 = 0;
uVar1 = _ma_get_block_info(param_1,local_78,(int)param_1[0x90],*(int8 *)(param_2 + 0x48));
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x40);
local_74 = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 | (uVar1 & 0xff0000000000) >> 0x18
| (uVar1 & 0xff00000000) >> 8 | (uVar1 & 0xff000000) << 8 |
(uVar1 & 0xff0000) << 0x18 | (uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x6e8))(param_1,&local_74,8,*(long *)(param_2 + 0x48) + 4,4);
if (lVar2 == 0) {
if (*(long *)(param_2 + 0x40) == -1) {
LAB_00144dd4:
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + -1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) - *(long *)(param_2 + 0x28);
*(long *)(*param_1 + 0xc0) = *(long *)(*param_1 + 0xc0) + -1;
if (param_1[0x14] == *(long *)(param_2 + 0x38)) {
param_1[0x14] = param_1[0x14] + *(long *)(param_2 + 0x28);
}
uVar3 = 0;
goto LAB_00144e63;
}
uVar1 = _ma_get_block_info(param_1,local_78,(int)param_1[0x90]);
if ((uVar1 & 4) != 0) {
uVar1 = *(ulong *)(param_2 + 0x48);
local_6c[0] = uVar1 >> 0x38 | (uVar1 & 0xff000000000000) >> 0x28 |
(uVar1 & 0xff0000000000) >> 0x18 | (uVar1 & 0xff00000000) >> 8 |
(uVar1 & 0xff000000) << 8 | (uVar1 & 0xff0000) << 0x18 |
(uVar1 & 0xff00) << 0x28 | uVar1 << 0x38;
lVar2 = (**(code **)(*param_1 + 0x6e8))
(param_1,local_6c,8,*(long *)(param_2 + 0x40) + 0xc,4);
if (lVar2 == 0) goto LAB_00144dd4;
}
}
}
uVar3 = 1;
LAB_00144e63:
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
|
|
13,765
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9])
|
llama.cpp/common/json.hpp
|
reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [9], 0>(char const (&) [9]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb5bfb
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb5be5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f60
testl %eax, %eax
je 0xb5bda
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xb5bbb
jmp 0xb5bdd
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xb5c59
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20640
movq %rax, %rbx
movq %r14, %rdi
callq 0x89d5c
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x651f4(%rip), %rsi # 0x11ae11
leaq 0x20(%rsp), %rdi
callq 0x7f3bd
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x89b84
xorl %ebp, %ebp
leaq 0xaa3f8(%rip), %rsi # 0x160040
leaq -0x3ff3f(%rip), %rdx # 0x75d10
movq %rbx, %rdi
callq 0x20a40
jmp 0xb5cd2
movl $0x20, %edi
callq 0x20640
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x20670
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2801a
leaq 0x65199(%rip), %rsi # 0x11ae27
leaq 0x65198(%rip), %rcx # 0x11ae2d
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7f445
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x882e8
xorl %ebp, %ebp
leaq 0xaa2fd(%rip), %rsi # 0x15ffc0
leaq -0x3ffba(%rip), %rdx # 0x75d10
movq %rbx, %rdi
callq 0x20a40
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5cf0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb5d3b
movq 0x10(%rsp), %rsi
jmp 0xb5d33
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb5d45
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xb5d45
jmp 0xb5d42
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5d3b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xb5d45
jmp 0xb5d4d
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ef0
movq %r14, %rdi
callq 0x20ae0
nop
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; void *
push r15; int
push r14; __int64
push r12; int
push rbx; void *
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_B5BFB
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_B5BE5
loc_B5BBB:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_B5BDA
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_B5BBB
jmp short loc_B5BDD
loc_B5BDA:
mov rax, rbx
loc_B5BDD:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_B5BE5:
cmp rax, rbx
jz short loc_B5C59
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B5BFB:
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)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_B5CD2
loc_B5C59:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_B5CD2:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B5CF0
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B5CF0:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_B5D3B
mov rsi, [rsp+68h+var_58]
jmp short loc_B5D33
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_B5D45
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B5D45
jmp short loc_B5D42
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B5D3B
mov rsi, [rsp+68h+var_38]
loc_B5D33:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B5D3B:
test bpl, bpl
jnz short loc_B5D45
jmp short loc_B5D4D
loc_B5D42:
mov r14, rax
loc_B5D45:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B5D4D:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
void *v9[2]; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+10h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-48h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = (void *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(long long)v11,
(long long)"cannot use at() with ",
v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
v11);
__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);
}
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
goto LABEL_7;
}
v4 = v3;
LABEL_7:
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
if ( v4 == v3 )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = &v10;
v8 = strlen(a2);
std::string::_M_construct<char const*>((long long)v9, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(long long)v11,
(long long)"key '",
v9,
(long long)"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v7,
403,
v11);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001b5bfb
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001b5be5
LAB_001b5bbb:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120f60
TEST EAX,EAX
JZ 0x001b5bda
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001b5bbb
JMP 0x001b5bdd
LAB_001b5bda:
MOV RAX,RBX
LAB_001b5bdd:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001b5be5:
CMP RAX,RBX
JZ 0x001b5c59
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b5bfb:
MOV EDI,0x20
CALL 0x00120640
MOV RBX,RAX
MOV RDI,R14
CALL 0x00189d5c
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001b5c16:
LEA RSI,[0x21ae11]
LEA RDI,[RSP + 0x20]
CALL 0x0017f3bd
MOV BPL,0x1
LAB_001b5c2a:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00189b84
XOR EBP,EBP
LEA RSI,[0x260040]
LEA RDX,[0x175d10]
MOV RDI,RBX
CALL 0x00120a40
LAB_001b5c59:
MOV EDI,0x20
CALL 0x00120640
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x00120670
LEA RDX,[RAX + R15*0x1]
LAB_001b5c7c:
MOV RDI,RSP
MOV RSI,R15
CALL 0x0012801a
LAB_001b5c87:
LEA RSI,[0x21ae27]
LEA RCX,[0x21ae2d]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0017f445
MOV BPL,0x1
LAB_001b5ca5:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001882e8
XOR EBP,EBP
LEA RSI,[0x25ffc0]
LEA RDX,[0x175d10]
MOV RDI,RBX
CALL 0x00120a40
|
char * _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (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 001b5c16 to 001b5c26 has its CatchHandler @ 001b5d42 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001b5c2a to 001b5c56 has its CatchHandler @ 001b5d1d */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001b5c7c to 001b5c86 has its CatchHandler @ 001b5d1b */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001b5c87 to 001b5ca1 has its CatchHandler @ 001b5d00 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001b5ca5 to 001b5cd1 has its CatchHandler @ 001b5cd2 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
|
13,766
|
ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&)
|
Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/color.cpp
|
void Render(Screen& screen) override {
for (int y = box_.y_min; y <= box_.y_max; ++y) {
for (int x = box_.x_min; x <= box_.x_max; ++x) {
screen.PixelAt(x, y).background_color = color_;
}
}
NodeDecorator::Render(screen);
}
|
O2
|
cpp
|
ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x54(%rdi), %ebp
cmpl 0x58(%r14), %ebp
jg 0x1de95
movl 0x4c(%r14), %r15d
cmpl 0x50(%r14), %r15d
jg 0x1de91
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x303fa
movl 0x5c(%r14), %ecx
movl %ecx, 0x28(%rax)
incl %r15d
jmp 0x1de72
incl %ebp
jmp 0x1de68
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1efe0
|
_ZN5ftxui12_GLOBAL__N_17BgColor6RenderERNS_6ScreenE:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov ebp, [rdi+54h]
loc_1DE68:
cmp ebp, [r14+58h]
jg short loc_1DE95
mov r15d, [r14+4Ch]
loc_1DE72:
cmp r15d, [r14+50h]
jg short loc_1DE91
mov rdi, rbx; this
mov esi, r15d; int
mov edx, ebp; int
call _ZN5ftxui6Screen7PixelAtEii; ftxui::Screen::PixelAt(int,int)
mov ecx, [r14+5Ch]
mov [rax+28h], ecx
inc r15d
jmp short loc_1DE72
loc_1DE91:
inc ebp
jmp short loc_1DE68
loc_1DE95:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN5ftxui4Node6RenderERNS_6ScreenE; ftxui::Node::Render(ftxui::Screen &)
|
long long ftxui::`anonymous namespace'::BgColor::Render(
ftxui::_anonymous_namespace_::BgColor *this,
ftxui::Screen *a2)
{
int i; // ebp
int j; // r15d
for ( i = *((_DWORD *)this + 21); i <= *((_DWORD *)this + 22); ++i )
{
for ( j = *((_DWORD *)this + 19); j <= *((_DWORD *)this + 20); ++j )
*(_DWORD *)(ftxui::Screen::PixelAt(a2, j, i) + 40) = *((_DWORD *)this + 23);
}
return ftxui::Node::Render(this, a2);
}
|
Render:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV EBP,dword ptr [RDI + 0x54]
LAB_0011de68:
CMP EBP,dword ptr [R14 + 0x58]
JG 0x0011de95
MOV R15D,dword ptr [R14 + 0x4c]
LAB_0011de72:
CMP R15D,dword ptr [R14 + 0x50]
JG 0x0011de91
MOV RDI,RBX
MOV ESI,R15D
MOV EDX,EBP
CALL 0x001303fa
MOV ECX,dword ptr [R14 + 0x5c]
MOV dword ptr [RAX + 0x28],ECX
INC R15D
JMP 0x0011de72
LAB_0011de91:
INC EBP
JMP 0x0011de68
LAB_0011de95:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0011efe0
|
/* ftxui::(anonymous namespace)::BgColor::Render(ftxui::Screen&) */
void __thiscall ftxui::(anonymous_namespace)::BgColor::Render(BgColor *this,Screen *param_1)
{
long lVar1;
int iVar2;
int iVar3;
for (iVar2 = *(int *)(this + 0x54); iVar2 <= *(int *)(this + 0x58); iVar2 = iVar2 + 1) {
for (iVar3 = *(int *)(this + 0x4c); iVar3 <= *(int *)(this + 0x50); iVar3 = iVar3 + 1) {
lVar1 = Screen::PixelAt(param_1,iVar3,iVar2);
*(int4 *)(lVar1 + 0x28) = *(int4 *)(this + 0x5c);
}
}
Node::Render((Node *)this,param_1);
return;
}
|
|
13,767
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const
|
monkey531[P]llama/common/./json.hpp
|
const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
}
|
O0
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
jne 0x173d1a
leaq 0x16d06e(%rip), %rdi # 0x2e0d6e
movl $0x3519, %esi # imm = 0x3519
leaq 0x16d0ae(%rip), %rdx # 0x2e0dba
leaq 0x16f712(%rip), %rcx # 0x2e3425
movb $0x0, %al
callq 0x651d0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xa65b0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x173d31
jmp 0x173d44
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xe40c0
addq $0x58, %rsp
retq
movb $0x1, 0x1b(%rsp)
movl $0x20, %edi
callq 0x64880
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x654b0
movq 0x8(%rsp), %rdx
leaq 0x16f6c7(%rip), %rsi # 0x2e3439
leaq 0x30(%rsp), %rdi
callq 0x98e10
jmp 0x173d7e
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl $0xcf, %esi
leaq 0x30(%rsp), %rdx
callq 0x14e170
jmp 0x173d9b
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x242ed5(%rip), %rsi # 0x3b6c80
leaq -0x267f2(%rip), %rdx # 0x14d5c0
callq 0x64d60
jmp 0x173e09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x173de1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x65a60
leaq 0x2f(%rsp), %rdi
callq 0x65a30
testb $0x1, 0x1b(%rsp)
jne 0x173df4
jmp 0x173dfd
movq (%rsp), %rdi
callq 0x652b0
jmp 0x173dff
movq 0x20(%rsp), %rdi
callq 0x64e40
nopl (%rax)
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
sub rsp, 58h
mov qword ptr [rsp+58h+var_8], rdi; char
mov rax, qword ptr [rsp+58h+var_8]
mov qword ptr [rsp+58h+var_48], rax; int
cmp qword ptr [rax], 0
jnz short loc_173D1A
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 3519h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov al, 0
call _ggml_abort
loc_173D1A:
mov rax, qword ptr [rsp+58h+var_48]
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; 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>::is_object(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_173D31
jmp short loc_173D44
loc_173D31:
mov rdi, qword ptr [rsp+58h+var_48]
add rdi, 8
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
add rsp, 58h
retn
loc_173D44:
mov [rsp+58h+var_3D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+58h+var_58], rax; int
lea rdi, [rsp+58h+var_29]
mov qword ptr [rsp+58h+var_50], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+58h+var_50]
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdi, [rsp+58h+var_29+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_173D7E:
mov rdi, [rsp+58h+var_58]; int
mov rax, qword ptr [rsp+58h+var_48]
mov rcx, [rax]
mov esi, 0CFh
lea rdx, [rsp+58h+var_29+1]
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_173D9B:
mov rdi, [rsp+58h+var_58]; void *
mov [rsp+58h+var_3D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorD2Ev; void (*)(void *)
call ___cxa_throw
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(
long long *a1,
long long a2)
{
long long v3; // rdx
nlohmann::json_abi_v3_11_3::detail::invalid_iterator *exception; // [rsp+0h] [rbp-58h]
int v5[8]; // [rsp+2Fh] [rbp-29h] BYREF
char v6[8]; // [rsp+50h] [rbp-8h]
*(_QWORD *)v6 = a1;
if ( !*a1 )
{
a2 = 13593LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
}
if ( !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>::is_object((_BYTE *)*a1) )
{
exception = (nlohmann::json_abi_v3_11_3::detail::invalid_iterator *)__cxa_allocate_exception(0x20uLL);
std::allocator<char>::allocator(v5, a2, v3);
std::string::basic_string<std::allocator<char>>(
(long long)v5 + 1,
(long long)"cannot use key() for non-object iterators",
(long long)v5);
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
207LL,
(long long)v5 + 1,
*a1);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
return __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)(a1 + 1));
}
| |||
13,768
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const
|
monkey531[P]llama/common/./json.hpp
|
const typename object_t::key_type& key() const
{
JSON_ASSERT(m_object != nullptr);
if (JSON_HEDLEY_LIKELY(m_object->is_object()))
{
return m_it.object_iterator->first;
}
JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::key() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x8bba5
movq %rdi, %r14
cmpb $0x1, (%rax)
jne 0x8bb47
movq 0x8(%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc28c0(%rip), %rsi # 0x14e424
leaq 0xc28e2(%rip), %rdx # 0x14e44d
leaq 0x8(%rsp), %rdi
callq 0x4c588
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcf, %esi
callq 0x7bc9e
xorl %ebp, %ebp
leaq 0x11d242(%rip), %rsi # 0x1a8dd8
leaq -0xcb09(%rip), %rdx # 0x7f094
movq %rbx, %rdi
callq 0x202e0
leaq 0xc01e2(%rip), %rdi # 0x14bd8e
leaq 0xc0227(%rip), %rdx # 0x14bdda
leaq 0xc2856(%rip), %rcx # 0x14e410
movl $0x3519, %esi # imm = 0x3519
xorl %eax, %eax
callq 0x20250
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8bbe8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1fae0
jmp 0x8bbe8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8bbf5
movq %rbx, %rdi
callq 0x1f7e0
movq %r14, %rdi
callq 0x20380
nop
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv:
push rbp; char
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz short loc_8BBA5
mov r14, rdi
cmp byte ptr [rax], 1
jnz short loc_8BB47
mov rax, [r14+8]
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8BB47:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotUseKeyFo; "cannot use key() for non-object iterato"...
lea rdx, aCannotUseKeyFo+29h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0CFh; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_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_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_8BBA5:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 3519h
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_8BBE8
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8BBE8
mov r14, rax
mov bpl, 1
loc_8BBE8:
test bpl, bpl
jz short loc_8BBF5
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8BBF5:
mov rdi, r14
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(
_QWORD *a1)
{
void *v1; // rbx
char v2; // bp
void *v3; // r15
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
long long v6; // rax
long long v7; // r14
void *v8[2]; // [rsp+8h] [rbp-40h] BYREF
long long v9; // [rsp+18h] [rbp-30h] BYREF
if ( !*a1 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
13593LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
v7 = v6;
if ( v8[0] != v3 )
operator delete(v8[0], v9 + 1);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v7);
}
if ( *(_BYTE *)*a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v8[0] = &v9;
std::string::_M_construct<char const*>(v8, "cannot use key() for non-object iterators", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
207,
v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return a1[1];
}
|
key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018bba5
MOV R14,RDI
CMP byte ptr [RAX],0x1
JNZ 0x0018bb47
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018bb47:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0018bb5d:
LEA RSI,[0x24e424]
LEA RDX,[0x24e44d]
LEA RDI,[RSP + 0x8]
CALL 0x0014c588
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_0018bb7b:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcf
CALL 0x0017bc9e
XOR EBP,EBP
LEA RSI,[0x2a8dd8]
LEA RDX,[0x17f094]
MOV RDI,RBX
CALL 0x001202e0
LAB_0018bba5:
LEA RDI,[0x24bd8e]
LEA RDX,[0x24bdda]
LEA RCX,[0x24e410]
MOV ESI,0x3519
XOR EAX,EAX
CALL 0x00120250
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::key() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
int8 uVar1;
int1 *local_40 [2];
int1 local_30 [16];
if (*(char **)this == (char *)0x0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",0x3519,
"GGML_ASSERT(%s) failed","m_object != nullptr");
}
if (**(char **)this == '\x01') {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0018bb5d to 0018bb74 has its CatchHandler @ 0018bbe2 */
std::__cxx11::string::_M_construct<char_const*>
(local_40,"cannot use key() for non-object iterators","");
/* try { // try from 0018bb7b to 0018bba4 has its CatchHandler @ 0018bbc6 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0xcf,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&invalid_iterator::typeinfo,exception::~exception);
}
|
|
13,769
|
minja::Parser::parseConstant()
|
monkey531[P]llama/common/minja.hpp
|
std::shared_ptr<Value> parseConstant() {
auto start = it;
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"' || *it == '\'') {
auto str = parseString();
if (str) return std::make_shared<Value>(*str);
}
static std::regex prim_tok(R"(true\b|True\b|false\b|False\b|None\b)");
auto token = consumeToken(prim_tok);
if (!token.empty()) {
if (token == "true" || token == "True") return std::make_shared<Value>(true);
if (token == "false" || token == "False") return std::make_shared<Value>(false);
if (token == "None") return std::make_shared<Value>(nullptr);
throw std::runtime_error("Unknown constant token: " + token);
}
auto number = parseNumber(it, end);
if (!number.is_null()) return std::make_shared<Value>(number);
it = start;
return nullptr;
}
|
O2
|
cpp
|
minja::Parser::parseConstant():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x613ca
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x65d03
movzbl (%rax), %eax
cmpl $0x27, %eax
je 0x65cd8
cmpl $0x22, %eax
jne 0x65d16
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x669f0
movq (%r15), %rsi
testq %rsi, %rsi
je 0x65d0e
movq %rbx, %rdi
callq 0x66a46
movq %rsp, %rdi
callq 0x66a64
jmp 0x65dff
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x65dff
movq %rsp, %rdi
callq 0x66a64
leaq 0x97473(%rip), %rax # 0xfd190
movb (%rax), %al
testb %al, %al
je 0x65e35
leaq 0x97442(%rip), %rdx # 0xfd170
movq %rsp, %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x604c0
cmpq $0x0, 0x8(%r15)
je 0x65d7e
leaq 0x43ecd(%rip), %rsi # 0xa9c1a
movq %rsp, %rdi
callq 0x391b2
testb %al, %al
jne 0x65d6c
leaq 0x4cf7c(%rip), %rsi # 0xb2cdc
movq %rsp, %rdi
callq 0x391b2
testb %al, %al
je 0x65dac
leaq 0x20(%rsp), %rsi
movb $0x1, (%rsi)
movq %rbx, %rdi
callq 0x66a7e
jmp 0x65df7
leaq 0x20(%r14), %r15
leaq 0x18(%r14), %rcx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x66aba
cmpb $0x0, 0x20(%rsp)
je 0x65de4
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x66d83
jmp 0x65ded
leaq 0x46b50(%rip), %rsi # 0xac903
movq %rsp, %rdi
callq 0x391b2
testb %al, %al
jne 0x65dd2
leaq 0x4cf1b(%rip), %rsi # 0xb2ce1
movq %rsp, %rdi
callq 0x391b2
testb %al, %al
je 0x65e0f
leaq 0x20(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x66a7e
jmp 0x65df7
movq %r12, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x3cfcc
movq %rsp, %rdi
callq 0x241b8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d2e6(%rip), %rsi # 0xb30fc
movq %rsp, %rdi
callq 0x391b2
testb %al, %al
je 0x65e8a
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x66a9c
jmp 0x65df7
leaq 0x97354(%rip), %rdi # 0xfd190
callq 0x23ff0
testl %eax, %eax
je 0x65d27
leaq 0x97320(%rip), %rdi # 0xfd170
leaq 0x4d280(%rip), %rsi # 0xb30d7
pushq $0x10
popq %rdx
callq 0x460ca
leaq -0x1fb76(%rip), %rdi # 0x462f0
leaq 0x97303(%rip), %rsi # 0xfd170
leaq 0x96a74(%rip), %rdx # 0xfc8e8
callq 0x237b0
leaq 0x97310(%rip), %rdi # 0xfd190
callq 0x235d0
jmp 0x65d27
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x4d265(%rip), %rsi # 0xb3101
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x39318
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x23e20
xorl %ebp, %ebp
movq 0x9612e(%rip), %rsi # 0xfbff0
movq 0x9608f(%rip), %rdx # 0xfbf58
movq %r14, %rdi
callq 0x23ef0
movq %rax, %rbx
leaq 0x972b5(%rip), %rdi # 0xfd190
callq 0x235c0
jmp 0x65f30
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x241b8
testb %bpl, %bpl
jne 0x65ef9
jmp 0x65f1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x23680
jmp 0x65f1b
jmp 0x65f18
jmp 0x65f18
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3cfcc
jmp 0x65f1b
jmp 0x65f18
movq %rax, %rbx
movq %rsp, %rdi
callq 0x241b8
jmp 0x65f30
movq %rax, %rbx
movq %rsp, %rdi
callq 0x66a64
movq %rbx, %rdi
callq 0x23f80
|
_ZN5minja6Parser13parseConstantEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
push 1
pop rsi
mov rdi, r14
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r14+20h]
cmp rax, [r14+18h]
jz short loc_65D03
movzx eax, byte ptr [rax]
cmp eax, 27h ; '''
jz short loc_65CD8
cmp eax, 22h ; '"'
jnz short loc_65D16
loc_65CD8:
mov r15, rsp
mov rdi, r15
mov rsi, r14
call _ZN5minja6Parser11parseStringB5cxx11Ev; minja::Parser::parseString(void)
mov rsi, [r15]
test rsi, rsi
jz short loc_65D0E
mov rdi, rbx
call _ZSt11make_sharedIN5minja5ValueEJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::Value,std::string &>(std::string &)
mov rdi, rsp
call _ZNSt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EED2Ev; std::unique_ptr<std::string>::~unique_ptr()
jmp loc_65DFF
loc_65D03:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
jmp loc_65DFF
loc_65D0E:
mov rdi, rsp
call _ZNSt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EED2Ev; std::unique_ptr<std::string>::~unique_ptr()
loc_65D16:
lea rax, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; `guard variable for'minja::Parser::parseConstant(void)::prim_tok
mov al, [rax]
test al, al
jz loc_65E35
loc_65D27:
lea rdx, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
mov r15, rsp
push 1
pop rcx
mov rdi, r15
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp qword ptr [r15+8], 0
jz short loc_65D7E
lea rsi, aTrue; "true"
mov rdi, rsp
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_65D6C
lea rsi, aTrue_0; "True"
mov rdi, rsp
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_65DAC
loc_65D6C:
lea rsi, [rsp+68h+var_48]
mov byte ptr [rsi], 1
mov rdi, rbx
call _ZSt11make_sharedIN5minja5ValueEJbEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::Value,bool>(bool &&)
jmp short loc_65DF7
loc_65D7E:
lea r15, [r14+20h]
lea rcx, [r14+18h]
lea rdi, [rsp+68h+var_48]
mov rsi, r14
mov rdx, r15
call _ZN5minja6Parser11parseNumberERN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKSB_; minja::Parser::parseNumber(__gnu_cxx::__normal_iterator<char const*,std::string> &,__gnu_cxx::__normal_iterator<char const*,std::string> const&)
cmp [rsp+68h+var_48], 0
jz short loc_65DE4
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call _ZSt11make_sharedIN5minja5ValueEJRN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::Value,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &>(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> &)
jmp short loc_65DED
loc_65DAC:
lea rsi, aAdvancedOption+0ABh; "false"
mov rdi, rsp
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_65DD2
lea rsi, aFalse; "False"
mov rdi, rsp
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_65E0F
loc_65DD2:
lea rsi, [rsp+68h+var_48]
mov byte ptr [rsi], 0
mov rdi, rbx
call _ZSt11make_sharedIN5minja5ValueEJbEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::Value,bool>(bool &&)
jmp short loc_65DF7
loc_65DE4:
mov [r15], r12
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_65DED:
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_65DF7:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_65DFF:
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_65E0F:
lea rsi, aNone_0; "None"
mov rdi, rsp
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_65E8A
lea rsi, [rsp+68h+var_48]
and qword ptr [rsi], 0
mov rdi, rbx
call _ZSt11make_sharedIN5minja5ValueEJDnEESt10shared_ptrIT_EDpOT0_; std::make_shared<minja::Value,decltype(nullptr)>(decltype(nullptr) &&)
jmp short loc_65DF7
loc_65E35:
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_65D27
lea rdi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; minja::Parser::parseConstant(void)::prim_tok
lea rsi, aTrueBTrueBFals; "true\\b|True\\b|false\\b|False\\b|None"...
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_65D27
loc_65E8A:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUnknownConstan; "Unknown constant token: "
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+68h+var_48]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser13parseConstantEvE8prim_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_65F30
mov rbx, rax
lea rdi, [rsp+68h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_65EF9
jmp short loc_65F1B
mov rbx, rax
loc_65EF9:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_65F1B
jmp short loc_65F18
jmp short loc_65F18
mov rbx, rax
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_65F1B
jmp short $+2
loc_65F18:
mov rbx, rax
loc_65F1B:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_65F30
mov rbx, rax
mov rdi, rsp
call _ZNSt10unique_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt14default_deleteIS5_EED2Ev; std::unique_ptr<std::string>::~unique_ptr()
loc_65F30:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseConstant(minja::Parser *this, long long a2)
{
long long v2; // r12
unsigned __int8 *v3; // rax
int v4; // eax
void *exception; // r14
_QWORD v7[4]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v8[9]; // [rsp+20h] [rbp-48h] BYREF
v2 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, 1);
v3 = *(unsigned __int8 **)(a2 + 32);
if ( v3 == *(unsigned __int8 **)(a2 + 24) )
{
*(_OWORD *)this = 0LL;
return this;
}
v4 = *v3;
if ( v4 == 39 || v4 == 34 )
{
minja::Parser::parseString[abi:cxx11](v7, a2);
if ( v7[0] )
{
std::make_shared<minja::Value,std::string &>(this);
std::unique_ptr<std::string>::~unique_ptr(v7);
return this;
}
std::unique_ptr<std::string>::~unique_ptr(v7);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
(long long)"true\\b|True\\b|false\\b|False\\b|None\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseConstant(void)::prim_tok[abi:cxx11]);
}
minja::Parser::consumeToken(v7, a2, (long long)&minja::Parser::parseConstant(void)::prim_tok[abi:cxx11], 1u);
if ( v7[1] )
{
if ( std::operator==<char>((long long)v7) || std::operator==<char>((long long)v7) )
{
LOBYTE(v8[0]) = 1;
std::make_shared<minja::Value,bool>(this, v8);
}
else if ( std::operator==<char>((long long)v7) || std::operator==<char>((long long)v7) )
{
LOBYTE(v8[0]) = 0;
std::make_shared<minja::Value,bool>(this, v8);
}
else
{
if ( !std::operator==<char>((long long)v7) )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v8, (long long)"Unknown constant token: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v8[0] = 0LL;
std::make_shared<minja::Value,decltype(nullptr)>(this, v8);
}
}
else
{
minja::Parser::parseNumber(v8, a2, a2 + 32, a2 + 24);
if ( LOBYTE(v8[0]) )
{
std::make_shared<minja::Value,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> &>(
this,
v8);
}
else
{
*(_QWORD *)(a2 + 32) = v2;
*(_OWORD *)this = 0LL;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v8);
}
std::string::~string(v7);
return this;
}
|
parseConstant:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x001613ca
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x18]
JZ 0x00165d03
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x27
JZ 0x00165cd8
CMP EAX,0x22
JNZ 0x00165d16
LAB_00165cd8:
MOV R15,RSP
MOV RDI,R15
MOV RSI,R14
CALL 0x001669f0
MOV RSI,qword ptr [R15]
TEST RSI,RSI
JZ 0x00165d0e
LAB_00165cee:
MOV RDI,RBX
CALL 0x00166a46
LAB_00165cf6:
MOV RDI,RSP
CALL 0x00166a64
JMP 0x00165dff
LAB_00165d03:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x00165dff
LAB_00165d0e:
MOV RDI,RSP
CALL 0x00166a64
LAB_00165d16:
LEA RAX,[0x1fd190]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00165e35
LAB_00165d27:
LEA RDX,[0x1fd170]
MOV R15,RSP
PUSH 0x1
POP RCX
MOV RDI,R15
MOV RSI,R14
CALL 0x001604c0
CMP qword ptr [R15 + 0x8],0x0
JZ 0x00165d7e
LEA RSI,[0x1a9c1a]
MOV RDI,RSP
CALL 0x001391b2
TEST AL,AL
JNZ 0x00165d6c
LEA RSI,[0x1b2cdc]
MOV RDI,RSP
CALL 0x001391b2
TEST AL,AL
JZ 0x00165dac
LAB_00165d6c:
LEA RSI,[RSP + 0x20]
MOV byte ptr [RSI],0x1
LAB_00165d74:
MOV RDI,RBX
CALL 0x00166a7e
JMP 0x00165df7
LAB_00165d7e:
LEA R15,[R14 + 0x20]
LEA RCX,[R14 + 0x18]
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV RDX,R15
CALL 0x00166aba
CMP byte ptr [RSP + 0x20],0x0
JZ 0x00165de4
LAB_00165d9d:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00166d83
JMP 0x00165ded
LAB_00165dac:
LEA RSI,[0x1ac903]
MOV RDI,RSP
CALL 0x001391b2
TEST AL,AL
JNZ 0x00165dd2
LEA RSI,[0x1b2ce1]
MOV RDI,RSP
CALL 0x001391b2
TEST AL,AL
JZ 0x00165e0f
LAB_00165dd2:
LEA RSI,[RSP + 0x20]
MOV byte ptr [RSI],0x0
LAB_00165dda:
MOV RDI,RBX
CALL 0x00166a7e
JMP 0x00165df7
LAB_00165de4:
MOV qword ptr [R15],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00165ded:
LEA RDI,[RSP + 0x20]
CALL 0x0013cfcc
LAB_00165df7:
MOV RDI,RSP
CALL 0x001241b8
LAB_00165dff:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00165e0f:
LEA RSI,[0x1b30fc]
MOV RDI,RSP
CALL 0x001391b2
TEST AL,AL
JZ 0x00165e8a
LEA RSI,[RSP + 0x20]
AND qword ptr [RSI],0x0
LAB_00165e2b:
MOV RDI,RBX
CALL 0x00166a9c
JMP 0x00165df7
LAB_00165e35:
LEA RDI,[0x1fd190]
CALL 0x00123ff0
TEST EAX,EAX
JZ 0x00165d27
LAB_00165e49:
LEA RDI,[0x1fd170]
LEA RSI,[0x1b30d7]
PUSH 0x10
POP RDX
CALL 0x001460ca
LAB_00165e5f:
LEA RDI,[0x1462f0]
LEA RSI,[0x1fd170]
LEA RDX,[0x1fc8e8]
CALL 0x001237b0
LEA RDI,[0x1fd190]
CALL 0x001235d0
JMP 0x00165d27
LAB_00165e8a:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_00165e95:
LEA RSI,[0x1b3101]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00139318
MOV BPL,0x1
LAB_00165eac:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
CALL 0x00123e20
XOR EBP,EBP
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,R14
CALL 0x00123ef0
|
/* minja::Parser::parseConstant() */
void minja::Parser::parseConstant(void)
{
char cVar1;
int8 uVar2;
bool bVar3;
int iVar4;
runtime_error *this;
__normal_iterator *in_RSI;
string *in_RDI;
long local_68;
long local_60;
ulong local_48 [4];
uVar2 = *(int8 *)(in_RSI + 0x20);
consumeSpaces();
if (*(char **)(in_RSI + 0x20) == *(char **)(in_RSI + 0x18)) {
*(int8 *)in_RDI = 0;
*(int8 *)(in_RDI + 8) = 0;
return;
}
cVar1 = **(char **)(in_RSI + 0x20);
if ((cVar1 == '\'') || (cVar1 == '\"')) {
parseString_abi_cxx11_();
if (local_68 != 0) {
/* try { // try from 00165cee to 00165cf5 has its CatchHandler @ 00165f25 */
std::make_shared<minja::Value,std::__cxx11::string&>(in_RDI);
std::unique_ptr<std::__cxx11::string,std::default_delete<std::__cxx11::string>>::~unique_ptr
((unique_ptr<std::__cxx11::string,std::default_delete<std::__cxx11::string>> *)
&local_68);
return;
}
std::unique_ptr<std::__cxx11::string,std::default_delete<std::__cxx11::string>>::~unique_ptr
((unique_ptr<std::__cxx11::string,std::default_delete<std::__cxx11::string>> *)
&local_68);
}
if ((parseConstant()::prim_tok_abi_cxx11_ == '\0') &&
(iVar4 = __cxa_guard_acquire(&parseConstant()::prim_tok_abi_cxx11_), iVar4 != 0)) {
/* try { // try from 00165e49 to 00165e5e has its CatchHandler @ 00165ed1 */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseConstant()::prim_tok_abi_cxx11_,"true\\b|True\\b|false\\b|False\\b|None\\b",0x10
);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseConstant()::prim_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseConstant()::prim_tok_abi_cxx11_);
}
consumeToken(&local_68);
if (local_60 == 0) {
/* try { // try from 00165d7e to 00165d95 has its CatchHandler @ 00165f16 */
parseNumber((__normal_iterator *)local_48,in_RSI);
if (local_48[0]._0_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>
)0x0) {
*(int8 *)(in_RSI + 0x20) = uVar2;
*(int8 *)in_RDI = 0;
*(int8 *)(in_RDI + 8) = 0;
}
else {
/* try { // try from 00165d9d to 00165da9 has its CatchHandler @ 00165f07 */
std::
make_shared<minja::Value,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>&>
(in_RDI);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)local_48);
}
else {
bVar3 = std::operator==((string *)&local_68,"true");
if ((bVar3) || (bVar3 = std::operator==((string *)&local_68,"True"), bVar3)) {
local_48[0] = CONCAT71(local_48[0]._1_7_,1);
/* try { // try from 00165d74 to 00165d7b has its CatchHandler @ 00165f18 */
std::make_shared<minja::Value,bool>((bool *)in_RDI);
}
else {
bVar3 = std::operator==((string *)&local_68,"false");
if ((bVar3) || (bVar3 = std::operator==((string *)&local_68,"False"), bVar3)) {
local_48[0] = local_48[0] & 0xffffffffffffff00;
/* try { // try from 00165dda to 00165de1 has its CatchHandler @ 00165f05 */
std::make_shared<minja::Value,bool>((bool *)in_RDI);
}
else {
bVar3 = std::operator==((string *)&local_68,"None");
if (!bVar3) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00165e95 to 00165ea8 has its CatchHandler @ 00165ef6 */
std::operator+((char *)local_48,(string *)"Unknown constant token: ");
/* try { // try from 00165eac to 00165ed0 has its CatchHandler @ 00165ee2 */
std::runtime_error::runtime_error(this,(string *)local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
local_48[0] = 0;
/* try { // try from 00165e2b to 00165e32 has its CatchHandler @ 00165f03 */
std::make_shared<minja::Value,decltype(nullptr)>((_func_decltype_nullptr **)in_RDI);
}
}
}
std::__cxx11::string::~string((string *)&local_68);
return;
}
|
|
13,770
|
my_hash_sort_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static void
my_hash_sort_utf8mb4(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb4_nopad(cs, s, e - s, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_utf8mb4:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0x5acab
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0x5acab
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0x5acd0
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0x5ac93
jmp 0x5acae
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0x5acca
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0x5acb4
popq %rbp
jmp 0x5af54
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0x5acae
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0x5acae
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x5ace7
jmp 0x5acae
|
my_hash_sort_utf8mb4:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_5ACAB
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_5ACAB
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_5AC93:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_5ACD0
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_5AC93
jmp short loc_5ACAE
loc_5ACAB:
mov rax, r10
loc_5ACAE:
mov r9, rax
sub r9, rsi
loc_5ACB4:
mov rdx, r9
cmp rax, rsi
jbe short loc_5ACCA
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_5ACB4
loc_5ACCA:
pop rbp
jmp my_hash_sort_utf8mb4_nopad
loc_5ACD0:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_5ACAE
mov r9, rax
loc_5ACE7:
mov rax, r9
cmp r9, rdx
jbe short loc_5ACAE
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_5ACE7
jmp short loc_5ACAE
|
long long my_hash_sort_utf8mb4(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb4_nopad(a1, a2, v11, a4, a5, v10);
}
|
my_hash_sort_utf8mb4:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x0015acab
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x0015acab
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_0015ac93:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x0015acd0
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x0015ac93
JMP 0x0015acae
LAB_0015acab:
MOV RAX,R10
LAB_0015acae:
MOV R9,RAX
SUB R9,RSI
LAB_0015acb4:
MOV RDX,R9
CMP RAX,RSI
JBE 0x0015acca
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x0015acb4
LAB_0015acca:
POP RBP
JMP 0x0015af54
LAB_0015acd0:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x0015acae
MOV R9,RAX
LAB_0015ace7:
MOV RAX,R9
CMP R9,RDX
JBE 0x0015acae
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x0015ace7
JMP 0x0015acae
|
void my_hash_sort_utf8mb4(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_0015ace7;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_0015acb4;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_0015ace7:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_0015acb4:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb4_nopad();
return;
}
|
|
13,771
|
bytes_dup
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
}
|
O0
|
c
|
bytes_dup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %edi
callq 0x185a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x192a1
cmpl $0x0, -0x20(%rbp)
jbe 0x192a1
movl $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x192c3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x5060
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
|
bytes_dup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], edi
mov [rbp+var_18], rsi
mov eax, [rbp+var_20]
mov dword ptr [rbp+var_30], eax
mov eax, [rbp+var_20]
mov edi, eax
call safe_malloc
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_192A1
cmp [rbp+var_20], 0
jbe short loc_192A1
mov dword ptr [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_192C3
loc_192A1:
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_20]
mov edx, eax
call _memcpy
mov rax, [rbp+var_30]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_192C3:
mov eax, dword ptr [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
long long bytes_dup(unsigned int a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-28h]
v3 = safe_malloc(a1);
if ( v3 || !a1 )
{
memcpy(v3, a2, a1);
return a1;
}
else
{
return 0;
}
}
|
bytes_dup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x20],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x20]
MOV EDI,EAX
CALL 0x001185a0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001192a1
CMP dword ptr [RBP + -0x20],0x0
JBE 0x001192a1
MOV dword ptr [RBP + -0x10],0x0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001192c3
LAB_001192a1:
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x20]
MOV EDX,EAX
CALL 0x00105060
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_001192c3:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
int1 auVar1 [16];
int8 local_10;
local_10 = (void *)safe_malloc(param_1);
if ((local_10 == (void *)0x0) && (param_1 != 0)) {
param_1 = 0;
local_10 = (void *)0x0;
}
else {
memcpy(local_10,param_2,(ulong)param_1);
}
auVar1._4_4_ = 0;
auVar1._0_4_ = param_1;
auVar1._8_8_ = local_10;
return auVar1;
}
|
|
13,772
|
bytes_dup
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
}
|
O1
|
c
|
bytes_dup:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movl %edi, %r12d
movq %r12, %rdi
callq 0x12838
movq %rax, %r14
testq %rax, %rax
sete %al
testl %ebx, %ebx
setne %cl
testb %al, %cl
je 0x12df7
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x12e05
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5060
movl %ebx, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
bytes_dup:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov ebx, edi
mov r12d, edi
mov rdi, r12
call safe_malloc
mov r14, rax
test rax, rax
setz al
test ebx, ebx
setnz cl
test cl, al
jz short loc_12DF7
xor ebx, ebx
xor r14d, r14d
jmp short loc_12E05
loc_12DF7:
mov rdi, r14
mov rsi, r15
mov rdx, r12
call _memcpy
loc_12E05:
mov eax, ebx
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long bytes_dup(unsigned int a1, long long a2)
{
unsigned int v2; // ebx
long long v3; // r14
v2 = a1;
v3 = safe_malloc(a1);
if ( v3 == 0 && a1 != 0 )
return 0;
else
memcpy(v3, a2, a1);
return v2;
}
|
bytes_dup:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV EBX,EDI
MOV R12D,EDI
MOV RDI,R12
CALL 0x00112838
MOV R14,RAX
TEST RAX,RAX
SETZ AL
TEST EBX,EBX
SETNZ CL
TEST CL,AL
JZ 0x00112df7
XOR EBX,EBX
XOR R14D,R14D
JMP 0x00112e05
LAB_00112df7:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00105060
LAB_00112e05:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
void *__dest;
int1 auVar1 [16];
__dest = (void *)safe_malloc((ulong)param_1);
if (param_1 == 0 || __dest != (void *)0x0) {
memcpy(__dest,param_2,(ulong)param_1);
}
else {
param_1 = 0;
__dest = (void *)0x0;
}
auVar1._4_4_ = 0;
auVar1._0_4_ = param_1;
auVar1._8_8_ = __dest;
return auVar1;
}
|
|
13,773
|
bytes_dup
|
corpus-core[P]colibri-stateless/src/util/bytes.c
|
bytes_t bytes_dup(bytes_t data) {
bytes_t result = {.data = safe_malloc(data.len), .len = data.len};
if (!result.data && data.len > 0) {
// This case should technically not be reached if safe_malloc exits on failure,
// but kept for conceptual completeness or if safe_malloc behaviour changes.
return NULL_BYTES; // Indicate failure if malloc fails
}
memcpy(result.data, data.data, data.len);
return result;
}
|
O3
|
c
|
bytes_dup:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %ebx
movl %edi, %r12d
movq %r12, %rdi
callq 0x12540
movq %rax, %r14
testq %rax, %rax
sete %cl
testl %ebx, %ebx
setne %dl
xorl %eax, %eax
testb %cl, %dl
jne 0x12b0c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5060
movl %ebx, %eax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
bytes_dup:
push r15
push r14
push r12
push rbx
push rax
mov r15, rsi
mov ebx, edi
mov r12d, edi
mov rdi, r12
call safe_malloc
mov r14, rax
test rax, rax
setz cl
test ebx, ebx
setnz dl
xor eax, eax
test dl, cl
jnz short loc_12B0C
mov rdi, r14
mov rsi, r15
mov rdx, r12
call _memcpy
mov eax, ebx
loc_12B0C:
mov rdx, r14
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long bytes_dup(unsigned int a1, long long a2)
{
long long v2; // r14
long long result; // rax
v2 = safe_malloc(a1);
result = 0LL;
if ( v2 != 0 || a1 == 0 )
{
memcpy(v2, a2, a1);
return a1;
}
return result;
}
|
bytes_dup:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV EBX,EDI
MOV R12D,EDI
MOV RDI,R12
CALL 0x00112540
MOV R14,RAX
TEST RAX,RAX
SETZ CL
TEST EBX,EBX
SETNZ DL
XOR EAX,EAX
TEST DL,CL
JNZ 0x00112b0c
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00105060
MOV EAX,EBX
LAB_00112b0c:
MOV RDX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] bytes_dup(uint param_1,void *param_2)
{
void *__dest;
ulong uVar1;
int1 auVar2 [16];
__dest = (void *)safe_malloc((ulong)param_1);
uVar1 = 0;
if (param_1 == 0 || __dest != (void *)0x0) {
memcpy(__dest,param_2,(ulong)param_1);
uVar1 = (ulong)param_1;
}
auVar2._8_8_ = __dest;
auVar2._0_8_ = uVar1;
return auVar2;
}
|
|
13,774
|
simple_key_cache_insert
|
eloqsql/mysys/mf_keycache.c
|
static
int simple_key_cache_insert(SIMPLE_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length)
{
int error= 0;
DBUG_ENTER("key_cache_insert");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file,(ulong) filepos, length));
if (keycache->key_cache_inited)
{
/* Key cache is used */
reg1 BLOCK_LINK *block;
uint read_length;
uint offset;
int page_st;
my_bool locked_and_incremented= FALSE;
/*
When the keycache is once initialized, we use the cache_lock to
reliably distinguish the cases of normal operation, resizing, and
disabled cache. We always increment and decrement
'cnt_for_resize_op' so that a resizer can wait for pending I/O.
*/
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
We do not load index data into a disabled cache nor into an
ongoing resize.
*/
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Register the pseudo I/O for the next resize. */
inc_counter_for_resize_op(keycache);
locked_and_incremented= TRUE;
/* Loaded data may not always be aligned to cache blocks. */
offset= (uint) (filepos % keycache->key_cache_block_size);
/* Load data in key_cache_block_size increments. */
do
{
/* Cache could be disabled or resizing in a later iteration. */
if (!keycache->can_be_used || keycache->in_resize)
goto no_key_cache;
/* Start loading at the beginning of the cache block. */
filepos-= offset;
/* Do not load beyond the end of the cache block. */
read_length= length;
set_if_smaller(read_length, keycache->key_cache_block_size-offset);
KEYCACHE_DBUG_ASSERT(read_length > 0);
/* The block has been read by the caller already. */
keycache->global_cache_read++;
/* Request the cache block that matches file/pos. */
keycache->global_cache_r_requests++;
block= find_key_block(keycache, file, filepos, level, 0, &page_st);
if (!block)
{
/*
This happens only for requests submitted during key cache
resize. The block is not in the cache and shall not go in.
Stop loading index data.
*/
goto no_key_cache;
}
if (!(block->status & BLOCK_ERROR))
{
if (page_st == PAGE_WAIT_TO_BE_READ)
{
/*
this is a secondary request for a block to be read into the
cache. The block is in eviction. It is not yet assigned to
the requested file block (It does not point to the right
hash_link). So we cannot call remove_reader() on the block.
And we cannot access the hash_link directly here. We need to
wait until the assignment is complete. read_block_secondary()
executes the correct wait.
*/
read_block_secondary(keycache, block);
/*
A secondary request must now have the block assigned to the
requested file block.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
}
else if (page_st == PAGE_TO_BE_READ &&
(offset || (read_length < keycache->key_cache_block_size)))
{
/*
this is a primary request for a block to be read into the
cache and the supplied data does not fill the whole block.
This function is called on behalf of a LOAD INDEX INTO CACHE
statement, which is a read-only task and allows other
readers. It is possible that a parallel running reader tries
to access this block. If it needs more data than has been
supplied here, it would report an error. To be sure that we
have all data in the block that is available in the file, we
read the block ourselves.
Though reading again what the caller did read already is an
expensive operation, we need to do this for correctness.
*/
read_block_primary(keycache, block, keycache->key_cache_block_size,
read_length + offset);
}
else if (page_st == PAGE_TO_BE_READ)
{
/*
This is a new block in the cache. If we come here, we have
data for the whole block.
*/
DBUG_ASSERT(block->hash_link->requests);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
/*
Here other threads may step in and register as secondary readers.
They will register in block->wqueue[COND_FOR_REQUESTED].
*/
#endif
/* Copy data from buff */
memcpy(block->buffer+offset, buff, (size_t) read_length);
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_lock(&keycache->cache_lock);
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT((page_st == PAGE_TO_BE_READ) ||
(block->status & BLOCK_READ));
#endif
/*
After the data is in the buffer, we can declare the block
valid. Now other threads do not need to register as
secondary readers any more. They can immediately access the
block.
*/
block->status|= BLOCK_READ;
block->length= read_length+offset;
/*
Do not set block->offset here. If this block is marked
BLOCK_CHANGED later, we want to flush only the modified part. So
only a writer may set block->offset down from
keycache->key_cache_block_size.
*/
KEYCACHE_DBUG_PRINT("key_cache_insert",
("primary request: new page in cache"));
/* Signal all pending requests. */
release_whole_queue(&block->wqueue[COND_FOR_REQUESTED]);
}
else
{
/*
page_st == PAGE_READ. The block is in the buffer. All data
must already be present. Blocks are always read with all
data available on file. Assert that the block does not have
less contents than the preloader supplies. If the caller has
data beyond block->length, it means that a file write has
been done while this block was in cache and not extended
with the new data. If the condition is met, we can simply
ignore the block.
*/
DBUG_ASSERT((page_st == PAGE_READ) &&
(read_length + offset <= block->length));
}
/*
A secondary request must now have the block assigned to the
requested file block. It does not hurt to check it for primary
requests too.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
} /* end of if (!(block->status & BLOCK_ERROR)) */
remove_reader(block);
/* Error injection for coverage testing. */
DBUG_EXECUTE_IF("key_cache_insert_block_error",
block->status|= BLOCK_ERROR; errno=EIO;);
/* Do not link erroneous blocks into the LRU ring, but free them. */
if (!(block->status & BLOCK_ERROR))
{
/*
Link the block into the LRU ring if it's the last submitted
request for the block. This enables eviction for the block.
*/
unreg_request(keycache, block, 1);
}
else
{
free_block(keycache, block);
error= 1;
break;
}
buff+= read_length;
filepos+= read_length+offset;
offset= 0;
} while ((length-= read_length));
no_key_cache:
if (locked_and_incremented)
dec_counter_for_resize_op(keycache);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
}
DBUG_RETURN(error);
}
|
O3
|
c
|
simple_key_cache_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movl %ecx, -0x48(%rbp)
movl %esi, -0x44(%rbp)
cmpb $0x0, (%rdi)
je 0x545cb
movq %r8, %r15
movq %rdx, %r13
movq %rdi, %r12
leaq 0xc0(%rdi), %r14
cmpq $0x0, 0x100(%rdi)
jne 0x54623
movq %r14, %rdi
callq 0x28560
xorl %ebx, %ebx
cmpb $0x0, 0x3(%r12)
je 0x545fd
cmpb $0x0, 0x1(%r12)
jne 0x545fd
movq %r15, -0x60(%rbp)
movq %r14, -0x38(%rbp)
incq 0x70(%r12)
movl 0x18(%r12), %ecx
movq %r13, -0x40(%rbp)
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movq %r12, %r15
cmpb $0x0, 0x3(%r15)
je 0x545cf
cmpb $0x0, 0x1(%r15)
jne 0x545cf
movl %r13d, %eax
movq -0x40(%rbp), %rdx
movq %rax, -0x70(%rbp)
subq %rax, %rdx
movl 0x18(%r15), %r14d
subl %r13d, %r14d
movl -0x2c(%rbp), %eax
cmpl %r14d, %eax
cmovbl %eax, %r14d
movdqu 0x150(%r15), %xmm0
psubq 0x43293(%rip), %xmm0 # 0x97700
movdqu %xmm0, 0x150(%r15)
xorl %ebx, %ebx
movq %r15, %rdi
movl -0x44(%rbp), %esi
movq %rdx, -0x40(%rbp)
movl -0x48(%rbp), %ecx
xorl %r8d, %r8d
leaq -0x4c(%rbp), %r9
callq 0x52911
testq %rax, %rax
je 0x545e3
movq %rax, %r12
testb $0x1, 0x50(%rax)
movl %r14d, %ebx
jne 0x5455e
movl -0x4c(%rbp), %eax
cmpl $0x1, %eax
je 0x544d0
cmpl $0x2, %eax
jne 0x5455e
movq %r12, %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x52880
jmp 0x5455e
movl 0x18(%r15), %edx
testl %r13d, %r13d
jne 0x5454f
cmpl %edx, %r14d
jb 0x5454f
movq %rbx, -0x58(%rbp)
movq %r15, -0x68(%rbp)
movq 0x100(%r15), %rdi
testq %rdi, %rdi
jne 0x5459d
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x28270
movq -0x70(%rbp), %rdi
addq 0x40(%r12), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x282c0
movq -0x68(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x545b2
movq %rbx, %rdi
callq 0x28560
orb $0x2, 0x50(%r12)
movl %r14d, 0x4c(%r12)
movq %r12, %rdi
addq $0x28, %rdi
callq 0x53b35
movq -0x58(%rbp), %rbx
jmp 0x5455e
leal (%r14,%r13), %ecx
movq %r15, %rdi
movq %r12, %rsi
callq 0x53112
movq %r12, %rdi
callq 0x531e0
testb $0x1, 0x50(%r12)
jne 0x545d3
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x53228
addq %rbx, -0x60(%rbp)
addl %r14d, %r13d
addq %r13, -0x40(%rbp)
xorl %r13d, %r13d
movl $0x0, %ebx
subl %r14d, -0x2c(%rbp)
jne 0x54427
jmp 0x545e3
leaq 0x2db8ac(%rip), %rax # 0x32fe50
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x544f6
movq %rbx, %rdi
leaq 0x3e4f3(%rip), %rsi # 0x92aaf
movl $0xc4b, %edx # imm = 0xC4B
callq 0x29edc
jmp 0x54532
xorl %ebx, %ebx
jmp 0x54612
xorl %ebx, %ebx
jmp 0x545e3
movq %r15, %rdi
movq %r12, %rsi
callq 0x53330
movl $0x1, %ebx
decq 0x70(%r15)
movq %r15, %r12
jne 0x545f9
leaq 0x110(%r12), %rdi
callq 0x53b35
movq -0x38(%rbp), %r14
movq 0x100(%r12), %rdi
testq %rdi, %rdi
jne 0x5463c
movq %r14, %rdi
callq 0x28270
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e485(%rip), %rsi # 0x92aaf
movq %r14, %rdi
movl $0xbe2, %edx # imm = 0xBE2
callq 0x29edc
jmp 0x543e9
leaq 0x2db80d(%rip), %rax # 0x32fe50
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x5460a
|
simple_key_cache_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_2C], r9d
mov [rbp+var_48], ecx
mov [rbp+var_44], esi
cmp byte ptr [rdi], 0
jz loc_545CB
mov r15, r8
mov r13, rdx
mov r12, rdi
lea r14, [rdi+0C0h]
cmp qword ptr [rdi+100h], 0
jnz loc_54623
mov rdi, r14
call _pthread_mutex_lock
loc_543E9:
xor ebx, ebx
cmp byte ptr [r12+3], 0
jz loc_545FD
cmp byte ptr [r12+1], 0
jnz loc_545FD
mov [rbp+var_60], r15
mov [rbp+var_38], r14
inc qword ptr [r12+70h]
mov ecx, [r12+18h]
mov [rbp+var_40], r13
mov rax, r13
xor edx, edx
div rcx
mov r13, rdx
mov r15, r12
loc_54427:
cmp byte ptr [r15+3], 0
jz loc_545CF
cmp byte ptr [r15+1], 0
jnz loc_545CF
mov eax, r13d
mov rdx, [rbp+var_40]
mov [rbp+var_70], rax
sub rdx, rax
mov r14d, [r15+18h]
sub r14d, r13d
mov eax, [rbp+var_2C]
cmp eax, r14d
cmovb r14d, eax
movdqu xmm0, xmmword ptr [r15+150h]
psubq xmm0, cs:xmmword_97700
movdqu xmmword ptr [r15+150h], xmm0
xor ebx, ebx
mov rdi, r15
mov esi, [rbp+var_44]
mov [rbp+var_40], rdx
mov ecx, [rbp+var_48]
xor r8d, r8d
lea r9, [rbp+var_4C]
call find_key_block
test rax, rax
jz loc_545E3
mov r12, rax
test byte ptr [rax+50h], 1
mov ebx, r14d
jnz loc_5455E
mov eax, [rbp+var_4C]
cmp eax, 1
jz short loc_544D0
cmp eax, 2
jnz loc_5455E
mov rdi, r12
add rdi, 28h ; '('
mov rsi, [rbp+var_38]
call wait_on_queue
jmp loc_5455E
loc_544D0:
mov edx, [r15+18h]
test r13d, r13d
jnz short loc_5454F
cmp r14d, edx
jb short loc_5454F
mov [rbp+var_58], rbx
mov [rbp+var_68], r15
mov rdi, [r15+100h]
test rdi, rdi
jnz loc_5459D
loc_544F6:
mov rbx, [rbp+var_38]
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, [rbp+var_70]
add rdi, [r12+40h]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_58]
call _memcpy
mov rax, [rbp+var_68]
cmp qword ptr [rax+100h], 0
jnz loc_545B2
mov rdi, rbx
call _pthread_mutex_lock
loc_54532:
or byte ptr [r12+50h], 2
mov [r12+4Ch], r14d
mov rdi, r12
add rdi, 28h ; '('
call release_whole_queue
mov rbx, [rbp+var_58]
jmp short loc_5455E
loc_5454F:
lea ecx, [r14+r13]
mov rdi, r15
mov rsi, r12
call read_block_primary
loc_5455E:
mov rdi, r12
call remove_reader
test byte ptr [r12+50h], 1
jnz short loc_545D3
mov rdi, r15
mov rsi, r12
mov edx, 1
call unreg_request
add [rbp+var_60], rbx
add r13d, r14d
add [rbp+var_40], r13
xor r13d, r13d
mov ebx, 0
sub [rbp+var_2C], r14d
jnz loc_54427
jmp short loc_545E3
loc_5459D:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_544F6
loc_545B2:
mov rdi, rbx
lea rsi, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0C4Bh
call psi_mutex_lock
jmp loc_54532
loc_545CB:
xor ebx, ebx
jmp short loc_54612
loc_545CF:
xor ebx, ebx
jmp short loc_545E3
loc_545D3:
mov rdi, r15
mov rsi, r12
call free_block
mov ebx, 1
loc_545E3:
dec qword ptr [r15+70h]
mov r12, r15
jnz short loc_545F9
lea rdi, [r12+110h]
call release_whole_queue
loc_545F9:
mov r14, [rbp+var_38]
loc_545FD:
mov rdi, [r12+100h]
test rdi, rdi
jnz short loc_5463C
loc_5460A:
mov rdi, r14
call _pthread_mutex_unlock
loc_54612:
mov eax, ebx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_54623:
lea rsi, aWorkspaceLlm4b_21; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 0BE2h
call psi_mutex_lock
jmp loc_543E9
loc_5463C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_5460A
|
long long simple_key_cache_insert(
__m128i *a1,
unsigned int a2,
unsigned long long a3,
int a4,
long long a5,
unsigned int a6)
{
__m128i *v8; // r12
long long m128i_i64; // r14
unsigned int v10; // ebx
unsigned long long v11; // rcx
unsigned long long v12; // r13
unsigned long long v14; // rdx
unsigned int v15; // r14d
long long key_block; // rax
long long v17; // r12
long long v18; // rbx
unsigned int v19; // edx
long long v20; // rdi
long long v21; // rbx
bool v22; // zf
long long v24; // [rsp+10h] [rbp-60h]
int v25; // [rsp+24h] [rbp-4Ch] BYREF
int v26; // [rsp+28h] [rbp-48h]
unsigned int v27; // [rsp+2Ch] [rbp-44h]
unsigned long long v28; // [rsp+30h] [rbp-40h]
__m128i *v29; // [rsp+38h] [rbp-38h]
unsigned int v30; // [rsp+44h] [rbp-2Ch]
v30 = a6;
v26 = a4;
v27 = a2;
if ( a1->m128i_i8[0] )
{
v8 = a1;
m128i_i64 = (long long)a1[12].m128i_i64;
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(
(long long)a1[12].m128i_i64,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xBE2u);
else
pthread_mutex_lock(&a1[12]);
v10 = 0;
if ( a1->m128i_i8[3] && !a1->m128i_i8[1] )
{
v24 = a5;
v29 = a1 + 12;
++a1[7].m128i_i64[0];
v11 = a1[1].m128i_u32[2];
v28 = a3;
v12 = a3 % v11;
while ( 1 )
{
if ( !a1->m128i_i8[3] || a1->m128i_i8[1] )
{
v10 = 0;
goto LABEL_31;
}
v14 = v28 - (unsigned int)v12;
v15 = a1[1].m128i_i32[2] - v12;
if ( v30 < v15 )
v15 = v30;
a1[21] = _mm_sub_epi64(_mm_loadu_si128(a1 + 21), (__m128i)xmmword_97700);
v10 = 0;
v28 = v14;
key_block = find_key_block((unsigned long long)a1, v27, v14, v26, 0, &v25);
if ( !key_block )
goto LABEL_31;
v17 = key_block;
v18 = v15;
if ( (*(_BYTE *)(key_block + 80) & 1) == 0 )
{
if ( v25 == 1 )
{
v19 = a1[1].m128i_u32[2];
if ( (_DWORD)v12 || v15 < v19 )
{
read_block_primary((long long)a1, key_block, v19, v15 + v12);
}
else
{
v20 = a1[16].m128i_i64[0];
if ( v20 )
((void ( *)(long long))PSI_server[44])(v20);
v21 = (long long)v29;
pthread_mutex_unlock(v29);
memcpy(*(_QWORD *)(v17 + 64) + (unsigned int)v12, v24, v15);
if ( a1[16].m128i_i64[0] )
psi_mutex_lock(v21, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 0xC4Bu);
else
pthread_mutex_lock(v21);
*(_BYTE *)(v17 + 80) |= 2u;
*(_DWORD *)(v17 + 76) = v15;
release_whole_queue((long long *)(v17 + 40));
v18 = v15;
}
}
else if ( v25 == 2 )
{
wait_on_queue((long long *)(key_block + 40), (long long)v29);
}
}
remove_reader(v17);
if ( (*(_BYTE *)(v17 + 80) & 1) != 0 )
break;
unreg_request(a1, v17, 1LL);
v24 += v18;
v28 += v15 + (unsigned int)v12;
LODWORD(v12) = 0;
v10 = 0;
v30 -= v15;
if ( !v30 )
goto LABEL_31;
}
free_block((long long)a1, v17);
v10 = 1;
LABEL_31:
v22 = a1[7].m128i_i64[0]-- == 1;
v8 = a1;
if ( v22 )
release_whole_queue(a1[17].m128i_i64);
m128i_i64 = (long long)v29;
}
if ( v8[16].m128i_i64[0] )
PSI_server[44]();
pthread_mutex_unlock(m128i_i64);
}
else
{
return 0;
}
return v10;
}
|
simple_key_cache_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x2c],R9D
MOV dword ptr [RBP + -0x48],ECX
MOV dword ptr [RBP + -0x44],ESI
CMP byte ptr [RDI],0x0
JZ 0x001545cb
MOV R15,R8
MOV R13,RDX
MOV R12,RDI
LEA R14,[RDI + 0xc0]
CMP qword ptr [RDI + 0x100],0x0
JNZ 0x00154623
MOV RDI,R14
CALL 0x00128560
LAB_001543e9:
XOR EBX,EBX
CMP byte ptr [R12 + 0x3],0x0
JZ 0x001545fd
CMP byte ptr [R12 + 0x1],0x0
JNZ 0x001545fd
MOV qword ptr [RBP + -0x60],R15
MOV qword ptr [RBP + -0x38],R14
INC qword ptr [R12 + 0x70]
MOV ECX,dword ptr [R12 + 0x18]
MOV qword ptr [RBP + -0x40],R13
MOV RAX,R13
XOR EDX,EDX
DIV RCX
MOV R13,RDX
MOV R15,R12
LAB_00154427:
CMP byte ptr [R15 + 0x3],0x0
JZ 0x001545cf
CMP byte ptr [R15 + 0x1],0x0
JNZ 0x001545cf
MOV EAX,R13D
MOV RDX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x70],RAX
SUB RDX,RAX
MOV R14D,dword ptr [R15 + 0x18]
SUB R14D,R13D
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,R14D
CMOVC R14D,EAX
MOVDQU XMM0,xmmword ptr [R15 + 0x150]
PSUBQ XMM0,xmmword ptr [0x00197700]
MOVDQU xmmword ptr [R15 + 0x150],XMM0
XOR EBX,EBX
MOV RDI,R15
MOV ESI,dword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0x40],RDX
MOV ECX,dword ptr [RBP + -0x48]
XOR R8D,R8D
LEA R9,[RBP + -0x4c]
CALL 0x00152911
TEST RAX,RAX
JZ 0x001545e3
MOV R12,RAX
TEST byte ptr [RAX + 0x50],0x1
MOV EBX,R14D
JNZ 0x0015455e
MOV EAX,dword ptr [RBP + -0x4c]
CMP EAX,0x1
JZ 0x001544d0
CMP EAX,0x2
JNZ 0x0015455e
MOV RDI,R12
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00152880
JMP 0x0015455e
LAB_001544d0:
MOV EDX,dword ptr [R15 + 0x18]
TEST R13D,R13D
JNZ 0x0015454f
CMP R14D,EDX
JC 0x0015454f
MOV qword ptr [RBP + -0x58],RBX
MOV qword ptr [RBP + -0x68],R15
MOV RDI,qword ptr [R15 + 0x100]
TEST RDI,RDI
JNZ 0x0015459d
LAB_001544f6:
MOV RBX,qword ptr [RBP + -0x38]
MOV RDI,RBX
CALL 0x00128270
MOV RDI,qword ptr [RBP + -0x70]
ADD RDI,qword ptr [R12 + 0x40]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x001282c0
MOV RAX,qword ptr [RBP + -0x68]
CMP qword ptr [RAX + 0x100],0x0
JNZ 0x001545b2
MOV RDI,RBX
CALL 0x00128560
LAB_00154532:
OR byte ptr [R12 + 0x50],0x2
MOV dword ptr [R12 + 0x4c],R14D
MOV RDI,R12
ADD RDI,0x28
CALL 0x00153b35
MOV RBX,qword ptr [RBP + -0x58]
JMP 0x0015455e
LAB_0015454f:
LEA ECX,[R14 + R13*0x1]
MOV RDI,R15
MOV RSI,R12
CALL 0x00153112
LAB_0015455e:
MOV RDI,R12
CALL 0x001531e0
TEST byte ptr [R12 + 0x50],0x1
JNZ 0x001545d3
MOV RDI,R15
MOV RSI,R12
MOV EDX,0x1
CALL 0x00153228
ADD qword ptr [RBP + -0x60],RBX
ADD R13D,R14D
ADD qword ptr [RBP + -0x40],R13
XOR R13D,R13D
MOV EBX,0x0
SUB dword ptr [RBP + -0x2c],R14D
JNZ 0x00154427
JMP 0x001545e3
LAB_0015459d:
LEA RAX,[0x42fe50]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001544f6
LAB_001545b2:
MOV RDI,RBX
LEA RSI,[0x192aaf]
MOV EDX,0xc4b
CALL 0x00129edc
JMP 0x00154532
LAB_001545cb:
XOR EBX,EBX
JMP 0x00154612
LAB_001545cf:
XOR EBX,EBX
JMP 0x001545e3
LAB_001545d3:
MOV RDI,R15
MOV RSI,R12
CALL 0x00153330
MOV EBX,0x1
LAB_001545e3:
DEC qword ptr [R15 + 0x70]
MOV R12,R15
JNZ 0x001545f9
LEA RDI,[R12 + 0x110]
CALL 0x00153b35
LAB_001545f9:
MOV R14,qword ptr [RBP + -0x38]
LAB_001545fd:
MOV RDI,qword ptr [R12 + 0x100]
TEST RDI,RDI
JNZ 0x0015463c
LAB_0015460a:
MOV RDI,R14
CALL 0x00128270
LAB_00154612:
MOV EAX,EBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00154623:
LEA RSI,[0x192aaf]
MOV RDI,R14
MOV EDX,0xbe2
CALL 0x00129edc
JMP 0x001543e9
LAB_0015463c:
LEA RAX,[0x42fe50]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0015460a
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8
simple_key_cache_insert
(char *param_1,int4 param_2,ulong param_3,int4 param_4,void *param_5,
uint param_6)
{
long *plVar1;
uint uVar2;
ulong uVar3;
int8 uVar4;
int iVar5;
pthread_mutex_t *ppVar6;
long lVar7;
void *local_68;
int local_54;
int4 local_50;
int4 local_4c;
ulong local_48;
pthread_mutex_t *local_40;
uint local_34;
if (*param_1 == '\0') {
uVar4 = 0;
}
else {
ppVar6 = (pthread_mutex_t *)(param_1 + 0xc0);
local_50 = param_4;
local_4c = param_2;
local_34 = param_6;
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xbe2);
}
uVar4 = 0;
if ((param_1[3] != '\0') && (param_1[1] == '\0')) {
*(long *)(param_1 + 0x70) = *(long *)(param_1 + 0x70) + 1;
uVar3 = param_3 % (ulong)*(uint *)(param_1 + 0x18);
local_68 = param_5;
local_48 = param_3;
local_40 = ppVar6;
do {
if ((param_1[3] == '\0') || (param_1[1] != '\0')) {
uVar4 = 0;
break;
}
iVar5 = (int)uVar3;
local_48 = local_48 - uVar3;
uVar2 = *(int *)(param_1 + 0x18) - iVar5;
if (local_34 < (uint)(*(int *)(param_1 + 0x18) - iVar5)) {
uVar2 = local_34;
}
lVar7 = *(long *)(param_1 + 0x158) - _UNK_00197708;
*(long *)(param_1 + 0x150) = *(long *)(param_1 + 0x150) - _DAT_00197700;
*(long *)(param_1 + 0x158) = lVar7;
uVar4 = 0;
lVar7 = find_key_block(param_1,local_4c,local_48,local_50,0,&local_54);
if (lVar7 == 0) break;
if ((*(byte *)(lVar7 + 0x50) & 1) == 0) {
if (local_54 == 1) {
if ((iVar5 == 0) && (*(uint *)(param_1 + 0x18) <= uVar2)) {
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
ppVar6 = local_40;
pthread_mutex_unlock(local_40);
memcpy((void *)(uVar3 + *(long *)(lVar7 + 0x40)),local_68,(ulong)uVar2);
if (*(long *)(param_1 + 0x100) == 0) {
pthread_mutex_lock(ppVar6);
}
else {
psi_mutex_lock(ppVar6,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c"
,0xc4b);
}
*(byte *)(lVar7 + 0x50) = *(byte *)(lVar7 + 0x50) | 2;
*(uint *)(lVar7 + 0x4c) = uVar2;
release_whole_queue(lVar7 + 0x28);
}
else {
read_block_primary(param_1,lVar7,*(uint *)(param_1 + 0x18),uVar2 + iVar5);
}
}
else if (local_54 == 2) {
wait_on_queue(lVar7 + 0x28,local_40);
}
}
remove_reader(lVar7);
if ((*(byte *)(lVar7 + 0x50) & 1) != 0) {
free_block(param_1,lVar7);
uVar4 = 1;
break;
}
unreg_request(param_1,lVar7,1);
local_68 = (void *)((long)local_68 + (ulong)uVar2);
local_48 = local_48 + (iVar5 + uVar2);
uVar3 = 0;
uVar4 = 0;
local_34 = local_34 - uVar2;
} while (local_34 != 0);
plVar1 = (long *)(param_1 + 0x70);
*plVar1 = *plVar1 + -1;
ppVar6 = local_40;
if (*plVar1 == 0) {
release_whole_queue(param_1 + 0x110);
ppVar6 = local_40;
}
}
if (*(long *)(param_1 + 0x100) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(ppVar6);
}
return uVar4;
}
|
|
13,775
|
multi_alloc_root
|
eloqsql/mysys/my_alloc.c
|
void *multi_alloc_root(MEM_ROOT *root, ...)
{
va_list args;
char **ptr, *start, *res;
size_t tot_length, length;
DBUG_ENTER("multi_alloc_root");
/*
We don't need to do DBUG_PRINT here as it will be done when alloc_root
is called
*/
va_start(args, root);
tot_length= 0;
while ((ptr= va_arg(args, char **)))
{
length= va_arg(args, uint);
tot_length+= ALIGN_SIZE(length);
}
va_end(args);
if (!(start= (char*) alloc_root(root, tot_length)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args, root);
res= start;
while ((ptr= va_arg(args, char **)))
{
*ptr= res;
length= va_arg(args, uint);
res+= ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
}
|
O0
|
c
|
multi_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0x3b701
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x108(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x3b78f
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x3b7ac
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3b846
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x3b7ff
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x3b81c
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x3b754
leaq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3b410
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x3b870
jmp 0x3b863
movq $0x0, -0x8(%rbp)
jmp 0x3b9a5
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0x3b8d7
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0x3b8f4
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3b999
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x3b952
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0x3b96f
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3b89c
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
multi_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_3B701
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_3B701:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_108], rsi
mov [rbp+var_10], rdi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
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 [rbp+var_50], 0
loc_3B754:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_3B78F
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_3B7AC
loc_3B78F:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_3B7AC:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_3B846
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_3B7FF
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_3B81C
loc_3B7FF:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_3B81C:
mov rax, [rbp+var_140]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_3B754
loc_3B846:
lea rax, [rbp+var_30]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_50]
call alloc_root
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_3B870
jmp short $+2
loc_3B863:
mov [rbp+var_8], 0
jmp loc_3B9A5
loc_3B870:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
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, [rbp+var_40]
mov [rbp+var_48], rax
loc_3B89C:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_3B8D7
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_3B8F4
loc_3B8D7:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_3B8F4:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_3B999
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_3B952
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_3B96F
loc_3B952:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_3B96F:
mov rax, [rbp+var_170]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_3B89C
loc_3B999:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_3B9A5:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
|
char * multi_alloc_root(
_QWORD **a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char *v15; // rax
char *v16; // rax
char *v17; // rax
char *v18; // rax
char v20; // [rsp+60h] [rbp-110h] BYREF
long long v21; // [rsp+68h] [rbp-108h]
long long v22; // [rsp+70h] [rbp-100h]
long long v23; // [rsp+78h] [rbp-F8h]
long long v24; // [rsp+80h] [rbp-F0h]
long long v25; // [rsp+88h] [rbp-E8h]
__m128 v26; // [rsp+90h] [rbp-E0h]
__m128 v27; // [rsp+A0h] [rbp-D0h]
__m128 v28; // [rsp+B0h] [rbp-C0h]
__m128 v29; // [rsp+C0h] [rbp-B0h]
__m128 v30; // [rsp+D0h] [rbp-A0h]
__m128 v31; // [rsp+E0h] [rbp-90h]
__m128 v32; // [rsp+F0h] [rbp-80h]
__m128 v33; // [rsp+100h] [rbp-70h]
long long v34; // [rsp+118h] [rbp-58h]
long long i; // [rsp+120h] [rbp-50h]
char *j; // [rsp+128h] [rbp-48h]
char *v37; // [rsp+130h] [rbp-40h]
char **v38; // [rsp+138h] [rbp-38h]
int v39; // [rsp+140h] [rbp-30h]
int v40; // [rsp+144h] [rbp-2Ch]
char *v41; // [rsp+148h] [rbp-28h]
char *v42; // [rsp+150h] [rbp-20h]
_QWORD **v43; // [rsp+160h] [rbp-10h]
v26 = a7;
v27 = a8;
v28 = a9;
v29 = a10;
v30 = a11;
v31 = a12;
v32 = a13;
v33 = a14;
v25 = a6;
v24 = a5;
v23 = a4;
v22 = a3;
v21 = a2;
v43 = a1;
v42 = &v20;
v41 = &a15;
v40 = 48;
v39 = 8;
for ( i = 0LL; ; i += (v34 + 7) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( (unsigned int)v39 > 0x28 )
{
v15 = v41;
v41 += 8;
}
else
{
v15 = &v42[v39];
v39 += 8;
}
v38 = *(char ***)v15;
if ( !v38 )
break;
if ( (unsigned int)v39 > 0x28 )
{
v16 = v41;
v41 += 8;
}
else
{
v16 = &v42[v39];
v39 += 8;
}
v34 = *(unsigned int *)v16;
}
v37 = alloc_root(v43, i);
if ( !v37 )
return 0LL;
v42 = &v20;
v41 = &a15;
v40 = 48;
v39 = 8;
for ( j = v37; ; j += (v34 + 7) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( (unsigned int)v39 > 0x28 )
{
v17 = v41;
v41 += 8;
}
else
{
v17 = &v42[v39];
v39 += 8;
}
v38 = *(char ***)v17;
if ( !v38 )
break;
*v38 = j;
if ( (unsigned int)v39 > 0x28 )
{
v18 = v41;
v41 += 8;
}
else
{
v18 = &v42[v39];
v39 += 8;
}
v34 = *(unsigned int *)v18;
}
return v37;
}
|
multi_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x0013b701
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_0013b701:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV qword ptr [RBP + -0x108],RSI
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
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 qword ptr [RBP + -0x50],0x0
LAB_0013b754:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x0013b78f
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x0013b7ac
LAB_0013b78f:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_0013b7ac:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x0013b846
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x0013b7ff
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x0013b81c
LAB_0013b7ff:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_0013b81c:
MOV RAX,qword ptr [RBP + -0x140]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0013b754
LAB_0013b846:
LEA RAX,[RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x0013b410
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x0013b870
JMP 0x0013b863
LAB_0013b863:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0013b9a5
LAB_0013b870:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
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 [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_0013b89c:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x0013b8d7
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x0013b8f4
LAB_0013b8d7:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_0013b8f4:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x0013b999
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x0013b952
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x0013b96f
LAB_0013b952:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_0013b96f:
MOV RAX,qword ptr [RBP + -0x170]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0013b89c
LAB_0013b999:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013b9a5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long multi_alloc_root(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
uint *local_178;
uint *local_160;
uint *local_148;
uint *local_130;
uint local_118 [2];
int8 local_110;
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
ulong local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
uint *local_30;
uint *local_28;
int8 local_18;
long local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (uint *)&stack0x00000008;
local_34 = 0x30;
local_38 = 8;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 2;
}
local_40 = *(long *)local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 2;
}
local_60 = (ulong)*local_148;
local_58 = (local_60 + 7 & 0xfffffffffffffff8) + local_58;
}
local_110 = param_10;
local_108 = param_11;
local_100 = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_18 = param_9;
local_10 = alloc_root(param_9,local_58);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (uint *)&stack0x00000008;
local_38 = 8;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 2;
}
if (*(long **)local_160 == (long *)0x0) break;
**(long **)local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 2;
}
local_50 = ((ulong)*local_178 + 7 & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
|
|
13,776
|
mbedtls_ctr_drbg_random_with_add
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/ctr_drbg.c
|
int mbedtls_ctr_drbg_random_with_add(void *p_rng,
unsigned char *output, size_t output_len,
const unsigned char *additional, size_t add_len)
{
int ret = 0;
mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng;
unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = output;
unsigned char tmp[MBEDTLS_CTR_DRBG_BLOCKSIZE];
int i;
size_t use_len;
if (output_len > MBEDTLS_CTR_DRBG_MAX_REQUEST) {
return MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG;
}
if (add_len > MBEDTLS_CTR_DRBG_MAX_INPUT) {
return MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG;
}
memset(add_input, 0, MBEDTLS_CTR_DRBG_SEEDLEN);
if (ctx->reseed_counter > ctx->reseed_interval ||
ctx->prediction_resistance) {
if ((ret = mbedtls_ctr_drbg_reseed(ctx, additional, add_len)) != 0) {
return ret;
}
add_len = 0;
}
if (add_len > 0) {
if ((ret = block_cipher_df(add_input, additional, add_len)) != 0) {
goto exit;
}
if ((ret = ctr_drbg_update_internal(ctx, add_input)) != 0) {
goto exit;
}
}
while (output_len > 0) {
/*
* Increase counter
*/
for (i = MBEDTLS_CTR_DRBG_BLOCKSIZE; i > 0; i--) {
if (++ctx->counter[i - 1] != 0) {
break;
}
}
/*
* Crypt counter block
*/
if ((ret = mbedtls_aes_crypt_ecb(&ctx->aes_ctx, MBEDTLS_AES_ENCRYPT,
ctx->counter, tmp)) != 0) {
goto exit;
}
use_len = (output_len > MBEDTLS_CTR_DRBG_BLOCKSIZE)
? MBEDTLS_CTR_DRBG_BLOCKSIZE : output_len;
/*
* Copy random block to destination
*/
memcpy(p, tmp, use_len);
p += use_len;
output_len -= use_len;
}
if ((ret = ctr_drbg_update_internal(ctx, add_input)) != 0) {
goto exit;
}
ctx->reseed_counter++;
exit:
mbedtls_platform_zeroize(add_input, sizeof(add_input));
mbedtls_platform_zeroize(tmp, sizeof(tmp));
return ret;
}
|
O3
|
c
|
mbedtls_ctr_drbg_random_with_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0xffffffca, %ebp # imm = 0xFFFFFFCA
cmpq $0x400, %rdx # imm = 0x400
ja 0x832a3
movl $0xffffffc8, %ebp # imm = 0xFFFFFFC8
cmpq $0x100, %r8 # imm = 0x100
ja 0x832a3
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl 0x10(%rdi), %eax
cmpl 0x20(%rdi), %eax
jg 0x831cf
cmpl $0x0, 0x14(%rbx)
je 0x8325b
movq %rbx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
xorl %ecx, %ecx
callq 0x82fb9
movl %eax, %ebp
testl %eax, %eax
jne 0x832a3
testq %r14, %r14
je 0x83245
leaq 0x28(%rbx), %r12
leaq 0x30(%rsp), %r13
movl $0xf, %eax
cmpq $-0x1, %rax
je 0x8320b
incb (%rbx,%rax)
leaq -0x1(%rax), %rax
je 0x831fc
movq %r12, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x7c8d5
testl %eax, %eax
jne 0x83285
cmpq $0x10, %r14
movl $0x10, %ebp
cmovbq %r14, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xf3a0
addq %rbp, %r15
subq %rbp, %r14
jne 0x831f7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82edd
testl %eax, %eax
jne 0x83285
incl 0x10(%rbx)
xorl %ebp, %ebp
jmp 0x83287
testq %r8, %r8
je 0x831e9
movq %rsp, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x82ca1
testl %eax, %eax
jne 0x83285
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82edd
testl %eax, %eax
je 0x831e9
movl %eax, %ebp
movq %rsp, %rdi
movl $0x30, %esi
callq 0x8db8c
leaq 0x30(%rsp), %rdi
movl $0x10, %esi
callq 0x8db8c
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
mbedtls_ctr_drbg_random_with_add:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebp, 0FFFFFFCAh
cmp rdx, 400h
ja loc_832A3
mov ebp, 0FFFFFFC8h
cmp r8, 100h
ja loc_832A3
mov r14, rdx
mov r15, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+78h+var_58], xmm0
movaps [rsp+78h+var_68], xmm0
movaps [rsp+78h+var_78], xmm0
mov eax, [rdi+10h]
cmp eax, [rdi+20h]
jg short loc_831CF
cmp dword ptr [rbx+14h], 0
jz loc_8325B
loc_831CF:
mov rdi, rbx
mov rsi, rcx
mov rdx, r8
xor ecx, ecx
call mbedtls_ctr_drbg_reseed_internal
mov ebp, eax
test eax, eax
jnz loc_832A3
loc_831E9:
test r14, r14
jz short loc_83245
lea r12, [rbx+28h]
lea r13, [rsp+78h+var_48]
loc_831F7:
mov eax, 0Fh
loc_831FC:
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_8320B
inc byte ptr [rbx+rax]
lea rax, [rax-1]
jz short loc_831FC
loc_8320B:
mov rdi, r12
mov esi, 1
mov rdx, rbx
mov rcx, r13
call mbedtls_aes_crypt_ecb
test eax, eax
jnz short loc_83285
cmp r14, 10h
mov ebp, 10h
cmovb rbp, r14
mov rdi, r15
mov rsi, r13
mov rdx, rbp
call _memcpy
add r15, rbp
sub r14, rbp
jnz short loc_831F7
loc_83245:
mov rsi, rsp
mov rdi, rbx
call ctr_drbg_update_internal
test eax, eax
jnz short loc_83285
inc dword ptr [rbx+10h]
xor ebp, ebp
jmp short loc_83287
loc_8325B:
test r8, r8
jz short loc_831E9
mov rdi, rsp
mov rsi, rcx
mov rdx, r8
call block_cipher_df
test eax, eax
jnz short loc_83285
mov rsi, rsp
mov rdi, rbx
call ctr_drbg_update_internal
test eax, eax
jz loc_831E9
loc_83285:
mov ebp, eax
loc_83287:
mov rdi, rsp
mov esi, 30h ; '0'
call mbedtls_platform_zeroize
lea rdi, [rsp+78h+var_48]
mov esi, 10h
call mbedtls_platform_zeroize
loc_832A3:
mov eax, ebp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long mbedtls_ctr_drbg_random_with_add(
_DWORD *a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5)
{
unsigned int v5; // ebp
unsigned long long v6; // r14
long long v8; // rax
unsigned int updated; // eax
long long v11; // rbp
_OWORD v13[3]; // [rsp+0h] [rbp-78h] BYREF
_BYTE v14[72]; // [rsp+30h] [rbp-48h] BYREF
v5 = -54;
if ( a3 <= 0x400 )
{
v5 = -56;
if ( a5 <= 0x100 )
{
v6 = a3;
memset(v13, 0, sizeof(v13));
if ( a1[4] <= a1[8] && !a1[5] )
{
if ( a5 )
{
updated = block_cipher_df(v13, a4, a5);
if ( updated )
goto LABEL_19;
updated = ctr_drbg_update_internal(a1, (long long)v13);
if ( updated )
goto LABEL_19;
}
goto LABEL_6;
}
v5 = mbedtls_ctr_drbg_reseed_internal((long long)a1, a4, a5, 0LL);
if ( !v5 )
{
LABEL_6:
if ( v6 )
{
while ( 1 )
{
v8 = 15LL;
do
{
if ( v8 == -1 )
break;
}
while ( (*((_BYTE *)a1 + v8--))++ == 0xFF );
updated = mbedtls_aes_crypt_ecb((long long)(a1 + 10), 1u, a1, v14);
if ( updated )
break;
v11 = 16LL;
if ( v6 < 0x10 )
v11 = v6;
memcpy(a2, v14, v11);
a2 += v11;
v6 -= v11;
if ( !v6 )
goto LABEL_14;
}
}
else
{
LABEL_14:
updated = ctr_drbg_update_internal(a1, (long long)v13);
if ( !updated )
{
++a1[4];
v5 = 0;
LABEL_20:
mbedtls_platform_zeroize(v13, 48LL);
mbedtls_platform_zeroize(v14, 16LL);
return v5;
}
}
LABEL_19:
v5 = updated;
goto LABEL_20;
}
}
}
return v5;
}
|
mbedtls_ctr_drbg_random_with_add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBP,0xffffffca
CMP RDX,0x400
JA 0x001832a3
MOV EBP,0xffffffc8
CMP R8,0x100
JA 0x001832a3
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV EAX,dword ptr [RDI + 0x10]
CMP EAX,dword ptr [RDI + 0x20]
JG 0x001831cf
CMP dword ptr [RBX + 0x14],0x0
JZ 0x0018325b
LAB_001831cf:
MOV RDI,RBX
MOV RSI,RCX
MOV RDX,R8
XOR ECX,ECX
CALL 0x00182fb9
MOV EBP,EAX
TEST EAX,EAX
JNZ 0x001832a3
LAB_001831e9:
TEST R14,R14
JZ 0x00183245
LEA R12,[RBX + 0x28]
LEA R13,[RSP + 0x30]
LAB_001831f7:
MOV EAX,0xf
LAB_001831fc:
CMP RAX,-0x1
JZ 0x0018320b
INC byte ptr [RBX + RAX*0x1]
LEA RAX,[RAX + -0x1]
JZ 0x001831fc
LAB_0018320b:
MOV RDI,R12
MOV ESI,0x1
MOV RDX,RBX
MOV RCX,R13
CALL 0x0017c8d5
TEST EAX,EAX
JNZ 0x00183285
CMP R14,0x10
MOV EBP,0x10
CMOVC RBP,R14
MOV RDI,R15
MOV RSI,R13
MOV RDX,RBP
CALL 0x0010f3a0
ADD R15,RBP
SUB R14,RBP
JNZ 0x001831f7
LAB_00183245:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00182edd
TEST EAX,EAX
JNZ 0x00183285
INC dword ptr [RBX + 0x10]
XOR EBP,EBP
JMP 0x00183287
LAB_0018325b:
TEST R8,R8
JZ 0x001831e9
MOV RDI,RSP
MOV RSI,RCX
MOV RDX,R8
CALL 0x00182ca1
TEST EAX,EAX
JNZ 0x00183285
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00182edd
TEST EAX,EAX
JZ 0x001831e9
LAB_00183285:
MOV EBP,EAX
LAB_00183287:
MOV RDI,RSP
MOV ESI,0x30
CALL 0x0018db8c
LEA RDI,[RSP + 0x30]
MOV ESI,0x10
CALL 0x0018db8c
LAB_001832a3:
MOV EAX,EBP
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int mbedtls_ctr_drbg_random_with_add
(long param_1,void *param_2,ulong param_3,int8 param_4,ulong param_5)
{
char *pcVar1;
int iVar2;
long lVar3;
size_t __n;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int1 local_48 [24];
if (0x400 < param_3) {
return -0x36;
}
if (0x100 < param_5) {
return -0x38;
}
local_58 = 0;
uStack_50 = 0;
local_68 = 0;
uStack_60 = 0;
local_78 = 0;
uStack_70 = 0;
if ((*(int *)(param_1 + 0x20) < *(int *)(param_1 + 0x10)) || (*(int *)(param_1 + 0x14) != 0)) {
iVar2 = mbedtls_ctr_drbg_reseed_internal(param_1,param_4,param_5,0);
if (iVar2 != 0) {
return iVar2;
}
}
else if ((param_5 != 0) &&
((iVar2 = block_cipher_df(&local_78,param_4,param_5), iVar2 != 0 ||
(iVar2 = ctr_drbg_update_internal(param_1,&local_78), iVar2 != 0)))) goto LAB_00183287;
if (param_3 != 0) {
do {
lVar3 = 0xf;
do {
if (lVar3 == -1) break;
pcVar1 = (char *)(param_1 + lVar3);
*pcVar1 = *pcVar1 + '\x01';
lVar3 = lVar3 + -1;
} while (*pcVar1 == '\0');
iVar2 = mbedtls_aes_crypt_ecb(param_1 + 0x28,1,param_1,local_48);
if (iVar2 != 0) goto LAB_00183287;
__n = 0x10;
if (param_3 < 0x10) {
__n = param_3;
}
memcpy(param_2,local_48,__n);
param_2 = (void *)((long)param_2 + __n);
param_3 = param_3 - __n;
} while (param_3 != 0);
}
iVar2 = ctr_drbg_update_internal(param_1,&local_78);
if (iVar2 == 0) {
*(int *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) + 1;
iVar2 = 0;
}
LAB_00183287:
mbedtls_platform_zeroize(&local_78,0x30);
mbedtls_platform_zeroize(local_48,0x10);
return iVar2;
}
|
|
13,777
|
coro::detail::when_all_task_promise<unsigned long&&>::unhandled_exception()
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/when_all.hpp
|
auto unhandled_exception() noexcept { m_exception_ptr = std::current_exception(); }
|
O3
|
cpp
|
coro::detail::when_all_task_promise<unsigned long&&>::unhandled_exception():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17450
movq (%r14), %rax
movq $0x0, (%r14)
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rbx)
testq %rcx, %rcx
je 0x44ddf
leaq 0x10(%rsp), %rdi
callq 0x17260
cmpq $0x0, 0x8(%rsp)
je 0x44ddf
leaq 0x8(%rsp), %rdi
callq 0x17260
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN4coro6detail21when_all_task_promiseIOmE19unhandled_exceptionEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lea r14, [rsp+28h+var_20]
mov rdi, r14
call __ZSt17current_exceptionv; std::current_exception(void)
mov rax, [r14]
mov qword ptr [r14], 0
mov rcx, [rbx+8]
mov [rsp+28h+var_18], rcx
mov [rbx+8], rax
test rcx, rcx
jz short loc_44DDF
lea rdi, [rsp+28h+var_18]; this
call __ZNSt15__exception_ptr13exception_ptr10_M_releaseEv; std::__exception_ptr::exception_ptr::_M_release(void)
cmp [rsp+28h+var_20], 0
jz short loc_44DDF
lea rdi, [rsp+28h+var_20]; this
call __ZNSt15__exception_ptr13exception_ptr10_M_releaseEv; std::__exception_ptr::exception_ptr::_M_release(void)
loc_44DDF:
add rsp, 18h
pop rbx
pop r14
retn
|
long long coro::detail::when_all_task_promise<unsigned long &&>::unhandled_exception(long long a1)
{
long long result; // rax
long long v2; // rcx
long long v3; // [rsp+8h] [rbp-20h] BYREF
_QWORD v4[3]; // [rsp+10h] [rbp-18h] BYREF
std::current_exception();
result = v3;
v3 = 0LL;
v4[0] = *(_QWORD *)(a1 + 8);
v2 = v4[0];
*(_QWORD *)(a1 + 8) = result;
if ( v2 )
{
result = std::__exception_ptr::exception_ptr::_M_release((std::__exception_ptr::exception_ptr *)v4);
if ( v3 )
return std::__exception_ptr::exception_ptr::_M_release((std::__exception_ptr::exception_ptr *)&v3);
}
return result;
}
|
unhandled_exception:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00117450
MOV RAX,qword ptr [R14]
MOV qword ptr [R14],0x0
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RBX + 0x8],RAX
TEST RCX,RCX
JZ 0x00144ddf
LEA RDI,[RSP + 0x10]
CALL 0x00117260
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00144ddf
LEA RDI,[RSP + 0x8]
CALL 0x00117260
LAB_00144ddf:
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* WARNING: Removing unreachable block (ram,0x00144dd5) */
/* coro::detail::when_all_task_promise<unsigned long&&>::unhandled_exception() */
void __thiscall
coro::detail::when_all_task_promise<unsigned_long&&>::unhandled_exception
(when_all_task_promise<unsigned_long&&> *this)
{
long lVar1;
int8 local_20;
std::current_exception();
lVar1 = *(long *)(this + 8);
*(int8 *)(this + 8) = local_20;
if (lVar1 != 0) {
std::__exception_ptr::exception_ptr::_M_release();
}
return;
}
|
|
13,778
|
inline_mysql_rwlock_unlock
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_rwlock_unlock(
mysql_rwlock_t *that)
{
int result;
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_RWLOCK_CALL(unlock_rwlock)(that->m_psi);
#endif
result= rw_unlock(&that->m_rwlock);
return result;
}
|
O0
|
c
|
inline_mysql_rwlock_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa26d1
leaq 0x21eb7e(%rip), %rax # 0x2c1238
movq (%rax), %rax
movq 0x168(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0xfb000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
inline_mysql_rwlock_unlock_4:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 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_A26D1
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+168h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+90h]
call rax
loc_A26D1:
mov rdi, [rbp+var_8]
call my_rw_unlock
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long inline_mysql_rwlock_unlock_4(long long a1)
{
if ( *(_QWORD *)(a1 + 144) )
((void ( *)(_QWORD))PSI_server[45])(*(_QWORD *)(a1 + 144));
return (unsigned int)my_rw_unlock(a1);
}
|
inline_mysql_rwlock_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],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 0x001a26d1
LEA RAX,[0x3c1238]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x168]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x90]
CALL RAX
LAB_001a26d1:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fb000
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int4 inline_mysql_rwlock_unlock(long param_1)
{
int4 uVar1;
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x168))(*(int8 *)(param_1 + 0x90));
}
uVar1 = my_rw_unlock(param_1);
return uVar1;
}
|
|
13,779
|
uf_endspace
|
eloqsql/storage/maria/ma_packrec.c
|
static void uf_endspace(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill(end - spaces, spaces, ' ');
}
|
O3
|
c
|
uf_endspace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movl 0x4(%rsi), %ecx
movl 0x24(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x3afcd
subl %ecx, %r13d
leaq 0xa61a2(%rip), %rax # 0xe1130
movl (%rax,%rcx,4), %r14d
andl (%r15), %r14d
movl %r13d, %ecx
shll %cl, %r14d
movq %rdi, -0x30(%rbp)
movq %r15, %rdi
movq %rdx, %r12
callq 0x3a7b0
movq -0x30(%rbp), %rdi
movq %r12, %rdx
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %r14d, %eax
jmp 0x3afe6
movl (%r15), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r15)
shrl %cl, %eax
movl 0x24(%rdi), %ecx
leaq 0xa614d(%rip), %rsi # 0xe1130
andl (%rsi,%rcx,4), %eax
movl %eax, %r13d
leaq (%rdx,%r13), %rax
cmpq %rbx, %rax
jbe 0x3b009
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
negq %r14
cmpq %rbx, %rax
je 0x3b020
leaq (%rbx,%r14), %rcx
movq %r15, %rsi
callq 0x3a96d
addq %r14, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
|
uf_endspace:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rsi
mov ecx, [rsi+4]
mov r13d, [rdi+24h]
cmp ecx, r13d
jnb short loc_3AFCD
sub r13d, ecx
lea rax, mask
mov r14d, [rax+rcx*4]
and r14d, [r15]
mov ecx, r13d
shl r14d, cl
mov [rbp+var_30], rdi
mov rdi, r15
mov r12, rdx
call fill_buffer
mov rdi, [rbp+var_30]
mov rdx, r12
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, r14d
jmp short loc_3AFE6
loc_3AFCD:
mov eax, [r15]
sub ecx, r13d
mov [r15+4], ecx
shr eax, cl
mov ecx, [rdi+24h]
lea rsi, mask
and eax, [rsi+rcx*4]
loc_3AFE6:
mov r13d, eax
lea rax, [rdx+r13]
cmp rax, rbx
jbe short loc_3B009
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3B009:
mov r14, r13
neg r14
cmp rax, rbx
jz short loc_3B020
lea rcx, [rbx+r14]
mov rsi, r15
call decode_bytes
loc_3B020:
add rbx, r14
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
|
unsigned long long uf_endspace(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
long long v5; // rcx
unsigned int v6; // r13d
int v7; // r13d
int v8; // r14d
_BYTE *v9; // r12
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // ecx
long long v13; // r13
unsigned long long result; // rax
v5 = a2[1];
v6 = *(_DWORD *)(a1 + 36);
if ( (unsigned int)v5 >= v6 )
{
v11 = *a2;
v12 = v5 - v6;
a2[1] = v12;
v10 = mask[*(unsigned int *)(a1 + 36)] & (v11 >> v12);
}
else
{
v7 = v6 - v5;
v8 = (*a2 & mask[v5]) << v7;
v9 = a3;
fill_buffer((long long)a2);
a3 = v9;
a2[1] = 32 - v7;
v10 = v8 + (*a2 >> -(char)v7);
}
v13 = v10;
result = (unsigned long long)&a3[v10];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes(a1, (long long)a2, a3, (_BYTE *)(a4 - v13));
return memset(a4 - v13, 32LL, v13);
}
else
{
a2[10] = 1;
}
return result;
}
|
uf_endspace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RSI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x24]
CMP ECX,R13D
JNC 0x0013afcd
SUB R13D,ECX
LEA RAX,[0x1e1130]
MOV R14D,dword ptr [RAX + RCX*0x4]
AND R14D,dword ptr [R15]
MOV ECX,R13D
SHL R14D,CL
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,R15
MOV R12,RDX
CALL 0x0013a7b0
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,R12
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,R14D
JMP 0x0013afe6
LAB_0013afcd:
MOV EAX,dword ptr [R15]
SUB ECX,R13D
MOV dword ptr [R15 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [RDI + 0x24]
LEA RSI,[0x1e1130]
AND EAX,dword ptr [RSI + RCX*0x4]
LAB_0013afe6:
MOV R13D,EAX
LEA RAX,[RDX + R13*0x1]
CMP RAX,RBX
JBE 0x0013b009
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013b009:
MOV R14,R13
NEG R14
CMP RAX,RBX
JZ 0x0013b020
LEA RCX,[RBX + R14*0x1]
MOV RSI,R15
CALL 0x0013a96d
LAB_0013b020:
ADD RBX,R14
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
ulong __n;
uVar4 = param_2[1];
uVar1 = *(uint *)(param_1 + 0x24);
if (uVar4 < uVar1) {
uVar2 = (&mask)[uVar4];
uVar3 = *param_2;
bVar5 = (byte)(uVar1 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar4);
uVar4 = (*param_2 >> (-bVar5 & 0x1f)) + ((uVar2 & uVar3) << (bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar1;
uVar4 = *param_2 >> ((byte)(uVar4 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
__n = (ulong)uVar4;
if (param_4 < param_3 + __n) {
param_2[10] = 1;
return;
}
if (param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
memset((void *)(param_4 + -__n),0x20,__n);
return;
}
|
|
13,780
|
my_printv_error
|
eloqsql/mysys/my_error.c
|
void my_printv_error(uint error, const char *format, myf MyFlags, va_list ap)
{
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printv_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
(void) my_vsnprintf(ebuff, sizeof(ebuff), format, ap);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_printv_error:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
movq %rcx, -0x230(%rbp)
jmp 0xf41f5
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rdx
movq -0x230(%rbp), %rcx
movl $0x200, %esi # imm = 0x200
callq 0x156390
leaq 0x1d6da5(%rip), %rax # 0x2cafc0
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq *%rax
jmp 0xf4236
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xf4251
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
my_printv_error:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
mov [rbp+var_230], rcx
jmp short $+2
loc_F41F5:
lea rdi, [rbp+var_210]
mov rdx, [rbp+var_220]
mov rcx, [rbp+var_230]
mov esi, 200h
call my_vsnprintf
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_228]
call rax
jmp short $+2
loc_F4236:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_F4251
add rsp, 230h
pop rbp
retn
loc_F4251:
call ___stack_chk_fail
|
unsigned long long my_printv_error(long long a1, long long a2, long long a3, long long a4)
{
_BYTE v5[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v6; // [rsp+228h] [rbp-8h]
v6 = __readfsqword(0x28u);
my_vsnprintf(v5, 512LL, a2, a4);
error_handler_hook();
return __readfsqword(0x28u);
}
|
my_printv_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
MOV qword ptr [RBP + -0x230],RCX
JMP 0x001f41f5
LAB_001f41f5:
LEA RDI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
MOV ESI,0x200
CALL 0x00256390
LEA RAX,[0x3cafc0]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x228]
CALL RAX
JMP 0x001f4236
LAB_001f4236:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001f4251
ADD RSP,0x230
POP RBP
RET
LAB_001f4251:
CALL 0x0012a270
|
void my_printv_error(int4 param_1,int8 param_2,int8 param_3,int8 param_4)
{
long in_FS_OFFSET;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
my_vsnprintf(local_218,0x200,param_2,param_4);
(*(code *)error_handler_hook)(param_1,local_218,param_3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
13,781
|
Execute_load_log_event::do_apply_event(rpl_group_info*)
|
eloqsql/sql/log_event_server.cc
|
int Execute_load_log_event::do_apply_event(rpl_group_info *rgi)
{
char fname[FN_REFLEN+10];
char *ext;
int fd;
int error= 1;
IO_CACHE file;
Load_log_event *lev= 0;
Relay_log_info const *rli= rgi->rli;
ext= slave_load_file_stem(fname, file_id, server_id, ".info",
&rli->mi->cmp_connection_name);
if ((fd= mysql_file_open(key_file_log_event_info,
fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
MYF(MY_WME))) < 0 ||
init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
MYF(MY_WME|MY_NABP)))
{
rli->report(ERROR_LEVEL, my_errno, rgi->gtid_info(),
"Error in Exec_load event: could not open file '%s'",
fname);
goto err;
}
if (!(lev= (Load_log_event*)
Log_event::read_log_event(&file,
rli->relay_log.description_event_for_exec,
opt_slave_sql_verify_checksum)) ||
lev->get_type_code() != NEW_LOAD_EVENT)
{
rli->report(ERROR_LEVEL, 0, rgi->gtid_info(), "Error in Exec_load event: "
"file '%s' appears corrupted", fname);
goto err;
}
lev->thd = thd;
/*
lev->do_apply_event should use rli only for errors i.e. should
not advance rli's position.
lev->do_apply_event is the place where the table is loaded (it
calls mysql_load()).
*/
if (lev->do_apply_event(0,rgi,1))
{
/*
We want to indicate the name of the file that could not be loaded
(SQL_LOADxxx).
But as we are here we are sure the error is in rli->last_slave_error and
rli->last_slave_errno (example of error: duplicate entry for key), so we
don't want to overwrite it with the filename.
What we want instead is add the filename to the current error message.
*/
char *tmp= my_strdup(PSI_INSTRUMENT_ME, rli->last_error().message, MYF(MY_WME));
if (tmp)
{
rli->report(ERROR_LEVEL, rli->last_error().number, rgi->gtid_info(),
"%s. Failed executing load from '%s'", tmp, fname);
my_free(tmp);
}
goto err;
}
/*
We have an open file descriptor to the .info file; we need to close it
or Windows will refuse to delete the file in mysql_file_delete().
*/
if (fd >= 0)
{
mysql_file_close(fd, MYF(0));
end_io_cache(&file);
fd= -1;
}
mysql_file_delete(key_file_log_event_info, fname, MYF(MY_WME));
memcpy(ext, ".data", 6);
mysql_file_delete(key_file_log_event_data, fname, MYF(MY_WME));
error = 0;
err:
delete lev;
if (fd >= 0)
{
mysql_file_close(fd, MYF(0));
end_io_cache(&file);
}
return error;
}
|
O0
|
cpp
|
Execute_load_log_event::do_apply_event(rpl_group_info*):
pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x228(%rbp)
movq %rsi, -0x230(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x368(%rbp)
movl $0x1, -0x240(%rbp)
movq $0x0, -0x350(%rbp)
movq -0x230(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x358(%rbp)
leaq -0x220(%rbp), %rdi
movl 0x6c(%rax), %esi
movl 0x40(%rax), %edx
movq -0x358(%rbp), %rax
movq 0x1c58(%rax), %r8
addq $0xba8, %r8 # imm = 0xBA8
leaq 0x628958(%rip), %rcx # 0x138ae8c
callq 0xd61570
movq %rax, -0x238(%rbp)
leaq 0xf68ccd(%rip), %rax # 0x1ccb214
movl (%rax), %edi
leaq -0x220(%rbp), %rcx
leaq 0x6776a5(%rip), %rsi # 0x13d9bfc
movl $0x1347, %edx # imm = 0x1347
movl $0x20000, %r8d # imm = 0x20000
movl $0x10, %r9d
callq 0xd61f80
movl %eax, -0x23c(%rbp)
cmpl $0x0, %eax
jl 0xd625a9
movl -0x23c(%rbp), %esi
leaq -0x348(%rbp), %rdi
movl $0x1000, %edx # imm = 0x1000
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movq $0x14, (%rsp)
callq 0x12ac7f0
cmpl $0x0, %eax
je 0xd625fc
movq -0x358(%rbp), %rax
movq %rax, -0x378(%rbp)
callq 0x12ca030
movl (%rax), %eax
movl %eax, -0x36c(%rbp)
movq -0x230(%rbp), %rdi
callq 0xa4a910
movq -0x378(%rbp), %rdi
movl -0x36c(%rbp), %edx
movq %rax, %rcx
leaq -0x220(%rbp), %r9
xorl %esi, %esi
leaq 0x677f74(%rip), %r8 # 0x13da564
movb $0x0, %al
callq 0xd6fc10
jmp 0xd62809
movq -0x358(%rbp), %rax
movq 0x12a8(%rax), %rsi
leaq -0x348(%rbp), %rdi
leaq 0xd62a9c(%rip), %rax # 0x1ac50b4
movsbl (%rax), %edx
callq 0xd47ca0
movq %rax, -0x350(%rbp)
cmpq $0x0, %rax
je 0xd6263f
movq -0x350(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0xc, %eax
je 0xd62681
movq -0x358(%rbp), %rax
movq %rax, -0x380(%rbp)
movq -0x230(%rbp), %rdi
callq 0xa4a910
movq -0x380(%rbp), %rdi
movq %rax, %rcx
leaq -0x220(%rbp), %r9
xorl %edx, %edx
leaq 0x677f24(%rip), %r8 # 0x13da597
movl %edx, %esi
movb $0x0, %al
callq 0xd6fc10
jmp 0xd62809
movq -0x368(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x350(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x350(%rbp), %rdi
movq -0x230(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0xd5afe0
cmpl $0x0, %eax
je 0xd6275d
movq -0x358(%rbp), %rdi
callq 0x8118a0
movq %rax, %rsi
addq $0x4, %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0x12c7620
movq %rax, -0x360(%rbp)
cmpq $0x0, -0x360(%rbp)
je 0xd62758
movq -0x358(%rbp), %rax
movq %rax, -0x390(%rbp)
movq -0x358(%rbp), %rdi
callq 0x8118a0
movl (%rax), %eax
movl %eax, -0x384(%rbp)
movq -0x230(%rbp), %rdi
callq 0xa4a910
movq -0x390(%rbp), %rdi
movl -0x384(%rbp), %edx
movq %rax, %rcx
movq -0x360(%rbp), %r9
leaq -0x220(%rbp), %rax
xorl %esi, %esi
leaq 0x677e8c(%rip), %r8 # 0x13da5cd
movq %rax, (%rsp)
movb $0x0, %al
callq 0xd6fc10
movq -0x360(%rbp), %rdi
callq 0x12c7520
jmp 0xd62809
cmpl $0x0, -0x23c(%rbp)
jl 0xd62797
movl -0x23c(%rbp), %edx
leaq 0x677489(%rip), %rdi # 0x13d9bfc
movl $0x137c, %esi # imm = 0x137C
xorl %eax, %eax
movl %eax, %ecx
callq 0xd617e0
leaq -0x348(%rbp), %rdi
callq 0x12ae480
movl $0xffffffff, -0x23c(%rbp) # imm = 0xFFFFFFFF
leaq 0xf68a76(%rip), %rax # 0x1ccb214
movl (%rax), %edi
leaq -0x220(%rbp), %rcx
leaq 0x67744e(%rip), %rsi # 0x13d9bfc
movl $0x1380, %edx # imm = 0x1380
movl $0x10, %r8d
callq 0xd61630
movq -0x238(%rbp), %rax
movl 0x6cc64b(%rip), %ecx # 0x142ee16
movl %ecx, (%rax)
movw 0x6cc646(%rip), %cx # 0x142ee1a
movw %cx, 0x4(%rax)
leaq 0xf68a31(%rip), %rax # 0x1ccb210
movl (%rax), %edi
leaq -0x220(%rbp), %rcx
leaq 0x67740d(%rip), %rsi # 0x13d9bfc
movl $0x1382, %edx # imm = 0x1382
movl $0x10, %r8d
callq 0xd61630
movl $0x0, -0x240(%rbp)
movq -0x350(%rbp), %rax
movq %rax, -0x398(%rbp)
cmpq $0x0, %rax
je 0xd6282a
movq -0x398(%rbp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
cmpl $0x0, -0x23c(%rbp)
jl 0xd6285a
movl -0x23c(%rbp), %edx
leaq 0x6773bc(%rip), %rdi # 0x13d9bfc
movl $0x1389, %esi # imm = 0x1389
xorl %eax, %eax
movl %eax, %ecx
callq 0xd617e0
leaq -0x348(%rbp), %rdi
callq 0x12ae480
movl -0x240(%rbp), %eax
movl %eax, -0x39c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xd62887
movl -0x39c(%rbp), %eax
addq $0x3b0, %rsp # imm = 0x3B0
popq %rbp
retq
callq 0x758480
nopl (%rax)
|
_ZN22Execute_load_log_event14do_apply_eventEP14rpl_group_info:
push rbp
mov rbp, rsp
sub rsp, 3B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_228], rdi
mov [rbp+var_230], rsi
mov rax, [rbp+var_228]
mov [rbp+var_368], rax
mov [rbp+var_240], 1
mov [rbp+var_350], 0
mov rcx, [rbp+var_230]
mov rcx, [rcx+8]
mov [rbp+var_358], rcx
lea rdi, [rbp+var_220]
mov esi, [rax+6Ch]
mov edx, [rax+40h]
mov rax, [rbp+var_358]
mov r8, [rax+1C58h]
add r8, 0BA8h
lea rcx, aRelayLogInfo+9; ".info"
call _ZL20slave_load_file_stemPcjiPKcP25st_mysql_const_lex_string; slave_load_file_stem(char *,uint,int,char const*,st_mysql_const_lex_string *)
mov [rbp+var_238], rax
lea rax, key_file_log_event_info
mov edi, [rax]; unsigned int
lea rcx, [rbp+var_220]; char *
lea rsi, aWorkspaceLlm4b_103; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1347h; unsigned int
mov r8d, 20000h; int
mov r9d, 10h; unsigned __int64
call _ZL22inline_mysql_file_openjPKcjS0_im_14; inline_mysql_file_open(uint,char const*,uint,char const*,int,ulong)
mov [rbp+var_23C], eax
cmp eax, 0
jl short loc_D625A9
mov esi, [rbp+var_23C]
lea rdi, [rbp+var_348]
mov edx, 1000h
mov ecx, 1
xor eax, eax
mov r8d, eax
xor r9d, r9d
mov [rsp+3B0h+var_3B0], 14h
call init_io_cache
cmp eax, 0
jz short loc_D625FC
loc_D625A9:
mov rax, [rbp+var_358]
mov [rbp+var_378], rax
call _my_thread_var
mov eax, [rax]
mov [rbp+var_36C], eax
mov rdi, [rbp+var_230]; this
call _ZN14rpl_group_info9gtid_infoEv; rpl_group_info::gtid_info(void)
mov rdi, [rbp+var_378]
mov edx, [rbp+var_36C]
mov rcx, rax
lea r9, [rbp+var_220]
xor esi, esi
lea r8, aErrorInExecLoa; "Error in Exec_load event: could not ope"...
mov al, 0
call _ZNK26Slave_reporting_capability6reportE8logleveliPKcS2_z; Slave_reporting_capability::report(loglevel,int,char const*,char const*,...)
jmp loc_D62809
loc_D625FC:
mov rax, [rbp+var_358]
mov rsi, [rax+12A8h]
lea rdi, [rbp+var_348]
lea rax, opt_slave_sql_verify_checksum
movsx edx, byte ptr [rax]
call _ZN9Log_event14read_log_eventEP11st_io_cachePK28Format_description_log_eventc; Log_event::read_log_event(st_io_cache *,Format_description_log_event const*,char)
mov [rbp+var_350], rax
cmp rax, 0
jz short loc_D6263F
mov rdi, [rbp+var_350]
mov rax, [rdi]
call qword ptr [rax+28h]
cmp eax, 0Ch
jz short loc_D62681
loc_D6263F:
mov rax, [rbp+var_358]
mov [rbp+var_380], rax
mov rdi, [rbp+var_230]; this
call _ZN14rpl_group_info9gtid_infoEv; rpl_group_info::gtid_info(void)
mov rdi, [rbp+var_380]
mov rcx, rax
lea r9, [rbp+var_220]
xor edx, edx
lea r8, aErrorInExecLoa_0; "Error in Exec_load event: file '%s' app"...
mov esi, edx
mov al, 0
call _ZNK26Slave_reporting_capability6reportE8logleveliPKcS2_z; Slave_reporting_capability::report(loglevel,int,char const*,char const*,...)
jmp loc_D62809
loc_D62681:
mov rax, [rbp+var_368]
mov rcx, [rax+60h]
mov rax, [rbp+var_350]
mov [rax+60h], rcx
mov rdi, [rbp+var_350]
mov rdx, [rbp+var_230]
xor eax, eax
mov esi, eax
mov ecx, 1
call _ZN14Load_log_event14do_apply_eventEP6st_netP14rpl_group_infob; Load_log_event::do_apply_event(st_net *,rpl_group_info *,bool)
cmp eax, 0
jz loc_D6275D
mov rdi, [rbp+var_358]; this
call _ZNK26Slave_reporting_capability10last_errorEv; Slave_reporting_capability::last_error(void)
mov rsi, rax
add rsi, 4
xor edi, edi
mov edx, 10h
call my_strdup
mov [rbp+var_360], rax
cmp [rbp+var_360], 0
jz short loc_D62758
mov rax, [rbp+var_358]
mov [rbp+var_390], rax
mov rdi, [rbp+var_358]; this
call _ZNK26Slave_reporting_capability10last_errorEv; Slave_reporting_capability::last_error(void)
mov eax, [rax]
mov [rbp+var_384], eax
mov rdi, [rbp+var_230]; this
call _ZN14rpl_group_info9gtid_infoEv; rpl_group_info::gtid_info(void)
mov rdi, [rbp+var_390]
mov edx, [rbp+var_384]
mov rcx, rax
mov r9, [rbp+var_360]
lea rax, [rbp+var_220]
xor esi, esi
lea r8, aSFailedExecuti; "%s. Failed executing load from '%s'"
mov [rsp+3B0h+var_3B0], rax
mov al, 0
call _ZNK26Slave_reporting_capability6reportE8logleveliPKcS2_z; Slave_reporting_capability::report(loglevel,int,char const*,char const*,...)
mov rdi, [rbp+var_360]
call my_free
loc_D62758:
jmp loc_D62809
loc_D6275D:
cmp [rbp+var_23C], 0
jl short loc_D62797
mov edx, [rbp+var_23C]; int
lea rdi, aWorkspaceLlm4b_103; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 137Ch; unsigned int
xor eax, eax
mov ecx, eax; unsigned __int64
call _ZL23inline_mysql_file_closePKcjim_19; inline_mysql_file_close(char const*,uint,int,ulong)
lea rdi, [rbp+var_348]
call end_io_cache
mov [rbp+var_23C], 0FFFFFFFFh
loc_D62797:
lea rax, key_file_log_event_info
mov edi, [rax]; unsigned int
lea rcx, [rbp+var_220]; char *
lea rsi, aWorkspaceLlm4b_103; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1380h; unsigned int
mov r8d, 10h; unsigned __int64
call _ZL24inline_mysql_file_deletejPKcjS0_m_12; inline_mysql_file_delete(uint,char const*,uint,char const*,ulong)
mov rax, [rbp+var_238]
mov ecx, dword ptr cs:aBpageZipData+0Ah; ".data"
mov [rax], ecx
mov cx, word ptr cs:aBpageZipData+0Eh; "a"
mov [rax+4], cx
lea rax, key_file_log_event_data
mov edi, [rax]; unsigned int
lea rcx, [rbp+var_220]; char *
lea rsi, aWorkspaceLlm4b_103; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1382h; unsigned int
mov r8d, 10h; unsigned __int64
call _ZL24inline_mysql_file_deletejPKcjS0_m_12; inline_mysql_file_delete(uint,char const*,uint,char const*,ulong)
mov [rbp+var_240], 0
loc_D62809:
mov rax, [rbp+var_350]
mov [rbp+var_398], rax
cmp rax, 0
jz short loc_D6282A
mov rdi, [rbp+var_398]
mov rax, [rdi]
call qword ptr [rax+50h]
loc_D6282A:
cmp [rbp+var_23C], 0
jl short loc_D6285A
mov edx, [rbp+var_23C]; int
lea rdi, aWorkspaceLlm4b_103; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1389h; unsigned int
xor eax, eax
mov ecx, eax; unsigned __int64
call _ZL23inline_mysql_file_closePKcjim_19; inline_mysql_file_close(char const*,uint,int,ulong)
lea rdi, [rbp+var_348]
call end_io_cache
loc_D6285A:
mov eax, [rbp+var_240]
mov [rbp+var_39C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_D62887
mov eax, [rbp+var_39C]
add rsp, 3B0h
pop rbp
retn
loc_D62887:
call ___stack_chk_fail
|
long long Execute_load_log_event::do_apply_event(
Execute_load_log_event *this,
Slave_reporting_capability **a2)
{
_BYTE *v2; // rdi
unsigned long long v3; // rsi
int v4; // eax
int v5; // eax
long long v6; // rsi
int v7; // eax
char *v8; // rax
int v10; // [rsp+2Ch] [rbp-384h]
int v11; // [rsp+44h] [rbp-36Ch]
long long v13; // [rsp+50h] [rbp-360h]
Slave_reporting_capability *v14; // [rsp+58h] [rbp-358h]
Log_event *log_event; // [rsp+60h] [rbp-350h]
_BYTE v16[264]; // [rsp+68h] [rbp-348h] BYREF
unsigned int v17; // [rsp+170h] [rbp-240h]
int v18; // [rsp+174h] [rbp-23Ch]
char *file_stem; // [rsp+178h] [rbp-238h]
rpl_group_info *v20; // [rsp+180h] [rbp-230h]
Execute_load_log_event *v21; // [rsp+188h] [rbp-228h]
char v22[536]; // [rsp+190h] [rbp-220h] BYREF
unsigned long long v23; // [rsp+3A8h] [rbp-8h]
v23 = __readfsqword(0x28u);
v21 = this;
v20 = (rpl_group_info *)a2;
v17 = 1;
log_event = 0LL;
v14 = a2[1];
file_stem = (char *)slave_load_file_stem(
(long long)v22,
*((_DWORD *)this + 27),
*((_DWORD *)this + 16),
(long long)".info",
*((_QWORD *)v14 + 907) + 2984LL);
v2 = (_BYTE *)key_file_log_event_info;
v3 = (unsigned long long)"/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc";
v18 = inline_mysql_file_open(
key_file_log_event_info,
"/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc",
0x1347u,
v22,
0x20000u,
16LL);
if ( v18 < 0
|| (v3 = (unsigned int)v18, v2 = v16, (unsigned int)init_io_cache((unsigned int)v16, v18, 4096, 1, 0, 0, 20LL)) )
{
v11 = *(_DWORD *)my_thread_var(v2, v3);
v4 = rpl_group_info::gtid_info(v20);
Slave_reporting_capability::report(
(_DWORD)v14,
0,
v11,
v4,
(unsigned int)"Error in Exec_load event: could not open file '%s'",
(unsigned int)v22);
}
else
{
log_event = Log_event::read_log_event((long long)v16, *((char ***)v14 + 597), opt_slave_sql_verify_checksum);
if ( log_event && (*(unsigned int ( **)(Log_event *))(*(_QWORD *)log_event + 40LL))(log_event) == 12 )
{
*((_QWORD *)log_event + 12) = *((_QWORD *)this + 12);
if ( (unsigned int)Load_log_event::do_apply_event((long long)log_event, 0LL, v20, 1) )
{
v6 = Slave_reporting_capability::last_error(v14) + 4;
v13 = my_strdup(0LL, v6, 16LL);
if ( v13 )
{
v10 = *(_DWORD *)Slave_reporting_capability::last_error(v14);
v7 = rpl_group_info::gtid_info(v20);
Slave_reporting_capability::report(
(_DWORD)v14,
0,
v10,
v7,
(unsigned int)"%s. Failed executing load from '%s'",
v13);
my_free(v13);
}
}
else
{
if ( v18 >= 0 )
{
inline_mysql_file_close("/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc", 0x137Cu, v18, 0LL);
end_io_cache(v16);
v18 = -1;
}
inline_mysql_file_delete(
key_file_log_event_info,
"/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc",
0x1380u,
v22,
16LL);
v8 = file_stem;
*(_DWORD *)file_stem = *(_DWORD *)".data";
strcpy(v8 + 4, "a");
inline_mysql_file_delete(
key_file_log_event_data,
"/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc",
0x1382u,
v22,
16LL);
v17 = 0;
}
}
else
{
v5 = rpl_group_info::gtid_info(v20);
Slave_reporting_capability::report(
(_DWORD)v14,
0,
0,
v5,
(unsigned int)"Error in Exec_load event: file '%s' appears corrupted",
(unsigned int)v22);
}
}
if ( log_event )
(*(void ( **)(Log_event *))(*(_QWORD *)log_event + 80LL))(log_event);
if ( v18 >= 0 )
{
inline_mysql_file_close("/workspace/llm4binary/github2025/eloqsql/sql/log_event_server.cc", 0x1389u, v18, 0LL);
end_io_cache(v16);
}
return v17;
}
|
make_same:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RSI
MOV EDI,0x20
CALL 0x008dbfd0
MOV RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV byte ptr [RBP + -0x11],0x0
XOR EAX,EAX
CMP RCX,0x0
MOV qword ptr [RBP + -0x30],RAX
JZ 0x00d62506
MOV RDI,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x11],0x1
LAB_00d624f5:
CALL 0x00c08150
LAB_00d624fa:
JMP 0x00d624fc
LAB_00d624fc:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00d62506
LAB_00d62506:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
/* cmp_item_datetime::make_same(THD*) */
cmp_item_datetime * __thiscall cmp_item_datetime::make_same(cmp_item_datetime *this,THD *param_1)
{
cmp_item_datetime *this_00;
cmp_item_datetime *local_38;
this_00 = (cmp_item_datetime *)Sql_alloc::operator_new(0x20,*(st_mem_root **)(param_1 + 0x28));
local_38 = (cmp_item_datetime *)0x0;
if (this_00 != (cmp_item_datetime *)0x0) {
/* try { // try from 00d624f5 to 00d624f9 has its CatchHandler @ 00d62510 */
cmp_item_datetime(this_00);
local_38 = this_00;
}
return local_38;
}
|
|
13,782
|
js_number_toExponential
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_number_toExponential(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
double d;
int f;
val = js_thisNumberValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
if (JS_ToInt32Sat(ctx, &f, argv[0]))
return JS_EXCEPTION;
if (!isfinite(d))
return js_dtoa_infinite(ctx, d);
if (!JS_IsUndefined(argv[0])) {
if (f < 0 || f > 100) {
return JS_ThrowRangeError(ctx, "toExponential() argument must be between 0 and 100");
}
f += 1; /* number of significant digits between 1 and 101 */
}
return js_dtoa(ctx, d, f, JS_DTOA_EXPONENTIAL);
}
|
O1
|
c
|
js_number_toExponential:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rdi, %r14
callq 0x79af7
movq %rax, %r15
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x79316
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r15, %rcx
jmp 0x79400
cmpl $0x2, %ebx
ja 0x79328
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x79352
cmpl $0x7, %ebx
jne 0x79334
movq %r15, 0x10(%rsp)
jmp 0x79352
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3d31b
testl %eax, %eax
je 0x79352
movl $0x6, %ebx
jmp 0x79382
movq (%r12), %rdx
movq 0x8(%r12), %rcx
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x7936c
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x26aaf
movl $0x6, %ebx
testl %eax, %eax
je 0x79389
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x79403
movq 0x10(%rsp), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x793b2
movq %r14, %rdi
callq 0x3d68d
jmp 0x793f0
cmpl $0x3, 0x8(%r12)
je 0x793df
movl 0x8(%rsp), %eax
cmpl $0x65, %eax
jb 0x793d9
leaq 0x27436(%rip), %rsi # 0xa0800
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1fec9
jmp 0x79385
incl %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x270d3
movq %rax, %r15
movq %rdx, %rbx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %r15d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_number_toExponential:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, r8
mov r14, rdi
call js_thisNumberValue
mov r15, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_79316
mov rax, 0FFFFFFFF00000000h
mov rcx, r15
jmp loc_79400
loc_79316:
cmp ebx, 2
ja short loc_79328
cvtsi2sd xmm0, r15d
movsd [rsp+38h+var_28], xmm0
jmp short loc_79352
loc_79328:
cmp ebx, 7
jnz short loc_79334
mov [rsp+38h+var_28], r15
jmp short loc_79352
loc_79334:
lea rsi, [rsp+38h+var_28]
mov rdi, r14
mov rdx, r15
mov rcx, rbx
call __JS_ToFloat64Free
test eax, eax
jz short loc_79352
mov ebx, 6
jmp short loc_79382
loc_79352:
mov rdx, [r12]
mov rcx, [r12+8]
mov [rsp+38h+var_30], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_7936C
mov rax, [rsp+38h+var_30]
inc dword ptr [rax]
loc_7936C:
lea rsi, [rsp+38h+var_30]
mov rdi, r14
call JS_ToInt32SatFree
mov ebx, 6
test eax, eax
jz short loc_79389
loc_79382:
xor r15d, r15d
loc_79385:
xor ecx, ecx
jmp short loc_79403
loc_79389:
movq xmm0, [rsp+38h+var_28]
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_793B2
mov rdi, r14
call js_dtoa_infinite
jmp short loc_793F0
loc_793B2:
cmp dword ptr [r12+8], 3
jz short loc_793DF
mov eax, dword ptr [rsp+38h+var_30]
cmp eax, 65h ; 'e'
jb short loc_793D9
lea rsi, aToexponentialA; "toExponential() argument must be betwee"...
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
jmp short loc_79385
loc_793D9:
inc eax
mov dword ptr [rsp+38h+var_30], eax
loc_793DF:
mov esi, dword ptr [rsp+38h+var_30]
mov rdi, r14
mov edx, 1
call js_dtoa
loc_793F0:
mov r15, rax
mov rbx, rdx
mov rcx, 0FFFFFFFF00000000h
loc_79400:
and rcx, rax
loc_79403:
mov eax, r15d
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long js_number_toExponential(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13)
{
long long v14; // rax
long long v15; // rdx
unsigned long long v16; // r15
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // rdx
long long v20; // rcx
long long v21; // rdx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
unsigned long long v26; // rcx
__m128 v27; // xmm0
char v29; // [rsp+0h] [rbp-38h]
_DWORD *v30; // [rsp+8h] [rbp-30h] BYREF
__m128i v31[2]; // [rsp+10h] [rbp-28h] BYREF
v14 = js_thisNumberValue();
v16 = v14;
if ( (_DWORD)v15 == 6 )
{
v17 = 0xFFFFFFFF00000000LL;
v18 = v16;
LABEL_21:
v26 = v17 & v18;
return v26 | (unsigned int)v16;
}
if ( (unsigned int)v15 > 2 )
{
if ( (_DWORD)v15 == 7 )
{
v31[0].m128i_i64[0] = v14;
}
else if ( (unsigned int)_JS_ToFloat64Free(a1, v31[0].m128i_i64, v14, v15) )
{
goto LABEL_11;
}
}
else
{
*(double *)v31[0].m128i_i64 = (double)(int)v14;
}
v19 = *a13;
v20 = a13[1];
v30 = (_DWORD *)*a13;
if ( (unsigned int)v20 >= 0xFFFFFFF7 )
++*v30;
if ( !(unsigned int)JS_ToInt32SatFree(a1, (int *)&v30, v19, v20) )
{
v27 = (__m128)_mm_loadl_epi64(v31);
if ( (v27.m128_u64[0] & 0x7FFFFFFFFFFFFFFFLL) < 0x7FF0000000000000LL )
{
if ( *((_DWORD *)a13 + 2) != 3 )
{
if ( (unsigned int)v30 >= 0x65 )
{
LODWORD(v16) = 0;
JS_ThrowRangeError(
a1,
(long long)"toExponential() argument must be between 0 and 100",
v21,
0x7FF0000000000000LL,
v22,
v23,
v27,
a3,
a4,
a5,
v24,
v25,
a8,
a9,
v29);
goto LABEL_12;
}
LODWORD(v30) = (_DWORD)v30 + 1;
}
v17 = js_dtoa(a1, (int)v30, 1, (__m128i)v27);
}
else
{
v17 = js_dtoa_infinite(a1, *(double *)v27.m128_u64);
}
LODWORD(v16) = v17;
v18 = 0xFFFFFFFF00000000LL;
goto LABEL_21;
}
LABEL_11:
LODWORD(v16) = 0;
LABEL_12:
v26 = 0LL;
return v26 | (unsigned int)v16;
}
|
js_number_toExponential:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R8
MOV R14,RDI
CALL 0x00179af7
MOV R15,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x00179316
MOV RAX,-0x100000000
MOV RCX,R15
JMP 0x00179400
LAB_00179316:
CMP EBX,0x2
JA 0x00179328
CVTSI2SD XMM0,R15D
MOVSD qword ptr [RSP + 0x10],XMM0
JMP 0x00179352
LAB_00179328:
CMP EBX,0x7
JNZ 0x00179334
MOV qword ptr [RSP + 0x10],R15
JMP 0x00179352
LAB_00179334:
LEA RSI,[RSP + 0x10]
MOV RDI,R14
MOV RDX,R15
MOV RCX,RBX
CALL 0x0013d31b
TEST EAX,EAX
JZ 0x00179352
MOV EBX,0x6
JMP 0x00179382
LAB_00179352:
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x0017936c
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0017936c:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x00126aaf
MOV EBX,0x6
TEST EAX,EAX
JZ 0x00179389
LAB_00179382:
XOR R15D,R15D
LAB_00179385:
XOR ECX,ECX
JMP 0x00179403
LAB_00179389:
MOVQ XMM0,qword ptr [RSP + 0x10]
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JL 0x001793b2
MOV RDI,R14
CALL 0x0013d68d
JMP 0x001793f0
LAB_001793b2:
CMP dword ptr [R12 + 0x8],0x3
JZ 0x001793df
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,0x65
JC 0x001793d9
LEA RSI,[0x1a0800]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011fec9
JMP 0x00179385
LAB_001793d9:
INC EAX
MOV dword ptr [RSP + 0x8],EAX
LAB_001793df:
MOV ESI,dword ptr [RSP + 0x8]
MOV RDI,R14
MOV EDX,0x1
CALL 0x001270d3
LAB_001793f0:
MOV R15,RAX
MOV RBX,RDX
MOV RCX,-0x100000000
LAB_00179400:
AND RCX,RAX
LAB_00179403:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_number_toExponential(int8 param_1)
{
int iVar1;
double dVar2;
ulong uVar3;
uint uVar4;
int8 uVar5;
int8 *in_R8;
double dVar6;
int1 auVar7 [16];
int1 auVar8 [16];
int *local_30;
double local_28;
auVar7 = js_thisNumberValue();
dVar6 = auVar7._0_8_;
uVar4 = auVar7._8_4_;
if (uVar4 == 6) {
dVar2 = -NAN;
LAB_00179400:
uVar5 = auVar7._8_8_;
uVar3 = auVar7._0_8_ & (ulong)dVar2;
}
else {
if (uVar4 < 3) {
dVar6 = (double)auVar7._0_4_;
LAB_00179352:
local_28 = dVar6;
local_30 = (int *)*in_R8;
if (0xfffffff6 < (uint)in_R8[1]) {
*local_30 = *local_30 + 1;
}
iVar1 = JS_ToInt32SatFree(param_1,&local_30);
if (iVar1 == 0) {
if ((ulong)ABS(local_28) < 0x7ff0000000000000) {
if (*(int *)(in_R8 + 1) != 3) {
if (100 < (uint)local_30) {
JS_ThrowRangeError(param_1,"toExponential() argument must be between 0 and 100");
goto LAB_00179385;
}
local_30 = (int *)CONCAT44(local_30._4_4_,(uint)local_30 + 1);
}
auVar7 = js_dtoa(param_1,(ulong)local_30 & 0xffffffff,1);
}
else {
auVar7 = js_dtoa_infinite(param_1);
}
dVar2 = auVar7._0_8_;
auVar7._8_8_ = auVar7._8_8_;
auVar7._0_8_ = 0xffffffff00000000;
dVar6 = dVar2;
goto LAB_00179400;
}
}
else if ((uVar4 == 7) ||
(iVar1 = __JS_ToFloat64Free(param_1,&local_28,dVar6,auVar7._8_8_), dVar6 = local_28,
iVar1 == 0)) goto LAB_00179352;
LAB_00179385:
dVar6 = 0.0;
uVar5 = 6;
uVar3 = 0;
}
auVar8._0_8_ = (ulong)dVar6 & 0xffffffff | uVar3;
auVar8._8_8_ = uVar5;
return auVar8;
}
|
|
13,783
|
js_number_toExponential
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_number_toExponential(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val;
double d;
int f;
val = js_thisNumberValue(ctx, this_val);
if (JS_IsException(val))
return val;
if (JS_ToFloat64Free(ctx, &d, val))
return JS_EXCEPTION;
if (JS_ToInt32Sat(ctx, &f, argv[0]))
return JS_EXCEPTION;
if (!isfinite(d))
return js_dtoa_infinite(ctx, d);
if (!JS_IsUndefined(argv[0])) {
if (f < 0 || f > 100) {
return JS_ThrowRangeError(ctx, "toExponential() argument must be between 0 and 100");
}
f += 1; /* number of significant digits between 1 and 101 */
}
return js_dtoa(ctx, d, f, JS_DTOA_EXPONENTIAL);
}
|
O3
|
c
|
js_number_toExponential:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rdi, %r14
callq 0x7c460
movq %rax, %r15
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x7bc81
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r15, %rcx
jmp 0x7bd59
cmpl $0x2, %ebx
ja 0x7bc93
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x7bcbd
cmpl $0x7, %ebx
jne 0x7bc9f
movq %r15, 0x8(%rsp)
jmp 0x7bcbd
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3e93d
testl %eax, %eax
je 0x7bcbd
movl $0x6, %ebx
jmp 0x7bce3
movq (%r12), %rdx
movq 0x8(%r12), %rcx
cmpl $-0x9, %ecx
jb 0x7bccd
incl (%rdx)
leaq 0x14(%rsp), %rsi
movq %r14, %rdi
callq 0x27161
movl $0x6, %ebx
testl %eax, %eax
je 0x7bcea
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x7bd5c
movq 0x8(%rsp), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x7bd13
movq %r14, %rdi
callq 0x3edb7
jmp 0x7bd49
cmpl $0x3, 0x8(%r12)
movl 0x14(%rsp), %esi
je 0x7bd3c
cmpl $0x65, %esi
jb 0x7bd3a
leaq 0x27a8f(%rip), %rsi # 0xa37ba
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x205f0
jmp 0x7bce6
incl %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x27790
movq %rax, %r15
movq %rdx, %rbx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %r15d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_number_toExponential:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, r8
mov r14, rdi
call js_thisNumberValue
mov r15, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_7BC81
mov rax, 0FFFFFFFF00000000h
mov rcx, r15
jmp loc_7BD59
loc_7BC81:
cmp ebx, 2
ja short loc_7BC93
cvtsi2sd xmm0, r15d
movsd [rsp+38h+var_30], xmm0
jmp short loc_7BCBD
loc_7BC93:
cmp ebx, 7
jnz short loc_7BC9F
mov [rsp+38h+var_30], r15
jmp short loc_7BCBD
loc_7BC9F:
lea rsi, [rsp+38h+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, rbx
call __JS_ToFloat64Free
test eax, eax
jz short loc_7BCBD
mov ebx, 6
jmp short loc_7BCE3
loc_7BCBD:
mov rdx, [r12]
mov rcx, [r12+8]
cmp ecx, 0FFFFFFF7h
jb short loc_7BCCD
inc dword ptr [rdx]
loc_7BCCD:
lea rsi, [rsp+38h+var_24]
mov rdi, r14
call JS_ToInt32SatFree
mov ebx, 6
test eax, eax
jz short loc_7BCEA
loc_7BCE3:
xor r15d, r15d
loc_7BCE6:
xor ecx, ecx
jmp short loc_7BD5C
loc_7BCEA:
movq xmm0, [rsp+38h+var_30]
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_7BD13
mov rdi, r14
call js_dtoa_infinite
jmp short loc_7BD49
loc_7BD13:
cmp dword ptr [r12+8], 3
mov esi, [rsp+38h+var_24]
jz short loc_7BD3C
cmp esi, 65h ; 'e'
jb short loc_7BD3A
lea rsi, aToexponentialA; "toExponential() argument must be betwee"...
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowRangeError
jmp short loc_7BCE6
loc_7BD3A:
inc esi
loc_7BD3C:
mov rdi, r14
mov edx, 1
call js_dtoa
loc_7BD49:
mov r15, rax
mov rbx, rdx
mov rcx, 0FFFFFFFF00000000h
loc_7BD59:
and rcx, rax
loc_7BD5C:
mov eax, r15d
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long js_number_toExponential(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13)
{
long long v14; // rax
long long v15; // rdx
unsigned long long v16; // r15
long long v17; // rax
unsigned long long v18; // rcx
_DWORD *v19; // rdx
long long v20; // rcx
long long v21; // rdx
long long v22; // r8
long long v23; // r9
__m128 v24; // xmm4
__m128 v25; // xmm5
unsigned long long v26; // rcx
__m128 v27; // xmm0
int v28; // esi
char v30; // [rsp+0h] [rbp-38h]
__m128i v31[3]; // [rsp+8h] [rbp-30h] BYREF
v14 = js_thisNumberValue();
v16 = v14;
if ( (_DWORD)v15 == 6 )
{
v17 = 0xFFFFFFFF00000000LL;
v18 = v16;
LABEL_21:
v26 = v17 & v18;
return v26 | (unsigned int)v16;
}
if ( (unsigned int)v15 > 2 )
{
if ( (_DWORD)v15 == 7 )
{
v31[0].m128i_i64[0] = v14;
}
else if ( (unsigned int)_JS_ToFloat64Free(a1, (double *)v31[0].m128i_i64, v14, v15) )
{
goto LABEL_11;
}
}
else
{
*(double *)v31[0].m128i_i64 = (double)(int)v14;
}
v19 = *(_DWORD **)a13;
v20 = *(_QWORD *)(a13 + 8);
if ( (unsigned int)v20 >= 0xFFFFFFF7 )
++*v19;
if ( !(unsigned int)JS_ToInt32SatFree(a1, &v31[0].m128i_i32[3], (long long)v19, v20) )
{
v27 = (__m128)_mm_loadl_epi64(v31);
if ( (v27.m128_u64[0] & 0x7FFFFFFFFFFFFFFFLL) < 0x7FF0000000000000LL )
{
v28 = v31[0].m128i_i32[3];
if ( *(_DWORD *)(a13 + 8) != 3 )
{
if ( v31[0].m128i_i32[3] >= 0x65u )
{
LODWORD(v16) = 0;
JS_ThrowRangeError(
a1,
(long long)"toExponential() argument must be between 0 and 100",
v21,
0x7FF0000000000000LL,
v22,
v23,
v27,
a3,
a4,
a5,
v24,
v25,
a8,
a9,
v30);
goto LABEL_12;
}
v28 = v31[0].m128i_i32[3] + 1;
}
v17 = js_dtoa(a1, v28, 1, (__m128i)v27);
}
else
{
v17 = js_dtoa_infinite(a1, *(double *)v27.m128_u64);
}
LODWORD(v16) = v17;
v18 = 0xFFFFFFFF00000000LL;
goto LABEL_21;
}
LABEL_11:
LODWORD(v16) = 0;
LABEL_12:
v26 = 0LL;
return v26 | (unsigned int)v16;
}
|
js_number_toExponential:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,R8
MOV R14,RDI
CALL 0x0017c460
MOV R15,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x0017bc81
MOV RAX,-0x100000000
MOV RCX,R15
JMP 0x0017bd59
LAB_0017bc81:
CMP EBX,0x2
JA 0x0017bc93
CVTSI2SD XMM0,R15D
MOVSD qword ptr [RSP + 0x8],XMM0
JMP 0x0017bcbd
LAB_0017bc93:
CMP EBX,0x7
JNZ 0x0017bc9f
MOV qword ptr [RSP + 0x8],R15
JMP 0x0017bcbd
LAB_0017bc9f:
LEA RSI,[RSP + 0x8]
MOV RDI,R14
MOV RDX,R15
MOV RCX,RBX
CALL 0x0013e93d
TEST EAX,EAX
JZ 0x0017bcbd
MOV EBX,0x6
JMP 0x0017bce3
LAB_0017bcbd:
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
CMP ECX,-0x9
JC 0x0017bccd
INC dword ptr [RDX]
LAB_0017bccd:
LEA RSI,[RSP + 0x14]
MOV RDI,R14
CALL 0x00127161
MOV EBX,0x6
TEST EAX,EAX
JZ 0x0017bcea
LAB_0017bce3:
XOR R15D,R15D
LAB_0017bce6:
XOR ECX,ECX
JMP 0x0017bd5c
LAB_0017bcea:
MOVQ XMM0,qword ptr [RSP + 0x8]
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JL 0x0017bd13
MOV RDI,R14
CALL 0x0013edb7
JMP 0x0017bd49
LAB_0017bd13:
CMP dword ptr [R12 + 0x8],0x3
MOV ESI,dword ptr [RSP + 0x14]
JZ 0x0017bd3c
CMP ESI,0x65
JC 0x0017bd3a
LEA RSI,[0x1a37ba]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x001205f0
JMP 0x0017bce6
LAB_0017bd3a:
INC ESI
LAB_0017bd3c:
MOV RDI,R14
MOV EDX,0x1
CALL 0x00127790
LAB_0017bd49:
MOV R15,RAX
MOV RBX,RDX
MOV RCX,-0x100000000
LAB_0017bd59:
AND RCX,RAX
LAB_0017bd5c:
MOV EAX,R15D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_number_toExponential(int8 param_1)
{
int iVar1;
double dVar2;
ulong uVar3;
uint uVar4;
int8 uVar5;
int8 *in_R8;
double dVar6;
int1 auVar7 [16];
int1 auVar8 [16];
double local_30;
uint local_24;
auVar7 = js_thisNumberValue();
dVar6 = auVar7._0_8_;
uVar4 = auVar7._8_4_;
if (uVar4 == 6) {
dVar2 = -NAN;
LAB_0017bd59:
uVar5 = auVar7._8_8_;
uVar3 = auVar7._0_8_ & (ulong)dVar2;
}
else {
if (uVar4 < 3) {
dVar6 = (double)auVar7._0_4_;
LAB_0017bcbd:
local_30 = dVar6;
if (0xfffffff6 < (uint)in_R8[1]) {
*(int *)*in_R8 = *(int *)*in_R8 + 1;
}
iVar1 = JS_ToInt32SatFree(param_1,&local_24);
if (iVar1 == 0) {
if ((ulong)ABS(local_30) < 0x7ff0000000000000) {
if (*(int *)(in_R8 + 1) != 3) {
if (100 < local_24) {
JS_ThrowRangeError(param_1,"toExponential() argument must be between 0 and 100");
goto LAB_0017bce6;
}
local_24 = local_24 + 1;
}
auVar7 = js_dtoa(param_1,local_24,1);
}
else {
auVar7 = js_dtoa_infinite(param_1);
}
dVar2 = auVar7._0_8_;
auVar7._8_8_ = auVar7._8_8_;
auVar7._0_8_ = 0xffffffff00000000;
dVar6 = dVar2;
goto LAB_0017bd59;
}
}
else if ((uVar4 == 7) ||
(iVar1 = __JS_ToFloat64Free(param_1,&local_30,dVar6,auVar7._8_8_), dVar6 = local_30,
iVar1 == 0)) goto LAB_0017bcbd;
LAB_0017bce6:
dVar6 = 0.0;
uVar5 = 6;
uVar3 = 0;
}
auVar8._0_8_ = (ulong)dVar6 & 0xffffffff | uVar3;
auVar8._8_8_ = uVar5;
return auVar8;
}
|
|
13,784
|
minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&)
|
monkey531[P]llama/common/./minja.hpp
|
Value(const json & v) {
if (v.is_object()) {
auto object = std::make_shared<ObjectType>();
for (auto it = v.begin(); it != v.end(); ++it) {
(*object)[it.key()] = it.value();
}
object_ = std::move(object);
} else if (v.is_array()) {
auto array = std::make_shared<ArrayType>();
for (const auto& item : v) {
array->push_back(Value(item));
}
array_ = array;
} else {
primitive_ = v;
}
}
|
O3
|
cpp
|
minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r15
leaq 0x40(%rdi), %r14
movq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rdi, (%rsp)
movb $0x0, 0x40(%rdi)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
movzbl (%r15), %eax
cmpl $0x2, %eax
je 0x4d9ef
cmpl $0x1, %eax
jne 0x4db40
movq %r14, 0x8(%rsp)
movl $0x30, %edi
callq 0x18690
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xa0b9a(%rip), %rcx # 0xee458
movq %rcx, (%rax)
movq %rax, %r13
addq $0x10, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rax)
leaq 0x88(%rsp), %rbp
movq %r15, (%rbp)
movups %xmm0, 0x8(%rbp)
movq %rdx, 0x18(%rbp)
movq %rbp, %rdi
callq 0x4e262
leaq 0x30(%rsp), %rbx
leaq 0x68(%rsp), %r14
leaq 0x28(%rsp), %r12
movq %r15, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x40(%rsp)
movq %r12, %rdi
callq 0x4e598
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4e2c6
testb %al, %al
jne 0x4db93
movq %rbp, %rdi
callq 0x4df62
movq %r12, %rdi
movq %rax, %rsi
callq 0x4d826
movq %rbp, %rdi
callq 0x4dd6e
movq %r13, %rdi
movq %rax, %rsi
callq 0x4dc72
movq %rax, %rdi
movq %r12, %rsi
callq 0x4de48
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r14, %rdi
callq 0x4a5c0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4d98e
callq 0x2f80e
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4d99d
callq 0x2f80e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4d9ac
callq 0x2f80e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4d9e2
movq 0xa25e3(%rip), %rax # 0xeffa0
cmpb $0x0, (%rax)
je 0x4d9cd
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x4d9d7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x4d9e2
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbp, %rdi
callq 0x4df16
jmp 0x4d907
movq %r14, 0x8(%rsp)
movl $0x28, %edi
callq 0x18690
leaq 0x20(%rsp), %rdx
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xa0a90(%rip), %rcx # 0xee4a8
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%rdx)
movq %rcx, -0x8(%rdx)
leaq 0x88(%rsp), %r14
movq %r15, (%r14)
movups %xmm0, 0x8(%r14)
movabsq $-0x8000000000000000, %rbx # imm = 0x8000000000000000
movq %rbx, 0x18(%r14)
movq %r14, %rdi
callq 0x4e262
leaq 0xa8(%rsp), %r13
movq %r15, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r13)
movq %rbx, 0x18(%r13)
movq %r13, %rdi
callq 0x4e598
leaq 0x68(%rsp), %r15
leaq 0x28(%rsp), %rbp
movq 0xa2511(%rip), %rbx # 0xeffa0
movq %r14, %rdi
movq %r13, %rsi
callq 0x4e2c6
testb %al, %al
jne 0x4db71
movq %r14, %rdi
callq 0x4df62
movq 0x18(%rsp), %r12
movq %rbp, %rdi
movq %rax, %rsi
callq 0x4d826
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4efa4
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r15, %rdi
callq 0x4a5c0
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4dae6
callq 0x2f80e
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4daf5
callq 0x2f80e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4db04
callq 0x2f80e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4db33
cmpb $0x0, (%rbx)
je 0x4db1e
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x4db28
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x4db33
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0x4df16
jmp 0x4da8f
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x2b1f8
leaq 0x78(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x46ee0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3d970
movq %rbx, %rdi
callq 0x4a5c0
jmp 0x4dbb2
movq 0x18(%rsp), %rax
movq (%rsp), %rdi
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4f20e
movq 0x20(%rsp), %rdi
jmp 0x4dba8
movq (%rsp), %rax
movq %r13, 0x20(%rax)
movq 0x28(%rax), %rdi
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rax)
testq %rdi, %rdi
je 0x4dbb2
callq 0x2f80e
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rsp)
jmp 0x4dbcd
jmp 0x4dbcd
movq %rax, %r14
jmp 0x4dc14
jmp 0x4dbe9
jmp 0x4dc02
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3d8e4
jmp 0x4dc05
jmp 0x4dc02
jmp 0x4dbe9
movq %rax, %r14
jmp 0x4dbfb
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3d8e4
movq 0x10(%rsp), %rdi
jmp 0x4dc0f
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4dc14
callq 0x2f80e
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3d970
movq %rbx, %rdi
callq 0x4a5c0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x4dc3d
callq 0x2f80e
movq (%rsp), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x4dc4f
callq 0x2f80e
movq (%rsp), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x4dc61
callq 0x2f80e
movq (%rsp), %rdi
callq 0x3faee
movq %r14, %rdi
callq 0x18b90
|
_ZN5minja5ValueC2ERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r15, rsi
lea r14, [rdi+40h]
mov qword ptr [rdi+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
mov [rsp+0F8h+var_F8], rdi
mov byte ptr [rdi+40h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
movzx eax, byte ptr [r15]
cmp eax, 2
jz loc_4D9EF
cmp eax, 1
jnz loc_4DB40
mov [rsp+0F8h+var_F0], r14
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, 8000000000000000h
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, off_EE458
mov [rax], rcx
mov r13, rax
add r13, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov [rsp+0F8h+var_E8], rax
mov qword ptr [rax+20h], 0
lea rbp, [rsp+0F8h+var_70]
mov [rbp+0], r15
movups xmmword ptr [rbp+8], xmm0
mov [rbp+18h], rdx
mov rdi, rbp
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea rbx, [rsp+0F8h+var_C8]
lea r14, [rsp+0F8h+var_90]
lea r12, [rsp+0F8h+var_D0]
loc_4D907:
mov [rsp+0F8h+var_D0], r15
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
mov rax, 8000000000000000h
mov [rsp+0F8h+var_B8], rax
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
mov rdi, rbp
mov rsi, r12
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_4DB93
mov rdi, rbp
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, r12
mov rsi, rax
call _ZN5minja5ValueC2ERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEE; minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, rbp
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
mov rdi, r13
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_
mov rdi, rax
mov rsi, r12
call _ZN5minja5ValueaSEOS0_; minja::Value::operator=(minja::Value&&)
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+0F8h+var_98]
test rdi, rdi
jz short loc_4D98E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4D98E:
mov rdi, [rsp+0F8h+var_A8]
test rdi, rdi
jz short loc_4D99D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4D99D:
mov rdi, [rsp+0F8h+var_B8]
test rdi, rdi
jz short loc_4D9AC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4D9AC:
mov rdi, [rsp+0F8h+var_C8]
test rdi, rdi
jz short loc_4D9E2
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_4D9CD
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_4D9D7
loc_4D9CD:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_4D9D7:
cmp eax, 1
jnz short loc_4D9E2
mov rax, [rdi]
call qword ptr [rax+18h]
loc_4D9E2:
mov rdi, rbp
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
jmp loc_4D907
loc_4D9EF:
mov [rsp+0F8h+var_F0], r14
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
lea rdx, [rsp+0F8h+var_D8]
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, off_EE4A8
mov [rax], rcx
mov rcx, rax
add rcx, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
mov [rdx], rax
mov [rdx-8], rcx
lea r14, [rsp+0F8h+var_70]
mov [r14], r15
movups xmmword ptr [r14+8], xmm0
mov rbx, 8000000000000000h
mov [r14+18h], rbx
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9set_beginEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_begin(void)
lea r13, [rsp+0F8h+var_50]
mov [r13+0], r15
xorps xmm0, xmm0
movups xmmword ptr [r13+8], xmm0
mov [r13+18h], rbx
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::set_end(void)
lea r15, [rsp+0F8h+var_90]
lea rbp, [rsp+0F8h+var_D0]
mov rbx, cs:__libc_single_threaded_ptr
loc_4DA8F:
mov rdi, r14
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_4DB71
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov r12, [rsp+0F8h+var_E0]
mov rdi, rbp
mov rsi, rax
call _ZN5minja5ValueC2ERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEE; minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, r12
mov rsi, rbp
call _ZNSt6vectorIN5minja5ValueESaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<minja::Value>::emplace_back<minja::Value>(minja::Value &&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+0F8h+var_98]
test rdi, rdi
jz short loc_4DAE6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DAE6:
mov rdi, [rsp+0F8h+var_A8]
test rdi, rdi
jz short loc_4DAF5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DAF5:
mov rdi, [rsp+0F8h+var_B8]
test rdi, rdi
jz short loc_4DB04
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DB04:
mov rdi, [rsp+0F8h+var_C8]
test rdi, rdi
jz short loc_4DB33
cmp byte ptr [rbx], 0
jz short loc_4DB1E
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_4DB28
loc_4DB1E:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_4DB28:
cmp eax, 1
jnz short loc_4DB33
mov rax, [rdi]
call qword ptr [rax+18h]
loc_4DB33:
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
jmp loc_4DA8F
loc_4DB40:
lea rdi, [rsp+0F8h+var_80]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rbx, [rsp+0F8h+var_80]
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_4DBB2
loc_4DB71:
mov rax, [rsp+0F8h+var_E0]
mov rdi, [rsp+0F8h+var_F8]
mov [rdi+10h], rax
add rdi, 18h
lea rsi, [rsp+0F8h+var_D8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov rdi, [rsp+0F8h+var_D8]
jmp short loc_4DBA8
loc_4DB93:
mov rax, [rsp+0F8h+var_F8]
mov [rax+20h], r13
mov rdi, [rax+28h]
mov rcx, [rsp+0F8h+var_E8]
mov [rax+28h], rcx
loc_4DBA8:
test rdi, rdi
jz short loc_4DBB2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DBB2:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov [rsp+arg_0], r14
jmp short loc_4DBCD
jmp short $+2
loc_4DBCD:
mov r14, rax
jmp short loc_4DC14
jmp short loc_4DBE9
jmp short loc_4DC02
mov r14, rax
lea rdi, [rsp+arg_20]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_4DC05
jmp short loc_4DC02
jmp short $+2
loc_4DBE9:
mov r14, rax
jmp short loc_4DBFB
mov r14, rax
lea rdi, [rsp+arg_20]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_4DBFB:
mov rdi, [rsp+arg_8]
jmp short loc_4DC0F
loc_4DC02:
mov r14, rax
loc_4DC05:
mov rdi, [rsp+arg_18]
test rdi, rdi
jz short loc_4DC14
loc_4DC0F:
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DC14:
mov rbx, [rsp+arg_0]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, [rsp+0]
mov rdi, [rax+38h]
test rdi, rdi
jz short loc_4DC3D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DC3D:
mov rax, [rsp+0]
mov rdi, [rax+28h]
test rdi, rdi
jz short loc_4DC4F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DC4F:
mov rax, [rsp+0]
mov rdi, [rax+18h]
test rdi, rdi
jz short loc_4DC61
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4DC61:
mov rdi, [rsp+0]
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::Value(long long a1, unsigned __int8 *a2)
{
int v2; // eax
long long v3; // rax
long long v4; // r13
int v5; // eax
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rax
long long v11; // rax
long long v12; // rdi
signed __int32 v13; // eax
long long v14; // rax
int v15; // eax
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
long long v20; // rdi
signed __int32 v21; // eax
long long result; // rax
volatile signed __int32 *v23; // rdi
long long v25; // [rsp+10h] [rbp-E8h]
long long v26; // [rsp+18h] [rbp-E0h]
volatile signed __int32 *v27; // [rsp+20h] [rbp-D8h] BYREF
unsigned __int8 *v28; // [rsp+28h] [rbp-D0h] BYREF
__int128 v29; // [rsp+30h] [rbp-C8h]
volatile signed __int32 *v30; // [rsp+40h] [rbp-B8h]
volatile signed __int32 *v31; // [rsp+50h] [rbp-A8h]
volatile signed __int32 *v32; // [rsp+60h] [rbp-98h]
void **v33[2]; // [rsp+68h] [rbp-90h] BYREF
void **v34[2]; // [rsp+78h] [rbp-80h] BYREF
unsigned __int8 *v35; // [rsp+88h] [rbp-70h] BYREF
__int128 v36; // [rsp+90h] [rbp-68h]
unsigned long long v37; // [rsp+A0h] [rbp-58h]
unsigned __int8 *v38; // [rsp+A8h] [rbp-50h] BYREF
__int128 v39; // [rsp+B0h] [rbp-48h]
unsigned long long v40; // [rsp+C0h] [rbp-38h]
*(_QWORD *)(a1 + 72) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_BYTE *)(a1 + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
v2 = *a2;
if ( v2 == 2 )
{
v14 = operator new(0x28uLL);
*(_QWORD *)(v14 + 8) = 0x100000001LL;
*(_QWORD *)v14 = off_EE4A8;
*(_OWORD *)(v14 + 16) = 0LL;
*(_QWORD *)(v14 + 32) = 0LL;
v27 = (volatile signed __int32 *)v14;
v26 = v14 + 16;
v35 = a2;
v36 = 0LL;
v37 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v35);
v38 = a2;
v39 = 0LL;
v40 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v38);
while ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v35,
&v38) )
{
v15 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v35);
minja::Value::Value((unsigned int)&v28, v15, v16, v17, v18, v19);
std::vector<minja::Value>::emplace_back<minja::Value>(v26, &v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v33);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v33);
if ( v32 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v32);
if ( v31 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
v20 = v29;
if ( (_QWORD)v29 )
{
if ( _libc_single_threaded )
{
v21 = *(_DWORD *)(v29 + 12);
*(_DWORD *)(v29 + 12) = v21 - 1;
}
else
{
v21 = _InterlockedExchangeAdd((volatile signed __int32 *)(v29 + 12), 0xFFFFFFFF);
}
if ( v21 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v20 + 24LL))(v20, 0LL);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v35);
}
*(_QWORD *)(a1 + 16) = v26;
result = std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(a1 + 24, &v27);
v23 = v27;
}
else
{
if ( v2 != 1 )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v34,
(long long)a2);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
a1 + 64,
(long long)v34);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v34);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v34);
return result;
}
v3 = operator new(0x30uLL);
*(_QWORD *)(v3 + 8) = 0x100000001LL;
*(_QWORD *)v3 = off_EE458;
v4 = v3 + 16;
*(_OWORD *)(v3 + 16) = 0LL;
v25 = v3;
*(_QWORD *)(v3 + 32) = 0LL;
v35 = a2;
v36 = 0LL;
v37 = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_begin(&v35);
while ( 1 )
{
v28 = a2;
v29 = 0LL;
v30 = (volatile signed __int32 *)0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::set_end(&v28);
if ( (unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(
&v35,
&v28) )
break;
v5 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v35);
minja::Value::Value((unsigned int)&v28, v5, v6, v7, v8, v9);
v10 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(&v35);
v11 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_(
v4,
v10);
minja::Value::operator=(v11, &v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v33);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v33);
if ( v32 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v32);
if ( v31 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
v12 = v29;
if ( (_QWORD)v29 )
{
if ( _libc_single_threaded )
{
v13 = *(_DWORD *)(v29 + 12);
*(_DWORD *)(v29 + 12) = v13 - 1;
}
else
{
v13 = _InterlockedExchangeAdd((volatile signed __int32 *)(v29 + 12), 0xFFFFFFFF);
}
if ( v13 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v12 + 24LL))(v12, 0LL);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v35);
}
result = a1;
*(_QWORD *)(a1 + 32) = v4;
v23 = *(volatile signed __int32 **)(a1 + 40);
*(_QWORD *)(a1 + 40) = v25;
}
if ( v23 )
return std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v23);
return result;
}
|
Value:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R15,RSI
LEA R14,[RDI + 0x40]
MOV qword ptr [RDI + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [RSP],RDI
MOV byte ptr [RDI + 0x40],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
MOVZX EAX,byte ptr [R15]
CMP EAX,0x2
JZ 0x0014d9ef
CMP EAX,0x1
JNZ 0x0014db40
LAB_0014d890:
MOV qword ptr [RSP + 0x8],R14
MOV EDI,0x30
CALL 0x00118690
MOV RDX,-0x8000000000000000
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1ee458]
MOV qword ptr [RAX],RCX
MOV R13,RAX
ADD R13,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RAX + 0x20],0x0
LEA RBP,[RSP + 0x88]
MOV qword ptr [RBP],R15
MOVUPS xmmword ptr [RBP + 0x8],XMM0
MOV qword ptr [RBP + 0x18],RDX
MOV RDI,RBP
CALL 0x0014e262
LEA RBX,[RSP + 0x30]
LEA R14,[RSP + 0x68]
LEA R12,[RSP + 0x28]
LAB_0014d907:
MOV qword ptr [RSP + 0x28],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV RAX,-0x8000000000000000
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,R12
CALL 0x0014e598
LAB_0014d929:
MOV RDI,RBP
MOV RSI,R12
CALL 0x0014e2c6
TEST AL,AL
JNZ 0x0014db93
LAB_0014d93c:
MOV RDI,RBP
CALL 0x0014df62
MOV RDI,R12
MOV RSI,RAX
CALL 0x0014d826
LAB_0014d94f:
MOV RDI,RBP
CALL 0x0014dd6e
MOV RDI,R13
MOV RSI,RAX
CALL 0x0014dc72
LAB_0014d962:
MOV RDI,RAX
MOV RSI,R12
CALL 0x0014de48
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R14
CALL 0x0014a5c0
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x0014d98e
CALL 0x0012f80e
LAB_0014d98e:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x0014d99d
CALL 0x0012f80e
LAB_0014d99d:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0014d9ac
CALL 0x0012f80e
LAB_0014d9ac:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0014d9e2
MOV RAX,qword ptr [0x001effa0]
CMP byte ptr [RAX],0x0
JZ 0x0014d9cd
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0014d9d7
LAB_0014d9cd:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0014d9d7:
CMP EAX,0x1
JNZ 0x0014d9e2
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0014d9e2:
MOV RDI,RBP
CALL 0x0014df16
JMP 0x0014d907
LAB_0014d9ef:
MOV qword ptr [RSP + 0x8],R14
MOV EDI,0x28
CALL 0x00118690
LEA RDX,[RSP + 0x20]
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x1ee4a8]
MOV qword ptr [RAX],RCX
MOV RCX,RAX
ADD RCX,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RDX],RAX
MOV qword ptr [RDX + -0x8],RCX
LEA R14,[RSP + 0x88]
MOV qword ptr [R14],R15
MOVUPS xmmword ptr [R14 + 0x8],XMM0
MOV RBX,-0x8000000000000000
MOV qword ptr [R14 + 0x18],RBX
MOV RDI,R14
CALL 0x0014e262
LEA R13,[RSP + 0xa8]
MOV qword ptr [R13],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x8],XMM0
MOV qword ptr [R13 + 0x18],RBX
MOV RDI,R13
CALL 0x0014e598
LEA R15,[RSP + 0x68]
LEA RBP,[RSP + 0x28]
MOV RBX,qword ptr [0x001effa0]
LAB_0014da8f:
MOV RDI,R14
MOV RSI,R13
CALL 0x0014e2c6
TEST AL,AL
JNZ 0x0014db71
LAB_0014daa2:
MOV RDI,R14
CALL 0x0014df62
MOV R12,qword ptr [RSP + 0x18]
LAB_0014daaf:
MOV RDI,RBP
MOV RSI,RAX
CALL 0x0014d826
LAB_0014daba:
MOV RDI,R12
MOV RSI,RBP
CALL 0x0014efa4
LAB_0014dac5:
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R15
CALL 0x0014a5c0
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x0014dae6
CALL 0x0012f80e
LAB_0014dae6:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x0014daf5
CALL 0x0012f80e
LAB_0014daf5:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0014db04
CALL 0x0012f80e
LAB_0014db04:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0014db33
CMP byte ptr [RBX],0x0
JZ 0x0014db1e
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0014db28
LAB_0014db1e:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0014db28:
CMP EAX,0x1
JNZ 0x0014db33
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0014db33:
MOV RDI,R14
CALL 0x0014df16
JMP 0x0014da8f
LAB_0014db40:
LEA RDI,[RSP + 0x78]
MOV RSI,R15
CALL 0x0012b1f8
LAB_0014db4d:
LEA RBX,[RSP + 0x78]
MOV RDI,R14
MOV RSI,RBX
CALL 0x00146ee0
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,RBX
CALL 0x0014a5c0
JMP 0x0014dbb2
LAB_0014db71:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP]
MOV qword ptr [RDI + 0x10],RAX
ADD RDI,0x18
LEA RSI,[RSP + 0x20]
CALL 0x0014f20e
MOV RDI,qword ptr [RSP + 0x20]
JMP 0x0014dba8
LAB_0014db93:
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x20],R13
MOV RDI,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x28],RCX
LAB_0014dba8:
TEST RDI,RDI
JZ 0x0014dbb2
CALL 0x0012f80e
LAB_0014dbb2:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
void __thiscall minja::Value::Value(Value *this,basic_json *param_1)
{
int *piVar1;
int *puVar2;
char cVar3;
int iVar4;
int8 *puVar5;
basic_json *pbVar6;
int8 uVar7;
Value *this_00;
vector<minja::Value,std::allocator<minja::Value>> *this_01;
bool bVar8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_02;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_d8;
basic_json *local_d0;
long *local_c8;
int8 uStack_c0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_a8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
data local_90 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_80 [16];
basic_json *local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
basic_json *local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
*(int8 *)(this + 0x48) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
this[0x40] = (Value)0x0;
bVar8 = SUB81((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(this + 0x40),0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar8);
local_70 = param_1;
if (*param_1 == (basic_json)0x2) {
/* try { // try from 0014d9ef to 0014d9fd has its CatchHandler @ 0014dbcb */
local_d8 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x28);
*(int8 *)(local_d8 + 8) = 0x100000001;
*(int ***)local_d8 = &PTR___Sp_counted_ptr_inplace_001ee4a8;
this_01 = (vector<minja::Value,std::allocator<minja::Value>> *)(local_d8 + 0x10);
*(int8 *)(local_d8 + 0x10) = 0;
*(int8 *)(local_d8 + 0x18) = 0;
*(int8 *)(local_d8 + 0x20) = 0;
local_68 = 0;
uStack_60 = 0;
local_58 = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
local_48 = 0;
uStack_40 = 0;
local_38 = 0x8000000000000000;
local_50 = param_1;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50);
puVar2 = PTR___libc_single_threaded_001effa0;
/* try { // try from 0014da8f to 0014da99 has its CatchHandler @ 0014dc02 */
while (cVar3 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_50), cVar3 == '\0') {
/* try { // try from 0014daa2 to 0014daa9 has its CatchHandler @ 0014dbe5 */
pbVar6 = (basic_json *)
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
/* try { // try from 0014daaf to 0014dab9 has its CatchHandler @ 0014dbd4 */
Value((Value *)&local_d0,pbVar6);
/* try { // try from 0014daba to 0014dac4 has its CatchHandler @ 0014dbd6 */
std::vector<minja::Value,std::allocator<minja::Value>>::emplace_back<minja::Value>
(this_01,(Value *)&local_d0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*puVar2 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
/* try { // try from 0014db33 to 0014db3a has its CatchHandler @ 0014dc02 */
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
}
*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10) = this_01;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(this + 0x18),
(__shared_count *)&local_d8);
this_02 = local_d8;
}
else {
if (*param_1 != (basic_json)0x1) {
/* try { // try from 0014db40 to 0014db4c has its CatchHandler @ 0014dbc4 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_80,param_1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(this + 0x40),(data *)local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_80,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_80);
return;
}
/* try { // try from 0014d890 to 0014d89e has its CatchHandler @ 0014dbcd */
puVar5 = (int8 *)operator_new(0x30);
puVar5[1] = 0x100000001;
*puVar5 = &PTR___Sp_counted_ptr_inplace_001ee458;
puVar5[2] = 0;
puVar5[3] = 0;
puVar5[4] = 0;
local_68 = 0;
uStack_60 = 0;
local_58 = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_begin((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
while( true ) {
local_c8 = (long *)0x0;
uStack_c0 = 0;
local_b8 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x8000000000000000;
local_d0 = param_1;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::set_end((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_d0);
/* try { // try from 0014d929 to 0014d933 has its CatchHandler @ 0014dbe7 */
cVar3 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70,
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_d0);
if (cVar3 != '\0') break;
/* try { // try from 0014d93c to 0014d94e has its CatchHandler @ 0014dbe9 */
pbVar6 = (basic_json *)
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
Value((Value *)&local_d0,pbVar6);
/* try { // try from 0014d94f to 0014d961 has its CatchHandler @ 0014dbee */
uVar7 = nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
this_00 = (Value *)_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OST_
(puVar5 + 2,uVar7);
operator=(this_00,(Value *)&local_d0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001effa0 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar4 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar4 + -1;
}
if (iVar4 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
/* try { // try from 0014d9e2 to 0014d9e9 has its CatchHandler @ 0014dbd2 */
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_70);
}
*(int8 **)(this + 0x20) = puVar5 + 2;
this_02 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28);
*(int8 **)(this + 0x28) = puVar5;
}
if (this_02 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_02);
}
return;
}
|
|
13,785
|
evmone::VM::VM()
|
corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/vm.cpp
|
VM::VM() noexcept
: evmc_vm{
EVMC_ABI_VERSION,
"evmone",
PROJECT_VERSION,
evmone::destroy,
evmone::baseline::execute,
evmone::get_capabilities,
evmone::set_option,
}
{
m_execution_states.reserve(1025);
}
|
O2
|
cpp
|
evmone::VM::VM():
pushq %rax
movl $0xc, (%rdi)
leaq 0x4743d(%rip), %rax # 0x75f9f
movq %rax, 0x8(%rdi)
leaq 0x47439(%rip), %rax # 0x75fa6
movq %rax, 0x10(%rdi)
leaq 0x51(%rip), %rax # 0x2ebc9
movq %rax, 0x18(%rdi)
leaq 0x6b82(%rip), %rax # 0x35705
movq %rax, 0x20(%rdi)
leaq 0x72(%rip), %rax # 0x2ec00
movq %rax, 0x28(%rdi)
leaq 0x6b(%rip), %rax # 0x2ec04
movq %rax, 0x30(%rdi)
movw $0x1, 0x38(%rdi)
leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movl $0x401, %esi # imm = 0x401
movq %rax, %rdi
callq 0x2ee06
popq %rax
retq
movq %rax, %rdi
callq 0x2e859
|
_ZN6evmone2VMC2Ev:
push rax
mov dword ptr [rdi], 0Ch
lea rax, aEvmone; "evmone"
mov [rdi+8], rax
lea rax, a0141; "0.14.1"
mov [rdi+10h], rax
lea rax, _ZN6evmone12_GLOBAL__N_17destroyEP7evmc_vm; evmone::`anonymous namespace'::destroy(evmc_vm *)
mov [rdi+18h], rax
lea rax, _ZN6evmone8baseline7executeEP7evmc_vmPK19evmc_host_interfaceP17evmc_host_context13evmc_revisionPK12evmc_messagePKhm; evmone::baseline::execute(evmc_vm *,evmc_host_interface const*,evmc_host_context *,evmc_revision,evmc_message const*,uchar const*,ulong)
mov [rdi+20h], rax
lea rax, _ZN6evmone12_GLOBAL__N_116get_capabilitiesEP7evmc_vm; evmone::`anonymous namespace'::get_capabilities(evmc_vm *)
mov [rdi+28h], rax
lea rax, _ZN6evmone12_GLOBAL__N_110set_optionEP7evmc_vmPKcS4_; evmone::`anonymous namespace'::set_option(evmc_vm *,char const*,char const*)
mov [rdi+30h], rax
mov word ptr [rdi+38h], 1
lea rax, [rdi+40h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
mov esi, 401h
mov rdi, rax
call _ZNSt6vectorIN6evmone14ExecutionStateESaIS1_EE7reserveEm; std::vector<evmone::ExecutionState>::reserve(ulong)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> evmone::VM::VM(evmone::VM *this)
{
*(_DWORD *)this = 12;
*((_QWORD *)this + 1) = "evmone";
*((_QWORD *)this + 2) = "0.14.1";
*((_QWORD *)this + 3) = evmone::`anonymous namespace'::destroy;
*((_QWORD *)this + 4) = evmone::baseline::execute;
*((_QWORD *)this + 5) = evmone::`anonymous namespace'::get_capabilities;
*((_QWORD *)this + 6) = evmone::`anonymous namespace'::set_option;
*((_WORD *)this + 28) = 1;
*((_OWORD *)this + 4) = 0LL;
*((_OWORD *)this + 5) = 0LL;
std::vector<evmone::ExecutionState>::reserve((char *)this + 64, 1025LL);
}
|
VM:
PUSH RAX
MOV dword ptr [RDI],0xc
LEA RAX,[0x175f9f]
MOV qword ptr [RDI + 0x8],RAX
LEA RAX,[0x175fa6]
MOV qword ptr [RDI + 0x10],RAX
LEA RAX,[0x12ebc9]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x135705]
MOV qword ptr [RDI + 0x20],RAX
LEA RAX,[0x12ec00]
MOV qword ptr [RDI + 0x28],RAX
LEA RAX,[0x12ec04]
MOV qword ptr [RDI + 0x30],RAX
MOV word ptr [RDI + 0x38],0x1
LEA RAX,[RDI + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
LAB_0012ebb2:
MOV ESI,0x401
MOV RDI,RAX
CALL 0x0012ee06
POP RAX
RET
|
/* evmone::VM::VM() */
int8 __thiscall evmone::VM::VM(VM *this)
{
int8 in_RAX;
*(int4 *)this = 0xc;
*(char **)(this + 8) = "evmone";
*(char **)(this + 0x10) = "0.14.1";
*(code **)(this + 0x18) = (anonymous_namespace)::destroy;
*(code **)(this + 0x20) = baseline::execute;
*(code **)(this + 0x28) = (anonymous_namespace)::get_capabilities;
*(code **)(this + 0x30) = (anonymous_namespace)::set_option;
*(int2 *)(this + 0x38) = 1;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 0012ebb2 to 0012ebbe has its CatchHandler @ 0012ebc1 */
std::vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>>::reserve
((vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>> *)(this + 0x40),
0x401);
return in_RAX;
}
|
|
13,786
|
c4_verify_blockroot_signature
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c
|
c4_status_t c4_verify_blockroot_signature(verify_ctx_t* ctx, ssz_ob_t* header, ssz_ob_t* sync_committee_bits, ssz_ob_t* sync_committee_signature, uint64_t slot) {
bytes32_t root = {0};
c4_sync_state_t sync_state = {0};
if (slot == 0) slot = ssz_get_uint64(header, "slot") + 1;
if (slot == 0) THROW_ERROR("slot is missing in beacon header!");
// get the validators and make sure we have the right ones for the requested period
TRY_ASYNC(c4_get_validators(ctx, slot >> 13, &sync_state));
// compute blockhash
ssz_hash_tree_root(*header, root);
// compute signing message and store it in root again
calculate_signing_message(ctx, slot, root, root);
// verify the signature
bool valid = blst_verify(root, sync_committee_signature->bytes.data, sync_state.validators.data, 512, sync_committee_bits->bytes, sync_state.deserialized);
#ifndef C4_STATIC_MEMORY
safe_free(sync_state.validators.data);
#endif
if (!valid)
THROW_ERROR("invalid blockhash signature!");
return C4_SUCCESS;
}
|
O0
|
c
|
c4_verify_blockroot_signature:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
cmpq $0x0, -0x30(%rbp)
jne 0xfbae
movq -0x18(%rbp), %rdi
leaq 0x42c67(%rip), %rsi # 0x52808
callq 0xfcb0
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xfbd1
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x43576(%rip), %rsi # 0x5313a
callq 0x22510
movl %eax, -0x4(%rbp)
jmp 0xfc9f
jmp 0xfbd3
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
shrq $0xd, %rax
movl %eax, %esi
leaq -0x70(%rbp), %rdx
callq 0x17190
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
je 0xfbfe
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfc9f
jmp 0xfc00
movq -0x18(%rbp), %rax
leaq -0x50(%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 0x1cbf0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0xfd00
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x60(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x58(%rbp), %al
movl (%rcx), %r8d
movq 0x8(%rcx), %r9
movl $0x200, %ecx # imm = 0x200
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0x1f660
andb $0x1, %al
movb %al, -0x75(%rbp)
movq -0x60(%rbp), %rdi
callq 0x18740
testb $0x1, -0x75(%rbp)
jne 0xfc98
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0x434ce(%rip), %rsi # 0x5315c
callq 0x22510
movl %eax, -0x4(%rbp)
jmp 0xfc9f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
c4_verify_blockroot_signature:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 20h ; ' '
call _memset
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 20h ; ' '
call _memset
cmp [rbp+var_30], 0
jnz short loc_FBAE
mov rdi, [rbp+var_18]
lea rsi, aSlot; "slot"
call ssz_get_uint64_4
add rax, 1
mov [rbp+var_30], rax
loc_FBAE:
cmp [rbp+var_30], 0
jnz short loc_FBD1
mov rdi, [rbp+var_10]
add rdi, 70h ; 'p'
lea rsi, aSlotIsMissingI; "slot is missing in beacon header!"
call c4_state_add_error
mov [rbp+var_4], eax
jmp loc_FC9F
loc_FBD1:
jmp short $+2
loc_FBD3:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_30]
shr rax, 0Dh
mov esi, eax
lea rdx, [rbp+var_70]
call c4_get_validators
mov [rbp+var_74], eax
cmp [rbp+var_74], 0
jz short loc_FBFE
mov eax, [rbp+var_74]
mov [rbp+var_4], eax
jmp loc_FC9F
loc_FBFE:
jmp short $+2
loc_FC00:
mov rax, [rbp+var_18]
lea rdi, [rbp+var_50]
mov rcx, [rax]
mov [rsp+90h+var_90], rcx
mov rcx, [rax+8]
mov [rsp+90h+var_88], rcx
mov rax, [rax+10h]
mov [rsp+90h+var_80], rax
call ssz_hash_tree_root
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
lea rdx, [rbp+var_50]
lea rcx, [rbp+var_50]
call calculate_signing_message
lea rdi, [rbp+var_50]
mov rax, [rbp+var_28]
mov rsi, [rax+8]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_20]
mov al, [rbp+var_58]
mov r8d, [rcx]
mov r9, [rcx+8]
mov ecx, 200h
and al, 1
movzx eax, al
mov dword ptr [rsp+90h+var_90], eax
call blst_verify
and al, 1
mov [rbp+var_75], al
mov rdi, [rbp+var_60]
call safe_free
test [rbp+var_75], 1
jnz short loc_FC98
mov rdi, [rbp+var_10]
add rdi, 70h ; 'p'
lea rsi, aInvalidBlockha; "invalid blockhash signature!"
call c4_state_add_error
mov [rbp+var_4], eax
jmp short loc_FC9F
loc_FC98:
mov [rbp+var_4], 0
loc_FC9F:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
|
long long c4_verify_blockroot_signature(long long a1, _QWORD *a2, long long a3, long long a4, unsigned long long a5)
{
long long v5; // rsi
int v6; // edx
int v7; // r8d
int v8; // r9d
int v10; // [rsp+1Bh] [rbp-75h]
unsigned int validators; // [rsp+1Ch] [rbp-74h]
_BYTE v12[16]; // [rsp+20h] [rbp-70h] BYREF
long long v13; // [rsp+30h] [rbp-60h]
char v14; // [rsp+38h] [rbp-58h]
_BYTE v15[32]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v16; // [rsp+60h] [rbp-30h]
long long v17; // [rsp+68h] [rbp-28h]
long long v18; // [rsp+70h] [rbp-20h]
_QWORD *v19; // [rsp+78h] [rbp-18h]
long long v20; // [rsp+80h] [rbp-10h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
memset(v15, 0LL, sizeof(v15));
memset(v12, 0LL, 32LL);
if ( !v16 )
v16 = ssz_get_uint64_4(v19, "slot") + 1;
if ( v16 )
{
v5 = (unsigned int)(v16 >> 13);
validators = c4_get_validators(v20, v5, v12);
if ( validators )
{
return validators;
}
else
{
ssz_hash_tree_root((unsigned int)v15, v5, v6, v19[1], v7, v8, *v19, v19[1], v19[2]);
calculate_signing_message(v20, v16, v15, v15);
v10 = blst_verify(
(unsigned int)v15,
*(_QWORD *)(v17 + 8),
v13,
512,
*(_DWORD *)v18,
*(_QWORD *)(v18 + 8),
v14 & 1) & 1;
safe_free(v13);
if ( (v10 & 1) != 0 )
return 0;
else
return (unsigned int)c4_state_add_error(v20 + 112, "invalid blockhash signature!");
}
}
else
{
return (unsigned int)c4_state_add_error(v20 + 112, "slot is missing in beacon header!");
}
}
|
c4_verify_blockroot_signature:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0010fbae
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x152808]
CALL 0x0010fcb0
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
LAB_0010fbae:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0010fbd1
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x70
LEA RSI,[0x15313a]
CALL 0x00122510
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010fc9f
LAB_0010fbd1:
JMP 0x0010fbd3
LAB_0010fbd3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x30]
SHR RAX,0xd
MOV ESI,EAX
LEA RDX,[RBP + -0x70]
CALL 0x00117190
MOV dword ptr [RBP + -0x74],EAX
CMP dword ptr [RBP + -0x74],0x0
JZ 0x0010fbfe
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010fc9f
LAB_0010fbfe:
JMP 0x0010fc00
LAB_0010fc00:
MOV RAX,qword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x50]
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 0x0011cbf0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
LEA RDX,[RBP + -0x50]
LEA RCX,[RBP + -0x50]
CALL 0x0010fd00
LEA RDI,[RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x20]
MOV AL,byte ptr [RBP + -0x58]
MOV R8D,dword ptr [RCX]
MOV R9,qword ptr [RCX + 0x8]
MOV ECX,0x200
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP],EAX
CALL 0x0011f660
AND AL,0x1
MOV byte ptr [RBP + -0x75],AL
MOV RDI,qword ptr [RBP + -0x60]
CALL 0x00118740
TEST byte ptr [RBP + -0x75],0x1
JNZ 0x0010fc98
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x70
LEA RSI,[0x15315c]
CALL 0x00122510
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0010fc9f
LAB_0010fc98:
MOV dword ptr [RBP + -0x4],0x0
LAB_0010fc9f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int c4_verify_blockroot_signature
(long param_1,int8 *param_2,int4 *param_3,long param_4,ulong param_5)
{
byte bVar1;
long lVar2;
int4 uVar3;
int8 uVar4;
int8 uVar5;
int1 local_78 [16];
int8 local_68;
byte local_60;
int1 local_58 [32];
ulong local_38;
long local_30;
int4 *local_28;
int8 *local_20;
long local_18;
int local_c;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_58,0,0x20);
memset(local_78,0,0x20);
if (local_38 == 0) {
lVar2 = ssz_get_uint64(local_20,&DAT_00152808);
local_38 = lVar2 + 1;
}
if (local_38 == 0) {
local_c = c4_state_add_error(local_18 + 0x70,"slot is missing in beacon header!");
}
else {
local_c = c4_get_validators(local_18,local_38 >> 0xd & 0xffffffff,local_78);
if (local_c == 0) {
uVar3 = (int4)((ulong)*local_20 >> 0x20);
uVar4 = local_20[1];
uVar5 = local_20[2];
ssz_hash_tree_root(local_58);
calculate_signing_message(local_18,local_38,local_58,local_58);
bVar1 = blst_verify(local_58,*(int8 *)(local_30 + 8),local_68,0x200,*local_28,
*(int8 *)(local_28 + 2),CONCAT44(uVar3,(uint)(local_60 & 1)),uVar4,
uVar5);
safe_free(local_68);
if ((bVar1 & 1) == 0) {
local_c = c4_state_add_error(local_18 + 0x70,"invalid blockhash signature!");
}
else {
local_c = 0;
}
}
}
return local_c;
}
|
|
13,787
|
c4_verify_blockroot_signature
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c
|
c4_status_t c4_verify_blockroot_signature(verify_ctx_t* ctx, ssz_ob_t* header, ssz_ob_t* sync_committee_bits, ssz_ob_t* sync_committee_signature, uint64_t slot) {
bytes32_t root = {0};
c4_sync_state_t sync_state = {0};
if (slot == 0) slot = ssz_get_uint64(header, "slot") + 1;
if (slot == 0) THROW_ERROR("slot is missing in beacon header!");
// get the validators and make sure we have the right ones for the requested period
TRY_ASYNC(c4_get_validators(ctx, slot >> 13, &sync_state));
// compute blockhash
ssz_hash_tree_root(*header, root);
// compute signing message and store it in root again
calculate_signing_message(ctx, slot, root, root);
// verify the signature
bool valid = blst_verify(root, sync_committee_signature->bytes.data, sync_state.validators.data, 512, sync_committee_bits->bytes, sync_state.deserialized);
#ifndef C4_STATIC_MEMORY
safe_free(sync_state.validators.data);
#endif
if (!valid)
THROW_ERROR("invalid blockhash signature!");
return C4_SUCCESS;
}
|
O1
|
c
|
c4_verify_blockroot_signature:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
testq %r8, %r8
jne 0xcf0c
leaq 0x3093c(%rip), %rdx # 0x3d821
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x14ddd
movl (%r12), %edi
movq 0x8(%r12), %rsi
callq 0x135ae
movq %rax, %r12
incq %r12
testq %r12, %r12
je 0xcffa
movq %r12, %rsi
shrq $0xd, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x11a3f
testl %eax, %eax
jne 0xd00d
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq 0x60(%rsp), %r13
movq %r13, %rdi
callq 0x151e5
leaq 0xa0(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movaps (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps %xmm0, -0x20(%rdx)
movaps %xmm1, -0x10(%rdx)
movl 0x80(%rbx), %edi
movq %r12, %rsi
callq 0xcdf0
movl $0x40, 0x48(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x4a2e2(%rip), %rax # 0x57280
movq %rax, 0x58(%rsp)
movq %rax, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x151e5
movq 0x8(%r15), %rsi
movq 0x30(%rsp), %rdx
movzbl 0x38(%rsp), %eax
movl (%r14), %r8d
movq 0x8(%r14), %r9
movl %eax, (%rsp)
movq %r13, %rdi
movl $0x200, %ecx # imm = 0x200
callq 0x16bf8
movl %eax, %ebp
movq 0x30(%rsp), %rdi
callq 0x128b8
xorl %eax, %eax
testb %bpl, %bpl
jne 0xd00d
leaq 0x3117d(%rip), %rsi # 0x3e175
jmp 0xd001
leaq 0x31152(%rip), %rsi # 0x3e153
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x18879
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
c4_verify_blockroot_signature:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r12, r8
mov r15, rcx
mov r14, rdx
mov r13, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+0F8h+var_88], xmm0
movaps [rsp+0F8h+var_98], xmm0
movaps [rsp+0F8h+var_C8], xmm0
movaps [rsp+0F8h+var_D8], xmm0
test r8, r8
jnz short loc_CF0C
lea rdx, aSlot; "slot"
lea r12, [rsp+0F8h+var_78]
mov rdi, r12
mov rsi, r13
call ssz_get
mov edi, [r12]
mov rsi, [r12+8]
call bytes_as_le
mov r12, rax
inc r12
loc_CF0C:
test r12, r12
jz loc_CFFA
mov rsi, r12
shr rsi, 0Dh
lea rdx, [rsp+0F8h+var_D8]
mov rdi, rbx
call c4_get_validators
test eax, eax
jnz loc_D00D
mov rax, [r13+10h]
mov [rsp+0F8h+var_E8], rax
movups xmm0, xmmword ptr [r13+0]
movups [rsp+0F8h+var_F8], xmm0
lea r13, [rsp+0F8h+var_98]
mov rdi, r13
call ssz_hash_tree_root
lea rdx, [rsp+0F8h+var_58]
xorps xmm0, xmm0
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
movaps xmm0, xmmword ptr [r13+0]
movaps xmm1, xmmword ptr [r13+10h]
movaps xmmword ptr [rdx-20h], xmm0
movaps xmmword ptr [rdx-10h], xmm1
mov edi, [rbx+80h]
mov rsi, r12
call eth_calculate_domain
mov dword ptr [rsp+0F8h+var_B0], 40h ; '@'
lea rax, [rsp+0F8h+var_78]
mov qword ptr [rsp+0F8h+var_B0+8], rax
lea rax, SIGNING_DATA_CONTAINER
mov [rsp+0F8h+var_A0], rax
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_B0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, r13
call ssz_hash_tree_root
mov rsi, [r15+8]
mov rdx, qword ptr [rsp+0F8h+var_C8]
movzx eax, byte ptr [rsp+0F8h+var_C8+8]
mov r8d, [r14]
mov r9, [r14+8]
mov dword ptr [rsp+0F8h+var_F8], eax
mov rdi, r13
mov ecx, 200h
call blst_verify
mov ebp, eax
mov rdi, qword ptr [rsp+0F8h+var_C8]
call safe_free
xor eax, eax
test bpl, bpl
jnz short loc_D00D
lea rsi, aInvalidBlockha; "invalid blockhash signature!"
jmp short loc_D001
loc_CFFA:
lea rsi, aSlotIsMissingI; "slot is missing in beacon header!"
loc_D001:
add rbx, 70h ; 'p'
mov rdi, rbx
call c4_state_add_error
loc_D00D:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long c4_verify_blockroot_signature(long long a1, _QWORD *a2, long long a3, long long a4, unsigned long long a5)
{
unsigned long long v5; // r12
long long result; // rax
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
char v17; // bp
const char *v18; // rsi
__int128 v19; // [rsp+20h] [rbp-D8h] BYREF
__int128 v20; // [rsp+30h] [rbp-C8h]
long long v21; // [rsp+48h] [rbp-B0h]
_OWORD *v22; // [rsp+50h] [rbp-A8h]
char **v23; // [rsp+58h] [rbp-A0h]
__int128 v24; // [rsp+60h] [rbp-98h] BYREF
__int128 v25; // [rsp+70h] [rbp-88h]
_OWORD v26[2]; // [rsp+80h] [rbp-78h] BYREF
_BYTE v27[88]; // [rsp+A0h] [rbp-58h] BYREF
v5 = a5;
v25 = 0LL;
v24 = 0LL;
v20 = 0LL;
v19 = 0LL;
if ( !a5 )
{
ssz_get(v26, a2, "slot");
v5 = bytes_as_le(LODWORD(v26[0]), *((_QWORD *)&v26[0] + 1)) + 1;
}
if ( !v5 )
{
v18 = "slot is missing in beacon header!";
return c4_state_add_error(a1 + 112, v18);
}
result = c4_get_validators(a1, v5 >> 13, &v19);
if ( !(_DWORD)result )
{
ssz_hash_tree_root(&v24, v5 >> 13, v9, v10, v11, v12, *a2, a2[1], a2[2]);
memset(v27, 0, 32);
v26[0] = v24;
v26[1] = v25;
eth_calculate_domain(*(unsigned int *)(a1 + 128), v5, (long long)v27);
LODWORD(v21) = 64;
v22 = v26;
v23 = &SIGNING_DATA_CONTAINER;
ssz_hash_tree_root(&v24, v5, v13, v14, v15, v16, v21, v26, &SIGNING_DATA_CONTAINER);
v17 = blst_verify(
(unsigned int)&v24,
*(_QWORD *)(a4 + 8),
v20,
512,
*(_DWORD *)a3,
*(_QWORD *)(a3 + 8),
SBYTE8(v20));
safe_free(v20);
result = 0LL;
if ( !v17 )
{
v18 = "invalid blockhash signature!";
return c4_state_add_error(a1 + 112, v18);
}
}
return result;
}
|
c4_verify_blockroot_signature:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R12,R8
MOV R15,RCX
MOV R14,RDX
MOV R13,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
TEST R8,R8
JNZ 0x0010cf0c
LEA RDX,[0x13d821]
LEA R12,[RSP + 0x80]
MOV RDI,R12
MOV RSI,R13
CALL 0x00114ddd
MOV EDI,dword ptr [R12]
MOV RSI,qword ptr [R12 + 0x8]
CALL 0x001135ae
MOV R12,RAX
INC R12
LAB_0010cf0c:
TEST R12,R12
JZ 0x0010cffa
MOV RSI,R12
SHR RSI,0xd
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00111a3f
TEST EAX,EAX
JNZ 0x0010d00d
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS xmmword ptr [RSP],XMM0
LEA R13,[RSP + 0x60]
MOV RDI,R13
CALL 0x001151e5
LEA RDX,[RSP + 0xa0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOVAPS XMM0,xmmword ptr [R13]
MOVAPS XMM1,xmmword ptr [R13 + 0x10]
MOVAPS xmmword ptr [RDX + -0x20],XMM0
MOVAPS xmmword ptr [RDX + -0x10],XMM1
MOV EDI,dword ptr [RBX + 0x80]
MOV RSI,R12
CALL 0x0010cdf0
MOV dword ptr [RSP + 0x48],0x40
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x157280]
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R13
CALL 0x001151e5
MOV RSI,qword ptr [R15 + 0x8]
MOV RDX,qword ptr [RSP + 0x30]
MOVZX EAX,byte ptr [RSP + 0x38]
MOV R8D,dword ptr [R14]
MOV R9,qword ptr [R14 + 0x8]
MOV dword ptr [RSP],EAX
MOV RDI,R13
MOV ECX,0x200
CALL 0x00116bf8
MOV EBP,EAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001128b8
XOR EAX,EAX
TEST BPL,BPL
JNZ 0x0010d00d
LEA RSI,[0x13e175]
JMP 0x0010d001
LAB_0010cffa:
LEA RSI,[0x13e153]
LAB_0010d001:
ADD RBX,0x70
MOV RDI,RBX
CALL 0x00118879
LAB_0010d00d:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
c4_verify_blockroot_signature
(long param_1,int8 param_2,int4 *param_3,long param_4,ulong param_5)
{
char cVar1;
long lVar2;
int8 uVar3;
char *pcVar4;
int4 uVar5;
int1 *puVar6;
int8 local_d8;
int8 uStack_d0;
void *local_c8;
int8 uStack_c0;
int4 local_b0;
int4 *puStack_a8;
int1 *local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
local_88 = 0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
local_c8 = (void *)0x0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
if (param_5 == 0) {
ssz_get(&local_78,param_2,&DAT_0013d821);
lVar2 = bytes_as_le(local_78,CONCAT44(uStack_6c,uStack_70));
param_5 = lVar2 + 1;
}
if (param_5 == 0) {
pcVar4 = "slot is missing in beacon header!";
}
else {
uVar3 = c4_get_validators(param_1,param_5 >> 0xd,&local_d8);
if ((int)uVar3 != 0) {
return uVar3;
}
ssz_hash_tree_root(&local_98);
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
local_78 = (int4)local_98;
uStack_74 = local_98._4_4_;
uStack_70 = (int4)uStack_90;
uStack_6c = uStack_90._4_4_;
local_68 = (int4)local_88;
uStack_64 = local_88._4_4_;
uStack_60 = (int4)uStack_80;
uStack_5c = uStack_80._4_4_;
eth_calculate_domain(*(int4 *)(param_1 + 0x80),param_5);
local_b0 = 0x40;
puStack_a8 = &local_78;
local_a0 = SIGNING_DATA_CONTAINER;
puVar6 = SIGNING_DATA_CONTAINER;
uVar5 = puStack_a8._0_4_;
ssz_hash_tree_root(&local_98);
cVar1 = blst_verify(&local_98,*(int8 *)(param_4 + 8),local_c8,0x200,*param_3,
*(int8 *)(param_3 + 2),(int1)uStack_c0,uVar5,puVar6);
safe_free(local_c8);
if (cVar1 != '\0') {
return 0;
}
pcVar4 = "invalid blockhash signature!";
}
uVar3 = c4_state_add_error(param_1 + 0x70,pcVar4);
return uVar3;
}
|
|
13,788
|
c4_verify_blockroot_signature
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c
|
c4_status_t c4_verify_blockroot_signature(verify_ctx_t* ctx, ssz_ob_t* header, ssz_ob_t* sync_committee_bits, ssz_ob_t* sync_committee_signature, uint64_t slot) {
bytes32_t root = {0};
c4_sync_state_t sync_state = {0};
if (slot == 0) slot = ssz_get_uint64(header, "slot") + 1;
if (slot == 0) THROW_ERROR("slot is missing in beacon header!");
// get the validators and make sure we have the right ones for the requested period
TRY_ASYNC(c4_get_validators(ctx, slot >> 13, &sync_state));
// compute blockhash
ssz_hash_tree_root(*header, root);
// compute signing message and store it in root again
calculate_signing_message(ctx, slot, root, root);
// verify the signature
bool valid = blst_verify(root, sync_committee_signature->bytes.data, sync_state.validators.data, 512, sync_committee_bits->bytes, sync_state.deserialized);
#ifndef C4_STATIC_MEMORY
safe_free(sync_state.validators.data);
#endif
if (!valid)
THROW_ERROR("invalid blockhash signature!");
return C4_SUCCESS;
}
|
O3
|
c
|
c4_verify_blockroot_signature:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
testq %r8, %r8
jne 0xcda7
leaq 0x30aaf(%rip), %rdx # 0x3d821
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x14885
movl (%r12), %edi
movq 0x8(%r12), %rsi
callq 0x1329e
movq %rax, %r12
incq %r12
jne 0xcda7
leaq 0x313b1(%rip), %rsi # 0x3e153
jmp 0xce8a
movq %r12, %rsi
shrq $0xd, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x11784
testl %eax, %eax
jne 0xce96
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
leaq 0x60(%rsp), %r13
movq %r13, %rdi
callq 0x14b0a
movl 0x80(%rbx), %edi
leaq 0xa0(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movaps (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps %xmm0, -0x20(%rdx)
movaps %xmm1, -0x10(%rdx)
movq %r12, %rsi
callq 0xcc80
movl $0x40, 0x48(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x4a450(%rip), %rax # 0x57280
movq %rax, 0x58(%rsp)
movq %rax, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x14b0a
movq 0x8(%r15), %rsi
movq 0x30(%rsp), %rdx
movzbl 0x38(%rsp), %eax
movl (%r14), %r8d
movq 0x8(%r14), %r9
movl %eax, (%rsp)
movq %r13, %rdi
movl $0x200, %ecx # imm = 0x200
callq 0x164db
movl %eax, %ebp
movq 0x30(%rsp), %rdi
callq 0x125c0
xorl %eax, %eax
testb %bpl, %bpl
jne 0xce96
leaq 0x312eb(%rip), %rsi # 0x3e175
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x17ff5
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
c4_verify_blockroot_signature:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r12, r8
mov r15, rcx
mov r14, rdx
mov r13, rsi
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+0F8h+var_88], xmm0
movaps [rsp+0F8h+var_98], xmm0
movaps [rsp+0F8h+var_C8], xmm0
movaps [rsp+0F8h+var_D8], xmm0
test r8, r8
jnz short loc_CDA7
lea rdx, aSlot; "slot"
lea r12, [rsp+0F8h+var_78]
mov rdi, r12
mov rsi, r13
call ssz_get
mov edi, [r12]
mov rsi, [r12+8]
call bytes_as_le
mov r12, rax
inc r12
jnz short loc_CDA7
lea rsi, aSlotIsMissingI; "slot is missing in beacon header!"
jmp loc_CE8A
loc_CDA7:
mov rsi, r12
shr rsi, 0Dh
lea rdx, [rsp+0F8h+var_D8]
mov rdi, rbx
call c4_get_validators
test eax, eax
jnz loc_CE96
mov rax, [r13+10h]
mov [rsp+0F8h+var_E8], rax
movups xmm0, xmmword ptr [r13+0]
movups [rsp+0F8h+var_F8], xmm0
lea r13, [rsp+0F8h+var_98]
mov rdi, r13
call ssz_hash_tree_root
mov edi, [rbx+80h]
lea rdx, [rsp+0F8h+var_58]
xorps xmm0, xmm0
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
movaps xmm0, xmmword ptr [r13+0]
movaps xmm1, xmmword ptr [r13+10h]
movaps xmmword ptr [rdx-20h], xmm0
movaps xmmword ptr [rdx-10h], xmm1
mov rsi, r12
call eth_calculate_domain
mov dword ptr [rsp+0F8h+var_B0], 40h ; '@'
lea rax, [rsp+0F8h+var_78]
mov qword ptr [rsp+0F8h+var_B0+8], rax
lea rax, SIGNING_DATA_CONTAINER
mov [rsp+0F8h+var_A0], rax
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_B0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, r13
call ssz_hash_tree_root
mov rsi, [r15+8]
mov rdx, qword ptr [rsp+0F8h+var_C8]
movzx eax, byte ptr [rsp+0F8h+var_C8+8]
mov r8d, [r14]
mov r9, [r14+8]
mov dword ptr [rsp+0F8h+var_F8], eax
mov rdi, r13
mov ecx, 200h
call blst_verify
mov ebp, eax
mov rdi, qword ptr [rsp+0F8h+var_C8]
call safe_free
xor eax, eax
test bpl, bpl
jnz short loc_CE96
lea rsi, aInvalidBlockha; "invalid blockhash signature!"
loc_CE8A:
add rbx, 70h ; 'p'
mov rdi, rbx
call c4_state_add_error
loc_CE96:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long c4_verify_blockroot_signature(long long a1, _QWORD *a2, long long a3, long long a4, unsigned long long a5)
{
unsigned long long v5; // r12
long long v9; // rax
const char *v10; // rsi
long long result; // rax
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
long long v16; // rdi
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
char v21; // bp
__int128 v22; // [rsp+20h] [rbp-D8h] BYREF
__int128 v23; // [rsp+30h] [rbp-C8h]
long long v24; // [rsp+48h] [rbp-B0h]
_OWORD *v25; // [rsp+50h] [rbp-A8h]
char **v26; // [rsp+58h] [rbp-A0h]
__int128 v27; // [rsp+60h] [rbp-98h] BYREF
__int128 v28; // [rsp+70h] [rbp-88h]
_OWORD v29[2]; // [rsp+80h] [rbp-78h] BYREF
_BYTE v30[88]; // [rsp+A0h] [rbp-58h] BYREF
v5 = a5;
v28 = 0LL;
v27 = 0LL;
v23 = 0LL;
v22 = 0LL;
if ( !a5 )
{
ssz_get(v29, a2, "slot");
v9 = bytes_as_le(LODWORD(v29[0]), *((_QWORD *)&v29[0] + 1));
v5 = v9 + 1;
if ( v9 == -1 )
{
v10 = "slot is missing in beacon header!";
return c4_state_add_error(a1 + 112, v10);
}
}
result = c4_get_validators(a1, v5 >> 13, &v22);
if ( !(_DWORD)result )
{
ssz_hash_tree_root(&v27, v5 >> 13, v12, v13, v14, v15, *a2, a2[1], a2[2]);
v16 = *(unsigned int *)(a1 + 128);
memset(v30, 0, 32);
v29[0] = v27;
v29[1] = v28;
eth_calculate_domain(v16, v5, (long long)v30);
LODWORD(v24) = 64;
v25 = v29;
v26 = &SIGNING_DATA_CONTAINER;
ssz_hash_tree_root(&v27, v5, v17, v18, v19, v20, v24, v29, &SIGNING_DATA_CONTAINER);
v21 = blst_verify(
(unsigned int)&v27,
*(_QWORD *)(a4 + 8),
v23,
512,
*(_DWORD *)a3,
*(_QWORD *)(a3 + 8),
SBYTE8(v23));
safe_free(v23);
result = 0LL;
if ( !v21 )
{
v10 = "invalid blockhash signature!";
return c4_state_add_error(a1 + 112, v10);
}
}
return result;
}
|
c4_verify_blockroot_signature:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R12,R8
MOV R15,RCX
MOV R14,RDX
MOV R13,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
TEST R8,R8
JNZ 0x0010cda7
LEA RDX,[0x13d821]
LEA R12,[RSP + 0x80]
MOV RDI,R12
MOV RSI,R13
CALL 0x00114885
MOV EDI,dword ptr [R12]
MOV RSI,qword ptr [R12 + 0x8]
CALL 0x0011329e
MOV R12,RAX
INC R12
JNZ 0x0010cda7
LEA RSI,[0x13e153]
JMP 0x0010ce8a
LAB_0010cda7:
MOV RSI,R12
SHR RSI,0xd
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00111784
TEST EAX,EAX
JNZ 0x0010ce96
MOV RAX,qword ptr [R13 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R13]
MOVUPS xmmword ptr [RSP],XMM0
LEA R13,[RSP + 0x60]
MOV RDI,R13
CALL 0x00114b0a
MOV EDI,dword ptr [RBX + 0x80]
LEA RDX,[RSP + 0xa0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOVAPS XMM0,xmmword ptr [R13]
MOVAPS XMM1,xmmword ptr [R13 + 0x10]
MOVAPS xmmword ptr [RDX + -0x20],XMM0
MOVAPS xmmword ptr [RDX + -0x10],XMM1
MOV RSI,R12
CALL 0x0010cc80
MOV dword ptr [RSP + 0x48],0x40
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x50],RAX
LEA RAX,[0x157280]
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R13
CALL 0x00114b0a
MOV RSI,qword ptr [R15 + 0x8]
MOV RDX,qword ptr [RSP + 0x30]
MOVZX EAX,byte ptr [RSP + 0x38]
MOV R8D,dword ptr [R14]
MOV R9,qword ptr [R14 + 0x8]
MOV dword ptr [RSP],EAX
MOV RDI,R13
MOV ECX,0x200
CALL 0x001164db
MOV EBP,EAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001125c0
XOR EAX,EAX
TEST BPL,BPL
JNZ 0x0010ce96
LEA RSI,[0x13e175]
LAB_0010ce8a:
ADD RBX,0x70
MOV RDI,RBX
CALL 0x00117ff5
LAB_0010ce96:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
c4_verify_blockroot_signature
(long param_1,int8 param_2,int4 *param_3,long param_4,ulong param_5)
{
char cVar1;
long lVar2;
int8 uVar3;
char *pcVar4;
int4 uVar5;
int1 *puVar6;
int8 local_d8;
int8 uStack_d0;
void *local_c8;
int8 uStack_c0;
int4 local_b0;
int4 *puStack_a8;
int1 *local_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int4 local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
local_88 = 0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
local_c8 = (void *)0x0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
if (param_5 == 0) {
ssz_get(&local_78,param_2,&DAT_0013d821);
lVar2 = bytes_as_le(local_78,CONCAT44(uStack_6c,uStack_70));
param_5 = lVar2 + 1;
if (param_5 == 0) {
pcVar4 = "slot is missing in beacon header!";
goto LAB_0010ce8a;
}
}
uVar3 = c4_get_validators(param_1,param_5 >> 0xd,&local_d8);
if ((int)uVar3 != 0) {
return uVar3;
}
ssz_hash_tree_root(&local_98);
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
local_78 = (int4)local_98;
uStack_74 = local_98._4_4_;
uStack_70 = (int4)uStack_90;
uStack_6c = uStack_90._4_4_;
local_68 = (int4)local_88;
uStack_64 = local_88._4_4_;
uStack_60 = (int4)uStack_80;
uStack_5c = uStack_80._4_4_;
eth_calculate_domain(*(int4 *)(param_1 + 0x80),param_5);
local_b0 = 0x40;
puStack_a8 = &local_78;
local_a0 = SIGNING_DATA_CONTAINER;
puVar6 = SIGNING_DATA_CONTAINER;
uVar5 = puStack_a8._0_4_;
ssz_hash_tree_root(&local_98);
cVar1 = blst_verify(&local_98,*(int8 *)(param_4 + 8),local_c8,0x200,*param_3,
*(int8 *)(param_3 + 2),(int1)uStack_c0,uVar5,puVar6);
safe_free(local_c8);
if (cVar1 != '\0') {
return 0;
}
pcVar4 = "invalid blockhash signature!";
LAB_0010ce8a:
uVar3 = c4_state_add_error(param_1 + 0x70,pcVar4);
return uVar3;
}
|
|
13,789
|
my_8bit_charset_flags_from_data
|
eloqsql/strings/ctype-simple.c
|
uint my_8bit_charset_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (my_charset_is_8bit_pure_ascii(cs))
flags|= MY_CS_PUREASCII;
if (!my_charset_is_ascii_compatible(cs))
flags|= MY_CS_NONASCII;
return flags;
}
|
O0
|
c
|
my_8bit_charset_flags_from_data:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a680
cmpb $0x0, %al
je 0x3a65b
movl -0xc(%rbp), %eax
orl $0x1000, %eax # imm = 0x1000
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a6e0
cmpb $0x0, %al
jne 0x3a673
movl -0xc(%rbp), %eax
orl $0x2000, %eax # imm = 0x2000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
my_8bit_charset_flags_from_data:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rdi, [rbp+var_8]
call my_charset_is_8bit_pure_ascii
cmp al, 0
jz short loc_3A65B
mov eax, [rbp+var_C]
or eax, 1000h
mov [rbp+var_C], eax
loc_3A65B:
mov rdi, [rbp+var_8]
call my_charset_is_ascii_compatible
cmp al, 0
jnz short loc_3A673
mov eax, [rbp+var_C]
or eax, 2000h
mov [rbp+var_C], eax
loc_3A673:
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long my_8bit_charset_flags_from_data(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = 0;
if ( (unsigned __int8)my_charset_is_8bit_pure_ascii(a1) )
v2 = 4096;
if ( !(unsigned __int8)my_charset_is_ascii_compatible(a1) )
v2 |= 0x2000u;
return v2;
}
|
my_8bit_charset_flags_from_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013a680
CMP AL,0x0
JZ 0x0013a65b
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x1000
MOV dword ptr [RBP + -0xc],EAX
LAB_0013a65b:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013a6e0
CMP AL,0x0
JNZ 0x0013a673
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x2000
MOV dword ptr [RBP + -0xc],EAX
LAB_0013a673:
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
uint my_8bit_charset_flags_from_data(int8 param_1)
{
char cVar1;
int4 local_14;
local_14 = 0;
cVar1 = my_charset_is_8bit_pure_ascii(param_1);
if (cVar1 != '\0') {
local_14 = 0x1000;
}
cVar1 = my_charset_is_ascii_compatible(param_1);
if (cVar1 == '\0') {
local_14 = local_14 | 0x2000;
}
return local_14;
}
|
|
13,790
|
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 0xe373a
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0xe370a
cmpq $0x9, %rcx
je 0xe3722
cmpq $0x20, %rcx
je 0xe3722
jmp 0xe376c
cmpq $0x2b, %rcx
je 0xe3722
cmpq $0x2d, %rcx
jne 0xe376c
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 0xe36f2
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0xe3746
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 0xe384d
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 0xe37c9
movq %rax, -0x30(%rbp)
jmp 0xe37ee
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0xe37d9
addq $-0x37, %rsi
jmp 0xe37e7
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0xe385e
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0xe385e
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0xe3803
movq %rcx, %rdi
jmp 0xe381d
jne 0xe380f
movq -0x58(%rbp), %rdi
cmpq -0x68(%rbp), %rax
ja 0xe381d
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 0xe37ad
jmp 0xe3854
xorl %edi, %edi
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0xe38c7
movl %esi, %r9d
movq %rdi, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xe386a
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0xe38b8
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 0xe38e2
leaq -0x1(%rsi), %rax
testl %r8d, %r8d
movq -0x50(%rbp), %rcx
movl $0x22, (%rcx)
cmovneq %rsi, %rax
jmp 0xe375d
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0xe375b
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xe38d3
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0xe375b
movq %rcx, %rax
negq %rax
testl %r8d, %r8d
cmoveq %rcx, %rax
jmp 0xe375d
|
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_E373A
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_E36F2:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_E370A
cmp rcx, 9
jz short loc_E3722
cmp rcx, 20h ; ' '
jz short loc_E3722
jmp short loc_E376C
loc_E370A:
cmp rcx, 2Bh ; '+'
jz short loc_E3722
cmp rcx, 2Dh ; '-'
jnz short loc_E376C
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_E3722:
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_E36F2
loc_E373A:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_E3746
mov [rcx], r15
loc_E3746:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_E375B:
xor eax, eax
loc_E375D:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E376C:
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_E384D
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor r9d, r9d
loc_E37AD:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_E37C9
mov [rbp+var_30], rax
jmp short loc_E37EE
loc_E37C9:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_E37D9
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_E37E7
loc_E37D9:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_E385E
add rsi, 0FFFFFFFFFFFFFFA9h
loc_E37E7:
mov [rbp+var_30], rsi
mov rax, rsi
loc_E37EE:
cmp eax, [rbp+var_44]
jge short loc_E385E
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_E3803
mov rdi, rcx
jmp short loc_E381D
loc_E3803:
jnz short loc_E380F
mov rdi, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_E381D
loc_E380F:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, r9d
mov rdi, rax
loc_E381D:
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_E37AD
jmp short loc_E3854
loc_E384D:
xor edi, edi
mov rbx, r15
xor esi, esi
loc_E3854:
test eax, eax
jz short loc_E38C7
mov r9d, esi
mov rcx, rdi
loc_E385E:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_E386A
mov [rax], rbx
loc_E386A:
cmp rbx, r15
jz short loc_E38B8
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_E38E2
lea rax, [rsi-1]
test r8d, r8d
mov rcx, [rbp+var_50]
mov dword ptr [rcx], 22h ; '"'
cmovnz rax, rsi
jmp loc_E375D
loc_E38B8:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_E375B
loc_E38C7:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_E38D3
mov [rax], rbx
loc_E38D3:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_E375B
loc_E38E2:
mov rax, rcx
neg rax
test r8d, r8d
cmovz rax, rcx
jmp loc_E375D
|
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 0x001e373a
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_001e36f2:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x001e370a
CMP RCX,0x9
JZ 0x001e3722
CMP RCX,0x20
JZ 0x001e3722
JMP 0x001e376c
LAB_001e370a:
CMP RCX,0x2b
JZ 0x001e3722
CMP RCX,0x2d
JNZ 0x001e376c
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_001e3722:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x001e36f2
LAB_001e373a:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x001e3746
MOV qword ptr [RCX],R15
LAB_001e3746:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_001e375b:
XOR EAX,EAX
LAB_001e375d:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e376c:
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 0x001e384d
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR R9D,R9D
LAB_001e37ad:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x001e37c9
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001e37ee
LAB_001e37c9:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x001e37d9
ADD RSI,-0x37
JMP 0x001e37e7
LAB_001e37d9:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x001e385e
ADD RSI,-0x57
LAB_001e37e7:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_001e37ee:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x001e385e
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x001e3803
MOV RDI,RCX
JMP 0x001e381d
LAB_001e3803:
JNZ 0x001e380f
MOV RDI,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x001e381d
LAB_001e380f:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,R9D
MOV RDI,RAX
LAB_001e381d:
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 0x001e37ad
JMP 0x001e3854
LAB_001e384d:
XOR EDI,EDI
MOV RBX,R15
XOR ESI,ESI
LAB_001e3854:
TEST EAX,EAX
JZ 0x001e38c7
MOV R9D,ESI
MOV RCX,RDI
LAB_001e385e:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001e386a
MOV qword ptr [RAX],RBX
LAB_001e386a:
CMP RBX,R15
JZ 0x001e38b8
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 0x001e38e2
LEA RAX,[RSI + -0x1]
TEST R8D,R8D
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX],0x22
CMOVNZ RAX,RSI
JMP 0x001e375d
LAB_001e38b8:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x001e375b
LAB_001e38c7:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x001e38d3
MOV qword ptr [RAX],RBX
LAB_001e38d3:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x001e375b
LAB_001e38e2:
MOV RAX,RCX
NEG RAX
TEST R8D,R8D
CMOVZ RAX,RCX
JMP 0x001e375d
|
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_001e376c:
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_001e3854;
}
uVar11 = 0;
bVar5 = false;
goto LAB_001e37ad;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_001e376c;
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_001e385e;
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_001e37ad:
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_001e385e;
uVar13 = local_38 - 0x57;
}
}
}
LAB_001e3854:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_001e385e:
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;
}
|
|
13,791
|
entropy_update
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/entropy.c
|
static int entropy_update(mbedtls_entropy_context *ctx, unsigned char source_id,
const unsigned char *data, size_t len)
{
unsigned char header[2];
unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE];
size_t use_len = len;
const unsigned char *p = data;
int ret = 0;
if (use_len > MBEDTLS_ENTROPY_BLOCK_SIZE) {
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
if ((ret = mbedtls_sha512_ret(data, len, tmp, 0)) != 0) {
goto cleanup;
}
#else
if ((ret = mbedtls_sha256_ret(data, len, tmp, 0)) != 0) {
goto cleanup;
}
#endif
p = tmp;
use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
}
header[0] = source_id;
header[1] = use_len & 0xFF;
/*
* Start the accumulator if this has not already happened. Note that
* it is sufficient to start the accumulator here only because all calls to
* gather entropy eventually execute this code.
*/
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
if (ctx->accumulator_started == 0 &&
(ret = mbedtls_sha512_starts_ret(&ctx->accumulator, 0)) != 0) {
goto cleanup;
} else {
ctx->accumulator_started = 1;
}
if ((ret = mbedtls_sha512_update_ret(&ctx->accumulator, header, 2)) != 0) {
goto cleanup;
}
ret = mbedtls_sha512_update_ret(&ctx->accumulator, p, use_len);
#else
if (ctx->accumulator_started == 0 &&
(ret = mbedtls_sha256_starts_ret(&ctx->accumulator, 0)) != 0) {
goto cleanup;
} else {
ctx->accumulator_started = 1;
}
if ((ret = mbedtls_sha256_update_ret(&ctx->accumulator, header, 2)) != 0) {
goto cleanup;
}
ret = mbedtls_sha256_update_ret(&ctx->accumulator, p, use_len);
#endif
cleanup:
mbedtls_platform_zeroize(tmp, sizeof(tmp));
return ret;
}
|
O3
|
c
|
entropy_update:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movl %esi, %r12d
movq %rdi, %rbx
cmpq $0x41, %rcx
jb 0x88fef
leaq 0x10(%rsp), %r15
movq %rdx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x95f62
testl %eax, %eax
jne 0x89040
movl $0x40, %r14d
jmp 0x88ff2
movq %rdx, %r15
movb %r12b, 0xe(%rsp)
movb %r14b, 0xf(%rsp)
cmpl $0x0, (%rbx)
je 0x89031
movl $0x1, (%rbx)
addq $0x8, %rbx
leaq 0xe(%rsp), %rsi
movl $0x2, %edx
movq %rbx, %rdi
callq 0x95bc9
testl %eax, %eax
jne 0x89040
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x95bc9
jmp 0x89040
leaq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x955a6
testl %eax, %eax
je 0x89001
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
callq 0x8db8c
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
entropy_update:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov r14, rcx
mov r12d, esi
mov rbx, rdi
cmp rcx, 41h ; 'A'
jb short loc_88FEF
lea r15, [rsp+78h+var_68]
mov rdi, rdx
mov rsi, r14
mov rdx, r15
xor ecx, ecx
call mbedtls_sha512_ret
test eax, eax
jnz short loc_89040
mov r14d, 40h ; '@'
jmp short loc_88FF2
loc_88FEF:
mov r15, rdx
loc_88FF2:
mov [rsp+78h+var_6A], r12b
mov [rsp+78h+var_69], r14b
cmp dword ptr [rbx], 0
jz short loc_89031
loc_89001:
mov dword ptr [rbx], 1
add rbx, 8
lea rsi, [rsp+78h+var_6A]
mov edx, 2
mov rdi, rbx
call mbedtls_sha512_update_ret
test eax, eax
jnz short loc_89040
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call mbedtls_sha512_update_ret
jmp short loc_89040
loc_89031:
lea rdi, [rbx+8]
xor esi, esi
call mbedtls_sha512_starts_ret
test eax, eax
jz short loc_89001
loc_89040:
mov ebp, eax
lea rdi, [rsp+78h+var_68]
mov esi, 40h ; '@'
call mbedtls_platform_zeroize
mov eax, ebp
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long entropy_update(_DWORD *a1, char a2, _BYTE *a3, unsigned long long a4)
{
long long v4; // r14
_BYTE *v5; // r15
unsigned int updated; // eax
unsigned int v7; // ebp
_BYTE v9[2]; // [rsp+Eh] [rbp-6Ah] BYREF
_BYTE v10[104]; // [rsp+10h] [rbp-68h] BYREF
v4 = a4;
if ( a4 < 0x41 )
{
v5 = a3;
}
else
{
v5 = v10;
updated = mbedtls_sha512_ret(a3, a4, v10, 0LL);
if ( updated )
goto LABEL_9;
v4 = 64LL;
}
v9[0] = a2;
v9[1] = v4;
if ( *a1 || (updated = mbedtls_sha512_starts_ret(a1 + 2, 0LL)) == 0 )
{
*a1 = 1;
updated = mbedtls_sha512_update_ret(a1 + 2, v9, 2LL);
if ( !updated )
updated = mbedtls_sha512_update_ret(a1 + 2, v5, v4);
}
LABEL_9:
v7 = updated;
mbedtls_platform_zeroize(v10, 64LL);
return v7;
}
|
entropy_update:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RCX
MOV R12D,ESI
MOV RBX,RDI
CMP RCX,0x41
JC 0x00188fef
LEA R15,[RSP + 0x10]
MOV RDI,RDX
MOV RSI,R14
MOV RDX,R15
XOR ECX,ECX
CALL 0x00195f62
TEST EAX,EAX
JNZ 0x00189040
MOV R14D,0x40
JMP 0x00188ff2
LAB_00188fef:
MOV R15,RDX
LAB_00188ff2:
MOV byte ptr [RSP + 0xe],R12B
MOV byte ptr [RSP + 0xf],R14B
CMP dword ptr [RBX],0x0
JZ 0x00189031
LAB_00189001:
MOV dword ptr [RBX],0x1
ADD RBX,0x8
LEA RSI,[RSP + 0xe]
MOV EDX,0x2
MOV RDI,RBX
CALL 0x00195bc9
TEST EAX,EAX
JNZ 0x00189040
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00195bc9
JMP 0x00189040
LAB_00189031:
LEA RDI,[RBX + 0x8]
XOR ESI,ESI
CALL 0x001955a6
TEST EAX,EAX
JZ 0x00189001
LAB_00189040:
MOV EBP,EAX
LEA RDI,[RSP + 0x10]
MOV ESI,0x40
CALL 0x0018db8c
MOV EAX,EBP
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int entropy_update(int *param_1,int1 param_2,int1 *param_3,ulong param_4)
{
int iVar1;
int1 local_6a;
int1 local_69;
int1 local_68 [64];
if (0x40 < param_4) {
iVar1 = mbedtls_sha512_ret(param_3,param_4,local_68,0);
if (iVar1 != 0) goto LAB_00189040;
param_4 = 0x40;
param_3 = local_68;
}
local_69 = (int1)param_4;
local_6a = param_2;
if ((*param_1 != 0) || (iVar1 = mbedtls_sha512_starts_ret(param_1 + 2,0), iVar1 == 0)) {
*param_1 = 1;
iVar1 = mbedtls_sha512_update_ret(param_1 + 2,&local_6a,2);
if (iVar1 == 0) {
iVar1 = mbedtls_sha512_update_ret(param_1 + 2,param_3,param_4);
}
}
LAB_00189040:
mbedtls_platform_zeroize(local_68,0x40);
return iVar1;
}
|
|
13,792
|
bfdec_set_si
|
bluesky950520[P]quickjs/libbf.c
|
int bfdec_set_si(bfdec_t *r, int64_t v)
{
int ret;
if (v < 0) {
ret = bfdec_set_ui(r, -v);
r->sign = 1;
} else {
ret = bfdec_set_ui(r, v);
}
return ret;
}
|
O1
|
c
|
bfdec_set_si:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
js 0x8e1c9
movq %rbx, %rdi
popq %rbx
jmp 0x8e0ab
negq %rsi
movq %rbx, %rdi
callq 0x8e0ab
movl $0x1, 0x8(%rbx)
popq %rbx
retq
|
bfdec_set_si:
push rbx
mov rbx, rdi
test rsi, rsi
js short loc_8E1C9
mov rdi, rbx
pop rbx
jmp bfdec_set_ui
loc_8E1C9:
neg rsi
mov rdi, rbx
call bfdec_set_ui
mov dword ptr [rbx+8], 1
pop rbx
retn
|
long long bfdec_set_si(long long a1, signed long long a2)
{
long long result; // rax
if ( a2 >= 0 )
return bfdec_set_ui((_QWORD **)a1, a2);
result = bfdec_set_ui((_QWORD **)a1, -a2);
*(_DWORD *)(a1 + 8) = 1;
return result;
}
|
bfdec_set_si:
PUSH RBX
MOV RBX,RDI
TEST RSI,RSI
JS 0x0018e1c9
MOV RDI,RBX
POP RBX
JMP 0x0018e0ab
LAB_0018e1c9:
NEG RSI
MOV RDI,RBX
CALL 0x0018e0ab
MOV dword ptr [RBX + 0x8],0x1
POP RBX
RET
|
void bfdec_set_si(long param_1,long param_2)
{
if (-1 < param_2) {
bfdec_set_ui(param_1);
return;
}
bfdec_set_ui(param_1,-param_2);
*(int4 *)(param_1 + 8) = 1;
return;
}
|
|
13,793
|
bfdec_set_si
|
bluesky950520[P]quickjs/libbf.c
|
int bfdec_set_si(bfdec_t *r, int64_t v)
{
int ret;
if (v < 0) {
ret = bfdec_set_ui(r, -v);
r->sign = 1;
} else {
ret = bfdec_set_ui(r, v);
}
return ret;
}
|
O2
|
c
|
bfdec_set_si:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
js 0x768eb
movq %rbx, %rdi
popq %rbx
jmp 0x76842
negq %rsi
movq %rbx, %rdi
callq 0x76842
movl $0x1, 0x8(%rbx)
popq %rbx
retq
|
bfdec_set_si:
push rbx
mov rbx, rdi
test rsi, rsi
js short loc_768EB
mov rdi, rbx
pop rbx
jmp bfdec_set_ui
loc_768EB:
neg rsi
mov rdi, rbx
call bfdec_set_ui
mov dword ptr [rbx+8], 1
pop rbx
retn
|
long long bfdec_set_si(long long a1, signed long long a2)
{
long long result; // rax
if ( a2 >= 0 )
return bfdec_set_ui(a1, a2);
result = bfdec_set_ui(a1, -a2);
*(_DWORD *)(a1 + 8) = 1;
return result;
}
|
bfdec_set_si:
PUSH RBX
MOV RBX,RDI
TEST RSI,RSI
JS 0x001768eb
MOV RDI,RBX
POP RBX
JMP 0x00176842
LAB_001768eb:
NEG RSI
MOV RDI,RBX
CALL 0x00176842
MOV dword ptr [RBX + 0x8],0x1
POP RBX
RET
|
void bfdec_set_si(long param_1,long param_2)
{
if (-1 < param_2) {
bfdec_set_ui(param_1);
return;
}
bfdec_set_ui(param_1,-param_2);
*(int4 *)(param_1 + 8) = 1;
return;
}
|
|
13,794
|
heap_open_from_share_and_register
|
eloqsql/storage/heap/hp_open.c
|
HP_INFO *heap_open_from_share_and_register(HP_SHARE *share, int mode)
{
HP_INFO *info;
DBUG_ENTER("heap_open_from_share_and_register");
mysql_mutex_lock(&THR_LOCK_heap);
if ((info= heap_open_from_share(share, mode)))
{
info->open_list.data= (void*) info;
heap_open_list= list_add(heap_open_list,&info->open_list);
/* Unpin the share, it is now pinned by the file. */
share->open_count--;
}
mysql_mutex_unlock(&THR_LOCK_heap);
DBUG_RETURN(info);
}
|
O3
|
c
|
heap_open_from_share_and_register:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x345b4f(%rip), %r15 # 0x36d888
cmpq $0x0, 0x40(%r15)
jne 0x27dab
leaq 0x345b41(%rip), %rdi # 0x36d888
callq 0x24420
movq %rbx, %rdi
movl %r14d, %esi
callq 0x27c7c
movq %rax, %r14
testq %rax, %rax
je 0x27d8a
movq %r14, %rsi
addq $0x2c8, %rsi # imm = 0x2C8
movq %r14, 0x2d8(%r14)
leaq 0x344fa9(%rip), %r12 # 0x36cd20
movq (%r12), %rdi
callq 0x28a4c
movq %rax, (%r12)
decl 0x10c(%rbx)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
jne 0x27db2
leaq 0x345aee(%rip), %rdi # 0x36d888
callq 0x241e0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24644
jmp 0x27d4c
leaq 0x2ceaef(%rip), %rax # 0x2f68a8
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x27d93
|
heap_open_from_share_and_register:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, esi
mov rbx, rdi
lea r15, THR_LOCK_heap
cmp qword ptr [r15+40h], 0
jnz short loc_27DAB
lea rdi, THR_LOCK_heap
call _pthread_mutex_lock
loc_27D4C:
mov rdi, rbx
mov esi, r14d
call heap_open_from_share
mov r14, rax
test rax, rax
jz short loc_27D8A
mov rsi, r14
add rsi, 2C8h
mov [r14+2D8h], r14
lea r12, heap_open_list
mov rdi, [r12]
call list_add
mov [r12], rax
dec dword ptr [rbx+10Ch]
loc_27D8A:
mov rdi, [r15+40h]
test rdi, rdi
jnz short loc_27DB2
loc_27D93:
lea rdi, THR_LOCK_heap
call _pthread_mutex_unlock
mov rax, r14
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_27DAB:
call heap_open_from_share_and_register_cold_1
jmp short loc_27D4C
loc_27DB2:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_27D93
|
long long heap_open_from_share_and_register(long long a1, int a2)
{
long long v2; // rax
long long v3; // r14
if ( THR_LOCK_heap[8] )
heap_open_from_share_and_register_cold_1();
else
pthread_mutex_lock(THR_LOCK_heap);
v2 = heap_open_from_share(a1, a2);
v3 = v2;
if ( v2 )
{
*(_QWORD *)(v2 + 728) = v2;
heap_open_list = list_add(heap_open_list, v2 + 712);
--*(_DWORD *)(a1 + 268);
}
if ( THR_LOCK_heap[8] )
(*((void (**)(void))PSI_server[0] + 44))();
pthread_mutex_unlock(THR_LOCK_heap);
return v3;
}
|
heap_open_from_share_and_register:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,ESI
MOV RBX,RDI
LEA R15,[0x46d888]
CMP qword ptr [R15 + 0x40],0x0
JNZ 0x00127dab
LEA RDI,[0x46d888]
CALL 0x00124420
LAB_00127d4c:
MOV RDI,RBX
MOV ESI,R14D
CALL 0x00127c7c
MOV R14,RAX
TEST RAX,RAX
JZ 0x00127d8a
MOV RSI,R14
ADD RSI,0x2c8
MOV qword ptr [R14 + 0x2d8],R14
LEA R12,[0x46cd20]
MOV RDI,qword ptr [R12]
CALL 0x00128a4c
MOV qword ptr [R12],RAX
DEC dword ptr [RBX + 0x10c]
LAB_00127d8a:
MOV RDI,qword ptr [R15 + 0x40]
TEST RDI,RDI
JNZ 0x00127db2
LAB_00127d93:
LEA RDI,[0x46d888]
CALL 0x001241e0
MOV RAX,R14
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00127dab:
CALL 0x00124644
JMP 0x00127d4c
LAB_00127db2:
LEA RAX,[0x3f68a8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00127d93
|
long heap_open_from_share_and_register(long param_1,int4 param_2)
{
long lVar1;
if (THR_LOCK_heap._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_heap);
}
else {
heap_open_from_share_and_register_cold_1();
}
lVar1 = heap_open_from_share(param_1,param_2);
if (lVar1 != 0) {
*(long *)(lVar1 + 0x2d8) = lVar1;
heap_open_list = list_add(heap_open_list,lVar1 + 0x2c8);
*(int *)(param_1 + 0x10c) = *(int *)(param_1 + 0x10c) + -1;
}
if (THR_LOCK_heap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_heap);
return lVar1;
}
|
|
13,795
|
my_rw_wrlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_wrlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
rwp->waiters++; /* another writer queued */
my_rw_lock_assert_not_write_owner(rwp);
while (rwp->state)
pthread_cond_wait(&rwp->writers, &rwp->lock);
rwp->state = -1;
rwp->waiters--;
#ifdef SAFE_MUTEX
rwp->write_thread= pthread_self();
#endif
pthread_mutex_unlock(&rwp->lock);
return(0);
}
|
O0
|
c
|
my_rw_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25490
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x34d28
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
movq -0x8(%rbp), %rsi
callq 0x25530
jmp 0x34d08
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8c(%rax)
movq -0x8(%rbp), %rdi
callq 0x25210
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_rw_wrlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov ecx, [rax+8Ch]
add ecx, 1
mov [rax+8Ch], ecx
loc_34D08:
mov rax, [rbp+var_8]
cmp dword ptr [rax+88h], 0
jz short loc_34D28
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
mov rsi, [rbp+var_8]
call _pthread_cond_wait
jmp short loc_34D08
loc_34D28:
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0FFFFFFFFh
mov rax, [rbp+var_8]
mov ecx, [rax+8Ch]
add ecx, 0FFFFFFFFh
mov [rax+8Ch], ecx
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
xor eax, eax
add rsp, 10h
pop rbp
retn
|
long long my_rw_wrlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 140);
while ( *(_DWORD *)(a1 + 136) )
pthread_cond_wait(a1 + 88, a1);
*(_DWORD *)(a1 + 136) = -1;
--*(_DWORD *)(a1 + 140);
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00125490
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8c],ECX
LAB_00134d08:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x88],0x0
JZ 0x00134d28
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
MOV RSI,qword ptr [RBP + -0x8]
CALL 0x00125530
JMP 0x00134d08
LAB_00134d28:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0xffffffff
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8c]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x8c],ECX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00125210
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 my_rw_wrlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x8c) = *(int *)((long)param_1 + 0x8c) + 1;
while (*(int *)((long)param_1 + 0x88) != 0) {
pthread_cond_wait((pthread_cond_t *)((long)param_1 + 0x58),param_1);
}
*(int4 *)((long)param_1 + 0x88) = 0xffffffff;
*(int *)((long)param_1 + 0x8c) = *(int *)((long)param_1 + 0x8c) + -1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
13,796
|
my_rw_wrlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_wrlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
rwp->waiters++; /* another writer queued */
my_rw_lock_assert_not_write_owner(rwp);
while (rwp->state)
pthread_cond_wait(&rwp->writers, &rwp->lock);
rwp->state = -1;
rwp->waiters--;
#ifdef SAFE_MUTEX
rwp->write_thread= pthread_self();
#endif
pthread_mutex_unlock(&rwp->lock);
return(0);
}
|
O3
|
c
|
my_rw_wrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x244c0
movl 0x8c(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8c(%rbx)
cmpl $0x0, 0x88(%rbx)
je 0x2f320
leaq 0x58(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24560
cmpl $0x0, 0x88(%rbx)
jne 0x2f304
movl 0x8c(%rbx), %eax
decl %eax
movl $0xffffffff, 0x88(%rbx) # imm = 0xFFFFFFFF
movl %eax, 0x8c(%rbx)
movq %rbx, %rdi
callq 0x24220
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_wrlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov eax, [rbx+8Ch]
lea ecx, [rax+1]
mov [rbx+8Ch], ecx
cmp dword ptr [rbx+88h], 0
jz short loc_2F320
lea r14, [rbx+58h]
loc_2F304:
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
cmp dword ptr [rbx+88h], 0
jnz short loc_2F304
mov eax, [rbx+8Ch]
dec eax
loc_2F320:
mov dword ptr [rbx+88h], 0FFFFFFFFh
mov [rbx+8Ch], eax
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_wrlock(long long a1)
{
int v1; // eax
pthread_mutex_lock(a1);
v1 = *(_DWORD *)(a1 + 140);
*(_DWORD *)(a1 + 140) = v1 + 1;
if ( *(_DWORD *)(a1 + 136) )
{
do
pthread_cond_wait(a1 + 88, a1);
while ( *(_DWORD *)(a1 + 136) );
v1 = *(_DWORD *)(a1 + 140) - 1;
}
*(_DWORD *)(a1 + 136) = -1;
*(_DWORD *)(a1 + 140) = v1;
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_wrlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x001244c0
MOV EAX,dword ptr [RBX + 0x8c]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x8c],ECX
CMP dword ptr [RBX + 0x88],0x0
JZ 0x0012f320
LEA R14,[RBX + 0x58]
LAB_0012f304:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00124560
CMP dword ptr [RBX + 0x88],0x0
JNZ 0x0012f304
MOV EAX,dword ptr [RBX + 0x8c]
DEC EAX
LAB_0012f320:
MOV dword ptr [RBX + 0x88],0xffffffff
MOV dword ptr [RBX + 0x8c],EAX
MOV RDI,RBX
CALL 0x00124220
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_wrlock(pthread_mutex_t *param_1)
{
int iVar1;
pthread_mutex_lock(param_1);
iVar1 = *(int *)((long)param_1 + 0x8c);
*(int *)((long)param_1 + 0x8c) = iVar1 + 1;
if (*(int *)((long)param_1 + 0x88) != 0) {
do {
pthread_cond_wait((pthread_cond_t *)((long)param_1 + 0x58),param_1);
} while (*(int *)((long)param_1 + 0x88) != 0);
iVar1 = *(int *)((long)param_1 + 0x8c) + -1;
}
*(int4 *)((long)param_1 + 0x88) = 0xffffffff;
*(int *)((long)param_1 + 0x8c) = iVar1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
13,797
|
nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
|
msxemulator/build_O3/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp
|
static std::string name(const std::string& ename, int id_)
{
return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb $0x2e, 0xf(%rsp)
movl %edx, %ebp
negl %ebp
cmovsl %edx, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x5692b
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x56922
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x56928
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x5692b
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x568ef
addl $-0x3, %r12d
jmp 0x5692b
addl $-0x2, %r12d
jmp 0x5692b
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0xf520
addq (%r13), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x52291
leaq 0x4f7fc(%rip), %rsi # 0xa6162
leaq 0x4f806(%rip), %r9 # 0xa6173
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r13, %r8
callq 0x569cd
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x56999
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x569c5
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
|
_ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15d, edx
mov [rsp+68h+var_58], rsi
mov rbx, rdi
mov [rsp+68h+var_59], 2Eh ; '.'
mov ebp, edx
neg ebp
cmovs ebp, edx
mov r12d, 1
cmp ebp, 0Ah
jb short loc_5692B
mov r12d, 4
mov eax, 0D1B71759h
mov ecx, ebp
loc_568EF:
cmp ecx, 63h ; 'c'
jbe short loc_56922
cmp ecx, 3E7h
jbe short loc_56928
cmp ecx, 2710h
jb short loc_5692B
mov edx, ecx
imul rdx, rax
shr rdx, 2Dh
add r12d, 4
cmp ecx, 1869Fh
mov ecx, edx
ja short loc_568EF
add r12d, 0FFFFFFFDh
jmp short loc_5692B
loc_56922:
add r12d, 0FFFFFFFEh
jmp short loc_5692B
loc_56928:
dec r12d
loc_5692B:
shr r15d, 1Fh
lea esi, [r12+r15]
lea r14, [rsp+68h+var_40]
mov [r14-10h], r14
lea r13, [rsp+68h+var_50]
mov rdi, r13
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [r13+0]
mov rdi, r15
mov esi, r12d
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
lea rsi, aJsonException; "[json.exception."
lea r9, asc_A6173; "] "
lea rcx, [rsp+68h+var_59]
mov rdi, rbx
mov rdx, [rsp+68h+var_58]
mov r8, r13
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA17_KcRKS8_cS8_RA3_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(char const(&)[17],std::string const&,char,std::string,char const(&)[3] &&)
mov rdi, [rsp+68h+var_50]; void *
cmp rdi, r14
jz short loc_56999
mov rsi, [rsp+68h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_56999:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, r14
jz short loc_569C5
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_569C5:
mov rdi, rbx
call __Unwind_Resume
|
long long nlohmann::json_abi_v3_11_3::detail::exception::name(long long a1, long long a2, int a3)
{
unsigned int v3; // ebp
int v4; // r12d
unsigned int v5; // ecx
bool v6; // cc
unsigned int v7; // r15d
char v9; // [rsp+Fh] [rbp-59h] BYREF
long long v10; // [rsp+10h] [rbp-58h]
void *v11[2]; // [rsp+18h] [rbp-50h] BYREF
_QWORD v12[8]; // [rsp+28h] [rbp-40h] BYREF
v10 = a2;
v9 = 46;
v3 = -a3;
if ( a3 > 0 )
v3 = a3;
v4 = 1;
if ( v3 >= 0xA )
{
v4 = 4;
v5 = v3;
while ( 1 )
{
if ( v5 <= 0x63 )
{
v4 -= 2;
goto LABEL_12;
}
if ( v5 <= 0x3E7 )
break;
if ( v5 < 0x2710 )
goto LABEL_12;
v4 += 4;
v6 = v5 <= 0x1869F;
v5 /= 0x2710u;
if ( v6 )
{
v4 -= 3;
goto LABEL_12;
}
}
--v4;
}
LABEL_12:
v7 = (unsigned int)a3 >> 31;
v11[0] = v12;
std::string::_M_construct(v11, v4 + ((unsigned int)a3 >> 31), 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v11[0] + v7, v4, v3);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(
a1,
(unsigned int)"[json.exception.",
v10,
(unsigned int)&v9,
(unsigned int)v11,
(unsigned int)"] ");
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
return a1;
}
|
name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15D,EDX
MOV qword ptr [RSP + 0x10],RSI
MOV RBX,RDI
MOV byte ptr [RSP + 0xf],0x2e
MOV EBP,EDX
NEG EBP
CMOVS EBP,EDX
MOV R12D,0x1
CMP EBP,0xa
JC 0x0015692b
MOV R12D,0x4
MOV EAX,0xd1b71759
MOV ECX,EBP
LAB_001568ef:
CMP ECX,0x63
JBE 0x00156922
CMP ECX,0x3e7
JBE 0x00156928
CMP ECX,0x2710
JC 0x0015692b
MOV EDX,ECX
IMUL RDX,RAX
SHR RDX,0x2d
ADD R12D,0x4
CMP ECX,0x1869f
MOV ECX,EDX
JA 0x001568ef
ADD R12D,-0x3
JMP 0x0015692b
LAB_00156922:
ADD R12D,-0x2
JMP 0x0015692b
LAB_00156928:
DEC R12D
LAB_0015692b:
SHR R15D,0x1f
LEA ESI,[R12 + R15*0x1]
LEA R14,[RSP + 0x28]
MOV qword ptr [R14 + -0x10],R14
LEA R13,[RSP + 0x18]
MOV RDI,R13
MOV EDX,0x2d
CALL 0x0010f520
ADD R15,qword ptr [R13]
MOV RDI,R15
MOV ESI,R12D
MOV EDX,EBP
CALL 0x00152291
LAB_0015695f:
LEA RSI,[0x1a6162]
LEA R9,[0x1a6173]
LEA RCX,[RSP + 0xf]
MOV RDI,RBX
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,R13
CALL 0x001569cd
LAB_00156982:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R14
JZ 0x00156999
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0010f470
LAB_00156999:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::string const&, int) */
exception * __thiscall
nlohmann::json_abi_v3_11_3::detail::exception::name(exception *this,string *param_1,int param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
char local_59;
string *local_58;
long *local_50 [2];
long local_40 [2];
local_59 = '.';
uVar4 = -param_2;
if (0 < param_2) {
uVar4 = param_2;
}
uVar5 = 1;
if (9 < uVar4) {
uVar3 = (ulong)uVar4;
uVar1 = 4;
do {
uVar5 = uVar1;
uVar2 = (uint)uVar3;
if (uVar2 < 100) {
uVar5 = uVar5 - 2;
goto LAB_0015692b;
}
if (uVar2 < 1000) {
uVar5 = uVar5 - 1;
goto LAB_0015692b;
}
if (uVar2 < 10000) goto LAB_0015692b;
uVar3 = uVar3 / 10000;
uVar1 = uVar5 + 4;
} while (99999 < uVar2);
uVar5 = uVar5 + 1;
}
LAB_0015692b:
local_58 = param_1;
local_50[0] = local_40;
std::__cxx11::string::_M_construct((ulong)local_50,(char)uVar5 - (char)(param_2 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((ulong)((uint)param_2 >> 0x1f) + (long)local_50[0]),uVar5,uVar4);
/* try { // try from 0015695f to 00156981 has its CatchHandler @ 001569ab */
concat<std::__cxx11::string,char_const(&)[17],std::__cxx11::string_const&,char,std::__cxx11::string,char_const(&)[3]>
((detail *)this,"[json.exception.",local_58,&local_59,(string *)local_50,"] ");
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
|
|
13,798
|
create_last_word_mask
|
eloqsql/mysys/my_bitmap.c
|
void create_last_word_mask(MY_BITMAP *map)
{
unsigned char const mask= invers_last_byte_mask(map->n_bits);
/*
The first bytes are to be set to zero since they represent real bits
in the bitvector. The last bytes are set to 0xFF since they represent
bytes not used by the bitvector. Finally the last byte contains bits
as set by the mask above.
*/
unsigned char *ptr= (unsigned char*)&map->last_word_mask;
map->last_word_ptr= map->bitmap + no_words_in_map(map)-1;
switch (no_bytes_in_map(map) & 3) {
case 1:
map->last_word_mask= ~0U;
ptr[0]= mask;
return;
case 2:
map->last_word_mask= ~0U;
ptr[0]= 0;
ptr[1]= mask;
return;
case 3:
map->last_word_mask= 0U;
ptr[2]= mask;
ptr[3]= 0xFFU;
return;
case 0:
map->last_word_mask= 0U;
ptr[3]= mask;
return;
}
}
|
O3
|
c
|
create_last_word_mask:
pushq %rbp
movq %rsp, %rbp
movl 0x1c(%rdi), %eax
leal 0x7(%rax), %ecx
movq (%rdi), %rdx
addl $0x1f, %eax
shrl $0x5, %eax
leaq (%rdx,%rax,4), %rax
addq $-0x4, %rax
movq %rax, 0x8(%rdi)
movl %ecx, %eax
shrl $0x3, %eax
andl $0x3, %eax
leaq 0x44c96(%rip), %rdx # 0xe1bbc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl $0x0, 0x18(%rdi)
addq $0x1b, %rdi
jmp 0x9cf60
movl $0xffffff00, 0x18(%rdi) # imm = 0xFFFFFF00
addq $0x19, %rdi
jmp 0x9cf60
movl $0xff000000, 0x18(%rdi) # imm = 0xFF000000
addq $0x1a, %rdi
jmp 0x9cf60
addq $0x18, %rdi
movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF
andb $0x7, %cl
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
shll %cl, %eax
movb %al, (%rdi)
popq %rbp
retq
|
create_last_word_mask:
push rbp
mov rbp, rsp
mov eax, [rdi+1Ch]
lea ecx, [rax+7]
mov rdx, [rdi]
add eax, 1Fh
shr eax, 5
lea rax, [rdx+rax*4]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rdi+8], rax
mov eax, ecx
shr eax, 3
and eax, 3
lea rdx, jpt_9CF2D
movsxd rax, ds:(jpt_9CF2D - 0E1BBCh)[rdx+rax*4]; switch 4 cases
add rax, rdx
jmp rax; switch jump
loc_9CF2F:
mov dword ptr [rdi+18h], 0; jumptable 000000000009CF2D case 0
add rdi, 1Bh
jmp short loc_9CF60
loc_9CF3C:
mov dword ptr [rdi+18h], 0FFFFFF00h; jumptable 000000000009CF2D case 2
add rdi, 19h
jmp short loc_9CF60
loc_9CF49:
mov dword ptr [rdi+18h], 0FF000000h; jumptable 000000000009CF2D case 3
add rdi, 1Ah
jmp short loc_9CF60
loc_9CF56:
add rdi, 18h; jumptable 000000000009CF2D case 1
mov dword ptr [rdi], 0FFFFFFFFh
loc_9CF60:
and cl, 7
mov eax, 0FFFFFFFEh
shl eax, cl
mov [rdi], al
pop rbp
retn
|
long long create_last_word_mask(long long a1)
{
int v1; // eax
_DWORD *v2; // rdi
long long result; // rax
v1 = *(_DWORD *)(a1 + 28);
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1 + 4LL * ((unsigned int)(v1 + 31) >> 5) - 4;
switch ( ((unsigned int)(v1 + 7) >> 3) & 3 )
{
case 0u:
*(_DWORD *)(a1 + 24) = 0;
v2 = (_DWORD *)(a1 + 27);
break;
case 1u:
v2 = (_DWORD *)(a1 + 24);
*v2 = -1;
break;
case 2u:
*(_DWORD *)(a1 + 24) = -256;
v2 = (_DWORD *)(a1 + 25);
break;
case 3u:
*(_DWORD *)(a1 + 24) = -16777216;
v2 = (_DWORD *)(a1 + 26);
break;
}
result = (unsigned int)(-2 << ((v1 + 7) & 7));
*(_BYTE *)v2 = result;
return result;
}
|
create_last_word_mask:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RDI + 0x1c]
LEA ECX,[RAX + 0x7]
MOV RDX,qword ptr [RDI]
ADD EAX,0x1f
SHR EAX,0x5
LEA RAX,[RDX + RAX*0x4]
ADD RAX,-0x4
MOV qword ptr [RDI + 0x8],RAX
MOV EAX,ECX
SHR EAX,0x3
AND EAX,0x3
LEA RDX,[0x1e1bbc]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_0:
MOV dword ptr [RDI + 0x18],0x0
ADD RDI,0x1b
JMP 0x0019cf60
caseD_2:
MOV dword ptr [RDI + 0x18],0xffffff00
ADD RDI,0x19
JMP 0x0019cf60
caseD_3:
MOV dword ptr [RDI + 0x18],0xff000000
ADD RDI,0x1a
JMP 0x0019cf60
caseD_1:
ADD RDI,0x18
MOV dword ptr [RDI],0xffffffff
LAB_0019cf60:
AND CL,0x7
MOV EAX,0xfffffffe
SHL EAX,CL
MOV byte ptr [RDI],AL
POP RBP
RET
|
void create_last_word_mask(long *param_1)
{
uint uVar1;
uVar1 = *(int *)((long)param_1 + 0x1c) + 7;
param_1[1] = *param_1 + (ulong)(*(int *)((long)param_1 + 0x1c) + 0x1fU >> 5) * 4 + -4;
switch(uVar1 >> 3 & 3) {
case 0:
*(int4 *)(param_1 + 3) = 0;
param_1 = (long *)((long)param_1 + 0x1b);
break;
case 1:
param_1 = param_1 + 3;
*(int4 *)param_1 = 0xffffffff;
break;
case 2:
*(int4 *)(param_1 + 3) = 0xffffff00;
param_1 = (long *)((long)param_1 + 0x19);
break;
case 3:
*(int4 *)(param_1 + 3) = 0xff000000;
param_1 = (long *)((long)param_1 + 0x1a);
}
*(char *)param_1 = (char)(-2 << ((byte)uVar1 & 7));
return;
}
|
|
13,799
|
my_casefold_ujis
|
eloqsql/strings/ctype-ujis.c
|
static size_t
my_casefold_ujis(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)),
const uchar * const map,
size_t is_upper)
{
const char *srcend= src + srclen, *dst0= dst;
while (src < srcend)
{
size_t mblen= my_ismbchar(cs, src, srcend);
if (mblen)
{
MY_UNICASE_CHARACTER *ch;
ch= (mblen == 2) ?
get_case_info_for_ch(cs, 0, (uchar) src[0], (uchar) src[1]) :
get_case_info_for_ch(cs, 1, (uchar) src[1], (uchar) src[2]);
if (ch)
{
int code= is_upper ? ch->toupper : ch->tolower;
src+= mblen;
if (code > 0xFFFF)
*dst++= (char) (uchar) ((code >> 16) & 0xFF);
if (code > 0xFF)
*dst++= (char) (uchar) ((code >> 8) & 0xFF);
*dst++= (char) (uchar) (code & 0xFF);
}
else
{
if (mblen == 3)
*dst++= *src++;
*dst++= *src++;
*dst++= *src++;
}
}
else
{
*dst++= (char) map[(uchar) *src++];
}
}
return (size_t) (dst - dst0);
}
|
O3
|
c
|
my_casefold_ujis:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, %rbx
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x8e0af
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
addq %rsi, %r15
xorl %eax, %eax
testq %r9, %r9
sete %al
shll $0x2, %eax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
movq -0x30(%rbp), %rbx
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
cmovll %r14d, %eax
testl %eax, %eax
je 0x8e009
cmpl $0x2, %eax
jne 0x8e01f
movzbl (%r12), %ecx
movq 0x78(%r13), %rdx
movq 0x8(%rdx), %rdx
movq (%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x8e079
movzbl 0x1(%r12), %edx
jmp 0x8e040
movzbl (%r12), %eax
incq %r12
movq -0x40(%rbp), %rcx
movb (%rcx,%rax), %al
movb %al, (%rbx)
jmp 0x8e0a3
movzbl 0x1(%r12), %ecx
movq 0x78(%r13), %rdx
movq 0x8(%rdx), %rdx
movq 0x800(%rdx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x8e068
movzbl 0x2(%r12), %edx
leaq (%rdx,%rdx,2), %rdx
leaq (%rcx,%rdx,4), %rcx
testq %rcx, %rcx
je 0x8e068
movq -0x38(%rbp), %rdx
movl (%rcx,%rdx), %ecx
cmpl $0x10000, %ecx # imm = 0x10000
jl 0x8e091
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, (%rbx)
incq %rbx
jmp 0x8e099
cmpl $0x3, %eax
jne 0x8e079
movb (%r12), %al
incq %r12
movb %al, (%rbx)
incq %rbx
movb (%r12), %al
movb %al, (%rbx)
movb 0x1(%r12), %al
addq $0x2, %r12
movb %al, 0x1(%rbx)
addq $0x2, %rbx
jmp 0x8e0a6
cmpl $0x100, %ecx # imm = 0x100
jl 0x8e09e
movb %ch, (%rbx)
incq %rbx
addq %rax, %r12
movb %cl, (%rbx)
incq %rbx
cmpq %r15, %r12
jb 0x8dfc5
subq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_casefold_ujis:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_40], r8
mov rbx, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle loc_8E0AF
mov r15, rdx
mov r12, rsi
mov r13, rdi
add r15, rsi
xor eax, eax
test r9, r9
setz al
shl eax, 2
mov [rbp+var_38], rax
xor r14d, r14d
mov rbx, [rbp+var_30]
loc_8DFC5:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r15
call qword ptr [rax+0C0h]
cmp eax, 2
cmovl eax, r14d
test eax, eax
jz short loc_8E009
cmp eax, 2
jnz short loc_8E01F
movzx ecx, byte ptr [r12]
mov rdx, [r13+78h]
mov rdx, [rdx+8]
mov rcx, [rdx+rcx*8]
test rcx, rcx
jz short loc_8E079
movzx edx, byte ptr [r12+1]
jmp short loc_8E040
loc_8E009:
movzx eax, byte ptr [r12]
inc r12
mov rcx, [rbp+var_40]
mov al, [rcx+rax]
mov [rbx], al
jmp loc_8E0A3
loc_8E01F:
movzx ecx, byte ptr [r12+1]
mov rdx, [r13+78h]
mov rdx, [rdx+8]
mov rcx, [rdx+rcx*8+800h]
test rcx, rcx
jz short loc_8E068
movzx edx, byte ptr [r12+2]
loc_8E040:
lea rdx, [rdx+rdx*2]
lea rcx, [rcx+rdx*4]
test rcx, rcx
jz short loc_8E068
mov rdx, [rbp+var_38]
mov ecx, [rcx+rdx]
cmp ecx, 10000h
jl short loc_8E091
mov edx, ecx
shr edx, 10h
mov [rbx], dl
inc rbx
jmp short loc_8E099
loc_8E068:
cmp eax, 3
jnz short loc_8E079
mov al, [r12]
inc r12
mov [rbx], al
inc rbx
loc_8E079:
mov al, [r12]
mov [rbx], al
mov al, [r12+1]
add r12, 2
mov [rbx+1], al
add rbx, 2
jmp short loc_8E0A6
loc_8E091:
cmp ecx, 100h
jl short loc_8E09E
loc_8E099:
mov [rbx], ch
inc rbx
loc_8E09E:
add r12, rax
mov [rbx], cl
loc_8E0A3:
inc rbx
loc_8E0A6:
cmp r12, r15
jb loc_8DFC5
loc_8E0AF:
sub rbx, [rbp+var_30]
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_BYTE * my_casefold_ujis(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 *a4,
long long a5,
long long a6)
{
unsigned __int8 *v6; // rbx
unsigned __int8 *v7; // r12
unsigned long long v8; // r15
long long v9; // rax
long long v10; // rcx
long long v11; // rdx
long long v12; // rax
long long v13; // rcx
int v14; // ecx
unsigned __int8 v15; // al
unsigned __int8 v16; // al
long long v19; // [rsp+8h] [rbp-38h]
v6 = a4;
if ( a3 > 0 )
{
v7 = a2;
v8 = (unsigned long long)&a2[a3];
v19 = 4 * (unsigned int)(a6 == 0);
v6 = a4;
while ( 1 )
{
v9 = (*(long long ( **)(long long, unsigned __int8 *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(
a1,
v7,
v8);
if ( (int)v9 < 2 )
v9 = 0LL;
if ( !(_DWORD)v9 )
{
v12 = *v7++;
*v6 = *(_BYTE *)(a5 + v12);
goto LABEL_21;
}
if ( (_DWORD)v9 != 2 )
break;
v10 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL) + 8LL * *v7);
if ( v10 )
{
v11 = v7[1];
LABEL_12:
v13 = v10 + 12 * v11;
if ( v13 )
{
v14 = *(_DWORD *)(v13 + v19);
if ( v14 >= 0x10000 )
{
*v6++ = BYTE2(v14);
goto LABEL_19;
}
if ( v14 >= 256 )
LABEL_19:
*v6++ = BYTE1(v14);
v7 += v9;
*v6 = v14;
LABEL_21:
++v6;
goto LABEL_22;
}
goto LABEL_15;
}
LABEL_17:
*v6 = *v7;
v16 = v7[1];
v7 += 2;
v6[1] = v16;
v6 += 2;
LABEL_22:
if ( (unsigned long long)v7 >= v8 )
return (_BYTE *)(v6 - a4);
}
v10 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 120) + 8LL) + 8LL * v7[1] + 2048);
if ( v10 )
{
v11 = v7[2];
goto LABEL_12;
}
LABEL_15:
if ( (_DWORD)v9 == 3 )
{
v15 = *v7++;
*v6++ = v15;
}
goto LABEL_17;
}
return (_BYTE *)(v6 - a4);
}
|
my_casefold_ujis:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x40],R8
MOV RBX,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x0018e0af
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
ADD R15,RSI
XOR EAX,EAX
TEST R9,R9
SETZ AL
SHL EAX,0x2
MOV qword ptr [RBP + -0x38],RAX
XOR R14D,R14D
MOV RBX,qword ptr [RBP + -0x30]
LAB_0018dfc5:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
CMOVL EAX,R14D
TEST EAX,EAX
JZ 0x0018e009
CMP EAX,0x2
JNZ 0x0018e01f
MOVZX ECX,byte ptr [R12]
MOV RDX,qword ptr [R13 + 0x78]
MOV RDX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX + RCX*0x8]
TEST RCX,RCX
JZ 0x0018e079
MOVZX EDX,byte ptr [R12 + 0x1]
JMP 0x0018e040
LAB_0018e009:
MOVZX EAX,byte ptr [R12]
INC R12
MOV RCX,qword ptr [RBP + -0x40]
MOV AL,byte ptr [RCX + RAX*0x1]
MOV byte ptr [RBX],AL
JMP 0x0018e0a3
LAB_0018e01f:
MOVZX ECX,byte ptr [R12 + 0x1]
MOV RDX,qword ptr [R13 + 0x78]
MOV RDX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RDX + RCX*0x8 + 0x800]
TEST RCX,RCX
JZ 0x0018e068
MOVZX EDX,byte ptr [R12 + 0x2]
LAB_0018e040:
LEA RDX,[RDX + RDX*0x2]
LEA RCX,[RCX + RDX*0x4]
TEST RCX,RCX
JZ 0x0018e068
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RCX + RDX*0x1]
CMP ECX,0x10000
JL 0x0018e091
MOV EDX,ECX
SHR EDX,0x10
MOV byte ptr [RBX],DL
INC RBX
JMP 0x0018e099
LAB_0018e068:
CMP EAX,0x3
JNZ 0x0018e079
MOV AL,byte ptr [R12]
INC R12
MOV byte ptr [RBX],AL
INC RBX
LAB_0018e079:
MOV AL,byte ptr [R12]
MOV byte ptr [RBX],AL
MOV AL,byte ptr [R12 + 0x1]
ADD R12,0x2
MOV byte ptr [RBX + 0x1],AL
ADD RBX,0x2
JMP 0x0018e0a6
LAB_0018e091:
CMP ECX,0x100
JL 0x0018e09e
LAB_0018e099:
MOV byte ptr [RBX],CH
INC RBX
LAB_0018e09e:
ADD R12,RAX
MOV byte ptr [RBX],CL
LAB_0018e0a3:
INC RBX
LAB_0018e0a6:
CMP R12,R15
JC 0x0018dfc5
LAB_0018e0af:
SUB RBX,qword ptr [RBP + -0x30]
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casefold_ujis(long param_1,byte *param_2,long param_3,byte *param_4,long param_5,
long param_6)
{
byte *pbVar1;
byte bVar2;
uint uVar3;
int iVar4;
long lVar6;
byte *pbVar7;
byte *pbVar8;
ulong uVar5;
pbVar7 = param_4;
if (0 < param_3) {
pbVar8 = param_2 + param_3;
do {
uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_2,pbVar8);
uVar5 = (ulong)uVar3;
if ((int)uVar3 < 2) {
uVar5 = 0;
}
iVar4 = (int)uVar5;
if (iVar4 == 0) {
bVar2 = *param_2;
param_2 = param_2 + 1;
*pbVar7 = *(byte *)(param_5 + (ulong)bVar2);
LAB_0018e0a3:
pbVar7 = pbVar7 + 1;
}
else {
if (iVar4 == 2) {
lVar6 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + (ulong)*param_2 * 8);
if (lVar6 != 0) {
bVar2 = param_2[1];
LAB_0018e040:
lVar6 = lVar6 + (ulong)bVar2 * 0xc;
if (lVar6 == 0) goto LAB_0018e068;
iVar4 = *(int *)(lVar6 + (ulong)(param_6 == 0) * 4);
if (iVar4 < 0x10000) {
if (0xff < iVar4) goto LAB_0018e099;
}
else {
*pbVar7 = (byte)((uint)iVar4 >> 0x10);
pbVar7 = pbVar7 + 1;
LAB_0018e099:
*pbVar7 = (byte)((uint)iVar4 >> 8);
pbVar7 = pbVar7 + 1;
}
param_2 = param_2 + uVar5;
*pbVar7 = (byte)iVar4;
goto LAB_0018e0a3;
}
}
else {
lVar6 = *(long *)(*(long *)(*(long *)(param_1 + 0x78) + 8) + 0x800 + (ulong)param_2[1] * 8
);
if (lVar6 != 0) {
bVar2 = param_2[2];
goto LAB_0018e040;
}
LAB_0018e068:
if (iVar4 == 3) {
bVar2 = *param_2;
param_2 = param_2 + 1;
*pbVar7 = bVar2;
pbVar7 = pbVar7 + 1;
}
}
*pbVar7 = *param_2;
pbVar1 = param_2 + 1;
param_2 = param_2 + 2;
pbVar7[1] = *pbVar1;
pbVar7 = pbVar7 + 2;
}
} while (param_2 < pbVar8);
}
return (long)pbVar7 - (long)param_4;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.