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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
53,700 | delete_dir_entry | eloqsql/storage/maria/ma_blockrec.c | static int delete_dir_entry(MARIA_SHARE *share,
uchar *buff, uint record_number,
uint *empty_space_res)
{
uint block_size= share->block_size;
uint number_of_records= (uint) buff[DIR_COUNT_OFFSET];
uint length, empty_space;
uchar *dir;
DBUG_ENTER("delete_dir_entry");
DBUG_PRINT("enter", ("record_number: %u number_of_records: %u",
record_number, number_of_records));
#ifdef SANITY_CHECKS
if (record_number >= number_of_records ||
record_number > ((block_size - LSN_SIZE - PAGE_TYPE_SIZE - 1 -
PAGE_SUFFIX_SIZE) / DIR_ENTRY_SIZE))
{
DBUG_PRINT("error", ("record_number: %u number_of_records: %u",
record_number, number_of_records));
DBUG_RETURN(-1);
}
#endif
check_directory(share, buff, block_size, 0, (uint) -1);
empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
dir= dir_entry_pos(buff, block_size, record_number);
length= uint2korr(dir + 2); /* Length of entry we just deleted */
DBUG_ASSERT(uint2korr(dir) != 0 && length < block_size);
if (record_number == number_of_records - 1)
{
/* Delete this entry and all following free directory entries */
uchar *end= buff + block_size - PAGE_SUFFIX_SIZE;
number_of_records--;
dir+= DIR_ENTRY_SIZE;
empty_space+= DIR_ENTRY_SIZE;
/* Unlink and free the next empty ones */
while (dir < end && dir[0] == 0 && dir[1] == 0)
{
number_of_records--;
if (dir[2] == END_OF_DIR_FREE_LIST)
buff[DIR_FREE_OFFSET]= dir[3];
else
{
uchar *prev_entry= dir_entry_pos(buff, block_size, (uint) dir[2]);
DBUG_ASSERT(uint2korr(prev_entry) == 0 && prev_entry[3] ==
number_of_records);
prev_entry[3]= dir[3];
}
if (dir[3] != END_OF_DIR_FREE_LIST)
{
uchar *next_entry= dir_entry_pos(buff, block_size, (uint) dir[3]);
DBUG_ASSERT(uint2korr(next_entry) == 0 && next_entry[2] ==
number_of_records);
next_entry[2]= dir[2];
}
dir+= DIR_ENTRY_SIZE;
empty_space+= DIR_ENTRY_SIZE;
}
if (number_of_records == 0)
{
/* All entries on page deleted */
DBUG_PRINT("info", ("Page marked as unallocated"));
buff[PAGE_TYPE_OFFSET]= UNALLOCATED_PAGE;
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
dir= dir_entry_pos(buff, block_size, record_number);
bzero(dir, (record_number+1) * DIR_ENTRY_SIZE);
}
#endif
*empty_space_res= block_size;
DBUG_RETURN(1);
}
buff[DIR_COUNT_OFFSET]= (uchar) number_of_records;
}
else
{
/* Update directory */
dir[0]= dir[1]= 0;
dir[2]= END_OF_DIR_FREE_LIST;
if ((dir[3]= buff[DIR_FREE_OFFSET]) != END_OF_DIR_FREE_LIST)
{
/* Relink next entry to point to newly freed entry */
uchar *next_entry= dir_entry_pos(buff, block_size, (uint) dir[3]);
DBUG_ASSERT(uint2korr(next_entry) == 0 &&
next_entry[2] == END_OF_DIR_FREE_LIST);
next_entry[2]= record_number;
}
buff[DIR_FREE_OFFSET]= record_number;
}
empty_space+= length;
int2store(buff + EMPTY_SPACE_OFFSET, empty_space);
buff[PAGE_TYPE_OFFSET]|= (uchar) PAGE_CAN_BE_COMPACTED;
*empty_space_res= empty_space;
check_directory(share, buff, block_size, 0, empty_space);
DBUG_RETURN(0);
} | O3 | c | delete_dir_entry:
movzbl 0x8(%rsi), %r11d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %edx, %r11d
jbe 0x5fb57
leal -0xd(%rdi), %r8d
shrl $0x2, %r8d
cmpl %edx, %r8d
jb 0x5fb57
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movzwl 0xa(%rsi), %r8d
movl %edi, %r9d
addq %rsi, %r9
leal (,%rdx,4), %ebx
movq %r9, %rax
subq %rbx, %rax
movq $-0x8, %r10
subq %rbx, %r10
movzwl -0x6(%rax), %eax
decl %r11d
cmpl %edx, %r11d
jne 0x5fb02
testl %edx, %edx
je 0x5fb48
addl $0x4, %r8d
cmpb $0x0, 0x4(%r9,%r10)
jne 0x5faf9
cmpb $0x0, 0x5(%r9,%r10)
jne 0x5faf9
movzbl 0x6(%r9,%r10), %ebx
cmpq $0xff, %rbx
je 0x5fac3
movb 0x7(%r9,%r10), %r11b
shll $0x2, %ebx
movq %r9, %r14
subq %rbx, %r14
movb %r11b, -0x5(%r14)
jmp 0x5facc
movb 0x7(%r9,%r10), %r11b
movb %r11b, 0x9(%rsi)
cmpb $-0x1, %r11b
je 0x5fae9
movb 0x6(%r9,%r10), %bl
movzbl %r11b, %r11d
shll $0x2, %r11d
movq %r9, %r14
subq %r11, %r14
movb %bl, -0x6(%r14)
decl %edx
addl $0x4, %r8d
addq $0x4, %r10
cmpq $-0x8, %r10
jl 0x5fa90
testl %edx, %edx
je 0x5fb48
movb %dl, 0x8(%rsi)
jmp 0x5fb35
negq %rbx
xorl %edi, %edi
movb %dil, -0x7(%r9,%rbx)
movb %dil, (%r9,%r10)
movb $-0x1, -0x6(%r9,%rbx)
movzbl 0x9(%rsi), %edi
movb %dil, -0x5(%r9,%rbx)
cmpq $0xff, %rdi
je 0x5fb32
shll $0x2, %edi
subq %rdi, %r9
movb %dl, -0x6(%r9)
movb %dl, 0x9(%rsi)
addl %eax, %r8d
movw %r8w, 0xa(%rsi)
orb $-0x80, 0x7(%rsi)
xorl %eax, %eax
movl %r8d, %edi
jmp 0x5fb51
movb $0x0, 0x7(%rsi)
movl $0x1, %eax
movl %edi, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
| delete_dir_entry:
movzx r11d, byte ptr [rsi+8]
mov eax, 0FFFFFFFFh
cmp r11d, edx
jbe locret_5FB57
lea r8d, [rdi-0Dh]
shr r8d, 2
cmp r8d, edx
jb locret_5FB57
push rbp
mov rbp, rsp
push r14
push rbx
movzx r8d, word ptr [rsi+0Ah]
mov r9d, edi
add r9, rsi
lea ebx, ds:0[rdx*4]
mov rax, r9
sub rax, rbx
mov r10, 0FFFFFFFFFFFFFFF8h
sub r10, rbx
movzx eax, word ptr [rax-6]
dec r11d
cmp r11d, edx
jnz short loc_5FB02
test edx, edx
jz loc_5FB48
add r8d, 4
loc_5FA90:
cmp byte ptr [r9+r10+4], 0
jnz short loc_5FAF9
cmp byte ptr [r9+r10+5], 0
jnz short loc_5FAF9
movzx ebx, byte ptr [r9+r10+6]
cmp rbx, 0FFh
jz short loc_5FAC3
mov r11b, [r9+r10+7]
shl ebx, 2
mov r14, r9
sub r14, rbx
mov [r14-5], r11b
jmp short loc_5FACC
loc_5FAC3:
mov r11b, [r9+r10+7]
mov [rsi+9], r11b
loc_5FACC:
cmp r11b, 0FFh
jz short loc_5FAE9
mov bl, [r9+r10+6]
movzx r11d, r11b
shl r11d, 2
mov r14, r9
sub r14, r11
mov [r14-6], bl
loc_5FAE9:
dec edx
add r8d, 4
add r10, 4
cmp r10, 0FFFFFFFFFFFFFFF8h
jl short loc_5FA90
loc_5FAF9:
test edx, edx
jz short loc_5FB48
mov [rsi+8], dl
jmp short loc_5FB35
loc_5FB02:
neg rbx
xor edi, edi
mov [r9+rbx-7], dil
mov [r9+r10], dil
mov byte ptr [r9+rbx-6], 0FFh
movzx edi, byte ptr [rsi+9]
mov [r9+rbx-5], dil
cmp rdi, 0FFh
jz short loc_5FB32
shl edi, 2
sub r9, rdi
mov [r9-6], dl
loc_5FB32:
mov [rsi+9], dl
loc_5FB35:
add r8d, eax
mov [rsi+0Ah], r8w
or byte ptr [rsi+7], 80h
xor eax, eax
mov edi, r8d
jmp short loc_5FB51
loc_5FB48:
mov byte ptr [rsi+7], 0
mov eax, 1
loc_5FB51:
mov [rcx], edi
pop rbx
pop r14
pop rbp
locret_5FB57:
retn
| long long delete_dir_entry(unsigned int a1, long long a2, unsigned int a3, unsigned int *a4)
{
unsigned int v4; // r11d
long long result; // rax
int v6; // r8d
long long v7; // r9
long long v8; // rbx
long long v9; // r10
int v10; // eax
long long v11; // rbx
unsigned __int8 v12; // r11
long long v13; // rbx
long long v14; // rdi
unsigned int v15; // r8d
v4 = *(unsigned __int8 *)(a2 + 8);
result = 0xFFFFFFFFLL;
if ( v4 > a3 && (a1 - 13) >> 2 >= a3 )
{
v6 = *(unsigned __int16 *)(a2 + 10);
v7 = a2 + a1;
v8 = 4 * a3;
v9 = -8 - v8;
v10 = *(unsigned __int16 *)(v7 - v8 - 6);
if ( v4 - 1 == a3 )
{
if ( !a3 )
goto LABEL_20;
v6 += 4;
do
{
if ( *(_BYTE *)(v7 + v9 + 4) || *(_BYTE *)(v7 + v9 + 5) )
break;
v11 = *(unsigned __int8 *)(v7 + v9 + 6);
v12 = *(_BYTE *)(v7 + v9 + 7);
if ( v11 == 255 )
*(_BYTE *)(a2 + 9) = v12;
else
*(_BYTE *)(v7 - (unsigned int)(4 * v11) - 5) = v12;
if ( v12 != 0xFF )
*(_BYTE *)(v7 - 4 * (unsigned int)v12 - 6) = *(_BYTE *)(v7 + v9 + 6);
--a3;
v6 += 4;
v9 += 4LL;
}
while ( v9 < -8 );
if ( !a3 )
{
LABEL_20:
*(_BYTE *)(a2 + 7) = 0;
result = 1LL;
goto LABEL_21;
}
*(_BYTE *)(a2 + 8) = a3;
}
else
{
v13 = -v8;
*(_BYTE *)(v7 + v13 - 7) = 0;
*(_BYTE *)(v7 + v9) = 0;
*(_BYTE *)(v7 + v13 - 6) = -1;
v14 = *(unsigned __int8 *)(a2 + 9);
*(_BYTE *)(v7 + v13 - 5) = v14;
if ( v14 != 255 )
*(_BYTE *)(v7 - (unsigned int)(4 * v14) - 6) = a3;
*(_BYTE *)(a2 + 9) = a3;
}
v15 = v10 + v6;
*(_WORD *)(a2 + 10) = v15;
*(_BYTE *)(a2 + 7) |= 0x80u;
result = 0LL;
a1 = v15;
LABEL_21:
*a4 = a1;
}
return result;
}
| delete_dir_entry:
MOVZX R11D,byte ptr [RSI + 0x8]
MOV EAX,0xffffffff
CMP R11D,EDX
JBE 0x0015fb57
LEA R8D,[RDI + -0xd]
SHR R8D,0x2
CMP R8D,EDX
JC 0x0015fb57
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOVZX R8D,word ptr [RSI + 0xa]
MOV R9D,EDI
ADD R9,RSI
LEA EBX,[RDX*0x4]
MOV RAX,R9
SUB RAX,RBX
MOV R10,-0x8
SUB R10,RBX
MOVZX EAX,word ptr [RAX + -0x6]
DEC R11D
CMP R11D,EDX
JNZ 0x0015fb02
TEST EDX,EDX
JZ 0x0015fb48
ADD R8D,0x4
LAB_0015fa90:
CMP byte ptr [R9 + R10*0x1 + 0x4],0x0
JNZ 0x0015faf9
CMP byte ptr [R9 + R10*0x1 + 0x5],0x0
JNZ 0x0015faf9
MOVZX EBX,byte ptr [R9 + R10*0x1 + 0x6]
CMP RBX,0xff
JZ 0x0015fac3
MOV R11B,byte ptr [R9 + R10*0x1 + 0x7]
SHL EBX,0x2
MOV R14,R9
SUB R14,RBX
MOV byte ptr [R14 + -0x5],R11B
JMP 0x0015facc
LAB_0015fac3:
MOV R11B,byte ptr [R9 + R10*0x1 + 0x7]
MOV byte ptr [RSI + 0x9],R11B
LAB_0015facc:
CMP R11B,0xff
JZ 0x0015fae9
MOV BL,byte ptr [R9 + R10*0x1 + 0x6]
MOVZX R11D,R11B
SHL R11D,0x2
MOV R14,R9
SUB R14,R11
MOV byte ptr [R14 + -0x6],BL
LAB_0015fae9:
DEC EDX
ADD R8D,0x4
ADD R10,0x4
CMP R10,-0x8
JL 0x0015fa90
LAB_0015faf9:
TEST EDX,EDX
JZ 0x0015fb48
MOV byte ptr [RSI + 0x8],DL
JMP 0x0015fb35
LAB_0015fb02:
NEG RBX
XOR EDI,EDI
MOV byte ptr [R9 + RBX*0x1 + -0x7],DIL
MOV byte ptr [R9 + R10*0x1],DIL
MOV byte ptr [R9 + RBX*0x1 + -0x6],0xff
MOVZX EDI,byte ptr [RSI + 0x9]
MOV byte ptr [R9 + RBX*0x1 + -0x5],DIL
CMP RDI,0xff
JZ 0x0015fb32
SHL EDI,0x2
SUB R9,RDI
MOV byte ptr [R9 + -0x6],DL
LAB_0015fb32:
MOV byte ptr [RSI + 0x9],DL
LAB_0015fb35:
ADD R8D,EAX
MOV word ptr [RSI + 0xa],R8W
OR byte ptr [RSI + 0x7],0x80
XOR EAX,EAX
MOV EDI,R8D
JMP 0x0015fb51
LAB_0015fb48:
MOV byte ptr [RSI + 0x7],0x0
MOV EAX,0x1
LAB_0015fb51:
MOV dword ptr [RCX],EDI
POP RBX
POP R14
POP RBP
LAB_0015fb57:
RET
|
int8 delete_dir_entry(uint param_1,long param_2,uint param_3,uint *param_4)
{
byte bVar1;
ushort uVar2;
int8 uVar3;
ulong uVar4;
long lVar5;
uint uVar6;
long lVar7;
long lVar8;
byte bVar9;
if (*(byte *)(param_2 + 8) <= param_3) {
return 0xffffffff;
}
if (param_1 - 0xd >> 2 < param_3) {
return 0xffffffff;
}
uVar6 = (uint)*(ushort *)(param_2 + 10);
lVar7 = (ulong)param_1 + param_2;
uVar4 = (ulong)(param_3 * 4);
lVar8 = -8 - uVar4;
uVar2 = *(ushort *)((lVar7 - uVar4) + -6);
if (*(byte *)(param_2 + 8) - 1 == param_3) {
if (param_3 != 0) {
uVar6 = *(ushort *)(param_2 + 10) + 4;
do {
if ((*(char *)(lVar7 + 4 + lVar8) != '\0') || (*(char *)(lVar7 + 5 + lVar8) != '\0')) break;
bVar1 = *(byte *)(lVar7 + 6 + lVar8);
if (bVar1 == 0xff) {
bVar9 = *(byte *)(lVar7 + 7 + lVar8);
*(byte *)(param_2 + 9) = bVar9;
}
else {
bVar9 = *(byte *)(lVar7 + 7 + lVar8);
*(byte *)(lVar7 + (ulong)bVar1 * -4 + -5) = bVar9;
}
if (bVar9 != 0xff) {
*(int1 *)(lVar7 + (ulong)bVar9 * -4 + -6) = *(int1 *)(lVar7 + 6 + lVar8);
}
param_3 = param_3 - 1;
uVar6 = uVar6 + 4;
lVar8 = lVar8 + 4;
} while (lVar8 < -8);
if (param_3 != 0) {
*(char *)(param_2 + 8) = (char)param_3;
goto LAB_0015fb35;
}
}
*(int1 *)(param_2 + 7) = 0;
uVar3 = 1;
}
else {
lVar5 = -uVar4;
*(int1 *)(lVar7 + -7 + lVar5) = 0;
*(int1 *)(lVar7 + lVar8) = 0;
*(int1 *)(lVar7 + -6 + lVar5) = 0xff;
bVar1 = *(byte *)(param_2 + 9);
*(byte *)(lVar7 + -5 + lVar5) = bVar1;
if (bVar1 != 0xff) {
*(char *)(lVar7 + (ulong)bVar1 * -4 + -6) = (char)param_3;
}
*(char *)(param_2 + 9) = (char)param_3;
LAB_0015fb35:
param_1 = uVar6 + uVar2;
*(short *)(param_2 + 10) = (short)param_1;
*(byte *)(param_2 + 7) = *(byte *)(param_2 + 7) | 0x80;
uVar3 = 0;
}
*param_4 = param_1;
return uVar3;
}
| |
53,701 | testing::internal::FilePath::CreateFolder() const | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc | bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
delete[] unicode;
#elif GTEST_OS_WINDOWS
int result = _mkdir(pathname_.c_str());
#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
// do nothing
int result = 0;
#else
int result = mkdir(pathname_.c_str(), 0777);
#endif // GTEST_OS_WINDOWS_MOBILE
if (result == -1) {
return this->DirectoryExists(); // An error is OK if the directory exists.
}
return true; // No error.
} | O1 | cpp | testing::internal::FilePath::CreateFolder() const:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x9200
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x197f5
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x92a0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x9430
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4000
orl %eax, %ecx
sete %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| _ZNK7testing8internal8FilePath12CreateFolderEv:
push r14
push rbx
sub rsp, 98h
mov rbx, rdi
mov rdi, [rdi]
mov esi, 1FFh
call _mkdir
mov ecx, eax
mov al, 1
cmp ecx, 0FFFFFFFFh
jnz short loc_197F5
lea r14, [rsp+0A8h+var_A0]
mov edx, 90h
mov rdi, r14
xor esi, esi
call _memset
mov rdi, [rbx]
mov rsi, r14
call _stat
mov ecx, [r14+18h]
and ecx, 0F000h
xor ecx, 4000h
or ecx, eax
setz al
loc_197F5:
add rsp, 98h
pop rbx
pop r14
retn
| bool testing::internal::FilePath::CreateFolder(testing::internal::FilePath *this)
{
int v1; // ecx
bool result; // al
int v3; // eax
_BYTE v4[24]; // [rsp+8h] [rbp-A0h] BYREF
__int16 v5; // [rsp+20h] [rbp-88h]
v1 = mkdir(*(_QWORD *)this, 511LL);
result = 1;
if ( v1 == -1 )
{
memset(v4, 0LL, 144LL);
v3 = stat(*(_QWORD *)this, v4);
return (v3 | v5 & 0xF000 ^ 0x4000) == 0;
}
return result;
}
| CreateFolder:
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV ESI,0x1ff
CALL 0x00109200
MOV ECX,EAX
MOV AL,0x1
CMP ECX,-0x1
JNZ 0x001197f5
LEA R14,[RSP + 0x8]
MOV EDX,0x90
MOV RDI,R14
XOR ESI,ESI
CALL 0x001092a0
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x00109430
MOV ECX,dword ptr [R14 + 0x18]
AND ECX,0xf000
XOR ECX,0x4000
OR ECX,EAX
SETZ AL
LAB_001197f5:
ADD RSP,0x98
POP RBX
POP R14
RET
|
/* testing::internal::FilePath::CreateFolder() const */
int8 __thiscall testing::internal::FilePath::CreateFolder(FilePath *this)
{
int iVar1;
int4 extraout_var;
int8 uVar2;
int4 extraout_var_00;
stat local_a0;
iVar1 = mkdir(*(char **)this,0x1ff);
uVar2 = CONCAT71((int7)(CONCAT44(extraout_var,iVar1) >> 8),1);
if (iVar1 == -1) {
memset(&local_a0,0,0x90);
iVar1 = stat(*(char **)this,&local_a0);
uVar2 = CONCAT71((int7)(CONCAT44(extraout_var_00,iVar1) >> 8),
(local_a0.st_mode & 0xf000) == 0x4000 && iVar1 == 0);
}
return uVar2;
}
| |
53,702 | mi_ft_add | eloqsql/storage/myisam/ft_update.c | int _mi_ft_add(MI_INFO *info, uint keynr, uchar *keybuf, const uchar *record,
my_off_t pos)
{
int error= -1;
FT_WORD *wlist;
DBUG_ENTER("_mi_ft_add");
DBUG_PRINT("enter",("keynr: %d",keynr));
if ((wlist=_mi_ft_parserecord(info, keynr, record, &info->ft_memroot)))
error=_mi_ft_store(info,keynr,keybuf,wlist,pos);
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_PRINT("exit",("Return: %d",error));
DBUG_RETURN(error);
} | O0 | c | mi_ft_add:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0xa63f4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x90, %rcx
callq 0xa5d20
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa6434
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xa6340
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x90, %rdi
movl $0x2, %esi
callq 0xf0980
jmp 0xa644b
jmp 0xa644d
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| _mi_ft_add:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_2C], 0FFFFFFFFh
jmp short $+2
loc_A63F4:
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_8]
add rcx, 90h
call _mi_ft_parserecord
mov [rbp+var_38], rax
cmp rax, 0
jz short loc_A6434
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_38]
mov r8, [rbp+var_28]
call _mi_ft_store
mov [rbp+var_2C], eax
loc_A6434:
mov rdi, [rbp+var_8]
add rdi, 90h
mov esi, 2
call free_root
jmp short $+2
loc_A644B:
jmp short $+2
loc_A644D:
mov eax, [rbp+var_2C]
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
add rsp, 40h
pop rbp
retn
| long long mi_ft_add(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5)
{
_QWORD *v6; // [rsp+8h] [rbp-38h]
unsigned int v7; // [rsp+14h] [rbp-2Ch]
v7 = -1;
v6 = (_QWORD *)mi_ft_parserecord(a1, a2, a4, (long long)(a1 + 18));
if ( v6 )
v7 = mi_ft_store((long long)a1, a2, a3, v6, a5);
free_root(a1 + 18, 2LL);
return v7;
}
| _mi_ft_add:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x2c],0xffffffff
JMP 0x001a63f4
LAB_001a63f4:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x90
CALL 0x001a5d20
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001a6434
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x001a6340
MOV dword ptr [RBP + -0x2c],EAX
LAB_001a6434:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x90
MOV ESI,0x2
CALL 0x001f0980
JMP 0x001a644b
LAB_001a644b:
JMP 0x001a644d
LAB_001a644d:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD RSP,0x40
POP RBP
RET
|
int4
_mi_ft_add(long param_1,int4 param_2,int8 param_3,int8 param_4,int8 param_5)
{
long lVar1;
int4 local_34;
local_34 = 0xffffffff;
lVar1 = _mi_ft_parserecord(param_1,param_2,param_4,param_1 + 0x90);
if (lVar1 != 0) {
local_34 = _mi_ft_store(param_1,param_2,param_3,lVar1,param_5);
}
free_root(param_1 + 0x90,2);
return local_34;
}
| |
53,703 | MyCTX_gcm::update(unsigned char const*, unsigned int, unsigned char*, unsigned int*) | eloqsql/mysys_ssl/my_crypt.cc | int update(const uchar *src, uint slen, uchar *dst, uint *dlen)
{
/*
note that this GCM class cannot do streaming decryption, because
it needs the tag (which is located at the end of encrypted data)
before decrypting the data. it can encrypt data piecewise, like, first
half, then the second half, but it must decrypt all at once
*/
if (!EVP_CIPHER_CTX_encrypting(ctx))
{
/* encrypted string must contain authenticaton tag (see MDEV-11174) */
if (slen < MY_AES_BLOCK_SIZE)
return MY_AES_BAD_DATA;
slen-= MY_AES_BLOCK_SIZE;
if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, MY_AES_BLOCK_SIZE,
(void*)(src + slen)))
return MY_AES_OPENSSL_ERROR;
}
int unused;
if (aadlen && !EVP_CipherUpdate(ctx, NULL, &unused, aad, aadlen))
return MY_AES_OPENSSL_ERROR;
aadlen= 0;
return MyCTX::update(src, slen, dst, dlen);
} | O3 | cpp | MyCTX_gcm::update(unsigned char const*, unsigned int, unsigned char*, unsigned int*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r13
movq 0xc8(%rdi), %rdi
callq 0x29870
testl %eax, %eax
je 0xd839e
movl 0xd8(%r13), %r8d
testl %r8d, %r8d
je 0xd8370
movq 0xc8(%r13), %rdi
movq 0xd0(%r13), %rcx
leaq -0x2c(%rbp), %rdx
xorl %esi, %esi
callq 0x29890
testl %eax, %eax
je 0xd83cf
movq %rbx, %rdx
xorl %ebx, %ebx
movl %ebx, 0xd8(%r13)
movq 0xc8(%r13), %rdi
movq %r12, %rsi
movq %r15, %rcx
movl %r14d, %r8d
callq 0x29890
cmpl $0x1, %eax
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmovel %ebx, %eax
jmp 0xd83d4
movl $0xffffff9c, %eax # imm = 0xFFFFFF9C
cmpl $0x10, %r14d
jb 0xd83d4
addl $-0x10, %r14d
movq 0xc8(%r13), %rdi
leaq (%r15,%r14), %rcx
movl $0x11, %esi
movl $0x10, %edx
callq 0x292d0
testl %eax, %eax
jne 0xd8347
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN9MyCTX_gcm6updateEPKhjPhPj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r12, rcx
mov r14d, edx
mov r15, rsi
mov r13, rdi
mov rdi, [rdi+0C8h]
call _EVP_CIPHER_CTX_is_encrypting
test eax, eax
jz short loc_D839E
loc_D8347:
mov r8d, [r13+0D8h]
test r8d, r8d
jz short loc_D8370
mov rdi, [r13+0C8h]
mov rcx, [r13+0D0h]
lea rdx, [rbp+var_2C]
xor esi, esi
call _EVP_CipherUpdate
test eax, eax
jz short loc_D83CF
loc_D8370:
mov rdx, rbx
xor ebx, ebx
mov [r13+0D8h], ebx
mov rdi, [r13+0C8h]
mov rsi, r12
mov rcx, r15
mov r8d, r14d
call _EVP_CipherUpdate
cmp eax, 1
mov eax, 0FFFFFF9Bh
cmovz eax, ebx
jmp short loc_D83D4
loc_D839E:
mov eax, 0FFFFFF9Ch
cmp r14d, 10h
jb short loc_D83D4
add r14d, 0FFFFFFF0h
mov rdi, [r13+0C8h]
lea rcx, [r15+r14]
mov esi, 11h
mov edx, 10h
call _EVP_CIPHER_CTX_ctrl
test eax, eax
jnz loc_D8347
loc_D83CF:
mov eax, 0FFFFFF9Bh
loc_D83D4:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long MyCTX_gcm::update(
MyCTX_gcm *this,
const unsigned __int8 *a2,
unsigned int a3,
unsigned __int8 *a4,
unsigned int *a5)
{
long long v5; // rax
bool v9; // zf
long long result; // rax
_DWORD v11[11]; // [rsp+0h] [rbp-2Ch] BYREF
v11[0] = HIDWORD(v5);
if ( !(unsigned int)EVP_CIPHER_CTX_is_encrypting(*((_QWORD *)this + 25)) )
{
result = 4294967196LL;
if ( a3 < 0x10 )
return result;
if ( !(unsigned int)EVP_CIPHER_CTX_ctrl(*((_QWORD *)this + 25), 17LL, 16LL, &a2[a3 - 16]) )
return 4294967195LL;
}
if ( *((_DWORD *)this + 54)
&& !(unsigned int)EVP_CipherUpdate(*((_QWORD *)this + 25), 0LL, v11, *((_QWORD *)this + 26)) )
{
return 4294967195LL;
}
*((_DWORD *)this + 54) = 0;
v9 = (unsigned int)EVP_CipherUpdate(*((_QWORD *)this + 25), a4, a5, a2) == 1;
result = 4294967195LL;
if ( v9 )
return 0LL;
return result;
}
| update:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R12,RCX
MOV R14D,EDX
MOV R15,RSI
MOV R13,RDI
MOV RDI,qword ptr [RDI + 0xc8]
CALL 0x00129870
TEST EAX,EAX
JZ 0x001d839e
LAB_001d8347:
MOV R8D,dword ptr [R13 + 0xd8]
TEST R8D,R8D
JZ 0x001d8370
MOV RDI,qword ptr [R13 + 0xc8]
MOV RCX,qword ptr [R13 + 0xd0]
LEA RDX,[RBP + -0x2c]
XOR ESI,ESI
CALL 0x00129890
TEST EAX,EAX
JZ 0x001d83cf
LAB_001d8370:
MOV RDX,RBX
XOR EBX,EBX
MOV dword ptr [R13 + 0xd8],EBX
MOV RDI,qword ptr [R13 + 0xc8]
MOV RSI,R12
MOV RCX,R15
MOV R8D,R14D
CALL 0x00129890
CMP EAX,0x1
MOV EAX,0xffffff9b
CMOVZ EAX,EBX
JMP 0x001d83d4
LAB_001d839e:
MOV EAX,0xffffff9c
CMP R14D,0x10
JC 0x001d83d4
ADD R14D,-0x10
MOV RDI,qword ptr [R13 + 0xc8]
LEA RCX,[R15 + R14*0x1]
MOV ESI,0x11
MOV EDX,0x10
CALL 0x001292d0
TEST EAX,EAX
JNZ 0x001d8347
LAB_001d83cf:
MOV EAX,0xffffff9b
LAB_001d83d4:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MyCTX_gcm::update(unsigned char const*, unsigned int, unsigned char*, unsigned int*) */
int8 __thiscall
MyCTX_gcm::update(MyCTX_gcm *this,uchar *param_1,uint param_2,uchar *param_3,uint *param_4)
{
int iVar1;
int local_34;
iVar1 = EVP_CIPHER_CTX_is_encrypting(*(int8 *)(this + 200));
if (iVar1 == 0) {
if (param_2 < 0x10) {
return 0xffffff9c;
}
param_2 = param_2 - 0x10;
iVar1 = EVP_CIPHER_CTX_ctrl(*(EVP_CIPHER_CTX **)(this + 200),0x11,0x10,param_1 + param_2);
if (iVar1 == 0) {
return 0xffffff9b;
}
}
if ((*(int *)(this + 0xd8) != 0) &&
(iVar1 = EVP_CipherUpdate(*(EVP_CIPHER_CTX **)(this + 200),(uchar *)0x0,&local_34,
*(uchar **)(this + 0xd0),*(int *)(this + 0xd8)), iVar1 == 0)) {
return 0xffffff9b;
}
*(int4 *)(this + 0xd8) = 0;
iVar1 = EVP_CipherUpdate(*(EVP_CIPHER_CTX **)(this + 200),param_3,(int *)param_4,param_1,param_2);
if (iVar1 == 1) {
return 0;
}
return 0xffffff9b;
}
| |
53,704 | translog_max_lsn_to_header | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_max_lsn_to_header(File file, LSN lsn)
{
uchar lsn_buff[LSN_STORE_SIZE];
my_bool rc;
DBUG_ENTER("translog_max_lsn_to_header");
DBUG_PRINT("enter", ("File descriptor: %ld "
"lsn: " LSN_FMT,
(long) file,
LSN_IN_PARTS(lsn)));
lsn_store(lsn_buff, lsn);
rc= (my_pwrite(file, lsn_buff,
LSN_STORE_SIZE,
(LOG_HEADER_DATA_SIZE - LSN_STORE_SIZE),
log_write_flags) != 0 ||
mysql_file_sync(file, MYF(MY_WME)) != 0);
/*
We should not increase counter in case of error above, but it is so
unlikely that we can ignore this case
*/
translog_syncs++;
DBUG_RETURN(rc);
} | O0 | c | translog_max_lsn_to_header:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
jmp 0x359fe
jmp 0x35a00
jmp 0x35a02
movq -0x20(%rbp), %rax
sarq $0x20, %rax
movb %al, -0xf(%rbp)
movq -0x20(%rbp), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, -0xe(%rbp)
movq -0x20(%rbp), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, -0xd(%rbp)
jmp 0x35a2b
leaq -0xf(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x30(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x35a4f
movl -0x14(%rbp), %edi
leaq -0xf(%rbp), %rsi
movl $0x7, %edx
movl $0x25, %ecx
movl $0x34, %r8d
callq 0xfa980
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x31(%rbp)
jne 0x35a9b
movl -0x14(%rbp), %edx
leaq 0x121927(%rip), %rdi # 0x1573aa
movl $0x4a9, %esi # imm = 0x4A9
movl $0x10, %ecx
callq 0x35460
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x21(%rbp)
movq 0x4490db(%rip), %rax # 0x47eb88
addq $0x1, %rax
movq %rax, 0x4490d0(%rip) # 0x47eb88
movb -0x21(%rbp), %al
movb %al, -0x32(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x35ad9
movb -0x32(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
callq 0x2a250
nop
| translog_max_lsn_to_header:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
jmp short $+2
loc_359FE:
jmp short $+2
loc_35A00:
jmp short $+2
loc_35A02:
mov rax, [rbp+var_20]
sar rax, 20h
mov [rbp+var_F], al
mov rax, [rbp+var_20]
sar rax, 20h
shr eax, 8
mov [rbp+var_E], al
mov rax, [rbp+var_20]
sar rax, 20h
shr eax, 10h
mov [rbp+var_D], al
jmp short $+2
loc_35A2B:
lea rax, [rbp+var_F]
add rax, 3
mov [rbp+var_30], rax
mov rax, 0FFFFFFFFh
and rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_35A4F:
mov edi, [rbp+var_14]
lea rsi, [rbp+var_F]
mov edx, 7
mov ecx, 25h ; '%'
mov r8d, 34h ; '4'
call my_pwrite
mov rcx, rax
mov al, 1
cmp rcx, 0
mov [rbp+var_31], al
jnz short loc_35A9B
mov edx, [rbp+var_14]
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4A9h
mov ecx, 10h
call inline_mysql_file_sync
cmp eax, 0
setnz al
mov [rbp+var_31], al
loc_35A9B:
mov al, [rbp+var_31]
and al, 1
movzx eax, al
mov [rbp+var_21], al
mov rax, cs:translog_syncs
add rax, 1
mov cs:translog_syncs, rax
mov al, [rbp+var_21]
mov [rbp+var_32], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_35AD9
mov al, [rbp+var_32]
add rsp, 40h
pop rbp
retn
loc_35AD9:
call ___stack_chk_fail
| bool translog_max_lsn_to_header(unsigned int a1, long long a2)
{
bool v3; // [rsp+Fh] [rbp-31h]
__int16 v4; // [rsp+31h] [rbp-Fh] BYREF
char v5; // [rsp+33h] [rbp-Dh]
int v6; // [rsp+34h] [rbp-Ch]
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v4 = WORD2(a2);
v5 = BYTE6(a2);
v6 = a2;
v3 = 1;
if ( !my_pwrite(a1, &v4, 7LL, 37LL, 52LL) )
v3 = (unsigned int)inline_mysql_file_sync(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x4A9u,
a1,
16LL) != 0;
++translog_syncs;
return v3;
}
| translog_max_lsn_to_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
JMP 0x001359fe
LAB_001359fe:
JMP 0x00135a00
LAB_00135a00:
JMP 0x00135a02
LAB_00135a02:
MOV RAX,qword ptr [RBP + -0x20]
SAR RAX,0x20
MOV byte ptr [RBP + -0xf],AL
MOV RAX,qword ptr [RBP + -0x20]
SAR RAX,0x20
SHR EAX,0x8
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0x20]
SAR RAX,0x20
SHR EAX,0x10
MOV byte ptr [RBP + -0xd],AL
JMP 0x00135a2b
LAB_00135a2b:
LEA RAX,[RBP + -0xf]
ADD RAX,0x3
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,0xffffffff
AND RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
JMP 0x00135a4f
LAB_00135a4f:
MOV EDI,dword ptr [RBP + -0x14]
LEA RSI,[RBP + -0xf]
MOV EDX,0x7
MOV ECX,0x25
MOV R8D,0x34
CALL 0x001fa980
MOV RCX,RAX
MOV AL,0x1
CMP RCX,0x0
MOV byte ptr [RBP + -0x31],AL
JNZ 0x00135a9b
MOV EDX,dword ptr [RBP + -0x14]
LEA RDI,[0x2573aa]
MOV ESI,0x4a9
MOV ECX,0x10
CALL 0x00135460
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_00135a9b:
MOV AL,byte ptr [RBP + -0x31]
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x21],AL
MOV RAX,qword ptr [0x0057eb88]
ADD RAX,0x1
MOV qword ptr [0x0057eb88],RAX
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0x32],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00135ad9
MOV AL,byte ptr [RBP + -0x32]
ADD RSP,0x40
POP RBP
RET
LAB_00135ad9:
CALL 0x0012a250
|
int8 translog_max_lsn_to_header(int4 param_1,int8 param_2)
{
int iVar1;
long lVar2;
long in_FS_OFFSET;
bool local_39;
int1 local_17;
int1 local_16;
int1 local_15;
int4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_17 = (int1)((ulong)param_2 >> 0x20);
local_16 = (int1)((ulong)param_2 >> 0x28);
local_15 = (int1)((ulong)param_2 >> 0x30);
local_14 = (int4)param_2;
lVar2 = my_pwrite(param_1,&local_17,7,0x25,0x34);
local_39 = true;
if (lVar2 == 0) {
iVar1 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x4a9,param_1,0x10);
local_39 = iVar1 != 0;
}
translog_syncs = translog_syncs + 1;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_39);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
53,705 | load_env_plugins | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | static void load_env_plugins(MYSQL *mysql)
{
char *plugs, *free_env, *s= getenv("LIBMYSQL_PLUGINS");
if (ma_check_env_str(s))
return;
free_env= strdup(s);
plugs= s= free_env;
do {
if ((s= strchr(plugs, ';')))
*s= '\0';
mysql_load_plugin(mysql, plugs, -1, 0);
plugs= s + 1;
} while (s);
free(free_env);
} | O0 | c | load_env_plugins:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x719bc(%rip), %rdi # 0xcb2ef
callq 0x36760
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5a260
cmpb $0x0, %al
je 0x5994b
jmp 0x599b5
movq -0x20(%rbp), %rdi
callq 0x36030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0x364c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x59983
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movb $0x0, %al
callq 0x5a050
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x59964
movq -0x18(%rbp), %rdi
callq 0x361a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| load_env_plugins:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
lea rdi, aLibmysqlPlugin; "LIBMYSQL_PLUGINS"
call _getenv
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call ma_check_env_str
cmp al, 0
jz short loc_5994B
jmp short loc_599B5
loc_5994B:
mov rdi, [rbp+var_20]
call _strdup
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov [rbp+var_10], rax
loc_59964:
mov rdi, [rbp+var_10]
mov esi, 3Bh ; ';'
call _strchr
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_59983
mov rax, [rbp+var_20]
mov byte ptr [rax], 0
loc_59983:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 0FFFFFFFFh
xor ecx, ecx
mov al, 0
call mysql_load_plugin
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_10], rax
cmp [rbp+var_20], 0
jnz short loc_59964
mov rdi, [rbp+var_18]
call _free
loc_599B5:
add rsp, 20h
pop rbp
retn
| long long load_env_plugins(int a1)
{
long long result; // rax
int v2; // r8d
int v3; // r9d
long long v4; // [rsp+0h] [rbp-20h]
_BYTE *v5; // [rsp+0h] [rbp-20h]
long long v6; // [rsp+0h] [rbp-20h]
long long v7; // [rsp+8h] [rbp-18h]
long long v8; // [rsp+10h] [rbp-10h]
v4 = getenv("LIBMYSQL_PLUGINS");
result = ma_check_env_str(v4);
if ( !(_BYTE)result )
{
v7 = strdup(v4);
v8 = v7;
do
{
v5 = (_BYTE *)strchr(v8, 59LL);
if ( v5 )
*v5 = 0;
mysql_load_plugin(a1, v8, -1, 0, v2, v3, (char)v5);
v8 = v6 + 1;
}
while ( v6 );
return free(v7);
}
return result;
}
| load_env_plugins:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
LEA RDI,[0x1cb2ef]
CALL 0x00136760
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0015a260
CMP AL,0x0
JZ 0x0015994b
JMP 0x001599b5
LAB_0015994b:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00136030
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x10],RAX
LAB_00159964:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x3b
CALL 0x001364c0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x00159983
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x0
LAB_00159983:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0xffffffff
XOR ECX,ECX
MOV AL,0x0
CALL 0x0015a050
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00159964
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001361a0
LAB_001599b5:
ADD RSP,0x20
POP RBP
RET
|
void load_env_plugins(int8 param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
char *local_18;
pcVar2 = getenv("LIBMYSQL_PLUGINS");
cVar1 = ma_check_env_str(pcVar2);
if (cVar1 == '\0') {
pcVar2 = strdup(pcVar2);
local_18 = pcVar2;
do {
pcVar3 = strchr(local_18,0x3b);
if (pcVar3 != (char *)0x0) {
*pcVar3 = '\0';
}
mysql_load_plugin(param_1,local_18,0xffffffff,0);
local_18 = pcVar3 + 1;
} while (pcVar3 != (char *)0x0);
free(pcVar2);
}
return;
}
| |
53,706 | common_arg::set_env(char const*) | monkey531[P]llama/common/arg.cpp | common_arg & common_arg::set_env(const char * env) {
help = help + "\n(env: " + env + ")";
this->env = env;
return *this;
} | O2 | cpp | common_arg::set_env(char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rdi), %r15
leaq 0x846c5(%rip), %rdx # 0xac940
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x385b7
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x38598
leaq 0x9225c(%rip), %rdx # 0xba4fe
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x38598
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x24a90
movq %r12, %rdi
callq 0x251b8
leaq 0x8(%rsp), %rdi
callq 0x251b8
leaq 0x28(%rsp), %rdi
callq 0x251b8
movq %r14, 0x88(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x251b8
jmp 0x28305
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x251b8
movq %rbx, %rdi
callq 0x24f60
nop
| _ZN10common_arg7set_envEPKc:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea r15, [rdi+90h]
lea rdx, aEnv; "\n(env: "
lea r12, [rsp+88h+var_60]
mov rdi, r12
mov rsi, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_; std::operator+<char>(std::string const&,char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r12
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdx, a09401910201912+51h; ")"
lea rdi, [rsp+88h+var_40]
lea rsi, [rsp+88h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea r12, [rsp+88h+var_40]
mov rdi, r15
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r12; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+88h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+88h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov [rbx+88h], r14
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_28305
mov rbx, rax
loc_28305:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| common_arg * common_arg::set_env(common_arg *this, const char *a2)
{
_BYTE v3[32]; // [rsp+8h] [rbp-80h] BYREF
_BYTE v4[32]; // [rsp+28h] [rbp-60h] BYREF
_BYTE v5[64]; // [rsp+48h] [rbp-40h] BYREF
std::operator+<char>(v4, (char *)this + 144, "\n(env: ");
std::operator+<char>(v3, v4, a2);
std::operator+<char>(v5, v3, ")");
std::string::operator=((char *)this + 144, v5);
std::string::~string(v5);
std::string::~string(v3);
std::string::~string(v4);
*((_QWORD *)this + 17) = a2;
return this;
}
| set_env:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RDI + 0x90]
LEA RDX,[0x1ac940]
LEA R12,[RSP + 0x28]
MOV RDI,R12
MOV RSI,R15
CALL 0x001385b7
LAB_0012828b:
LEA RDI,[RSP + 0x8]
MOV RSI,R12
MOV RDX,R14
CALL 0x00138598
LAB_0012829b:
LEA RDX,[0x1ba4fe]
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x8]
CALL 0x00138598
LAB_001282b1:
LEA R12,[RSP + 0x48]
MOV RDI,R15
MOV RSI,R12
CALL 0x00124a90
MOV RDI,R12
CALL 0x001251b8
LEA RDI,[RSP + 0x8]
CALL 0x001251b8
LEA RDI,[RSP + 0x28]
CALL 0x001251b8
MOV qword ptr [RBX + 0x88],R14
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
|
/* common_arg::set_env(char const*) */
common_arg * __thiscall common_arg::set_env(common_arg *this,char *param_1)
{
string local_80 [32];
string local_60 [32];
string local_40 [32];
std::operator+(local_60,(char *)(this + 0x90));
/* try { // try from 0012828b to 0012829a has its CatchHandler @ 00128302 */
std::operator+(local_80,(char *)local_60);
/* try { // try from 0012829b to 001282b0 has its CatchHandler @ 001282f3 */
std::operator+(local_40,(char *)local_80);
std::__cxx11::string::operator=((string *)(this + 0x90),local_40);
std::__cxx11::string::~string(local_40);
std::__cxx11::string::~string(local_80);
std::__cxx11::string::~string(local_60);
*(char **)(this + 0x88) = param_1;
return this;
}
| |
53,707 | common_arg::set_env(char const*) | monkey531[P]llama/common/arg.cpp | common_arg & common_arg::set_env(const char * env) {
help = help + "\n(env: " + env + ")";
this->env = env;
return *this;
} | O3 | cpp | common_arg::set_env(char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x90(%rdi), %rsi
movq 0x98(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21bb4
leaq 0xc68f5(%rip), %rsi # 0xe8940
movq %r15, %rdi
callq 0x1c0d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c0d0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x22087
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2208f
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xd445c(%rip), %rsi # 0xf650e
callq 0x1c0d0
leaq 0x90(%rbx), %rdi
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x220e5
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x220ec
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rsi
callq 0x1ba70
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x22125
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2213c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x22153
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %r14, 0x88(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x2218d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8b0
jmp 0x2218d
jmp 0x2218a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x221a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rdi
callq 0x1bf70
| _ZN10common_arg7set_envEPKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea r12, [rsp+98h+var_80]
mov [r12-10h], r12
mov rsi, [rdi+90h]
mov rdx, [rdi+98h]
add rdx, rsi
lea r15, [rsp+98h+var_90]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rsi, aEnv; "\n(env: "
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+98h+var_90]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r13, [rsp+98h+var_60]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_22087
mov [rsp+98h+var_70], rdx
mov rdx, [rcx]
mov [rsp+98h+var_60], rdx
jmp short loc_2208F
loc_22087:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_2208F:
mov rdx, [rax+8]
lea rdi, [rsp+98h+var_70]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, a09401910201912+51h; ")"
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rbx+90h]
lea rbp, [rsp+98h+var_40]
mov [rbp-10h], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_220E5
mov [rsp+98h+var_50], rdx
mov rdx, [rcx]
mov [rsp+98h+var_40], rdx
jmp short loc_220EC
loc_220E5:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_220EC:
mov rdx, [rax+8]
lea r15, [rsp+98h+var_50]
mov [r15+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r15]; void *
cmp rdi, rbp
jz short loc_22125
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22125:
mov rdi, [rsp+98h+var_70]; void *
cmp rdi, r13
jz short loc_2213C
mov rsi, [rsp+98h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2213C:
mov rdi, [rsp+98h+var_90]; void *
cmp rdi, r12
jz short loc_22153
mov rsi, [rsp+98h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22153:
mov [rbx+88h], r14
mov rax, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_2218D
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2218D
jmp short $+2
loc_2218A:
mov rbx, rax
loc_2218D:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_221A4
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_221A4:
mov rdi, rbx
call __Unwind_Resume
| common_arg * common_arg::set_env(common_arg *this, const char *a2)
{
long long v2; // rax
__int128 *v3; // rcx
long long v4; // rax
_OWORD *v5; // rcx
void *v7[2]; // [rsp+8h] [rbp-90h] BYREF
_QWORD v8[2]; // [rsp+18h] [rbp-80h] BYREF
void *v9[2]; // [rsp+28h] [rbp-70h] BYREF
__int128 v10; // [rsp+38h] [rbp-60h] BYREF
void *v11[2]; // [rsp+48h] [rbp-50h] BYREF
_OWORD v12[4]; // [rsp+58h] [rbp-40h] BYREF
v7[0] = v8;
std::string::_M_construct<char *>(
(long long)v7,
*((_BYTE **)this + 18),
*((_QWORD *)this + 18) + *((_QWORD *)this + 19));
std::string::append(v7, "\n(env: ");
v2 = std::string::append(v7, a2);
v9[0] = &v10;
v3 = (__int128 *)(v2 + 16);
if ( *(_QWORD *)v2 == v2 + 16 )
{
v10 = *v3;
}
else
{
v9[0] = *(void **)v2;
*(_QWORD *)&v10 = *(_QWORD *)v3;
}
v9[1] = *(void **)(v2 + 8);
*(_QWORD *)v2 = v3;
*(_QWORD *)(v2 + 8) = 0LL;
*(_BYTE *)(v2 + 16) = 0;
v4 = std::string::append(v9, ")");
v11[0] = v12;
v5 = (_OWORD *)(v4 + 16);
if ( *(_QWORD *)v4 == v4 + 16 )
{
v12[0] = *v5;
}
else
{
v11[0] = *(void **)v4;
*(_QWORD *)&v12[0] = *(_QWORD *)v5;
}
v11[1] = *(void **)(v4 + 8);
*(_QWORD *)v4 = v5;
*(_QWORD *)(v4 + 8) = 0LL;
*(_BYTE *)(v4 + 16) = 0;
std::string::operator=((char *)this + 144, v11);
if ( v11[0] != v12 )
operator delete(v11[0], *(_QWORD *)&v12[0] + 1LL);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
*((_QWORD *)this + 17) = a2;
return this;
}
| |||
53,708 | google::protobuf::util::statusor_internal::StatusOr<int> google::protobuf::util::converter::(anonymous namespace)::ValidateNumberConversion<int, long>(int, long) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/util/internal/datapiece.cc | util::StatusOr<To> ValidateNumberConversion(To after, From before) {
if (after == before &&
MathUtil::Sign<From>(before) == MathUtil::Sign<To>(after)) {
return after;
} else {
return util::InvalidArgumentError(
std::is_integral<From>::value ? ValueAsString(before)
: std::is_same<From, double>::value ? DoubleAsString(before)
: FloatAsString(before));
}
} | O0 | cpp | google::protobuf::util::statusor_internal::StatusOr<int> google::protobuf::util::converter::(anonymous namespace)::ValidateNumberConversion<int, long>(int, long):
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movss %xmm0, 0xac(%rsp)
movq %rsi, 0xa0(%rsp)
movss 0xac(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x34(%rsp)
testq %rax, %rax
movss %xmm0, 0x38(%rsp)
js 0x3765ed
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x38(%rsp)
movss 0x30(%rsp), %xmm0
movss 0x38(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jne 0x37668f
jp 0x37668f
movq 0xa0(%rsp), %rdi
callq 0x379b20
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x37664e
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0xac(%rsp), %xmm0
callq 0x379910
movaps %xmm0, %xmm1
movss 0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jne 0x37668f
jp 0x37668f
movq 0x20(%rsp), %rdi
leaq 0xac(%rsp), %rsi
callq 0x3787c0
jmp 0x3767c2
movb $0x1, %al
testb $0x1, %al
jne 0x376697
jmp 0x3766ae
movq 0xa0(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x379b80
jmp 0x376740
xorl %eax, %eax
testb $0x1, %al
jne 0x3766b6
jmp 0x3766ed
movaps 0x75a83(%rip), %xmm1 # 0x3ec140
movq 0xa0(%rsp), %xmm0
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x75a7e(%rip), %xmm1 # 0x3ec150
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
leaq 0x48(%rsp), %rdi
callq 0x36dc90
jmp 0x37673e
movq 0xa0(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc(%rsp)
testq %rax, %rax
movss %xmm0, 0x10(%rsp)
js 0x37672e
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x36de30
jmp 0x376740
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x158e50
jmp 0x376751
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x78(%rsp), %rdi
callq 0x19d0b0
jmp 0x376767
movq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x379700
jmp 0x376778
leaq 0x78(%rsp), %rdi
callq 0x100ea0
leaq 0x48(%rsp), %rdi
callq 0x921e0
jmp 0x3767c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x3767b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x100ea0
leaq 0x48(%rsp), %rdi
callq 0x921e0
jmp 0x3767cf
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x90db0
nopl (%rax)
| _ZN6google8protobuf4util9converter12_GLOBAL__N_124ValidateNumberConversionIfmEENS1_17statusor_internal8StatusOrIT_EES7_T0_:
sub rsp, 0B8h
mov qword ptr [rsp+0B8h+var_98], rdi; int
mov rax, rdi
mov qword ptr [rsp+0B8h+var_90], rax; char
mov [rsp+0B8h+var_8], rdi
movss [rsp+0B8h+var_C], xmm0
mov [rsp+0B8h+var_18], rsi
movss xmm0, [rsp+0B8h+var_C]
movss [rsp+0B8h+var_88], xmm0; int
mov rax, [rsp+0B8h+var_18]
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rsp+0B8h+var_84], xmm1
test rax, rax
movss [rsp+0B8h+var_80], xmm0
js short loc_3765ED
movss xmm0, [rsp+0B8h+var_84]
movss [rsp+0B8h+var_80], xmm0; int
loc_3765ED:
movss xmm0, [rsp+0B8h+var_88]
movss xmm1, [rsp+0B8h+var_80]
ucomiss xmm0, xmm1
jnz loc_37668F
jp loc_37668F
mov rdi, [rsp+0B8h+var_18]
call _ZN6google8protobuf8MathUtil4SignImEET_S3_; google::protobuf::MathUtil::Sign<ulong>(ulong)
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rsp+0B8h+var_A0], xmm1
test rax, rax
movss [rsp+0B8h+var_9C], xmm0
js short loc_37664E
movss xmm0, [rsp+0B8h+var_A0]
movss [rsp+0B8h+var_9C], xmm0
loc_37664E:
movss xmm0, [rsp+0B8h+var_9C]
movss [rsp+0B8h+var_A4], xmm0
movss xmm0, [rsp+0B8h+var_C]
call _ZN6google8protobuf8MathUtil4SignIfEET_S3_; google::protobuf::MathUtil::Sign<float>(float)
movaps xmm1, xmm0
movss xmm0, [rsp+0B8h+var_A4]
ucomiss xmm0, xmm1
jnz short loc_37668F
jp short loc_37668F
mov rdi, qword ptr [rsp+0B8h+var_98]
lea rsi, [rsp+0B8h+var_C]
call _ZN6google8protobuf4util17statusor_internal8StatusOrIfEC2ERKf; google::protobuf::util::statusor_internal::StatusOr<float>::StatusOr(float const&)
jmp loc_3767C2
loc_37668F:
mov al, 1
test al, 1
jnz short loc_376697
jmp short loc_3766AE
loc_376697:
mov rsi, [rsp+0B8h+var_18]
lea rdi, [rsp+0B8h+var_70]
call _ZN6google8protobuf4util9converter13ValueAsStringImEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEET_; google::protobuf::util::converter::ValueAsString<ulong>(ulong)
jmp loc_376740
loc_3766AE:
xor eax, eax
test al, 1
jnz short loc_3766B6
jmp short loc_3766ED
loc_3766B6:
movaps xmm1, cs:xmmword_3EC140
movq xmm0, [rsp+0B8h+var_18]
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_3EC150
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
lea rdi, [rsp+0B8h+var_70]
call _ZN6google8protobuf4util9converter14DoubleAsStringB5cxx11Ed; google::protobuf::util::converter::DoubleAsString(double)
jmp short loc_37673E
loc_3766ED:
mov rax, [rsp+0B8h+var_18]
mov rdx, rax
shr rdx, 1
mov ecx, eax
and ecx, 1
or rcx, rdx
cvtsi2ss xmm0, rcx
addss xmm0, xmm0
cvtsi2ss xmm1, rax
movss [rsp+0B8h+var_AC], xmm1
test rax, rax
movss [rsp+0B8h+var_A8], xmm0
js short loc_37672E
movss xmm0, [rsp+0B8h+var_AC]
movss [rsp+0B8h+var_A8], xmm0
loc_37672E:
movss xmm0, [rsp+0B8h+var_A8]
lea rdi, [rsp+0B8h+var_70]
call _ZN6google8protobuf4util9converter13FloatAsStringB5cxx11Ef; google::protobuf::util::converter::FloatAsString(float)
loc_37673E:
jmp short $+2
loc_376740:
lea rdi, [rsp+0B8h+var_50]
lea rsi, [rsp+0B8h+var_70]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
jmp short $+2
loc_376751:
mov rsi, [rsp+0B8h+var_50]
mov rdx, [rsp+0B8h+var_48]
lea rdi, [rsp+0B8h+var_40]
call _ZN6google8protobuf4util15status_internal20InvalidArgumentErrorENS0_20stringpiece_internal11StringPieceE; google::protobuf::util::status_internal::InvalidArgumentError(google::protobuf::stringpiece_internal::StringPiece)
jmp short $+2
loc_376767:
mov rdi, qword ptr [rsp+0B8h+var_98]; int
lea rsi, [rsp+0B8h+var_40]; int
call _ZN6google8protobuf4util17statusor_internal8StatusOrIfEC2ERKNS1_15status_internal6StatusE; google::protobuf::util::statusor_internal::StatusOr<float>::StatusOr(google::protobuf::util::status_internal::Status const&)
jmp short $+2
loc_376778:
lea rdi, [rsp+0B8h+var_40]; this
call _ZN6google8protobuf4util15status_internal6StatusD2Ev; google::protobuf::util::status_internal::Status::~Status()
lea rdi, [rsp+0B8h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_3767C2
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
jmp short loc_3767B6
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
lea rdi, [rsp+arg_70]; this
call _ZN6google8protobuf4util15status_internal6StatusD2Ev; google::protobuf::util::status_internal::Status::~Status()
loc_3767B6:
lea rdi, [rsp+arg_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_3767CF
loc_3767C2:
mov rax, qword ptr [rsp+0B8h+var_90]
add rsp, 0B8h
retn
loc_3767CF:
mov rdi, [rsp+arg_38]
call __Unwind_Resume
| long long google::protobuf::util::converter::`anonymous namespace'::ValidateNumberConversion<float,unsigned long>(
long long a1,
long long a2,
float a3)
{
long long v3; // rax
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
google::protobuf::util::status_internal::Status *v13; // [rsp+0h] [rbp-B8h]
int v14; // [rsp+8h] [rbp-B0h]
int v15; // [rsp+10h] [rbp-A8h]
float v16; // [rsp+18h] [rbp-A0h]
float v17; // [rsp+1Ch] [rbp-9Ch]
char v18[8]; // [rsp+28h] [rbp-90h]
float v20; // [rsp+38h] [rbp-80h]
int v21; // [rsp+40h] [rbp-78h]
int v22[4]; // [rsp+48h] [rbp-70h] BYREF
long long v23; // [rsp+58h] [rbp-60h]
long long v24[2]; // [rsp+68h] [rbp-50h] BYREF
int v25[10]; // [rsp+78h] [rbp-40h] BYREF
long long v26; // [rsp+A0h] [rbp-18h]
int v27; // [rsp+ACh] [rbp-Ch] BYREF
long long v28; // [rsp+B0h] [rbp-8h]
*(_QWORD *)v18 = a1;
v28 = a1;
v27 = LODWORD(a3);
v26 = a2;
v20 = (float)(int)(((unsigned long long)a2 >> 1) | a2 & 1) + (float)(int)(((unsigned long long)a2 >> 1) | a2 & 1);
if ( a2 >= 0 )
v20 = (float)(int)a2;
if ( a3 != v20 )
goto LABEL_8;
v3 = google::protobuf::MathUtil::Sign<unsigned long>(v26);
v16 = (float)(int)v3;
v17 = (float)(int)(((unsigned long long)v3 >> 1) | v3 & 1) + (float)(int)(((unsigned long long)v3 >> 1) | v3 & 1);
if ( v3 >= 0 )
v17 = (float)(int)v3;
if ( v17 == google::protobuf::MathUtil::Sign<float>(*(float *)&v27) )
{
google::protobuf::util::statusor_internal::StatusOr<float>::StatusOr(a1, (unsigned int)&v27, v4, v5, v6, v7);
}
else
{
LABEL_8:
google::protobuf::util::converter::ValueAsString<unsigned long>(v22, v26);
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(v24, (long long)v22);
google::protobuf::util::status_internal::InvalidArgumentError(v25, v24[0], v24[1]);
google::protobuf::util::statusor_internal::StatusOr<float>::StatusOr(
a1,
(int)v25,
v8,
v9,
v10,
v11,
v13,
v14,
v15,
SLODWORD(v16),
a1,
a1,
SLODWORD(a3),
SLODWORD(v20),
v21,
v22[0],
v22[2],
v23);
google::protobuf::util::status_internal::Status::~Status((google::protobuf::util::status_internal::Status *)v25);
std::string::~string(v22);
}
return *(_QWORD *)v18;
}
| EndOffset<google::protobuf::MessageOptions>:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
CALL 0x00376590
MOV EAX,dword ptr [RAX]
POP RCX
RET
|
/* int google::protobuf::(anonymous namespace)::FlatAllocation<char, std::__cxx11::string,
google::protobuf::SourceCodeInfo, google::protobuf::FileDescriptorTables,
google::protobuf::MessageOptions, google::protobuf::FieldOptions, google::protobuf::EnumOptions,
google::protobuf::EnumValueOptions, google::protobuf::ExtensionRangeOptions,
google::protobuf::OneofOptions, google::protobuf::ServiceOptions,
google::protobuf::MethodOptions,
google::protobuf::FileOptions>::EndOffset<google::protobuf::MessageOptions>() const */
int __thiscall
google::protobuf::(anonymous_namespace)::
FlatAllocation<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
::EndOffset<google::protobuf::MessageOptions>
(FlatAllocation<char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
*this)
{
int *piVar1;
piVar1 = TypeMap<google::protobuf::(anonymous_namespace)::IntT,char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
::Get<google::protobuf::MessageOptions>
((TypeMap<google::protobuf::(anonymous_namespace)::IntT,char,std::__cxx11::string,google::protobuf::SourceCodeInfo,google::protobuf::FileDescriptorTables,google::protobuf::MessageOptions,google::protobuf::FieldOptions,google::protobuf::EnumOptions,google::protobuf::EnumValueOptions,google::protobuf::ExtensionRangeOptions,google::protobuf::OneofOptions,google::protobuf::ServiceOptions,google::protobuf::MethodOptions,google::protobuf::FileOptions>
*)this);
return *piVar1;
}
| |
53,709 | google::protobuf::util::statusor_internal::StatusOr<int> google::protobuf::util::converter::(anonymous namespace)::ValidateNumberConversion<int, long>(int, long) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/util/internal/datapiece.cc | util::StatusOr<To> ValidateNumberConversion(To after, From before) {
if (after == before &&
MathUtil::Sign<From>(before) == MathUtil::Sign<To>(after)) {
return after;
} else {
return util::InvalidArgumentError(
std::is_integral<From>::value ? ValueAsString(before)
: std::is_same<From, double>::value ? DoubleAsString(before)
: FloatAsString(before));
}
} | O3 | cpp | google::protobuf::util::statusor_internal::StatusOr<int> google::protobuf::util::converter::(anonymous namespace)::ValidateNumberConversion<int, long>(int, long):
pushq %r14
pushq %rbx
subq $0x78, %rsp
cvtsi2ss %rsi, %xmm1
movq %rdi, %rbx
ucomiss %xmm0, %xmm1
jne 0x12d5e4
jp 0x12d5e4
movq %rsi, %r14
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %cl
movaps %xmm0, %xmm1
je 0x12d58d
movb %cl, %al
leaq 0x453c0(%rip), %rcx # 0x172948
movss (%rcx,%rax,4), %xmm1
xorl %eax, %eax
xorl %ecx, %ecx
testq %r14, %r14
setg %cl
leal -0x1(%rcx,%rcx), %ecx
cmovel %eax, %ecx
cvtsi2ss %ecx, %xmm2
ucomiss %xmm2, %xmm1
jne 0x12d5e4
jp 0x12d5e4
movq %rbx, %rdi
callq 0x860a4
leaq 0x8(%rsp), %rdi
callq 0x86472
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8616a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d5db
callq 0x2d160
movq %r14, 0x28(%rbx)
jmp 0x12d67c
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x129e5a
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x30(%rsp), %rdi
callq 0x86611
movq %rbx, %rdi
callq 0x860a4
cmpl $0x0, 0x30(%rsp)
je 0x12d620
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x8616a
jmp 0x12d656
leaq 0x43d7a(%rip), %rsi # 0x1713a1
leaq 0x8(%rsp), %rdi
movl $0x23, %edx
callq 0x865f8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8616a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d656
callq 0x2d160
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d669
callq 0x2d160
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d67c
callq 0x2d160
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d6a1
callq 0x2d160
jmp 0x12d6a1
jmp 0x12d69e
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x12d6e2
callq 0x2d160
jmp 0x12d6e2
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d6d0
callq 0x2d160
jmp 0x12d6d0
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
jne 0x12d708
jmp 0x12d70d
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d6fa
callq 0x2d160
jmp 0x12d6fa
movq %rax, %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12d70d
callq 0x2d160
movq %r14, %rdi
callq 0x2e220
| _ZN6google8protobuf4util9converter12_GLOBAL__N_124ValidateNumberConversionIlfEENS1_17statusor_internal8StatusOrIT_EES7_T0_:
push r14
push rbx
sub rsp, 78h
cvtsi2ss xmm1, rsi
mov rbx, rdi
ucomiss xmm1, xmm0
jnz short loc_12D5E4
jp short loc_12D5E4
mov r14, rsi
xorps xmm1, xmm1
xor eax, eax
ucomiss xmm0, xmm1
setnbe cl
movaps xmm1, xmm0
jz short loc_12D58D
mov al, cl
lea rcx, flt_172948
movss xmm1, dword ptr [rcx+rax*4]
loc_12D58D:
xor eax, eax
xor ecx, ecx
test r14, r14
setnle cl
lea ecx, [rcx+rcx-1]
cmovz ecx, eax
cvtsi2ss xmm2, ecx
ucomiss xmm1, xmm2
jnz short loc_12D5E4
jp short loc_12D5E4
mov rdi, rbx; this
call _ZN6google8protobuf4util15status_internal6StatusC2Ev; google::protobuf::util::status_internal::Status::Status(void)
lea rdi, [rsp+88h+var_80]; this
call _ZN6google8protobuf4util15status_internal8OkStatusEv; google::protobuf::util::status_internal::OkStatus(void)
lea rsi, [rsp+88h+var_80]
mov rdi, rbx
call _ZN6google8protobuf4util15status_internal6StatusaSERKS3_; google::protobuf::util::status_internal::Status::operator=(google::protobuf::util::status_internal::Status const&)
lea rax, [rsp+88h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D5DB
call __ZdlPv; operator delete(void *)
loc_12D5DB:
mov [rbx+28h], r14
jmp loc_12D67C
loc_12D5E4:
lea r14, [rsp+88h+var_30]
mov rdi, r14
call _ZN6google8protobuf4util9converter13FloatAsStringB5cxx11Ef; google::protobuf::util::converter::FloatAsString(float)
mov rsi, [r14]
mov rdx, [r14+8]
lea rdi, [rsp+88h+var_58]
call _ZN6google8protobuf4util15status_internal20InvalidArgumentErrorENS0_20stringpiece_internal11StringPieceE; google::protobuf::util::status_internal::InvalidArgumentError(google::protobuf::stringpiece_internal::StringPiece)
mov rdi, rbx; this
call _ZN6google8protobuf4util15status_internal6StatusC2Ev; google::protobuf::util::status_internal::Status::Status(void)
cmp [rsp+88h+var_58], 0
jz short loc_12D620
lea rsi, [rsp+88h+var_58]
mov rdi, rbx
call _ZN6google8protobuf4util15status_internal6StatusaSERKS3_; google::protobuf::util::status_internal::Status::operator=(google::protobuf::util::status_internal::Status const&)
jmp short loc_12D656
loc_12D620:
lea rsi, aOkstatusIsNotA; "OkStatus() is not a valid argument."
lea rdi, [rsp+88h+var_80]
mov edx, 23h ; '#'
call _ZN6google8protobuf4util15status_internal13InternalErrorENS0_20stringpiece_internal11StringPieceE; google::protobuf::util::status_internal::InternalError(google::protobuf::stringpiece_internal::StringPiece)
lea rsi, [rsp+88h+var_80]
mov rdi, rbx
call _ZN6google8protobuf4util15status_internal6StatusaSERKS3_; google::protobuf::util::status_internal::Status::operator=(google::protobuf::util::status_internal::Status const&)
lea rax, [rsp+88h+var_68]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D656
call __ZdlPv; operator delete(void *)
loc_12D656:
lea rax, [rsp+88h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D669
call __ZdlPv; operator delete(void *)
loc_12D669:
lea rax, [rsp+88h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D67C
call __ZdlPv; operator delete(void *)
loc_12D67C:
add rsp, 78h
pop rbx
pop r14
retn
mov r14, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D6A1
call __ZdlPv; operator delete(void *)
jmp short loc_12D6A1
jmp short $+2
loc_12D69E:
mov r14, rax
loc_12D6A1:
mov rdi, [rbx+8]; void *
add rbx, 18h
cmp rdi, rbx
jz short loc_12D6E2
call __ZdlPv; operator delete(void *)
jmp short loc_12D6E2
mov r14, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D6D0
call __ZdlPv; operator delete(void *)
jmp short loc_12D6D0
mov r14, rax
loc_12D6D0:
mov rdi, [rbx+8]
add rbx, 18h
cmp rdi, rbx
jnz short loc_12D708
jmp short loc_12D70D
mov r14, rax
loc_12D6E2:
lea rax, [rsp+arg_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D6FA
call __ZdlPv; operator delete(void *)
jmp short loc_12D6FA
mov r14, rax
loc_12D6FA:
lea rax, [rsp+arg_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_12D70D
loc_12D708:
call __ZdlPv; operator delete(void *)
loc_12D70D:
mov rdi, r14
call __Unwind_Resume
| void google::protobuf::util::converter::`anonymous namespace'::ValidateNumberConversion<long,float>(
google::protobuf::util::status_internal::Status *this,
char *a2,
__m128i a3)
{
long long v3; // rax
float v4; // xmm1_4
int v5; // ecx
int v6; // [rsp+8h] [rbp-80h] BYREF
_BYTE *v7; // [rsp+10h] [rbp-78h]
_BYTE v8[16]; // [rsp+20h] [rbp-68h] BYREF
int v9; // [rsp+30h] [rbp-58h] BYREF
char *v10; // [rsp+38h] [rbp-50h]
char v11; // [rsp+48h] [rbp-40h] BYREF
void *v12[2]; // [rsp+58h] [rbp-30h] BYREF
char v13; // [rsp+68h] [rbp-20h] BYREF
if ( (float)(int)a2 != *(float *)a3.m128i_i32 )
goto LABEL_10;
v3 = 0LL;
v4 = *(float *)a3.m128i_i32;
if ( *(float *)a3.m128i_i32 != 0.0 )
{
LOBYTE(v3) = *(float *)a3.m128i_i32 > 0.0;
v4 = flt_172948[v3];
}
v5 = 2 * ((long long)a2 > 0) - 1;
if ( !a2 )
v5 = 0;
if ( v4 == (float)v5 )
{
google::protobuf::util::status_internal::Status::Status(this);
google::protobuf::util::status_internal::OkStatus((google::protobuf::util::status_internal *)&v6);
google::protobuf::util::status_internal::Status::operator=(this, &v6);
if ( v7 != v8 )
operator delete(v7);
*((_QWORD *)this + 5) = a2;
}
else
{
LABEL_10:
google::protobuf::util::converter::FloatAsString[abi:cxx11](v12, a2, a3);
google::protobuf::util::status_internal::InvalidArgumentError((long long)&v9, (long long)v12[0], (long long)v12[1]);
google::protobuf::util::status_internal::Status::Status(this);
if ( v9 )
{
google::protobuf::util::status_internal::Status::operator=(this, &v9);
}
else
{
google::protobuf::util::status_internal::InternalError(
(long long)&v6,
(long long)"OkStatus() is not a valid argument.",
35LL);
google::protobuf::util::status_internal::Status::operator=(this, &v6);
if ( v7 != v8 )
operator delete(v7);
}
if ( v10 != &v11 )
operator delete(v10);
if ( v12[0] != &v13 )
operator delete(v12[0]);
}
}
| |||
53,710 | my_b_safe_write | eloqsql/mysys/mf_iocache.c | int my_b_safe_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
/*
Sasha: We are not writing this with the ? operator to avoid hitting
a possible compiler bug. At least gcc 2.95 cannot deal with
several layers of ternary operators that evaluated comma(,) operator
expressions inside - I do have a test case if somebody wants it
*/
if (info->type == SEQ_READ_APPEND)
return my_b_append(info, Buffer, Count);
return my_b_write(info, Buffer, Count);
} | O0 | c | my_b_safe_write:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0xb0(%rax)
jne 0xb0f77
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb0c20
movl %eax, -0x4(%rbp)
jmp 0xb0f8b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb0fa0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_b_safe_write:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 3
jnz short loc_B0F77
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_b_append
mov [rbp+var_4], eax
jmp short loc_B0F8B
loc_B0F77:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_b_write_1
mov [rbp+var_4], eax
loc_B0F8B:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_b_safe_write(long long a1, long long a2, unsigned long long a3)
{
if ( *(_DWORD *)(a1 + 176) == 3 )
return (unsigned int)my_b_append(a1, a2, a3);
else
return (unsigned int)my_b_write_1(a1, a2, a3);
}
| my_b_safe_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x3
JNZ 0x001b0f77
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b0c20
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001b0f8b
LAB_001b0f77:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b0fa0
MOV dword ptr [RBP + -0x4],EAX
LAB_001b0f8b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_b_safe_write(long param_1,int8 param_2,int8 param_3)
{
int4 local_c;
if (*(int *)(param_1 + 0xb0) == 3) {
local_c = my_b_append(param_1,param_2,param_3);
}
else {
local_c = my_b_write(param_1,param_2,param_3);
}
return local_c;
}
| |
53,711 | mariadb_set_conf_option | eloqsql/libmariadb/libmariadb/mariadb_lib.c | my_bool _mariadb_set_conf_option(MYSQL *mysql, const char *config_option, const char *config_value)
{
if (config_option)
{
int i;
char *c;
/* CONC-395: replace underscore "_" by dash "-" */
while ((c= strchr(config_option, '_')))
*c= '-';
for (i=0; mariadb_defaults[i].conf_key; i++)
{
if (!strcmp(mariadb_defaults[i].conf_key, config_option))
{
my_bool val_bool;
int val_int;
size_t val_sizet;
int rc;
void *option_val= NULL;
switch (mariadb_defaults[i].type) {
case MARIADB_OPTION_FUNC:
return mariadb_defaults[i].u.option_func(mysql, config_option, config_value, -1);
break;
case MARIADB_OPTION_BOOL:
val_bool= 0;
if (config_value)
val_bool= atoi(config_value);
option_val= &val_bool;
break;
case MARIADB_OPTION_INT:
val_int= 0;
if (config_value)
val_int= atoi(config_value);
option_val= &val_int;
break;
case MARIADB_OPTION_SIZET:
val_sizet= 0;
if (config_value)
val_sizet= strtol(config_value, NULL, 10);
option_val= &val_sizet;
break;
case MARIADB_OPTION_STR:
option_val= (void*)config_value;
break;
case MARIADB_OPTION_NONE:
break;
}
rc= mysql_optionsv(mysql, mariadb_defaults[i].u.option, option_val);
return(test(rc));
}
}
}
/* unknown key */
return 1;
} | O3 | c | mariadb_set_conf_option:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %r12b
testq %rsi, %rsi
je 0x192d0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %r15, %rdi
movl $0x5f, %esi
callq 0x13180
testq %rax, %rax
je 0x191d9
movb $0x2d, (%rax)
jmp 0x191c2
leaq 0x331f0(%rip), %r13 # 0x4c3d0
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x192d0
movq %r15, %rsi
callq 0x13650
testl %eax, %eax
je 0x1921d
leaq 0x331d0(%rip), %r13 # 0x4c3d0
movq 0x28(%r13), %rdi
testq %rdi, %rdi
je 0x192d0
movq %r15, %rsi
callq 0x13650
addq $0x18, %r13
testl %eax, %eax
jne 0x19200
movl 0x8(%r13), %eax
decl %eax
cmpl $0x4, %eax
ja 0x192b6
leaq 0x22921(%rip), %rcx # 0x3bb54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x29(%rbp), %r15
movb $0x0, (%r15)
testq %r14, %r14
je 0x192b9
movq %r14, %rdi
callq 0x13700
movb %al, -0x29(%rbp)
jmp 0x192b9
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq *(%r13)
movl %eax, %r12d
jmp 0x192d0
leaq -0x38(%rbp), %r15
movq $0x0, (%r15)
testq %r14, %r14
je 0x192b9
movq %r14, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x13660
movq %rax, -0x38(%rbp)
jmp 0x192b9
movq %r14, %r15
jmp 0x192b9
leaq -0x30(%rbp), %r15
movl $0x0, (%r15)
testq %r14, %r14
je 0x192b9
movq %r14, %rdi
callq 0x13700
movl %eax, -0x30(%rbp)
jmp 0x192b9
xorl %r15d, %r15d
movl (%r13), %esi
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x192e2
testl %eax, %eax
setne %r12b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mariadb_set_conf_option:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12b, 1
test rsi, rsi
jz loc_192D0
mov r14, rdx
mov r15, rsi
mov rbx, rdi
loc_191C2:
mov rdi, r15
mov esi, 5Fh ; '_'
call _strchr
test rax, rax
jz short loc_191D9
mov byte ptr [rax], 2Dh ; '-'
jmp short loc_191C2
loc_191D9:
lea r13, mariadb_defaults
mov rdi, [r13+10h]
test rdi, rdi
jz loc_192D0
mov rsi, r15
call _strcmp
test eax, eax
jz short loc_1921D
lea r13, mariadb_defaults
loc_19200:
mov rdi, [r13+28h]
test rdi, rdi
jz loc_192D0
mov rsi, r15
call _strcmp
add r13, 18h
test eax, eax
jnz short loc_19200
loc_1921D:
mov eax, [r13+8]
dec eax; switch 5 cases
cmp eax, 4
ja def_1923A; jumptable 000000000001923A default case
lea rcx, jpt_1923A
movsxd rax, ds:(jpt_1923A - 3BB54h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1923C:
lea r15, [rbp+var_29]; jumptable 000000000001923A case 1
mov byte ptr [r15], 0
test r14, r14
jz short loc_192B9
mov rdi, r14
call _atoi
mov [rbp+var_29], al
jmp short loc_192B9
loc_19256:
mov rdi, rbx; jumptable 000000000001923A case 5
mov rsi, r15
mov rdx, r14
mov rcx, 0FFFFFFFFFFFFFFFFh
call qword ptr [r13+0]
mov r12d, eax
jmp short loc_192D0
loc_1926F:
lea r15, [rbp+var_38]; jumptable 000000000001923A case 3
mov qword ptr [r15], 0
test r14, r14
jz short loc_192B9
mov rdi, r14
xor esi, esi
mov edx, 0Ah
call _strtol
mov [rbp+var_38], rax
jmp short loc_192B9
loc_19294:
mov r15, r14; jumptable 000000000001923A case 4
jmp short loc_192B9
loc_19299:
lea r15, [rbp+var_30]; jumptable 000000000001923A case 2
mov dword ptr [r15], 0
test r14, r14
jz short loc_192B9
mov rdi, r14
call _atoi
mov [rbp+var_30], eax
jmp short loc_192B9
def_1923A:
xor r15d, r15d; jumptable 000000000001923A default case
loc_192B9:
mov esi, [r13+0]
mov rdi, rbx
mov rdx, r15
xor eax, eax
call mysql_optionsv
test eax, eax
setnz r12b
loc_192D0:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mariadb_set_conf_option(long long a1, long long a2, long long a3)
{
unsigned int v3; // r12d
_BYTE *v6; // rax
_DWORD *v7; // r13
long long v8; // rdi
int v9; // ecx
int v10; // r8d
int v11; // r9d
long long v12; // rdi
long long *v13; // r15
long long v15; // [rsp+8h] [rbp-38h] BYREF
int v16; // [rsp+10h] [rbp-30h] BYREF
char v17; // [rsp+17h] [rbp-29h] BYREF
LOBYTE(v3) = 1;
if ( a2 )
{
while ( 1 )
{
v6 = (_BYTE *)strchr(a2, 95LL);
if ( !v6 )
break;
*v6 = 45;
}
v7 = &mariadb_defaults;
v8 = *((_QWORD *)&mariadb_defaults + 2);
if ( v8 )
{
if ( !(unsigned int)strcmp(v8, a2) )
{
LABEL_9:
switch ( v7[2] )
{
case 1:
v13 = (long long *)&v17;
v17 = 0;
if ( a3 )
v17 = atoi(a3);
goto LABEL_19;
case 2:
v13 = (long long *)&v16;
v16 = 0;
if ( a3 )
v16 = atoi(a3);
goto LABEL_19;
case 3:
v13 = &v15;
v15 = 0LL;
if ( a3 )
v15 = strtol(a3, 0LL, 10LL);
goto LABEL_19;
case 4:
LODWORD(v13) = a3;
goto LABEL_19;
case 5:
return (*(unsigned int ( **)(long long, long long, long long, long long))v7)(a1, a2, a3, -1LL);
default:
LODWORD(v13) = 0;
LABEL_19:
LOBYTE(v3) = (unsigned int)mysql_optionsv(a1, *v7, (_DWORD)v13, v9, v10, v11) != 0;
break;
}
}
else
{
v7 = &mariadb_defaults;
while ( 1 )
{
v12 = *((_QWORD *)v7 + 5);
if ( !v12 )
break;
v7 += 6;
if ( !(unsigned int)strcmp(v12, a2) )
goto LABEL_9;
}
}
}
}
return v3;
}
| _mariadb_set_conf_option:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12B,0x1
TEST RSI,RSI
JZ 0x001192d0
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LAB_001191c2:
MOV RDI,R15
MOV ESI,0x5f
CALL 0x00113180
TEST RAX,RAX
JZ 0x001191d9
MOV byte ptr [RAX],0x2d
JMP 0x001191c2
LAB_001191d9:
LEA R13,[0x14c3d0]
MOV RDI,qword ptr [R13 + 0x10]
TEST RDI,RDI
JZ 0x001192d0
MOV RSI,R15
CALL 0x00113650
TEST EAX,EAX
JZ 0x0011921d
LEA R13,[0x14c3d0]
LAB_00119200:
MOV RDI,qword ptr [R13 + 0x28]
TEST RDI,RDI
JZ 0x001192d0
MOV RSI,R15
CALL 0x00113650
ADD R13,0x18
TEST EAX,EAX
JNZ 0x00119200
LAB_0011921d:
MOV EAX,dword ptr [R13 + 0x8]
DEC EAX
CMP EAX,0x4
JA 0x001192b6
LEA RCX,[0x13bb54]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
LEA R15,[RBP + -0x29]
MOV byte ptr [R15],0x0
TEST R14,R14
JZ 0x001192b9
MOV RDI,R14
CALL 0x00113700
MOV byte ptr [RBP + -0x29],AL
JMP 0x001192b9
caseD_5:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,-0x1
CALL qword ptr [R13]
MOV R12D,EAX
JMP 0x001192d0
caseD_3:
LEA R15,[RBP + -0x38]
MOV qword ptr [R15],0x0
TEST R14,R14
JZ 0x001192b9
MOV RDI,R14
XOR ESI,ESI
MOV EDX,0xa
CALL 0x00113660
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001192b9
caseD_4:
MOV R15,R14
JMP 0x001192b9
caseD_2:
LEA R15,[RBP + -0x30]
MOV dword ptr [R15],0x0
TEST R14,R14
JZ 0x001192b9
MOV RDI,R14
CALL 0x00113700
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001192b9
default:
XOR R15D,R15D
LAB_001192b9:
MOV ESI,dword ptr [R13]
MOV RDI,RBX
MOV RDX,R15
XOR EAX,EAX
CALL 0x001192e2
TEST EAX,EAX
SETNZ R12B
LAB_001192d0:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _mariadb_set_conf_option(int8 param_1,char *param_2,long *param_3)
{
int iVar1;
uint uVar2;
char *pcVar3;
int8 unaff_R12;
ulong uVar4;
int1 *puVar6;
long *plVar7;
long local_40;
int local_38;
int1 local_31;
int7 uVar5;
uVar5 = (int7)((ulong)unaff_R12 >> 8);
uVar4 = CONCAT71(uVar5,1);
if (param_2 != (char *)0x0) {
while (pcVar3 = strchr(param_2,0x5f), pcVar3 != (char *)0x0) {
*pcVar3 = '-';
}
puVar6 = mariadb_defaults;
if (mariadb_defaults._16_8_ != 0) {
iVar1 = strcmp((char *)mariadb_defaults._16_8_,param_2);
if (iVar1 != 0) {
puVar6 = mariadb_defaults;
do {
if (*(char **)((long)puVar6 + 0x28) == (char *)0x0) goto LAB_001192d0;
iVar1 = strcmp(*(char **)((long)puVar6 + 0x28),param_2);
puVar6 = (int1 *)((long)puVar6 + 0x18);
} while (iVar1 != 0);
}
switch(*(int4 *)((long)puVar6 + 8)) {
case 1:
plVar7 = (long *)&local_31;
local_31 = 0;
if (param_3 != (long *)0x0) {
iVar1 = atoi((char *)param_3);
local_31 = (int1)iVar1;
}
break;
case 2:
plVar7 = (long *)&local_38;
local_38 = 0;
if (param_3 != (long *)0x0) {
local_38 = atoi((char *)param_3);
}
break;
case 3:
plVar7 = &local_40;
local_40 = 0;
if (param_3 != (long *)0x0) {
local_40 = strtol((char *)param_3,(char **)0x0,10);
}
break;
case 4:
plVar7 = param_3;
break;
case 5:
uVar2 = (**(code **)puVar6)(param_1,param_2,param_3,0xffffffffffffffff);
uVar4 = (ulong)uVar2;
goto LAB_001192d0;
default:
plVar7 = (long *)0x0;
}
iVar1 = mysql_optionsv(param_1,*(int4 *)puVar6,plVar7);
uVar4 = CONCAT71(uVar5,iVar1 != 0);
}
}
LAB_001192d0:
return uVar4 & 0xffffffff;
}
| |
53,712 | pvio_socket_read | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | ssize_t pvio_socket_read(MARIADB_PVIO *pvio, uchar *buffer, size_t length)
{
ssize_t r;
int read_flags= MSG_DONTWAIT;
struct st_pvio_socket *csock;
int timeout;
if (!pvio || !pvio->data)
return -1;
csock= (struct st_pvio_socket *)pvio->data;
timeout = pvio->timeout[PVIO_READ_TIMEOUT];
while ((r = ma_recv(csock->socket, (void *)buffer, length, read_flags)) == -1)
{
int err = socket_errno;
if ((err != SOCKET_EAGAIN
#ifdef HAVE_SOCKET_EWOULDBLOCK
&& err != SOCKET_EWOULDBLOCK
#endif
) || timeout == 0)
return r;
if (pvio_socket_wait_io_or_timeout(pvio, TRUE, timeout) < 1)
return -1;
}
return r;
} | O0 | c | pvio_socket_read:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x40, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b7dc
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5b7e6
movq $-0x1, -0x8(%rbp)
jmp 0x5b865
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5ce20
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
jne 0x5b85d
callq 0x14050
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $0xb, -0x40(%rbp)
jne 0x5b831
cmpl $0x0, -0x3c(%rbp)
jne 0x5b83b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b865
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl $0x1, %esi
callq 0x5ba50
cmpl $0x1, %eax
jge 0x5b85b
movq $-0x1, -0x8(%rbp)
jmp 0x5b865
jmp 0x5b7fb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| pvio_socket_read:
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_2C], 40h ; '@'
cmp [rbp+var_10], 0
jz short loc_5B7DC
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_5B7E6
loc_5B7DC:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_5B865
loc_5B7E6:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov eax, [rax+28h]
mov [rbp+var_3C], eax
loc_5B7FB:
mov rax, [rbp+var_38]
mov edi, [rax]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_2C]
call ma_recv
mov [rbp+var_28], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_5B85D
call ___errno_location
mov eax, [rax]
mov [rbp+var_40], eax
cmp [rbp+var_40], 0Bh
jnz short loc_5B831
cmp [rbp+var_3C], 0
jnz short loc_5B83B
loc_5B831:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_5B865
loc_5B83B:
mov rdi, [rbp+var_10]
mov edx, [rbp+var_3C]
mov esi, 1
call pvio_socket_wait_io_or_timeout
cmp eax, 1
jge short loc_5B85B
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_5B865
loc_5B85B:
jmp short loc_5B7FB
loc_5B85D:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_5B865:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_read(unsigned int **a1, long long a2, long long a3)
{
long long v3; // rdi
unsigned int v5; // [rsp+4h] [rbp-3Ch]
unsigned int *v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+18h] [rbp-28h]
if ( !a1 || !*a1 )
return -1LL;
v6 = *a1;
v5 = *((_DWORD *)a1 + 10);
while ( 1 )
{
v3 = *v6;
v7 = ma_recv(v3, a2, a3, 64LL);
if ( v7 != -1 )
break;
if ( *(_DWORD *)__errno_location(v3) != 11 || !v5 )
return -1LL;
if ( (int)pvio_socket_wait_io_or_timeout(a1, 1LL, v5) < 1 )
return -1LL;
}
return v7;
}
| pvio_socket_read:
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 dword ptr [RBP + -0x2c],0x40
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015b7dc
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0015b7e6
LAB_0015b7dc:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0015b865
LAB_0015b7e6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RBP + -0x3c],EAX
LAB_0015b7fb:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x2c]
CALL 0x0015ce20
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,-0x1
JNZ 0x0015b85d
CALL 0x00114050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
CMP dword ptr [RBP + -0x40],0xb
JNZ 0x0015b831
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x0015b83b
LAB_0015b831:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015b865
LAB_0015b83b:
MOV RDI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x3c]
MOV ESI,0x1
CALL 0x0015ba50
CMP EAX,0x1
JGE 0x0015b85b
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0015b865
LAB_0015b85b:
JMP 0x0015b7fb
LAB_0015b85d:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_0015b865:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long pvio_socket_read(long *param_1,int8 param_2,int8 param_3)
{
int4 *puVar1;
long lVar2;
int iVar3;
long lVar4;
int *piVar5;
if ((param_1 != (long *)0x0) && (*param_1 != 0)) {
puVar1 = (int4 *)*param_1;
lVar2 = param_1[5];
do {
lVar4 = ma_recv(*puVar1,param_2,param_3,0x40);
if (lVar4 != -1) {
return lVar4;
}
piVar5 = __errno_location();
if (*piVar5 != 0xb) {
return -1;
}
if ((int)lVar2 == 0) {
return -1;
}
iVar3 = pvio_socket_wait_io_or_timeout(param_1,1,(int)lVar2);
} while (0 < iVar3);
}
return -1;
}
| |
53,713 | blst_sign_pk2_in_g1 | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/e2.c | void blst_sign_pk2_in_g1(unsigned char out[192], POINTonE2_affine *sig,
const POINTonE2 *hash, const pow256 SK)
{
POINTonE2 P[1];
POINTonE2_sign(P, hash, SK);
if (sig != NULL)
vec_copy(sig, P, sizeof(*sig));
if (out != NULL) {
limb_t sgn0_pty = POINTonE2_Serialize_BE(out, P);
out[0] |= (sgn0_pty & 2) << 4; /* pre-decorate */
out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;
}
} | O2 | c | blst_sign_pk2_in_g1:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x130(%rbp), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x54b6d
testq %r14, %r14
je 0x54db1
leaq -0x130(%rbp), %rsi
movl $0xc0, %edx
movq %r14, %rdi
callq 0x51055
testq %rbx, %rbx
je 0x54ddd
leaq -0x130(%rbp), %rsi
movq %rbx, %rdi
callq 0x54d13
shlb $0x4, %al
andb $0x20, %al
orb %al, (%rbx)
leaq -0x70(%rbp), %rdi
pushq $0x60
popq %rsi
callq 0x510f5
shlb $0x6, %al
orb %al, (%rbx)
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
| blst_sign_pk2_in_g1:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 120h
mov r14, rsi
mov rbx, rdi
lea rdi, [rbp+var_130]
mov rsi, rdx
mov rdx, rcx
call POINTonE2_sign
test r14, r14
jz short loc_54DB1
lea rsi, [rbp+var_130]
mov edx, 0C0h
mov rdi, r14
call vec_copy
loc_54DB1:
test rbx, rbx
jz short loc_54DDD
lea rsi, [rbp+var_130]
mov rdi, rbx
call POINTonE2_Serialize_BE
shl al, 4
and al, 20h
or [rbx], al
lea rdi, [rbp+var_70]
push 60h ; '`'
pop rsi
call vec_is_zero
shl al, 6
or [rbx], al
loc_54DDD:
add rsp, 120h
pop rbx
pop r14
pop rbp
retn
| char blst_sign_pk2_in_g1(_BYTE *a1, long long a2)
{
char result; // al
_BYTE v3[192]; // [rsp+0h] [rbp-130h] BYREF
_BYTE v4[112]; // [rsp+C0h] [rbp-70h] BYREF
result = POINTonE2_sign((long long)v3);
if ( a2 )
result = vec_copy(a2, (long long)v3, 0xC0uLL);
if ( a1 )
{
*a1 |= (16 * POINTonE2_Serialize_BE((long long)a1, (long long)v3)) & 0x20;
result = (unsigned __int8)vec_is_zero((long long)v4, 0x60uLL) << 6;
*a1 |= result;
}
return result;
}
| blst_sign_pk2_in_g1:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x120
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0x130]
MOV RSI,RDX
MOV RDX,RCX
CALL 0x00154b6d
TEST R14,R14
JZ 0x00154db1
LEA RSI,[RBP + -0x130]
MOV EDX,0xc0
MOV RDI,R14
CALL 0x00151055
LAB_00154db1:
TEST RBX,RBX
JZ 0x00154ddd
LEA RSI,[RBP + -0x130]
MOV RDI,RBX
CALL 0x00154d13
SHL AL,0x4
AND AL,0x20
OR byte ptr [RBX],AL
LEA RDI,[RBP + -0x70]
PUSH 0x60
POP RSI
CALL 0x001510f5
SHL AL,0x6
OR byte ptr [RBX],AL
LAB_00154ddd:
ADD RSP,0x120
POP RBX
POP R14
POP RBP
RET
|
void blst_sign_pk2_in_g1(byte *param_1,long param_2,int8 param_3,int8 param_4)
{
byte bVar1;
char cVar2;
int1 local_138 [192];
int1 local_78 [96];
POINTonE2_sign(local_138,param_3,param_4);
if (param_2 != 0) {
vec_copy(param_2,local_138,0xc0);
}
if (param_1 != (byte *)0x0) {
bVar1 = POINTonE2_Serialize_BE(param_1,local_138);
*param_1 = *param_1 | (bVar1 & 2) << 4;
cVar2 = vec_is_zero(local_78,0x60);
*param_1 = *param_1 | cVar2 << 6;
}
return;
}
| |
53,714 | aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisher::Initialize(YAML::Node) | aimrt_mujoco_sim/src/module/mujoco_sim_module/publisher/imu_sensor_publisher.cc | void ImuSensorPublisher::Initialize(YAML::Node options_node) {
InitializeBase(options_node);
AIMRT_CHECK_ERROR_THROW(aimrt::channel::RegisterPublishType<aimrt::protocols::sensor::ImuState>(publisher_),
"Register publish type failed.");
} | O3 | cpp | aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisher::Initialize(YAML::Node):
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
leaq 0x48(%rsp), %rdi
movb %al, -0x8(%rdi)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x2c640
movq 0x28(%r14), %rax
movq %rax, 0x10(%r15)
movq 0x30(%r14), %rax
movq %rax, 0x18(%r15)
testq %rax, %rax
je 0x4fbe1
movq 0x1c0355(%rip), %rcx # 0x20ff28
cmpb $0x0, (%rcx)
je 0x4fbdd
incl 0x8(%rax)
jmp 0x4fbe1
lock
incl 0x8(%rax)
movq 0x38(%r14), %rax
leaq 0x40(%rsp), %rsi
movq %rax, 0x38(%rsi)
movq %rbx, %rdi
callq 0x4f9fc
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x4fc05
callq 0x466d6
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x4fc1c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2d2d0
movq 0x98(%rbx), %rax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
callq 0x52a73
movq %rbx, %rdi
movq %rax, %rsi
callq 0x52990
testb %al, %al
je 0x4fc4c
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11382d(%rip), %rsi # 0x163480
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %r8
movl $0x1d, %edx
xorl %ecx, %ecx
callq 0x34203
callq 0x60724
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
callq 0x3400e
cmpl $0x4, %eax
ja 0x4fcb0
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x113809(%rip), %rcx # 0x16349e
leaq 0x14c366(%rip), %r8 # 0x19c002
leaq 0x30(%rsp), %rdi
movl $0x4, %esi
movl $0x47, %edx
callq 0x340ee
movl $0x28, %edi
callq 0x2c800
leaq 0x1b8c27(%rip), %rcx # 0x2088e8
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
leaq 0x20(%rsp), %rcx
movq -0x10(%rcx), %rsi
cmpq %rcx, %rsi
jne 0x4fce2
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x4fcef
movq %rsi, 0x8(%rax)
movq 0x20(%rsp), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x1b8a6e(%rip), %rsi # 0x208780
leaq -0x1bb45(%rip), %rdx # 0x341d4
movq %rax, %rdi
callq 0x2e0f0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x46052
jmp 0x4fd52
jmp 0x4fd34
jmp 0x4fd34
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fd52
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2d2d0
movq %rbx, %rdi
callq 0x2e220
| _ZN16aimrt_mujoco_sim17mujoco_sim_module9publisher18ImuSensorPublisher10InitializeEN4YAML4NodeE:
push r15
push r14
push rbx
sub rsp, 80h
mov r14, rsi
mov rbx, rdi
mov al, [rsi]
lea rdi, [rsp+98h+var_50]
mov [rdi-8], al
lea r15, [rsp+98h+var_40]
mov [r15-10h], r15
mov rsi, [rsi+8]
mov rdx, [r14+10h]
add rdx, rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rax, [r14+28h]
mov [r15+10h], rax
mov rax, [r14+30h]
mov [r15+18h], rax
test rax, rax
jz short loc_4FBE1
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_4FBDD
inc dword ptr [rax+8]
jmp short loc_4FBE1
loc_4FBDD:
lock inc dword ptr [rax+8]
loc_4FBE1:
mov rax, [r14+38h]
lea rsi, [rsp+98h+var_58]
mov [rsi+38h], rax
mov rdi, rbx
call _ZN16aimrt_mujoco_sim17mujoco_sim_module9publisher22ImuSensorPublisherBase14InitializeBaseEN4YAML4NodeE; aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisherBase::InitializeBase(YAML::Node)
mov rdi, [rsp+98h+var_28]
test rdi, rdi
jz short loc_4FC05
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4FC05:
mov rdi, [rsp+98h+var_50]; void *
cmp rdi, r15
jz short loc_4FC1C
mov rsi, [rsp+98h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4FC1C:
mov rax, [rbx+98h]
lea rbx, [rsp+98h+var_88]
mov [rbx], rax
call _ZN5aimrt29GetProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv
mov rdi, rbx
mov rsi, rax
call _ZN5aimrt7channel12PublisherRef19RegisterPublishTypeEPK25aimrt_type_support_base_t; aimrt::channel::PublisherRef::RegisterPublishType(aimrt_type_support_base_t const*)
test al, al
jz short loc_4FC4C
add rsp, 80h
pop rbx
pop r14
pop r15
retn
loc_4FC4C:
lea rsi, aRegisterPublis; "Register publish type failed."
lea rdi, [rsp+98h+var_88]; this
lea r8, [rsp+98h+var_68]; int
mov edx, 1Dh; int
xor ecx, ecx; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
call _ZN16aimrt_mujoco_sim17mujoco_sim_module9GetLoggerEv; aimrt_mujoco_sim::mujoco_sim_module::GetLogger(void)
lea rdi, [rsp+98h+var_68]; this
mov [rdi], rax
call _ZNK5aimrt6logger9LoggerRef11GetLogLevelEv; aimrt::logger::LoggerRef::GetLogLevel(void)
cmp eax, 4
ja short loc_4FCB0
mov r9, [rsp+98h+var_88]; char *
mov rax, [rsp+98h+var_80]
mov [rsp+98h+var_98], rax; unsigned __int64
lea rcx, aWorkspaceLlm4b_2; "/workspace/llm4binary/github2025/aimrt_"...
lea r8, aEglinitialize+3; char *
lea rdi, [rsp+98h+var_68]; this
mov esi, 4; unsigned int
mov edx, 47h ; 'G'; unsigned int
call _ZNK5aimrt6logger9LoggerRef3LogEjjPKcS3_S3_m; aimrt::logger::LoggerRef::Log(uint,uint,char const*,char const*,char const*,ulong)
loc_4FCB0:
mov edi, 28h ; '('; thrown_size
call ___cxa_allocate_exception
lea rcx, off_2088E8
mov [rax], rcx
lea rdx, [rax+18h]
mov [rax+8], rdx
lea rcx, [rsp+98h+var_78]
mov rsi, [rcx-10h]
cmp rsi, rcx
jnz short loc_4FCE2
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rdx], xmm0
jmp short loc_4FCEF
loc_4FCE2:
mov [rax+8], rsi
mov rdx, [rsp+98h+var_78]
mov [rax+18h], rdx
loc_4FCEF:
mov rdx, [rsp+98h+var_80]
mov [rax+10h], rdx
mov [rsp+98h+var_88], rcx
mov [rsp+98h+var_80], 0
mov byte ptr [rsp+98h+var_78], 0
lea rsi, _ZTIN5aimrt6common4util14AimRTExceptionE; lptinfo
lea rdx, _ZN5aimrt6common4util14AimRTExceptionD2Ev; void (*)(void *)
mov rdi, rax; void *
call ___cxa_throw
mov rbx, rax
lea rdi, [rsp+98h+var_58]; this
call _ZN4YAML4NodeD2Ev; YAML::Node::~Node()
jmp short loc_4FD52
jmp short loc_4FD34
jmp short $+2
loc_4FD34:
mov rbx, rax
lea rax, [rsp+98h+var_78]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4FD52
mov rsi, [rsp+98h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4FD52:
mov rdi, rbx
call __Unwind_Resume
| long long aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisher::Initialize(
long long a1,
long long a2,
double a3)
{
volatile signed __int32 *v5; // rax
void **v6; // rsi
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
int v11; // edi
long long ProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv; // rax
long long result; // rax
char *exception; // rax
char *v15; // [rsp+10h] [rbp-88h] BYREF
unsigned long long v16; // [rsp+18h] [rbp-80h]
__int128 v17; // [rsp+20h] [rbp-78h] BYREF
int v18[4]; // [rsp+30h] [rbp-68h] BYREF
void *v19; // [rsp+40h] [rbp-58h] BYREF
void *v20; // [rsp+48h] [rbp-50h] BYREF
_QWORD v21[3]; // [rsp+58h] [rbp-40h] BYREF
volatile signed __int32 *v22; // [rsp+70h] [rbp-28h]
long long v23; // [rsp+78h] [rbp-20h]
LOBYTE(v19) = *(_BYTE *)a2;
v20 = v21;
std::string::_M_construct<char *>(&v20, *(_QWORD *)(a2 + 8), *(_QWORD *)(a2 + 8) + *(_QWORD *)(a2 + 16));
v21[2] = *(_QWORD *)(a2 + 40);
v5 = *(volatile signed __int32 **)(a2 + 48);
v22 = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v5 + 2);
else
_InterlockedIncrement(v5 + 2);
}
v6 = &v19;
v23 = *(_QWORD *)(a2 + 56);
aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisherBase::InitializeBase(a1, &v19, a3);
if ( v22 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v22);
v11 = (int)v20;
if ( v20 != v21 )
{
LODWORD(v6) = LODWORD(v21[0]) + 1;
operator delete(v20, v21[0] + 1LL);
}
v15 = *(char **)(a1 + 152);
ProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv = ZN5aimrt29GetProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv(v11, (_DWORD)v6, v7, v8, v9, v10);
result = aimrt::channel::PublisherRef::RegisterPublishType(
&v15,
ProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv);
if ( !(_BYTE)result )
{
fmt::v10::vformat[abi:cxx11](&v15);
*(_QWORD *)v18 = aimrt_mujoco_sim::mujoco_sim_module::GetLogger((aimrt_mujoco_sim::mujoco_sim_module *)&v15);
if ( (unsigned int)aimrt::logger::LoggerRef::GetLogLevel((aimrt::logger::LoggerRef *)v18) <= 4 )
aimrt::logger::LoggerRef::Log(
(aimrt::logger::LoggerRef *)v18,
4LL,
71LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/src/module/mujoco_sim_module/publisher/imu_sensor_publisher.cc",
"Initialize",
v15,
v16);
exception = (char *)__cxa_allocate_exception(0x28uLL);
*(_QWORD *)exception = off_2088E8;
*((_QWORD *)exception + 1) = exception + 24;
if ( v15 == (char *)&v17 )
{
*(_OWORD *)(exception + 24) = v17;
}
else
{
*((_QWORD *)exception + 1) = v15;
*((_QWORD *)exception + 3) = v17;
}
*((_QWORD *)exception + 2) = v16;
v15 = (char *)&v17;
v16 = 0LL;
LOBYTE(v17) = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'aimrt::common::util::AimRTException,
(void (*)(void *))aimrt::common::util::AimRTException::~AimRTException);
}
return result;
}
| Initialize:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x80
MOV R14,RSI
MOV RBX,RDI
MOV AL,byte ptr [RSI]
LEA RDI,[RSP + 0x48]
MOV byte ptr [RDI + -0x8],AL
LEA R15,[RSP + 0x58]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [R14 + 0x10]
ADD RDX,RSI
CALL 0x0012c640
MOV RAX,qword ptr [R14 + 0x28]
MOV qword ptr [R15 + 0x10],RAX
MOV RAX,qword ptr [R14 + 0x30]
MOV qword ptr [R15 + 0x18],RAX
TEST RAX,RAX
JZ 0x0014fbe1
MOV RCX,qword ptr [0x0030ff28]
CMP byte ptr [RCX],0x0
JZ 0x0014fbdd
INC dword ptr [RAX + 0x8]
JMP 0x0014fbe1
LAB_0014fbdd:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0014fbe1:
MOV RAX,qword ptr [R14 + 0x38]
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI + 0x38],RAX
LAB_0014fbee:
MOV RDI,RBX
CALL 0x0014f9fc
LAB_0014fbf6:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x0014fc05
CALL 0x001466d6
LAB_0014fc05:
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R15
JZ 0x0014fc1c
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0012d2d0
LAB_0014fc1c:
MOV RAX,qword ptr [RBX + 0x98]
LEA RBX,[RSP + 0x10]
MOV qword ptr [RBX],RAX
CALL 0x00152a73
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00152990
TEST AL,AL
JZ 0x0014fc4c
ADD RSP,0x80
POP RBX
POP R14
POP R15
RET
LAB_0014fc4c:
LEA RSI,[0x263480]
LEA RDI,[RSP + 0x10]
LEA R8,[RSP + 0x30]
MOV EDX,0x1d
XOR ECX,ECX
CALL 0x00134203
LAB_0014fc69:
CALL 0x00160724
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RAX
LAB_0014fc76:
CALL 0x0013400e
CMP EAX,0x4
JA 0x0014fcb0
MOV R9,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
LAB_0014fc8a:
MOV qword ptr [RSP],RAX
LEA RCX,[0x26349e]
LEA R8,[0x29c002]
LEA RDI,[RSP + 0x30]
MOV ESI,0x4
MOV EDX,0x47
CALL 0x001340ee
LAB_0014fcb0:
MOV EDI,0x28
CALL 0x0012c800
LEA RCX,[0x3088e8]
MOV qword ptr [RAX],RCX
LEA RDX,[RAX + 0x18]
MOV qword ptr [RAX + 0x8],RDX
LEA RCX,[RSP + 0x20]
MOV RSI,qword ptr [RCX + -0x10]
CMP RSI,RCX
JNZ 0x0014fce2
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RDX],XMM0
JMP 0x0014fcef
LAB_0014fce2:
MOV qword ptr [RAX + 0x8],RSI
MOV RDX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x18],RDX
LAB_0014fcef:
MOV RDX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x18],0x0
MOV byte ptr [RSP + 0x20],0x0
LAB_0014fd0b:
LEA RSI,[0x308780]
LEA RDX,[0x1341d4]
MOV RDI,RAX
CALL 0x0012e0f0
|
/* aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisher::Initialize(YAML::Node) */
void __thiscall
aimrt_mujoco_sim::mujoco_sim_module::publisher::ImuSensorPublisher::Initialize
(ImuSensorPublisher *this,int1 *param_2)
{
char cVar1;
uint uVar2;
int8 *puVar3;
uint *local_88;
int8 local_80;
uint local_78;
int4 uStack_74;
int4 uStack_70;
int4 uStack_6c;
int8 local_68 [2];
int1 local_58;
long *local_50 [2];
long local_40 [2];
int8 local_30;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_28;
int8 local_20;
local_58 = *param_2;
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char*>
(local_50,*(long *)(param_2 + 8),*(long *)(param_2 + 0x10) + *(long *)(param_2 + 8));
local_30 = *(int8 *)(param_2 + 0x28);
local_28 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(param_2 + 0x30);
if (local_28 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0030ff28 == '\0') {
LOCK();
*(int *)(local_28 + 8) = *(int *)(local_28 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_28 + 8) = *(int *)(local_28 + 8) + 1;
}
}
local_20 = *(int8 *)(param_2 + 0x38);
/* try { // try from 0014fbee to 0014fbf5 has its CatchHandler @ 0014fd21 */
ImuSensorPublisherBase::InitializeBase((ImuSensorPublisherBase *)this);
if (local_28 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_28);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
local_88 = *(uint **)(this + 0x98);
_ZN5aimrt29GetProtobufMessageTypeSupportITkSt12derived_fromIN6google8protobuf7MessageEENS_9protocols6sensor8ImuStateEEEPK25aimrt_type_support_base_tv
();
cVar1 = aimrt::channel::PublisherRef::RegisterPublishType((aimrt_type_support_base_t *)&local_88);
if (cVar1 != '\0') {
return;
}
fmt::v10::vformat_abi_cxx11_(&local_88,"Register publish type failed.",0x1d,0,local_68);
/* try { // try from 0014fc69 to 0014fc6d has its CatchHandler @ 0014fd34 */
local_68[0] = GetLogger();
/* try { // try from 0014fc76 to 0014fc7a has its CatchHandler @ 0014fd32 */
uVar2 = aimrt::logger::LoggerRef::GetLogLevel((LoggerRef *)local_68);
if (uVar2 < 5) {
/* try { // try from 0014fc8a to 0014fcaf has its CatchHandler @ 0014fd30 */
aimrt::logger::LoggerRef::Log
((uint)local_68,4,(char *)0x47,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/src/module/mujoco_sim_module/publisher/imu_sensor_publisher.cc"
,"Initialize",(ulong)local_88);
}
puVar3 = (int8 *)__cxa_allocate_exception(0x28);
*puVar3 = &PTR__AimRTException_003088e8;
puVar3[1] = puVar3 + 3;
if (local_88 == &local_78) {
*(uint *)(puVar3 + 3) = local_78;
*(int4 *)((long)puVar3 + 0x1c) = uStack_74;
*(int4 *)(puVar3 + 4) = uStack_70;
*(int4 *)((long)puVar3 + 0x24) = uStack_6c;
}
else {
puVar3[1] = local_88;
puVar3[3] = CONCAT44(uStack_74,local_78);
}
puVar3[2] = local_80;
local_80 = 0;
local_78 = local_78 & 0xffffff00;
local_88 = &local_78;
/* try { // try from 0014fd0b to 0014fd20 has its CatchHandler @ 0014fd32 */
/* WARNING: Subroutine does not return */
__cxa_throw(puVar3,&aimrt::common::util::AimRTException::typeinfo,
aimrt::common::util::AimRTException::~AimRTException);
}
| |
53,715 | end_server | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void
end_server(MYSQL *mysql)
{
/* if net->error 2 and reconnect is activated, we need to inform
connection handler */
if (mysql->net.pvio != 0)
{
ma_pvio_close(mysql->net.pvio);
mysql->net.pvio= 0; /* Marker */
}
ma_net_end(&mysql->net);
free_old_query(mysql);
return;
} | O0 | c | end_server:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7aa1d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x885e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0xaa520
movq -0x8(%rbp), %rdi
callq 0x82be0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| end_server:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax], 0
jz short loc_7AA1D
mov rax, [rbp+var_8]
mov rdi, [rax]
call ma_pvio_close
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
loc_7AA1D:
mov rdi, [rbp+var_8]
call ma_net_end
mov rdi, [rbp+var_8]
call free_old_query
add rsp, 10h
pop rbp
retn
| long long end_server(_QWORD *a1)
{
if ( *a1 )
{
ma_pvio_close(*a1);
*a1 = 0LL;
}
ma_net_end(a1);
return free_old_query(a1);
}
| end_server:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX],0x0
JZ 0x0017aa1d
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
CALL 0x001885e0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
LAB_0017aa1d:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001aa520
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00182be0
ADD RSP,0x10
POP RBP
RET
|
void end_server(long *param_1)
{
if (*param_1 != 0) {
ma_pvio_close(*param_1);
*param_1 = 0;
}
ma_net_end(param_1);
free_old_query(param_1);
return;
}
| |
53,716 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O0 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x220(%rbp), %rax
cmpq -0x218(%rbp), %rax
jne 0x83a6c
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0xd58d0
leaq -0x210(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x230(%rbp), %rdx
callq 0x82ba0
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rdi
movq -0x230(%rbp), %rax
addq %rax, %rdi
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rcx
addq %rcx, %rsi
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
callq 0xd58d0
movq -0x218(%rbp), %rax
movq %rax, -0x238(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x83aec
movq -0x238(%rbp), %rax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x382c0
nopw %cs:(%rax,%rax)
| intern_filename:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_220]
cmp rax, [rbp+var_218]
jnz short loc_83A6C
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 200h
call strnmov
lea rax, [rbp+var_210]
mov [rbp+var_220], rax
loc_83A6C:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_230]
call dirname_part
mov [rbp+var_228], rax
mov rdi, [rbp+var_218]
mov rax, [rbp+var_230]
add rdi, rax
mov rsi, [rbp+var_220]
mov rcx, [rbp+var_228]
add rsi, rcx
mov edx, 200h
sub rdx, rax
call strnmov
mov rax, [rbp+var_218]
mov [rbp+var_238], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_83AEC
mov rax, [rbp+var_238]
add rsp, 240h
pop rbp
retn
loc_83AEC:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-230h] BYREF
long long v4; // [rsp+18h] [rbp-228h]
_BYTE *v5; // [rsp+20h] [rbp-220h]
long long v6; // [rsp+28h] [rbp-218h]
_BYTE v7[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+238h] [rbp-8h]
v8 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( a2 == (_BYTE *)a1 )
{
strnmov(v7, v5, 512LL);
v5 = v7;
}
v4 = dirname_part(v6, v5, &v3);
strnmov(v3 + v6, &v5[v4], 512 - v3);
return v6;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RBP + -0x218]
JNZ 0x00183a6c
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x200
CALL 0x001d58d0
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x220],RAX
LAB_00183a6c:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
LEA RDX,[RBP + -0x230]
CALL 0x00182ba0
MOV qword ptr [RBP + -0x228],RAX
MOV RDI,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x230]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x228]
ADD RSI,RCX
MOV EDX,0x200
SUB RDX,RAX
CALL 0x001d58d0
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00183aec
MOV RAX,qword ptr [RBP + -0x238]
ADD RSP,0x240
POP RBP
RET
LAB_00183aec:
CALL 0x001382c0
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long in_FS_OFFSET;
long local_238;
long local_230;
int1 *local_228;
int1 *local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
if (param_2 == param_1) {
strnmov(local_218,param_2,0x200);
local_228 = local_218;
}
local_230 = dirname_part(local_220,local_228,&local_238);
strnmov(local_220 + local_238,local_228 + local_230,0x200 - local_238);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
53,717 | ma_unpin_all_pages | eloqsql/storage/maria/ma_key_recover.c | void _ma_unpin_all_pages(MARIA_HA *info, LSN undo_lsn)
{
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&info->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + info->pinned_pages.elements;
DBUG_ENTER("_ma_unpin_all_pages");
DBUG_PRINT("info", ("undo_lsn: %lu", (ulong) undo_lsn));
if (!info->s->now_transactional)
DBUG_ASSERT(undo_lsn == LSN_IMPOSSIBLE || maria_in_recovery);
while (pinned_page-- != page_link)
{
/*
Note this assert fails if we got a disk error or the record file
is corrupted, which means we should have this enabled only in debug
builds.
*/
#ifdef EXTRA_DEBUG
DBUG_ASSERT((!pinned_page->changed ||
undo_lsn != LSN_IMPOSSIBLE || !info->s->now_transactional) ||
(info->s->state.changed & STATE_CRASHED_FLAGS));
#endif
pagecache_unlock_by_link(info->s->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
info->trn->rec_lsn, undo_lsn,
pinned_page->changed, FALSE);
}
info->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
} | O0 | c | ma_unpin_all_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x2e8(%rax), %rax
movq -0x8(%rbp), %rcx
imull $0x0, 0x2fc(%rcx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x2f0(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x45afa
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e7(%rax)
jne 0x45b10
jmp 0x45b0c
jmp 0x45b0e
jmp 0x45b10
jmp 0x45b12
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x18, %rcx
movq %rcx, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
je 0x45b78
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x600(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x90(%rax), %r8
movq -0x10(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x3, %ecx
xorl %r10d, %r10d
movsbl 0x10(%rax), %eax
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xb49b0
jmp 0x45b12
movq -0x8(%rbp), %rax
movl $0x0, 0x2f0(%rax)
jmp 0x45b88
addq $0x30, %rsp
popq %rbp
retq
nop
| _ma_unpin_all_pages:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+2E8h]
mov rcx, [rbp+var_8]
imul ecx, [rcx+2FCh], 0
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+2F0h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_20], rax
jmp short $+2
loc_45AFA:
mov rax, [rbp+var_8]
mov rax, [rax]
cmp byte ptr [rax+7E7h], 0
jnz short loc_45B10
jmp short $+2
loc_45B0C:
jmp short $+2
loc_45B0E:
jmp short $+2
loc_45B10:
jmp short $+2
loc_45B12:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_20], rcx
cmp rax, [rbp+var_18]
jz short loc_45B78
mov rax, [rbp+var_8]
mov rax, [rax]
mov rdi, [rax+600h]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov r8, [rax+90h]
mov r9, [rbp+var_10]
mov rax, [rbp+var_20]
mov ecx, 3
xor r10d, r10d
movsx eax, byte ptr [rax+10h]
mov [rsp+30h+var_30], eax
mov [rsp+30h+var_28], 0
call pagecache_unlock_by_link
jmp short loc_45B12
loc_45B78:
mov rax, [rbp+var_8]
mov dword ptr [rax+2F0h], 0
jmp short $+2
loc_45B88:
add rsp, 30h
pop rbp
retn
| long long ma_unpin_all_pages(long long a1, int a2)
{
long long v2; // rax
long long result; // rax
long long i; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v5 = *(_QWORD *)(a1 + 744);
for ( i = 24LL * *(unsigned int *)(a1 + 752) + v5;
;
pagecache_unlock_by_link(
*(_QWORD *)(*(_QWORD *)a1 + 1536LL),
*(_QWORD *)i,
*(_DWORD *)(i + 8),
3,
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL),
a2,
*(_BYTE *)(i + 16),
0) )
{
v2 = i;
i -= 24LL;
if ( v2 == v5 )
break;
}
result = a1;
*(_DWORD *)(a1 + 752) = 0;
return result;
}
| _ma_unpin_all_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2e8]
MOV RCX,qword ptr [RBP + -0x8]
IMUL ECX,dword ptr [RCX + 0x2fc],0x0
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x2f0]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00145afa
LAB_00145afa:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e7],0x0
JNZ 0x00145b10
JMP 0x00145b0c
LAB_00145b0c:
JMP 0x00145b0e
LAB_00145b0e:
JMP 0x00145b10
LAB_00145b10:
JMP 0x00145b12
LAB_00145b12:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,-0x18
MOV qword ptr [RBP + -0x20],RCX
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x00145b78
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x600]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R8,qword ptr [RAX + 0x90]
MOV R9,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x3
XOR R10D,R10D
MOVSX EAX,byte ptr [RAX + 0x10]
MOV dword ptr [RSP],EAX
MOV dword ptr [RSP + 0x8],0x0
CALL 0x001b49b0
JMP 0x00145b12
LAB_00145b78:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2f0],0x0
JMP 0x00145b88
LAB_00145b88:
ADD RSP,0x30
POP RBP
RET
|
void _ma_unpin_all_pages(long *param_1,int8 param_2)
{
int8 *puVar1;
int8 *local_28;
puVar1 = (int8 *)param_1[0x5d];
local_28 = puVar1 + (ulong)*(uint *)(param_1 + 0x5e) * 3;
while (local_28 != puVar1) {
pagecache_unlock_by_link
(*(int8 *)(*param_1 + 0x600),local_28[-3],*(int4 *)(local_28 + -2),3,
*(int8 *)(param_1[1] + 0x90),param_2,(int)*(char *)(local_28 + -1),0);
local_28 = local_28 + -3;
}
*(int4 *)(param_1 + 0x5e) = 0;
return;
}
| |
53,718 | translog_get_horizon | eloqsql/storage/maria/ma_loghandler.c | TRANSLOG_ADDRESS translog_get_horizon()
{
TRANSLOG_ADDRESS res;
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
translog_lock();
res= log_descriptor.horizon;
translog_unlock();
return res;
} | O0 | c | translog_get_horizon:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x54b9a
callq 0x500c0
movq 0xc25462(%rip), %rax # 0xc7a008
movq %rax, -0x8(%rbp)
callq 0x501b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| translog_get_horizon:
push rbp
mov rbp, rsp
sub rsp, 10h
jmp short $+2
loc_54B9A:
call translog_lock
mov rax, cs:qword_C7A008
mov [rbp+var_8], rax
call translog_unlock
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long translog_get_horizon()
{
long long v1; // [rsp+8h] [rbp-8h]
translog_lock();
v1 = qword_C7A008;
translog_unlock();
return v1;
}
| translog_get_horizon:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
JMP 0x00154b9a
LAB_00154b9a:
CALL 0x001500c0
MOV RAX,qword ptr [0x00d7a008]
MOV qword ptr [RBP + -0x8],RAX
CALL 0x001501b0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
int8 translog_get_horizon(void)
{
int8 uVar1;
translog_lock();
uVar1 = DAT_00d7a008;
translog_unlock();
return uVar1;
}
| |
53,719 | ma_check_index_cond | eloqsql/storage/maria/ma_key.c | check_result_t ma_check_index_cond(register MARIA_HA *info, uint keynr,
uchar *record)
{
check_result_t res= CHECK_POS;
if (info->index_cond_func)
{
if (_ma_put_key_in_record(info, keynr, FALSE, record))
{
/* Impossible case; Can only happen if bug in code */
_ma_print_error(info, HA_ERR_CRASHED, 0);
info->cur_row.lastpos= HA_OFFSET_ERROR; /* No active record */
my_errno= HA_ERR_CRASHED;
res= CHECK_ERROR;
}
else if ((res= info->index_cond_func(info->index_cond_func_arg)) ==
CHECK_OUT_OF_RANGE)
{
/* We got beyond the end of scanned range */
info->cur_row.lastpos= HA_OFFSET_ERROR; /* No active record */
my_errno= HA_ERR_END_OF_FILE;
}
}
return res;
} | O3 | c | ma_check_index_cond:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x6f8(%rdi)
je 0x427ed
movq %rdx, %rcx
movq %rdi, %rbx
xorl %edx, %edx
callq 0x423ad
testl %eax, %eax
je 0x427f5
movl $0x7e, %r15d
movq %rbx, %rdi
movl $0x7e, %esi
xorl %edx, %edx
callq 0x3c80e
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x42816
movl $0x1, %r14d
jmp 0x42829
movq 0x700(%rbx), %rdi
callq *0x6f8(%rbx)
movl %eax, %r14d
cmpl $0x2, %eax
jne 0x42829
movl $0x2, %r14d
movl $0x89, %r15d
movq $-0x1, 0x98(%rbx)
callq 0xac2be
movl %r15d, (%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ma_check_index_cond:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp qword ptr [rdi+6F8h], 0
jz short loc_427ED
mov rcx, rdx
mov rbx, rdi
xor edx, edx
call _ma_put_key_in_record
test eax, eax
jz short loc_427F5
mov r15d, 7Eh ; '~'
mov rdi, rbx
mov esi, 7Eh ; '~'
xor edx, edx
call _ma_print_error
mov r14d, 0FFFFFFFFh
jmp short loc_42816
loc_427ED:
mov r14d, 1
jmp short loc_42829
loc_427F5:
mov rdi, [rbx+700h]
call qword ptr [rbx+6F8h]
mov r14d, eax
cmp eax, 2
jnz short loc_42829
mov r14d, 2
mov r15d, 89h
loc_42816:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov [rax], r15d
loc_42829:
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_check_index_cond(long long a1, unsigned int a2, long long a3)
{
long long v3; // rbx
long long v4; // rcx
long long v5; // r8
int v6; // r9d
int v7; // r15d
unsigned int v8; // r14d
if ( *(_QWORD *)(a1 + 1784) )
{
v3 = a1;
if ( (unsigned int)ma_put_key_in_record(a1, a2, 0, a3) )
{
v7 = 126;
ma_print_error((_DWORD *)a1, 126, 0, v4, v5, v6);
v8 = -1;
LABEL_7:
*(_QWORD *)(v3 + 152) = -1LL;
*(_DWORD *)my_thread_var(a1) = v7;
return v8;
}
a1 = *(_QWORD *)(a1 + 1792);
v8 = (*(long long ( **)(long long))(v3 + 1784))(a1);
if ( v8 == 2 )
{
v8 = 2;
v7 = 137;
goto LABEL_7;
}
}
else
{
return 1;
}
return v8;
}
| ma_check_index_cond:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP qword ptr [RDI + 0x6f8],0x0
JZ 0x001427ed
MOV RCX,RDX
MOV RBX,RDI
XOR EDX,EDX
CALL 0x001423ad
TEST EAX,EAX
JZ 0x001427f5
MOV R15D,0x7e
MOV RDI,RBX
MOV ESI,0x7e
XOR EDX,EDX
CALL 0x0013c80e
MOV R14D,0xffffffff
JMP 0x00142816
LAB_001427ed:
MOV R14D,0x1
JMP 0x00142829
LAB_001427f5:
MOV RDI,qword ptr [RBX + 0x700]
CALL qword ptr [RBX + 0x6f8]
MOV R14D,EAX
CMP EAX,0x2
JNZ 0x00142829
MOV R14D,0x2
MOV R15D,0x89
LAB_00142816:
MOV qword ptr [RBX + 0x98],-0x1
CALL 0x001ac2be
MOV dword ptr [RAX],R15D
LAB_00142829:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int ma_check_index_cond(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
int4 uVar3;
if (*(long *)(param_1 + 0x6f8) == 0) {
iVar1 = 1;
}
else {
iVar1 = _ma_put_key_in_record(param_1,param_2,0,param_3);
if (iVar1 == 0) {
iVar1 = (**(code **)(param_1 + 0x6f8))(*(int8 *)(param_1 + 0x700));
if (iVar1 != 2) {
return iVar1;
}
iVar1 = 2;
uVar3 = 0x89;
}
else {
uVar3 = 0x7e;
_ma_print_error(param_1,0x7e,0);
iVar1 = -1;
}
*(int8 *)(param_1 + 0x98) = 0xffffffffffffffff;
puVar2 = (int4 *)_my_thread_var();
*puVar2 = uVar3;
}
return iVar1;
}
| |
53,720 | bf_mul_pow_radix | bluesky950520[P]quickjs/libbf.c | int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
slimb_t expn, limb_t prec, bf_flags_t flags)
{
int ret, expn_sign, overflow;
slimb_t e, extra_bits, prec1, ziv_extra_bits;
bf_t B_s, *B = &B_s;
if (T->len == 0) {
return bf_set(r, T);
} else if (expn == 0) {
ret = bf_set(r, T);
ret |= bf_round(r, prec, flags);
return ret;
}
e = expn;
expn_sign = 0;
if (e < 0) {
e = -e;
expn_sign = 1;
}
bf_init(r->ctx, B);
if (prec == BF_PREC_INF) {
/* infinite precision: only used if the result is known to be exact */
ret = bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
if (expn_sign) {
ret |= bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
} else {
ret |= bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
}
} else {
ziv_extra_bits = 16;
for(;;) {
prec1 = prec + ziv_extra_bits;
/* XXX: correct overflow/underflow handling */
/* XXX: rigorous error analysis needed */
extra_bits = ceil_log2(e) * 2 + 1;
ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
overflow = !bf_is_finite(B);
/* XXX: if bf_pow_ui_ui returns an exact result, can stop
after the next operation */
if (expn_sign)
ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
else
ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
if (ret & BF_ST_MEM_ERROR)
break;
if ((ret & BF_ST_INEXACT) &&
!bf_can_round(r, prec, flags & BF_RND_MASK, prec1) &&
!overflow) {
/* and more precision and retry */
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
} else {
/* XXX: need to use __bf_round() to pass the inexact
flag for the subnormal case */
ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
break;
}
}
}
bf_delete(B);
return ret;
} | O0 | c | bf_mul_pow_radix:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xf1a25
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xec5b0
movl %eax, 0x94(%rsp)
jmp 0xf1cf4
cmpq $0x0, 0x70(%rsp)
jne 0xf1a74
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xec5b0
movl %eax, 0x60(%rsp)
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
callq 0xed000
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x94(%rsp)
jmp 0xf1cf4
jmp 0xf1a76
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x5c(%rsp)
cmpq $0x0, 0x50(%rsp)
jge 0xf1aa4
xorl %eax, %eax
subq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x1, 0x5c(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xec260
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, 0x68(%rsp)
jne 0xf1b65
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x50(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
xorl %r8d, %r8d
callq 0xf1d10
movl %eax, 0x60(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0xf1b31
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x80(%rsp), %rax
movq 0x18(%rax), %rcx
shlq $0x6, %rcx
xorl %r8d, %r8d
callq 0xf06c0
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xf1b60
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
xorl %r8d, %r8d
callq 0xee970
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xf1cdf
movq $0x10, 0x38(%rsp)
movq 0x68(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xf1dc0
shll %eax
addl $0x1, %eax
cltq
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xf1d10
movl %eax, 0x60(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf1250
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x58(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0xf1c11
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xf06c0
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xf1c43
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xee970
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xf1c54
jmp 0xf1cdd
movl 0x60(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xf1cb3
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
andl $0x7, %edx
movq 0x40(%rsp), %rcx
callq 0xecdd0
cmpl $0x0, %eax
jne 0xf1cb3
cmpl $0x0, 0x58(%rsp)
jne 0xf1cb3
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x38(%rsp)
jmp 0xf1cd8
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
callq 0xed000
movl 0x60(%rsp), %ecx
andl $0x10, %ecx
orl %ecx, %eax
movl %eax, 0x60(%rsp)
jmp 0xf1cdd
jmp 0xf1b6e
jmp 0xf1cdf
movq 0x8(%rsp), %rdi
callq 0xef6c0
movl 0x60(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
| bf_mul_pow_radix:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov [rsp+98h+var_18], rsi
mov [rsp+98h+var_20], rdx
mov [rsp+98h+var_28], rcx
mov [rsp+98h+var_30], r8
mov [rsp+98h+var_34], r9d
lea rax, [rsp+98h+var_88]
mov [rsp+98h+var_90], rax
mov rax, [rsp+98h+var_18]
cmp qword ptr [rax+18h], 0
jnz short loc_F1A25
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
call bf_set
mov [rsp+98h+var_4], eax
jmp loc_F1CF4
loc_F1A25:
cmp [rsp+98h+var_28], 0
jnz short loc_F1A74
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
call bf_set
mov [rsp+98h+var_38], eax
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
call bf_round
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
mov eax, [rsp+98h+var_38]
mov [rsp+98h+var_4], eax
jmp loc_F1CF4
loc_F1A74:
jmp short $+2
loc_F1A76:
mov rax, [rsp+98h+var_28]
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_3C], 0
cmp [rsp+98h+var_48], 0
jge short loc_F1AA4
xor eax, eax
sub rax, [rsp+98h+var_48]
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_3C], 1
loc_F1AA4:
mov rax, [rsp+98h+var_10]
mov rdi, [rax]
mov rsi, [rsp+98h+var_90]
call bf_init
mov rax, 3FFFFFFFFFFFFFFFh
cmp [rsp+98h+var_30], rax
jnz loc_F1B65
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_48]
mov rcx, 3FFFFFFFFFFFFFFFh
xor r8d, r8d
call bf_pow_ui_ui
mov [rsp+98h+var_38], eax
cmp [rsp+98h+var_3C], 0
jz short loc_F1B31
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rax, [rsp+98h+var_18]
mov rcx, [rax+18h]
shl rcx, 6
xor r8d, r8d
call bf_div
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
jmp short loc_F1B60
loc_F1B31:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, 3FFFFFFFFFFFFFFFh
xor r8d, r8d
call bf_mul
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
loc_F1B60:
jmp loc_F1CDF
loc_F1B65:
mov [rsp+98h+var_60], 10h
loc_F1B6E:
mov rax, [rsp+98h+var_30]
add rax, [rsp+98h+var_60]
mov [rsp+98h+var_58], rax
mov rdi, [rsp+98h+var_48]
call ceil_log2
shl eax, 1
add eax, 1
cdqe
mov [rsp+98h+var_50], rax
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_48]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_pow_ui_ui
mov [rsp+98h+var_38], eax
mov rdi, [rsp+98h+var_90]
call bf_is_finite_0
cmp eax, 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rsp+98h+var_40], eax
cmp [rsp+98h+var_3C], 0
jz short loc_F1C11
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_div
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
jmp short loc_F1C43
loc_F1C11:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_mul
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
loc_F1C43:
mov eax, [rsp+98h+var_38]
and eax, 20h
cmp eax, 0
jz short loc_F1C54
jmp loc_F1CDD
loc_F1C54:
mov eax, [rsp+98h+var_38]
and eax, 10h
cmp eax, 0
jz short loc_F1CB3
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
and edx, 7
mov rcx, [rsp+98h+var_58]
call bf_can_round
cmp eax, 0
jnz short loc_F1CB3
cmp [rsp+98h+var_40], 0
jnz short loc_F1CB3
mov rax, [rsp+98h+var_60]
mov [rsp+98h+var_98], rax
mov rax, [rsp+98h+var_60]
mov ecx, 2
cqo
idiv rcx
mov rcx, rax
mov rax, [rsp+98h+var_98]
add rax, rcx
mov [rsp+98h+var_60], rax
jmp short loc_F1CD8
loc_F1CB3:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
call bf_round
mov ecx, [rsp+98h+var_38]
and ecx, 10h
or eax, ecx
mov [rsp+98h+var_38], eax
jmp short loc_F1CDD
loc_F1CD8:
jmp loc_F1B6E
loc_F1CDD:
jmp short $+2
loc_F1CDF:
mov rdi, [rsp+98h+var_90]
call bf_delete_0
mov eax, [rsp+98h+var_38]
mov [rsp+98h+var_4], eax
loc_F1CF4:
mov eax, [rsp+98h+var_4]
add rsp, 98h
retn
| long long bf_mul_pow_radix(long long *a1, long long *a2, long long a3, long long a4, long long a5, unsigned int a6)
{
long long *v6; // rsi
int v7; // eax
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
int v12; // eax
int v13; // eax
long long v15[5]; // [rsp+10h] [rbp-88h] BYREF
long long i; // [rsp+38h] [rbp-60h]
long long v17; // [rsp+40h] [rbp-58h]
long long v18; // [rsp+48h] [rbp-50h]
long long v19; // [rsp+50h] [rbp-48h]
BOOL v20; // [rsp+58h] [rbp-40h]
int v21; // [rsp+5Ch] [rbp-3Ch]
unsigned int v22; // [rsp+60h] [rbp-38h]
unsigned int v23; // [rsp+64h] [rbp-34h]
long long *v24; // [rsp+68h] [rbp-30h]
long long v25; // [rsp+70h] [rbp-28h]
long long v26; // [rsp+78h] [rbp-20h]
long long *v27; // [rsp+80h] [rbp-18h]
long long *v28; // [rsp+88h] [rbp-10h]
v28 = a1;
v27 = a2;
v26 = a3;
v25 = a4;
v24 = (long long *)a5;
v23 = a6;
if ( a2[3] )
{
if ( v25 )
{
v19 = v25;
v21 = 0;
if ( v25 < 0 )
{
v19 = -v19;
v21 = 1;
}
bf_init(*v28, (long long)v15);
if ( v24 == (long long *)0x3FFFFFFFFFFFFFFFLL )
{
v22 = bf_pow_ui_ui(v15, v26, v19, 0x3FFFFFFFFFFFFFFFLL, 0LL);
v6 = v27;
if ( v21 )
v7 = bf_div(v28, v27, v15, v27[3] << 6, 0);
else
v7 = bf_mul(v28, (long long)v27, (long long)v15, 0x3FFFFFFFFFFFFFFFLL, 0);
v22 |= v7;
}
else
{
for ( i = 16LL; ; i += i / 2 )
{
v17 = (long long)v24 + i;
v18 = (int)(2 * ceil_log2(v19) + 1);
v22 = bf_pow_ui_ui(v15, v26, v19, v18 + v17, 2016LL);
v20 = !bf_is_finite_0((long long)v15);
v6 = v27;
v12 = v21
? bf_div(v28, v27, v15, v18 + v17, 0x7E0u)
: bf_mul(v28, (long long)v27, (long long)v15, v18 + v17, 0x7E0u);
v22 |= v12;
if ( (v22 & 0x20) != 0 )
break;
if ( (v22 & 0x10) == 0 || bf_can_round(v28, (long long)v24, v23 & 7, v17) || v20 )
{
v6 = v24;
v13 = bf_round(v28, (long long)v24, v23);
v9 = v22 & 0x10;
v22 = v9 | v13;
break;
}
}
}
bf_delete_0(v15, (long long)v6, v8, v9, v10, v11);
return v22;
}
else
{
v22 = bf_set((long long)v28, (long long)v27);
return (unsigned int)(v22 | bf_round(v28, (long long)v24, v23));
}
}
else
{
return (unsigned int)bf_set((long long)v28, (long long)v27);
}
}
| bf_mul_pow_radix:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RDI
MOV qword ptr [RSP + 0x80],RSI
MOV qword ptr [RSP + 0x78],RDX
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x68],R8
MOV dword ptr [RSP + 0x64],R9D
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x80]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x001f1a25
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001ec5b0
MOV dword ptr [RSP + 0x94],EAX
JMP 0x001f1cf4
LAB_001f1a25:
CMP qword ptr [RSP + 0x70],0x0
JNZ 0x001f1a74
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001ec5b0
MOV dword ptr [RSP + 0x60],EAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
CALL 0x001ed000
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
MOV EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x94],EAX
JMP 0x001f1cf4
LAB_001f1a74:
JMP 0x001f1a76
LAB_001f1a76:
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x5c],0x0
CMP qword ptr [RSP + 0x50],0x0
JGE 0x001f1aa4
XOR EAX,EAX
SUB RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x5c],0x1
LAB_001f1aa4:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001ec260
MOV RAX,0x3fffffffffffffff
CMP qword ptr [RSP + 0x68],RAX
JNZ 0x001f1b65
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,0x3fffffffffffffff
XOR R8D,R8D
CALL 0x001f1d10
MOV dword ptr [RSP + 0x60],EAX
CMP dword ptr [RSP + 0x5c],0x0
JZ 0x001f1b31
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RAX + 0x18]
SHL RCX,0x6
XOR R8D,R8D
CALL 0x001f06c0
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001f1b60
LAB_001f1b31:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,0x3fffffffffffffff
XOR R8D,R8D
CALL 0x001ee970
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
LAB_001f1b60:
JMP 0x001f1cdf
LAB_001f1b65:
MOV qword ptr [RSP + 0x38],0x10
LAB_001f1b6e:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001f1dc0
SHL EAX,0x1
ADD EAX,0x1
CDQE
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001f1d10
MOV dword ptr [RSP + 0x60],EAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001f1250
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x58],EAX
CMP dword ptr [RSP + 0x5c],0x0
JZ 0x001f1c11
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001f06c0
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001f1c43
LAB_001f1c11:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001ee970
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
LAB_001f1c43:
MOV EAX,dword ptr [RSP + 0x60]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001f1c54
JMP 0x001f1cdd
LAB_001f1c54:
MOV EAX,dword ptr [RSP + 0x60]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001f1cb3
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
AND EDX,0x7
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x001ecdd0
CMP EAX,0x0
JNZ 0x001f1cb3
CMP dword ptr [RSP + 0x58],0x0
JNZ 0x001f1cb3
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV ECX,0x2
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
ADD RAX,RCX
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001f1cd8
LAB_001f1cb3:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
CALL 0x001ed000
MOV ECX,dword ptr [RSP + 0x60]
AND ECX,0x10
OR EAX,ECX
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001f1cdd
LAB_001f1cd8:
JMP 0x001f1b6e
LAB_001f1cdd:
JMP 0x001f1cdf
LAB_001f1cdf:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001ef6c0
MOV EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x94],EAX
LAB_001f1cf4:
MOV EAX,dword ptr [RSP + 0x94]
ADD RSP,0x98
RET
|
uint bf_mul_pow_radix(int8 *param_1,long param_2,int8 param_3,long param_4,long param_5,
uint param_6)
{
uint uVar1;
int iVar2;
int1 local_88 [40];
long local_60;
long local_58;
long local_50;
long local_48;
uint local_40;
uint local_3c;
uint local_38;
uint local_34;
long local_30;
long local_28;
int8 local_20;
long local_18;
int8 *local_10;
uint local_4;
local_34 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (*(long *)(param_2 + 0x18) == 0) {
local_4 = bf_set(param_1,param_2);
}
else if (param_4 == 0) {
local_38 = bf_set(param_1,param_2);
local_4 = bf_round(local_10,local_30,local_34);
local_4 = local_4 | local_38;
}
else {
local_48 = param_4;
if (param_4 < 0) {
local_48 = -param_4;
}
local_3c = (uint)(param_4 < 0);
bf_init(*param_1,local_88);
if (local_30 == 0x3fffffffffffffff) {
local_38 = bf_pow_ui_ui(local_88,local_20,local_48,0x3fffffffffffffff,0);
if (local_3c == 0) {
uVar1 = bf_mul(local_10,local_18,local_88,0x3fffffffffffffff,0);
local_38 = uVar1 | local_38;
}
else {
uVar1 = bf_div(local_10,local_18,local_88,*(long *)(local_18 + 0x18) << 6,0);
local_38 = uVar1 | local_38;
}
}
else {
local_60 = 0x10;
while( true ) {
local_58 = local_30 + local_60;
iVar2 = ceil_log2(local_48);
local_50 = (long)(iVar2 * 2 + 1);
local_38 = bf_pow_ui_ui(local_88,local_20,local_48,local_58 + local_50,0x7e0);
iVar2 = bf_is_finite(local_88);
local_40 = (uint)((iVar2 != 0 ^ 0xffU) & 1);
if (local_3c == 0) {
uVar1 = bf_mul(local_10,local_18,local_88,local_58 + local_50,0x7e0);
local_38 = uVar1 | local_38;
}
else {
uVar1 = bf_div(local_10,local_18,local_88,local_58 + local_50,0x7e0);
local_38 = uVar1 | local_38;
}
if ((local_38 & 0x20) != 0) goto LAB_001f1cdf;
if ((((local_38 & 0x10) == 0) ||
(iVar2 = bf_can_round(local_10,local_30,local_34 & 7,local_58), iVar2 != 0)) ||
(local_40 != 0)) break;
local_60 = local_60 + local_60 / 2;
}
uVar1 = bf_round(local_10,local_30,local_34);
local_38 = uVar1 | local_38 & 0x10;
}
LAB_001f1cdf:
bf_delete(local_88);
local_4 = local_38;
}
return local_4;
}
| |
53,721 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*) | monkey531[P]llama/common/json.hpp | reference operator[](T* key)
{
return operator[](typename object_t::key_type(key));
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[]<char const>(char const*):
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x1c998
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f9a4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68e5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68e88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rdi
callq 0x18bb0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rsp+38h+var_30]
lea rdx, [rsp+38h+var_31]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator[](std::string)
mov rbx, rax
lea rax, [rsp+38h+var_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_68E5F
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_68E5F:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_68E88
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_68E88:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
long long a1,
long long a2)
{
long long v2; // rbx
void *v4[2]; // [rsp+8h] [rbp-30h] BYREF
long long v5; // [rsp+18h] [rbp-20h] BYREF
std::string::basic_string<std::allocator<char>>(v4, a2);
v2 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
a1,
v4);
if ( v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
return v2;
}
| operator[]<char_const>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
CALL 0x0011c998
LAB_00168e36:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016f9a4
LAB_00168e41:
MOV RBX,RAX
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00168e5f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00168e5f:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[]<char const>(char const*) */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,char *param_1)
{
basic_json *pbVar1;
allocator local_31;
long *local_30 [2];
long local_20 [2];
std::__cxx11::string::string<std::allocator<char>>((string *)local_30,param_1,&local_31);
/* try { // try from 00168e36 to 00168e40 has its CatchHandler @ 00168e6a */
pbVar1 = (basic_json *)operator[](this,(string *)local_30);
if (local_30[0] != local_20) {
operator_delete(local_30[0],local_20[0] + 1);
}
return pbVar1;
}
| |
53,722 | mysql_client_plugin_deinit | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | void mysql_client_plugin_deinit()
{
int i;
struct st_client_plugin_int *p;
if (!initialized)
return;
for (i=0; i < MYSQL_CLIENT_MAX_PLUGINS; i++)
for (p= plugin_list[i]; p; p= p->next)
{
if (p->plugin->deinit)
p->plugin->deinit();
if (p->dlhandle)
(void)dlclose(p->dlhandle);
}
memset(&plugin_list, 0, sizeof(plugin_list));
initialized= 0;
ma_free_root(&mem_root, MYF(0));
pthread_mutex_destroy(&LOCK_load_client_plugin);
} | O0 | c | mysql_client_plugin_deinit:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x394571(%rip) # 0x3f0f20
jne 0x5c9b6
jmp 0x5ca5f
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x5ca2b
movslq -0x4(%rbp), %rcx
leaq 0x3945c2(%rip), %rax # 0x3f0f90
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ca1e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x5c9f7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
callq *0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5ca0f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x37a90
jmp 0x5ca11
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5c9d6
jmp 0x5ca20
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5c9bd
leaq 0x39455e(%rip), %rdi # 0x3f0f90
xorl %esi, %esi
movl $0x40, %edx
callq 0x37300
movb $0x0, 0x3944db(%rip) # 0x3f0f20
leaq 0x394504(%rip), %rdi # 0x3f0f50
xorl %esi, %esi
callq 0x4bae0
leaq 0x3944ce(%rip), %rdi # 0x3f0f28
callq 0x37100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_client_plugin_deinit:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:initialized, 0
jnz short loc_5C9B6
jmp loc_5CA5F
loc_5C9B6:
mov [rbp+var_4], 0
loc_5C9BD:
cmp [rbp+var_4], 3
jge short loc_5CA2B
movsxd rcx, [rbp+var_4]
lea rax, plugin_list
mov rax, [rax+rcx*8]
mov [rbp+var_10], rax
loc_5C9D6:
cmp [rbp+var_10], 0
jz short loc_5CA1E
mov rax, [rbp+var_10]
mov rax, [rax+10h]
cmp qword ptr [rax+48h], 0
jz short loc_5C9F7
mov rax, [rbp+var_10]
mov rax, [rax+10h]
call qword ptr [rax+48h]
loc_5C9F7:
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_5CA0F
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _dlclose
loc_5CA0F:
jmp short $+2
loc_5CA11:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_5C9D6
loc_5CA1E:
jmp short $+2
loc_5CA20:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_5C9BD
loc_5CA2B:
lea rdi, plugin_list
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov cs:initialized, 0
lea rdi, mem_root
xor esi, esi
call ma_free_root
lea rdi, LOCK_load_client_plugin
call _pthread_mutex_destroy
loc_5CA5F:
add rsp, 10h
pop rbp
retn
| long long mysql_client_plugin_deinit()
{
long long result; // rax
_QWORD *j; // [rsp+0h] [rbp-10h]
int i; // [rsp+Ch] [rbp-4h]
if ( initialized )
{
for ( i = 0; i < 3; ++i )
{
for ( j = (_QWORD *)plugin_list[i]; j; j = (_QWORD *)*j )
{
if ( *(_QWORD *)(j[2] + 72LL) )
(*(void (**)(void))(j[2] + 72LL))();
if ( j[1] )
dlclose(j[1]);
}
}
memset(plugin_list, 0LL, sizeof(plugin_list));
initialized = 0;
ma_free_root(mem_root, 0);
return pthread_mutex_destroy(&LOCK_load_client_plugin);
}
return result;
}
| mysql_client_plugin_deinit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP byte ptr [0x004f0f20],0x0
JNZ 0x0015c9b6
JMP 0x0015ca5f
LAB_0015c9b6:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015c9bd:
CMP dword ptr [RBP + -0x4],0x3
JGE 0x0015ca2b
MOVSXD RCX,dword ptr [RBP + -0x4]
LEA RAX,[0x4f0f90]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_0015c9d6:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0015ca1e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x0015c9f7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
CALL qword ptr [RAX + 0x48]
LAB_0015c9f7:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0015ca0f
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00137a90
LAB_0015ca0f:
JMP 0x0015ca11
LAB_0015ca11:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0015c9d6
LAB_0015ca1e:
JMP 0x0015ca20
LAB_0015ca20:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015c9bd
LAB_0015ca2b:
LEA RDI,[0x4f0f90]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00137300
MOV byte ptr [0x004f0f20],0x0
LEA RDI,[0x4f0f50]
XOR ESI,ESI
CALL 0x0014bae0
LEA RDI,[0x4f0f28]
CALL 0x00137100
LAB_0015ca5f:
ADD RSP,0x10
POP RBP
RET
|
void mysql_client_plugin_deinit(void)
{
int8 *local_18;
int local_c;
if (initialized != '\0') {
for (local_c = 0; local_c < 3; local_c = local_c + 1) {
for (local_18 = *(int8 **)(plugin_list + (long)local_c * 8);
local_18 != (int8 *)0x0; local_18 = (int8 *)*local_18) {
if (*(long *)(local_18[2] + 0x48) != 0) {
(**(code **)(local_18[2] + 0x48))();
}
if (local_18[1] != 0) {
dlclose(local_18[1]);
}
}
}
memset(plugin_list,0,0x40);
initialized = '\0';
ma_free_root(mem_root,0);
pthread_mutex_destroy((pthread_mutex_t *)LOCK_load_client_plugin);
}
return;
}
| |
53,723 | google::protobuf::SourceCodeInfo::~SourceCodeInfo() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | SourceCodeInfo::~SourceCodeInfo() {
// @@protoc_insertion_point(destructor:google.protobuf.SourceCodeInfo)
if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
(void)arena;
return;
}
SharedDtor();
} | O3 | cpp | google::protobuf::SourceCodeInfo::~SourceCodeInfo():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %rax
testb $0x1, %al
jne 0x571a5
andq $-0x4, %rax
jmp 0x571ad
movq %rbx, %rdi
callq 0x59746
testq %rax, %rax
jne 0x571bb
leaq 0x10(%r14), %rdi
callq 0x3f780
leaq 0xaa15e(%rip), %rax # 0x101320
addq $0x10, %rax
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59494
movq %rax, %rdi
callq 0x13387
| _ZN6google8protobuf14SourceCodeInfoD2Ev:
push r14
push rbx
push rax
mov r14, rdi
lea rbx, [rdi+8]
mov rax, [rdi+8]
test al, 1
jnz short loc_571A5
and rax, 0FFFFFFFFFFFFFFFCh
jmp short loc_571AD
loc_571A5:
mov rdi, rbx
call _ZN6google8protobuf8internal16InternalMetadata21DeleteOutOfLineHelperINS0_15UnknownFieldSetEEEPNS0_5ArenaEv; google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>(void)
loc_571AD:
test rax, rax
jnz short loc_571BB
lea rdi, [r14+10h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_23SourceCodeInfo_LocationEED2Ev; google::protobuf::RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::~RepeatedPtrField()
loc_571BB:
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [r14], rax
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, rax
call __clang_call_terminate
| void google::protobuf::SourceCodeInfo::~SourceCodeInfo(google::protobuf::SourceCodeInfo *this)
{
long long v1; // rax
unsigned long long v2; // rax
v1 = *((_QWORD *)this + 1);
if ( (v1 & 1) != 0 )
v2 = google::protobuf::internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>((char *)this + 8);
else
v2 = v1 & 0xFFFFFFFFFFFFFFFCLL;
if ( !v2 )
google::protobuf::RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::~RepeatedPtrField((google::protobuf::SourceCodeInfo *)((char *)this + 16));
*(_QWORD *)this = &`vtable for'google::protobuf::MessageLite + 2;
google::protobuf::internal::InternalMetadata::~InternalMetadata((google::protobuf::SourceCodeInfo *)((char *)this + 8));
}
| ~SourceCodeInfo:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
LEA RBX,[RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x8]
TEST AL,0x1
JNZ 0x001571a5
AND RAX,-0x4
JMP 0x001571ad
LAB_001571a5:
MOV RDI,RBX
CALL 0x00159746
LAB_001571ad:
TEST RAX,RAX
JNZ 0x001571bb
LEA RDI,[R14 + 0x10]
CALL 0x0013f780
LAB_001571bb:
LEA RAX,[0x201320]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00159494
|
/* google::protobuf::SourceCodeInfo::~SourceCodeInfo() */
void __thiscall google::protobuf::SourceCodeInfo::~SourceCodeInfo(SourceCodeInfo *this)
{
Arena *pAVar1;
if ((*(ulong *)(this + 8) & 1) == 0) {
pAVar1 = (Arena *)(*(ulong *)(this + 8) & 0xfffffffffffffffc);
}
else {
/* try { // try from 001571a5 to 001571ac has its CatchHandler @ 001571d8 */
pAVar1 = internal::InternalMetadata::DeleteOutOfLineHelper<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8));
}
if (pAVar1 == (Arena *)0x0) {
RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::~RepeatedPtrField
((RepeatedPtrField<google::protobuf::SourceCodeInfo_Location> *)(this + 0x10));
}
*(int ***)this = &PTR__MessageLite_00201330;
internal::InternalMetadata::~InternalMetadata((InternalMetadata *)(this + 8));
return;
}
| |
53,724 | testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
for (const auto& testcase : suites_) {
if (testcase.second.instantiated) continue;
if (ignored.find(testcase.first) != ignored.end()) continue;
std::string message =
"Type parameterized test suite " + testcase.first +
" is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
"via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
"\n\n"
"Ideally, TYPED_TEST_P definitions should only ever be included as "
"part of binaries that intend to use them. (As opposed to, for "
"example, being placed in a library that may be linked in to get "
"other "
"utilities.)"
"\n\n"
"To suppress this error for this test suite, insert the following "
"line "
"(in a non-header) in the namespace it is defined in:"
"\n\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
testcase.first + ");";
std::string full_name =
"UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
RegisterTest( //
"GoogleTestVerification", full_name.c_str(),
nullptr, // No type parameter.
nullptr, // No value parameter.
testcase.second.code_location.file.c_str(),
testcase.second.code_location.line, [message, testcase] {
return new FailureTest(testcase.second.code_location, message,
kErrorOnUninstantiatedTypeParameterizedTest);
});
}
} | O0 | cpp | testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations():
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0xfda90
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x1a8(%rsp)
movq %rax, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rdi
callq 0x125fd0
movq %rax, 0x198(%rsp)
movq 0x1a0(%rsp), %rdi
callq 0x125f80
movq %rax, 0x190(%rsp)
leaq 0x198(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x125f60
xorb $-0x1, %al
testb $0x1, %al
jne 0xfe6c3
jmp 0xfea09
leaq 0x198(%rsp), %rdi
callq 0x126000
movq %rax, 0x188(%rsp)
movq 0x188(%rsp), %rax
testb $0x1, 0x48(%rax)
je 0xfe6eb
jmp 0xfe8df
movq 0x1a8(%rsp), %rdi
movq 0x188(%rsp), %rsi
callq 0x125da0
movq %rax, 0x180(%rsp)
movq 0x1a8(%rsp), %rdi
callq 0x125dd0
movq %rax, 0x178(%rsp)
leaq 0x180(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0x125d80
xorb $-0x1, %al
testb $0x1, %al
jne 0xfe73a
jmp 0xfe73f
jmp 0xfe8df
movq 0x188(%rsp), %rdx
leaq 0x56e47(%rip), %rsi # 0x155595
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x7cc30
movq 0x28(%rsp), %rsi
leaq 0x56e48(%rip), %rdx # 0x1555b4
leaq 0x118(%rsp), %rdi
callq 0x7cbe0
jmp 0xfe77b
movq 0x188(%rsp), %rdx
leaq 0x138(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x124420
jmp 0xfe79a
leaq 0x56d8d(%rip), %rdx # 0x15552e
leaq 0x158(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x7cbe0
jmp 0xfe7b8
leaq 0x138(%rsp), %rdi
callq 0x1c160
leaq 0x118(%rsp), %rdi
callq 0x1c160
leaq 0xf8(%rsp), %rdi
callq 0x1c160
movq 0x188(%rsp), %rdx
leaq 0x56fce(%rip), %rsi # 0x1557bc
leaq 0xa8(%rsp), %rdi
callq 0x7cc30
jmp 0xfe7fd
leaq 0x57a5f(%rip), %rdx # 0x156263
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x7cbe0
jmp 0xfe81b
leaq 0xa8(%rsp), %rdi
callq 0x1c160
leaq 0xc8(%rsp), %rdi
callq 0x20e00
movq %rax, 0x8(%rsp)
movq 0x188(%rsp), %rdi
addq $0x20, %rdi
callq 0x20e00
movq %rax, 0x10(%rsp)
movq 0x188(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x158(%rsp), %rsi
callq 0x1fe60
jmp 0xfe878
leaq 0x58(%rsp), %rdi
movq 0x188(%rsp), %rsi
callq 0x126020
jmp 0xfe88c
movl 0x1c(%rsp), %r9d
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
movq %rsp, %rax
leaq 0x38(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x56caa(%rip), %rdi # 0x155557
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xfea20
jmp 0xfe8bb
leaq 0x38(%rsp), %rdi
callq 0xfed50
leaq 0xc8(%rsp), %rdi
callq 0x1c160
leaq 0x158(%rsp), %rdi
callq 0x1c160
leaq 0x198(%rsp), %rdi
callq 0x126080
jmp 0xfe6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xfe94b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xfe93e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x138(%rsp), %rdi
callq 0x1c160
leaq 0x118(%rsp), %rdi
callq 0x1c160
leaq 0xf8(%rsp), %rdi
callq 0x1c160
jmp 0xfea11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xfe9fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1c160
jmp 0xfe9fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0xfe9ed
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
callq 0x1c160
jmp 0xfe9ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xfed50
leaq 0xc8(%rsp), %rdi
callq 0x1c160
leaq 0x158(%rsp), %rdi
callq 0x1c160
jmp 0xfea11
addq $0x1b8, %rsp # imm = 0x1B8
retq
movq 0xf0(%rsp), %rdi
callq 0x15dd0
nop
| _ZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEv:
sub rsp, 1B8h
mov [rsp+1B8h+var_8], rdi
mov rax, [rsp+1B8h+var_8]
mov [rsp+1B8h+var_188], rax; int
call _ZN7testing8internal33GetIgnoredParameterizedTestSuitesB5cxx11Ev; testing::internal::GetIgnoredParameterizedTestSuites(void)
mov rcx, rax
mov rax, [rsp+1B8h+var_188]
mov [rsp+1B8h+var_10], rcx
mov [rsp+1B8h+var_18], rax
mov rdi, [rsp+1B8h+var_18]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoESt4lessIS5_ESaISt4pairIKS5_S9_EEE5beginEv; std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::begin(void)
mov [rsp+1B8h+var_20], rax
mov rdi, [rsp+1B8h+var_18]
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoESt4lessIS5_ESaISt4pairIKS5_S9_EEE3endEv; std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::end(void)
mov [rsp+1B8h+var_28], rax
loc_FE6A3:
lea rdi, [rsp+1B8h+var_20]
lea rsi, [rsp+1B8h+var_28]
call _ZSteqRKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEESF_; std::operator==(std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>> const&,std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>> const&)
xor al, 0FFh
test al, 1
jnz short loc_FE6C3
jmp loc_FEA09
loc_FE6C3:
lea rdi, [rsp+1B8h+var_20]
call _ZNKSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEEdeEv; std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator*(void)
mov qword ptr [rsp+1B8h+var_30], rax
mov rax, qword ptr [rsp+1B8h+var_30]
test byte ptr [rax+48h], 1
jz short loc_FE6EB
jmp loc_FE8DF
loc_FE6EB:
mov rdi, [rsp+1B8h+var_10]
mov rsi, qword ptr [rsp+1B8h+var_30]
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE4findERKS5_; std::set<std::string>::find(std::string const&)
mov [rsp+1B8h+var_38], rax
mov rdi, [rsp+1B8h+var_10]
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE3endEv; std::set<std::string>::end(void)
mov [rsp+1B8h+var_40], rax
lea rdi, [rsp+1B8h+var_38]
lea rsi, [rsp+1B8h+var_40]
call _ZSteqRKSt23_Rb_tree_const_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEES8_; std::operator==(std::_Rb_tree_const_iterator<std::string> const&,std::_Rb_tree_const_iterator<std::string> const&)
xor al, 0FFh
test al, 1
jnz short loc_FE73A
jmp short loc_FE73F
loc_FE73A:
jmp loc_FE8DF
loc_FE73F:
mov rdx, qword ptr [rsp+1B8h+var_30]; int
lea rsi, aTypeParameteri; "Type parameterized test suite "
lea rdi, [rsp+1B8h+var_C0]; int
mov qword ptr [rsp+1B8h+var_190], rdi; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov rsi, qword ptr [rsp+1B8h+var_190]
lea rdx, aIsDefinedViaRe; " is defined via REGISTER_TYPED_TEST_SUI"...
lea rdi, [rsp+1B8h+var_A0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_FE77B:
mov rdx, qword ptr [rsp+1B8h+var_30]
lea rdi, [rsp+1B8h+var_80]
lea rsi, [rsp+1B8h+var_A0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_FE79A:
lea rdx, asc_15552E; ");"
lea rdi, [rsp+1B8h+var_60]
lea rsi, [rsp+1B8h+var_80]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_FE7B8:
lea rdi, [rsp+1B8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1B8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1B8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdx, qword ptr [rsp+1B8h+var_30]; int
lea rsi, aUninstantiated_0; "UninstantiatedTypeParameterizedTestSuit"...
lea rdi, [rsp+1B8h+var_110]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
jmp short $+2
loc_FE7FD:
lea rdx, aType_0+9; ">"
lea rdi, [rsp+1B8h+var_F0]
lea rsi, [rsp+1B8h+var_110]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
jmp short $+2
loc_FE81B:
lea rdi, [rsp+1B8h+var_110]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1B8h+var_F0]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov qword ptr [rsp+1B8h+var_1B0], rax; int
mov rdi, qword ptr [rsp+1B8h+var_30]
add rdi, 20h ; ' '
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov qword ptr [rsp+1B8h+var_1A8], rax; int
mov rax, qword ptr [rsp+1B8h+var_30]
mov eax, [rax+40h]
mov [rsp+1B8h+var_19C], eax
lea rdi, [rsp+1B8h+var_180]
mov [rsp+1B8h+var_198], rdi; void *
lea rsi, [rsp+1B8h+var_60]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
jmp short $+2
loc_FE878:
lea rdi, [rsp+1B8h+var_160]
mov rsi, qword ptr [rsp+1B8h+var_30]
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEC2ERKSB_; std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::pair(std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo> const&)
jmp short $+2
loc_FE88C:
mov r9d, [rsp+1B8h+var_19C]; int
mov r8, qword ptr [rsp+1B8h+var_1A8]; int
mov rsi, qword ptr [rsp+1B8h+var_1B0]; int
mov rax, rsp
lea rcx, [rsp+1B8h+var_180]
mov [rax], rcx
lea rdi, aGoogletestveri; "GoogleTestVerification"
xor eax, eax
mov ecx, eax; int
mov rdx, rcx; int
call _ZN7testing12RegisterTestITpTnRiJEZNS_8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEvE3$_0EEPNS_8TestInfoEPKcS8_S8_S8_S8_iT0_
jmp short $+2
loc_FE8BB:
lea rdi, [rsp+1B8h+var_180]
call _ZZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEvEN3$_0D2Ev; testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations(void)::$_0::~$_0()
lea rdi, [rsp+1B8h+var_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1B8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_FE8DF:
lea rdi, [rsp+1B8h+var_20]
call _ZNSt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal34TypeParameterizedTestSuiteRegistry30TypeParameterizedTestSuiteInfoEEEppEv; std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator++(void)
jmp loc_FE6A3
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_FE94B
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_FE93E
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_130]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_FE93E:
lea rdi, [rsp+arg_110]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_FE94B:
lea rdi, [rsp+arg_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_FEA11
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp loc_FE9FA
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_FE9FA
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
jmp short loc_FE9ED
mov rdi, [rsp+arg_18]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_FE9ED
mov rcx, rax
mov eax, edx
mov [rsp+arg_E8], rcx
mov [rsp+arg_E4], eax
lea rdi, [rsp+arg_30]
call _ZZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEvEN3$_0D2Ev; testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations(void)::$_0::~$_0()
loc_FE9ED:
lea rdi, [rsp+arg_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_FE9FA:
lea rdi, [rsp+arg_150]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_FEA11
loc_FEA09:
add rsp, 1B8h
retn
loc_FEA11:
mov rdi, [rsp+arg_E8]
call __Unwind_Resume
| char testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations(
testing::internal::TypeParameterizedTestSuiteRegistry *this)
{
char result; // al
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // [rsp+0h] [rbp-1B8h]
long long v7; // [rsp+8h] [rbp-1B0h]
int v8; // [rsp+8h] [rbp-1B0h]
int v9; // [rsp+10h] [rbp-1A8h]
int v10; // [rsp+18h] [rbp-1A0h]
int v11; // [rsp+1Ch] [rbp-19Ch]
int v12; // [rsp+30h] [rbp-188h]
long long v13; // [rsp+38h] [rbp-180h] BYREF
int v14; // [rsp+40h] [rbp-178h]
int v15; // [rsp+48h] [rbp-170h]
int v16; // [rsp+50h] [rbp-168h]
int v17[12]; // [rsp+58h] [rbp-160h] BYREF
char v18; // [rsp+88h] [rbp-130h]
int v19; // [rsp+90h] [rbp-128h]
int v20; // [rsp+98h] [rbp-120h]
int v21; // [rsp+A0h] [rbp-118h]
int v22[8]; // [rsp+A8h] [rbp-110h] BYREF
int v23[12]; // [rsp+C8h] [rbp-F0h] BYREF
int v24; // [rsp+F8h] [rbp-C0h] BYREF
char v25; // [rsp+100h] [rbp-B8h]
int v26; // [rsp+108h] [rbp-B0h]
int v27; // [rsp+110h] [rbp-A8h]
int v28; // [rsp+118h] [rbp-A0h] BYREF
char v29; // [rsp+120h] [rbp-98h]
int v30; // [rsp+128h] [rbp-90h]
int v31; // [rsp+130h] [rbp-88h]
int v32[6]; // [rsp+138h] [rbp-80h] BYREF
long long v33; // [rsp+150h] [rbp-68h]
int v34; // [rsp+158h] [rbp-60h] BYREF
char v35; // [rsp+160h] [rbp-58h]
long long v36; // [rsp+178h] [rbp-40h] BYREF
long long v37; // [rsp+180h] [rbp-38h] BYREF
int v38[2]; // [rsp+188h] [rbp-30h]
long long v39; // [rsp+190h] [rbp-28h] BYREF
_QWORD v40[2]; // [rsp+198h] [rbp-20h] BYREF
long long v41; // [rsp+1A8h] [rbp-10h]
long long v42; // [rsp+1B0h] [rbp-8h]
v42 = (long long)this;
v12 = (int)this;
v41 = testing::internal::GetIgnoredParameterizedTestSuites[abi:cxx11](this);
v40[1] = this;
v40[0] = std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::begin(this);
v39 = std::map<std::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::end(this);
while ( 1 )
{
result = ~(unsigned __int8)std::operator==(v40, &v39);
if ( (result & 1) == 0 )
break;
*(_QWORD *)v38 = std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator*(v40);
if ( (*(_BYTE *)(*(_QWORD *)v38 + 72LL) & 1) == 0 )
{
v37 = std::set<std::string>::find(v41, *(_QWORD *)v38);
v36 = std::set<std::string>::end(v41);
if ( (std::operator==(&v37, &v36) & 1) != 0 )
{
std::operator+<char>((long long)&v24, (long long)"Type parameterized test suite ", *(long long *)v38);
std::operator+<char>(
(long long)&v28,
(long long)&v24,
(long long)" is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated via INSTANTIATE_TYPED_TEST_SUITE_"
"P. None of the test cases will run.\n"
"\n"
"Ideally, TYPED_TEST_P definitions should only ever be included as part of binaries that intend to use"
" them. (As opposed to, for example, being placed in a library that may be linked in to get other util"
"ities.)\n"
"\n"
"To suppress this error for this test suite, insert the following line (in a non-header) in the namesp"
"ace it is defined in:\n"
"\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(");
std::operator+<char>(v32, &v28, *(_QWORD *)v38);
std::operator+<char>((long long)&v34, (long long)v32, (long long)");");
std::string::~string(v32);
std::string::~string(&v28);
std::string::~string(&v24);
std::operator+<char>((long long)v22, (long long)"UninstantiatedTypeParameterizedTestSuite<", *(long long *)v38);
std::operator+<char>((long long)v23, (long long)v22, (long long)">");
std::string::~string(v22);
v7 = std::string::c_str((long long)v23);
v9 = std::string::c_str(*(_QWORD *)v38 + 32LL);
v11 = *(_DWORD *)(*(_QWORD *)v38 + 64LL);
std::string::basic_string(&v13, (long long)&v34);
std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>::pair(
(unsigned int)v17,
v38[0],
v2,
v3,
v4,
v5,
v6,
v7);
ZN7testing12RegisterTestITpTnRiJEZNS_8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEvE3__0EEPNS_8TestInfoEPKcS8_S8_S8_S8_iT0_(
(int)"GoogleTestVerification",
v8,
0,
0,
v9,
v11,
(int)&v13,
v8,
v9,
v10,
&v13,
(int)&v24,
v12,
v13,
v14,
v15,
v16,
v17[0],
v17[2],
v17[4],
v17[6],
v17[8],
v17[10],
v18,
v19,
v20,
v21,
v22[0],
v22[2],
v22[4],
v22[6],
v23[0],
v23[2],
v23[4],
v23[6],
v23[8],
v23[10],
v24,
v25,
v26,
v27,
v28,
v29,
v30,
v31,
v32[0],
v32[2],
v32[4],
v33,
v34,
v35);
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations(void)::$_0::~$_0(&v13);
std::string::~string(v23);
std::string::~string(&v34);
}
}
std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>::operator++(v40);
}
return result;
}
| CheckForInstantiations:
SUB RSP,0x1b8
MOV qword ptr [RSP + 0x1b0],RDI
MOV RAX,qword ptr [RSP + 0x1b0]
MOV qword ptr [RSP + 0x30],RAX
CALL 0x001fda90
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x1a8],RCX
MOV qword ptr [RSP + 0x1a0],RAX
MOV RDI,qword ptr [RSP + 0x1a0]
CALL 0x00225fd0
MOV qword ptr [RSP + 0x198],RAX
MOV RDI,qword ptr [RSP + 0x1a0]
CALL 0x00225f80
MOV qword ptr [RSP + 0x190],RAX
LAB_001fe6a3:
LEA RDI,[RSP + 0x198]
LEA RSI,[RSP + 0x190]
CALL 0x00225f60
XOR AL,0xff
TEST AL,0x1
JNZ 0x001fe6c3
JMP 0x001fea09
LAB_001fe6c3:
LEA RDI,[RSP + 0x198]
CALL 0x00226000
MOV qword ptr [RSP + 0x188],RAX
MOV RAX,qword ptr [RSP + 0x188]
TEST byte ptr [RAX + 0x48],0x1
JZ 0x001fe6eb
JMP 0x001fe8df
LAB_001fe6eb:
MOV RDI,qword ptr [RSP + 0x1a8]
MOV RSI,qword ptr [RSP + 0x188]
CALL 0x00225da0
MOV qword ptr [RSP + 0x180],RAX
MOV RDI,qword ptr [RSP + 0x1a8]
CALL 0x00225dd0
MOV qword ptr [RSP + 0x178],RAX
LEA RDI,[RSP + 0x180]
LEA RSI,[RSP + 0x178]
CALL 0x00225d80
XOR AL,0xff
TEST AL,0x1
JNZ 0x001fe73a
JMP 0x001fe73f
LAB_001fe73a:
JMP 0x001fe8df
LAB_001fe73f:
MOV RDX,qword ptr [RSP + 0x188]
LEA RSI,[0x255595]
LEA RDI,[RSP + 0xf8]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x0017cc30
MOV RSI,qword ptr [RSP + 0x28]
LAB_001fe765:
LEA RDX,[0x2555b4]
LEA RDI,[RSP + 0x118]
CALL 0x0017cbe0
JMP 0x001fe77b
LAB_001fe77b:
MOV RDX,qword ptr [RSP + 0x188]
LAB_001fe783:
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x118]
CALL 0x00224420
JMP 0x001fe79a
LAB_001fe79a:
LEA RDX,[0x25552e]
LEA RDI,[RSP + 0x158]
LEA RSI,[RSP + 0x138]
CALL 0x0017cbe0
JMP 0x001fe7b8
LAB_001fe7b8:
LEA RDI,[RSP + 0x138]
CALL 0x0011c160
LEA RDI,[RSP + 0x118]
CALL 0x0011c160
LEA RDI,[RSP + 0xf8]
CALL 0x0011c160
MOV RDX,qword ptr [RSP + 0x188]
LAB_001fe7e7:
LEA RSI,[0x2557bc]
LEA RDI,[RSP + 0xa8]
CALL 0x0017cc30
JMP 0x001fe7fd
LAB_001fe7fd:
LEA RDX,[0x256263]
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0xa8]
CALL 0x0017cbe0
JMP 0x001fe81b
LAB_001fe81b:
LEA RDI,[RSP + 0xa8]
CALL 0x0011c160
LEA RDI,[RSP + 0xc8]
CALL 0x00120e00
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x188]
ADD RDI,0x20
CALL 0x00120e00
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x188]
MOV EAX,dword ptr [RAX + 0x40]
MOV dword ptr [RSP + 0x1c],EAX
LEA RDI,[RSP + 0x38]
MOV qword ptr [RSP + 0x20],RDI
LAB_001fe869:
LEA RSI,[RSP + 0x158]
CALL 0x0011fe60
JMP 0x001fe878
LAB_001fe878:
LEA RDI,[RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x188]
LAB_001fe885:
CALL 0x00226020
JMP 0x001fe88c
LAB_001fe88c:
MOV R9D,dword ptr [RSP + 0x1c]
MOV R8,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV RAX,RSP
LEA RCX,[RSP + 0x38]
MOV qword ptr [RAX],RCX
LEA RDI,[0x255557]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001fea20
LAB_001fe8b9:
JMP 0x001fe8bb
LAB_001fe8bb:
LEA RDI,[RSP + 0x38]
CALL 0x001fed50
LEA RDI,[RSP + 0xc8]
CALL 0x0011c160
LEA RDI,[RSP + 0x158]
CALL 0x0011c160
LAB_001fe8df:
LEA RDI,[RSP + 0x198]
CALL 0x00226080
JMP 0x001fe6a3
LAB_001fea09:
ADD RSP,0x1b8
RET
|
/* testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() */
void __thiscall
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations
(TypeParameterizedTestSuiteRegistry *this)
{
int4 uVar1;
byte bVar2;
int8 uVar3;
int8 uVar4;
string local_180 [32];
pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>
local_160 [80];
string local_110 [32];
string local_f0 [48];
string local_c0 [32];
string local_a0 [32];
string local_80 [32];
string local_60 [32];
int8 local_40;
int8 local_38;
string *local_30;
int8 local_28;
int8 local_20;
map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
*local_18;
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*local_10;
TypeParameterizedTestSuiteRegistry *local_8;
local_8 = this;
local_10 = (set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
*)GetIgnoredParameterizedTestSuites_abi_cxx11_();
local_18 = (map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
*)this;
local_20 = std::
map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
::begin((map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
*)this);
local_28 = std::
map<std::__cxx11::string,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>>
::end(local_18);
while (bVar2 = std::operator==((_Rb_tree_iterator *)&local_20,(_Rb_tree_iterator *)&local_28),
((bVar2 ^ 0xff) & 1) != 0) {
local_30 = (string *)
std::
_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
::operator*((_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
*)&local_20);
if (((byte)local_30[0x48] & 1) == 0) {
local_38 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::find(local_10,local_30);
local_40 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::end(local_10);
bVar2 = std::operator==((_Rb_tree_const_iterator *)&local_38,
(_Rb_tree_const_iterator *)&local_40);
if (((bVar2 ^ 0xff) & 1) == 0) {
std::operator+((char *)local_c0,(string *)"Type parameterized test suite ");
/* try { // try from 001fe765 to 001fe778 has its CatchHandler @ 001fe8f1 */
std::operator+(local_a0,(char *)local_c0);
/* try { // try from 001fe783 to 001fe797 has its CatchHandler @ 001fe907 */
std::operator+(local_80,local_a0);
/* try { // try from 001fe79a to 001fe7b5 has its CatchHandler @ 001fe91d */
std::operator+(local_60,(char *)local_80);
std::__cxx11::string::~string(local_80);
std::__cxx11::string::~string(local_a0);
std::__cxx11::string::~string(local_c0);
/* try { // try from 001fe7e7 to 001fe7fa has its CatchHandler @ 001fe95d */
std::operator+((char *)local_110,(string *)"UninstantiatedTypeParameterizedTestSuite<");
/* try { // try from 001fe7fd to 001fe818 has its CatchHandler @ 001fe976 */
std::operator+(local_f0,(char *)local_110);
std::__cxx11::string::~string(local_110);
uVar3 = std::__cxx11::string::c_str(local_f0);
uVar4 = std::__cxx11::string::c_str(local_30 + 0x20);
uVar1 = *(int4 *)(local_30 + 0x40);
/* try { // try from 001fe869 to 001fe875 has its CatchHandler @ 001fe999 */
std::__cxx11::string::string(local_180,local_60);
/* try { // try from 001fe885 to 001fe889 has its CatchHandler @ 001fe9af */
std::
pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>
::pair(local_160,(pair *)local_30);
/* try { // try from 001fe88c to 001fe8b8 has its CatchHandler @ 001fe9cf */
_ZN7testing12RegisterTestITpTnRiJEZNS_8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEvE3__0EEPNS_8TestInfoEPKcS8_S8_S8_S8_iT0_
("GoogleTestVerification",uVar3,0,0,uVar4,uVar1,local_180);
CheckForInstantiations()::$_0::~__0((__0 *)local_180);
std::__cxx11::string::~string(local_f0);
std::__cxx11::string::~string(local_60);
}
}
std::
_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
::operator++((_Rb_tree_iterator<std::pair<std::__cxx11::string_const,testing::internal::TypeParameterizedTestSuiteRegistry::TypeParameterizedTestSuiteInfo>>
*)&local_20);
}
return;
}
| |
53,725 | my_strnxfrm_unicode_full_bin | eloqsql/strings/ctype-utf8.c | size_t
my_strnxfrm_unicode_full_bin(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *dst0= dst;
uchar *de= dst + dstlen;
dst+= my_strnxfrm_unicode_full_bin_internal(cs, dst, de, &nweights,
src, src + srclen);
DBUG_ASSERT(dst <= de); /* Safety */
if (flags & MY_STRXFRM_PAD_WITH_SPACE)
{
for ( ; dst < de && nweights; nweights--)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
my_strxfrm_desc_and_reverse(dst0, dst, flags, 0);
if (flags & MY_STRXFRM_PAD_TO_MAXLEN)
{
while (dst < de)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
return dst - dst0;
} | O0 | c | my_strnxfrm_unicode_full_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %r8
movq -0x28(%rbp), %r9
addq -0x30(%rbp), %r9
leaq -0x1c(%rbp), %rcx
callq 0xb8040
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xb81e1
movl 0x10(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xb826b
jmp 0xb81ee
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0xb8207
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xb8210
jmp 0xb8269
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb825c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb825a
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0xb825c
jmp 0xb825e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb81ee
jmp 0xb826b
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0x99540
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xb82e6
jmp 0xb828c
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb82e4
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb82e2
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xb82e0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
jmp 0xb82e2
jmp 0xb828c
jmp 0xb82e6
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_strnxfrm_unicode_full_bin:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_40]
mov r8, [rbp+var_28]
mov r9, [rbp+var_28]
add r9, [rbp+var_30]
lea rcx, [rbp+var_1C]
call my_strnxfrm_unicode_full_bin_internal
add rax, [rbp+var_10]
mov [rbp+var_10], rax
jmp short $+2
loc_B81E1:
mov eax, [rbp+arg_0]
and eax, 40h
cmp eax, 0
jz short loc_B826B
jmp short $+2
loc_B81EE:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_B8207
cmp [rbp+var_1C], 0
setnz al
mov [rbp+var_41], al
loc_B8207:
mov al, [rbp+var_41]
test al, 1
jnz short loc_B8210
jmp short loc_B8269
loc_B8210:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_B825C
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_B825A
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 20h ; ' '
loc_B825A:
jmp short $+2
loc_B825C:
jmp short $+2
loc_B825E:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp short loc_B81EE
loc_B8269:
jmp short $+2
loc_B826B:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+arg_0]
xor ecx, ecx
call my_strxfrm_desc_and_reverse
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_B82E6
jmp short $+2
loc_B828C:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_B82E4
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_B82E2
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp rax, [rbp+var_40]
jnb short loc_B82E0
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 20h ; ' '
loc_B82E0:
jmp short $+2
loc_B82E2:
jmp short loc_B828C
loc_B82E4:
jmp short $+2
loc_B82E6:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 50h
pop rbp
retn
| unsigned long long my_strnxfrm_unicode_full_bin(
long long a1,
_BYTE *a2,
long long a3,
int a4,
long long a5,
long long a6,
unsigned int a7)
{
_BYTE *v7; // rax
_BYTE *v8; // rax
_BYTE *v9; // rax
_BYTE *v10; // rax
_BYTE *v11; // rax
_BYTE *v12; // rax
_BYTE *v13; // rax
bool v15; // [rsp+Fh] [rbp-41h]
unsigned long long v16; // [rsp+10h] [rbp-40h]
int v17; // [rsp+34h] [rbp-1Ch] BYREF
long long v18; // [rsp+38h] [rbp-18h]
unsigned long long v19; // [rsp+40h] [rbp-10h]
long long v20; // [rsp+48h] [rbp-8h]
v20 = a1;
v19 = (unsigned long long)a2;
v18 = a3;
v17 = a4;
v16 = (unsigned long long)&a2[a3];
v7 = my_strnxfrm_unicode_full_bin_internal(a1, a2, (unsigned long long)&a2[a3], &v17, a5, a6 + a5);
v19 += (unsigned long long)v7;
if ( (a7 & 0x40) != 0 )
{
while ( 1 )
{
v15 = 0;
if ( v19 < v16 )
v15 = v17 != 0;
if ( !v15 )
break;
v8 = (_BYTE *)v19++;
*v8 = 0;
if ( v19 < v16 )
{
v9 = (_BYTE *)v19++;
*v9 = 0;
if ( v19 < v16 )
{
v10 = (_BYTE *)v19++;
*v10 = 32;
}
}
--v17;
}
}
my_strxfrm_desc_and_reverse(a2, v19, a7, 0);
if ( (a7 & 0x80) != 0 )
{
while ( v19 < v16 )
{
v11 = (_BYTE *)v19++;
*v11 = 0;
if ( v19 < v16 )
{
v12 = (_BYTE *)v19++;
*v12 = 0;
if ( v19 < v16 )
{
v13 = (_BYTE *)v19++;
*v13 = 32;
}
}
}
}
return v19 - (_QWORD)a2;
}
| my_strnxfrm_unicode_full_bin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x28]
ADD R9,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x1c]
CALL 0x001b8040
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001b81e1
LAB_001b81e1:
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x40
CMP EAX,0x0
JZ 0x001b826b
JMP 0x001b81ee
LAB_001b81ee:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x001b8207
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001b8207:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001b8210
JMP 0x001b8269
LAB_001b8210:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001b825c
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001b825a
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x20
LAB_001b825a:
JMP 0x001b825c
LAB_001b825c:
JMP 0x001b825e
LAB_001b825e:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001b81ee
LAB_001b8269:
JMP 0x001b826b
LAB_001b826b:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + 0x10]
XOR ECX,ECX
CALL 0x00199540
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001b82e6
JMP 0x001b828c
LAB_001b828c:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001b82e4
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001b82e2
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x001b82e0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x20
LAB_001b82e0:
JMP 0x001b82e2
LAB_001b82e2:
JMP 0x001b828c
LAB_001b82e4:
JMP 0x001b82e6
LAB_001b82e6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x50
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin
(int8 param_1,long param_2,long param_3,int param_4,long param_5,long param_6,
uint param_7)
{
int1 *puVar1;
long lVar2;
int1 *puVar3;
int1 *puVar4;
int local_24;
long local_20;
int1 *local_18;
int8 local_10;
puVar1 = (int1 *)(param_2 + param_3);
local_24 = param_4;
local_20 = param_3;
local_18 = (int1 *)param_2;
local_10 = param_1;
lVar2 = my_strnxfrm_unicode_full_bin_internal
(param_1,param_2,puVar1,&local_24,param_5,param_5 + param_6);
local_18 = (int1 *)(lVar2 + (long)local_18);
if ((param_7 & 0x40) != 0) {
for (; local_18 < puVar1 && local_24 != 0; local_24 = local_24 + -1) {
puVar3 = local_18 + 1;
*local_18 = 0;
if (puVar3 < puVar1) {
puVar4 = local_18 + 2;
*puVar3 = 0;
puVar3 = puVar4;
if (puVar4 < puVar1) {
*puVar4 = 0x20;
puVar3 = local_18 + 3;
}
}
local_18 = puVar3;
}
}
my_strxfrm_desc_and_reverse(param_2,local_18,param_7,0);
puVar3 = local_18;
if ((param_7 & 0x80) != 0) {
while (local_18 = puVar3, local_18 < puVar1) {
puVar3 = local_18 + 1;
*local_18 = 0;
if (puVar3 < puVar1) {
puVar4 = local_18 + 2;
*puVar3 = 0;
puVar3 = puVar4;
if (puVar4 < puVar1) {
*puVar4 = 0x20;
puVar3 = local_18 + 3;
}
}
}
}
return (long)local_18 - param_2;
}
| |
53,726 | LefDefParser::lefiVia::propNumber(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | double
lefiVia::propNumber(int index) const
{
char msg[160];
if (index < 0 || index >= numProps_) {
sprintf(msg, "ERROR (LEFPARS-1422): The layer number %d given for the VIA PROPERTY is invalid.\nValid number is from 0 to %d", index, numLayers_);
lefiError(0, 1422, msg);
return 0;
}
return propDValue_[index];
} | O0 | cpp | LefDefParser::lefiVia::propNumber(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x1836e
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x20(%rcx), %eax
jl 0x183af
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x48(%rax), %ecx
leaq 0x5f890(%rip), %rsi # 0x77c19
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x58e, %esi # imm = 0x58E
callq 0x3f4e0
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x183ce
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0xb4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nop
| _ZNK12LefDefParser7lefiVia10propNumberEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_1836E
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+20h]
jl short loc_183AF
loc_1836E:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+48h]
lea rsi, aErrorLefpars14_2; "ERROR (LEFPARS-1422): The layer number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 58Eh; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
movsd [rsp+0C8h+var_8], xmm0
jmp short loc_183CE
loc_183AF:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+38h]
movsxd rcx, [rsp+0C8h+var_14]
movsd xmm0, qword ptr [rax+rcx*8]
movsd [rsp+0C8h+var_8], xmm0
loc_183CE:
movsd xmm0, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| double LefDefParser::lefiVia::propNumber(LefDefParser::lefiVia *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiVia *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 8) )
return *(double *)(*((_QWORD *)this + 7) + 8LL * v5);
sprintf(
v4,
"ERROR (LEFPARS-1422): The layer number %d given for the VIA PROPERTY is invalid.\nValid number is from 0 to %d",
v5,
*((_DWORD *)this + 18));
LefDefParser::lefiError(0LL, 1422, (int)v4, v2);
return 0.0;
}
| propNumber:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x0011836e
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x20]
JL 0x001183af
LAB_0011836e:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x48]
LEA RSI,[0x177c19]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x58e
CALL 0x0013f4e0
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0xc0],XMM0
JMP 0x001183ce
LAB_001183af:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOVSD qword ptr [RSP + 0xc0],XMM0
LAB_001183ce:
MOVSD XMM0,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiVia::propNumber(int) const */
int8 __thiscall LefDefParser::lefiVia::propNumber(lefiVia *this,int param_1)
{
char local_b8 [164];
int local_14;
lefiVia *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x20) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1422): The layer number %d given for the VIA PROPERTY is invalid.\nValid number is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x48));
lefiError(0,0x58e,local_b8);
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x38) + (long)param_1 * 8);
}
return local_8;
}
| |
53,727 | read_user_name | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void read_user_name(char *name)
{
if (geteuid() == 0)
strcpy(name,"root"); /* allow use of surun */
else
{
#ifdef HAVE_GETPWUID
struct passwd *skr;
const char *str;
if ((skr=getpwuid(geteuid())) != NULL)
{
str=skr->pw_name;
} else if ((str=getlogin()) == NULL)
{
if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
!(str=getenv("LOGIN")))
str="UNKNOWN_USER";
}
ma_strmake(name,str,USERNAME_LENGTH);
#elif defined(HAVE_CUSERID)
(void) cuserid(name);
#else
ma_strmake(name,"UNKNOWN_USER", USERNAME_LENGTH);
#endif
}
return;
} | O3 | c | read_user_name:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x13290
testl %eax, %eax
je 0x162fb
callq 0x13290
movl %eax, %edi
callq 0x13530
testq %rax, %rax
je 0x1630c
movq (%rax), %rsi
jmp 0x1633b
movb $0x0, 0x4(%rbx)
movl $0x746f6f72, (%rbx) # imm = 0x746F6F72
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x13470
testq %rax, %rax
jne 0x16338
leaq 0x1e55c(%rip), %rdi # 0x34879
callq 0x13590
testq %rax, %rax
jne 0x16338
leaq 0x1e535(%rip), %rdi # 0x34863
callq 0x13590
testq %rax, %rax
je 0x1634e
movq %rax, %rsi
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x252b3
leaq 0x1e516(%rip), %rdi # 0x3486b
callq 0x13590
testq %rax, %rax
leaq 0x1e50d(%rip), %rsi # 0x34871
cmovneq %rax, %rsi
jmp 0x1633b
| read_user_name:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _geteuid
test eax, eax
jz short loc_162FB
call _geteuid
mov edi, eax
call _getpwuid
test rax, rax
jz short loc_1630C
mov rsi, [rax]
jmp short loc_1633B
loc_162FB:
mov byte ptr [rbx+4], 0
mov dword ptr [rbx], 746F6F72h
add rsp, 8
pop rbx
pop rbp
retn
loc_1630C:
call _getlogin
test rax, rax
jnz short loc_16338
lea rdi, aUnknownUser+8; "USER"
call _getenv
test rax, rax
jnz short loc_16338
lea rdi, aLogname; "LOGNAME"
call _getenv
test rax, rax
jz short loc_1634E
loc_16338:
mov rsi, rax
loc_1633B:
mov edx, 200h
mov rdi, rbx
add rsp, 8
pop rbx
pop rbp
jmp ma_strmake
loc_1634E:
lea rdi, aLogin; "LOGIN"
call _getenv
test rax, rax
lea rsi, aUnknownUser; "UNKNOWN_USER"
cmovnz rsi, rax
jmp short loc_1633B
| long long read_user_name(char *a1)
{
long long result; // rax
unsigned int v2; // eax
const char **v3; // rax
const char *v4; // rsi
long long v5; // rax
long long v6; // rax
result = geteuid(a1);
if ( (_DWORD)result )
{
v2 = geteuid(a1);
v3 = (const char **)getpwuid(v2);
if ( v3 )
{
v4 = *v3;
}
else
{
v5 = getlogin();
if ( v5 || (v5 = getenv("USER")) != 0 || (v5 = getenv("LOGNAME")) != 0 )
{
v4 = (const char *)v5;
}
else
{
v6 = getenv("LOGIN");
v4 = "UNKNOWN_USER";
if ( v6 )
v4 = (const char *)v6;
}
}
return ma_strmake(a1, v4, 512LL);
}
else
{
strcpy(a1, "root");
}
return result;
}
| read_user_name:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00113290
TEST EAX,EAX
JZ 0x001162fb
CALL 0x00113290
MOV EDI,EAX
CALL 0x00113530
TEST RAX,RAX
JZ 0x0011630c
MOV RSI,qword ptr [RAX]
JMP 0x0011633b
LAB_001162fb:
MOV byte ptr [RBX + 0x4],0x0
MOV dword ptr [RBX],0x746f6f72
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0011630c:
CALL 0x00113470
TEST RAX,RAX
JNZ 0x00116338
LEA RDI,[0x134879]
CALL 0x00113590
TEST RAX,RAX
JNZ 0x00116338
LEA RDI,[0x134863]
CALL 0x00113590
TEST RAX,RAX
JZ 0x0011634e
LAB_00116338:
MOV RSI,RAX
LAB_0011633b:
MOV EDX,0x200
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001252b3
LAB_0011634e:
LEA RDI,[0x13486b]
CALL 0x00113590
TEST RAX,RAX
LEA RSI,[0x134871]
CMOVNZ RSI,RAX
JMP 0x0011633b
|
void read_user_name(int4 *param_1)
{
__uid_t _Var1;
passwd *ppVar2;
char *pcVar3;
char *pcVar4;
_Var1 = geteuid();
if (_Var1 != 0) {
_Var1 = geteuid();
ppVar2 = getpwuid(_Var1);
if (ppVar2 == (passwd *)0x0) {
pcVar3 = getlogin();
if (((pcVar3 == (char *)0x0) && (pcVar3 = getenv("USER"), pcVar3 == (char *)0x0)) &&
(pcVar3 = getenv("LOGNAME"), pcVar3 == (char *)0x0)) {
pcVar4 = getenv("LOGIN");
pcVar3 = "UNKNOWN_USER";
if (pcVar4 != (char *)0x0) {
pcVar3 = pcVar4;
}
}
}
else {
pcVar3 = ppVar2->pw_name;
}
ma_strmake(param_1,pcVar3,0x200);
return;
}
*(int1 *)(param_1 + 1) = 0;
*param_1 = 0x746f6f72;
return;
}
| |
53,728 | llama_data_write_buffer::write(void const*, unsigned long) | monkey531[P]llama/src/llama-context.cpp | void write(const void * src, size_t size) override {
if (size > buf_size) {
throw std::runtime_error("unexpectedly reached end of buffer");
}
memcpy(ptr, src, size);
ptr += size;
size_written += size;
buf_size -= size;
} | O3 | cpp | llama_data_write_buffer::write(void const*, unsigned long):
pushq %r14
pushq %rbx
pushq %rax
cmpq %rdx, 0x10(%rdi)
jb 0xa01bd
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x67420
addq %rbx, 0x8(%r14)
addq %rbx, 0x18(%r14)
subq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x65cb0
movq %rax, %rbx
leaq 0x749a3(%rip), %rsi # 0x114b74
movq %rax, %rdi
callq 0x655d0
movq 0xbce10(%rip), %rsi # 0x15cff0
movq 0xbcb09(%rip), %rdx # 0x15ccf0
movq %rbx, %rdi
callq 0x6b270
movq %rax, %r14
movq %rbx, %rdi
callq 0x66d40
movq %r14, %rdi
callq 0x6b5d0
| _ZN23llama_data_write_buffer5writeEPKvm:
push r14
push rbx
push rax
cmp [rdi+10h], rdx
jb short loc_A01BD
mov rbx, rdx
mov r14, rdi
mov rdi, [rdi+8]
call _memcpy
add [r14+8], rbx
add [r14+18h], rbx
sub [r14+10h], rbx
add rsp, 8
pop rbx
pop r14
retn
loc_A01BD:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUnexpectedlyRe; "unexpectedly reached end of buffer"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long llama_data_write_buffer::write(llama_data_write_buffer *this, const void *a2, unsigned long long a3)
{
long long result; // rax
std::runtime_error *exception; // rbx
if ( *((_QWORD *)this + 2) < a3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "unexpectedly reached end of buffer");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
result = memcpy(*((_QWORD *)this + 1), a2, a3);
*((_QWORD *)this + 1) += a3;
*((_QWORD *)this + 3) += a3;
*((_QWORD *)this + 2) -= a3;
return result;
}
| write:
PUSH R14
PUSH RBX
PUSH RAX
CMP qword ptr [RDI + 0x10],RDX
JC 0x001a01bd
MOV RBX,RDX
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x00167420
ADD qword ptr [R14 + 0x8],RBX
ADD qword ptr [R14 + 0x18],RBX
SUB qword ptr [R14 + 0x10],RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001a01bd:
MOV EDI,0x10
CALL 0x00165cb0
MOV RBX,RAX
LAB_001a01ca:
LEA RSI,[0x214b74]
MOV RDI,RAX
CALL 0x001655d0
LAB_001a01d9:
MOV RSI,qword ptr [0x0025cff0]
MOV RDX,qword ptr [0x0025ccf0]
MOV RDI,RBX
CALL 0x0016b270
|
/* llama_data_write_buffer::write(void const*, unsigned long) */
void __thiscall
llama_data_write_buffer::write(llama_data_write_buffer *this,void *param_1,ulong param_2)
{
runtime_error *this_00;
if (param_2 <= *(ulong *)(this + 0x10)) {
memcpy(*(void **)(this + 8),param_1,param_2);
*(ulong *)(this + 8) = *(long *)(this + 8) + param_2;
*(ulong *)(this + 0x18) = *(long *)(this + 0x18) + param_2;
*(ulong *)(this + 0x10) = *(long *)(this + 0x10) - param_2;
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a01ca to 001a01d8 has its CatchHandler @ 001a01ef */
std::runtime_error::runtime_error(this_00,"unexpectedly reached end of buffer");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0025cff0,PTR__runtime_error_0025ccf0);
}
| |
53,729 | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling) | monkey531[P]llama/common/minja.hpp | std::string consumeToken(const std::regex & regex, SpaceHandling space_handling = SpaceHandling::Strip) {
auto start = it;
consumeSpaces(space_handling);
std::smatch match;
if (std::regex_search(it, end, match, regex) && match.position() == 0) {
it += match[0].length();
return match[0].str();
}
it = start;
return "";
} | O3 | cpp | minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, minja::SpaceHandling):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r12
movq %rsi, %rdi
movl %ecx, %esi
callq 0xa892a
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x9392f
testb %al, %al
je 0xa7b9f
movq 0x18(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0xa7b86
movq (%rax), %r8
cmpq $0x48, %rdx
jne 0xa7b97
cmpq %rsi, %r8
jne 0xa7b9f
jmp 0xa7b8d
cmpq %rsi, -0x48(%rax,%rdx)
jne 0xa7b9f
leaq (%rax,%rdx), %rdi
addq $-0x48, %rdi
jmp 0xa7be1
movq %rax, %rdi
cmpq %rsi, %r8
je 0xa7be1
movq %r12, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x61589(%rip), %rdx # 0x10913a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x26926
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa7bd2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %r8
subq %rsi, %r8
xorl %esi, %esi
cmpb $0x0, 0x10(%rdi)
cmovneq %r8, %rsi
addq %rsi, 0x20(%r14)
cmpq $0x48, %rdx
leaq -0x48(%rax,%rdx), %rsi
movq %rax, %rdx
cmoveq %rsi, %rdx
cmpq %rcx, %rax
cmoveq %rsi, %rdx
cmpb $0x1, 0x10(%rdx)
jne 0xa7c2b
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x94760
jmp 0xa7bbc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0xa7bbc
jmp 0xa7c45
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xa7c5e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq %rbx, %rdi
callq 0x1e660
| _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov r12, [rsi+20h]
mov rdi, rsi
mov esi, ecx
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
xorps xmm0, xmm0
mov rdx, rsp
movaps xmmword ptr [rdx+10h], xmm0
movaps xmmword ptr [rdx], xmm0
mov rsi, [r14+18h]
mov rdi, [r14+20h]
mov rcx, r15
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_A7B9F
mov rsi, [rsp+48h+var_30]
mov rax, [rsp+48h+var_48]
mov rcx, [rsp+48h+var_40]
mov rdx, rcx
sub rdx, rax
jz short loc_A7B86
mov r8, [rax]
cmp rdx, 48h ; 'H'
jnz short loc_A7B97
cmp r8, rsi
jnz short loc_A7B9F
jmp short loc_A7B8D
loc_A7B86:
cmp [rax+rdx-48h], rsi
jnz short loc_A7B9F
loc_A7B8D:
lea rdi, [rax+rdx]
add rdi, 0FFFFFFFFFFFFFFB8h
jmp short loc_A7BE1
loc_A7B97:
mov rdi, rax
cmp r8, rsi
jz short loc_A7BE1
loc_A7B9F:
mov [r14+20h], r12
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aSFailedToLoadI+2Ah; ""
mov rdi, rbx
mov rsi, rdx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_A7BBC:
mov rdi, [rsp+48h+var_48]; void *
test rdi, rdi
jz short loc_A7BD2
mov rsi, [rsp+48h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A7BD2:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_A7BE1:
mov r8, [rdi+8]
sub r8, rsi
xor esi, esi
cmp byte ptr [rdi+10h], 0
cmovnz rsi, r8
add [r14+20h], rsi
cmp rdx, 48h ; 'H'
lea rsi, [rax+rdx-48h]
mov rdx, rax
cmovz rdx, rsi
cmp rax, rcx
cmovz rdx, rsi
cmp byte ptr [rdx+10h], 1
jnz short loc_A7C2B
mov rsi, [rdx]
mov rdx, [rdx+8]
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
jmp short loc_A7BBC
loc_A7C2B:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
jmp loc_A7BBC
jmp short $+2
loc_A7C45:
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_A7C5E
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A7C5E:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::consumeToken(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v7; // r12
__int128 v8; // kr00_16
long long v9; // rdx
long long v10; // r8
long long v11; // rdi
long long v13; // rsi
bool v14; // zf
long long v15; // rsi
long long v16; // rdx
_BYTE *v17; // rsi
long long v18; // rdx
__int128 v19; // [rsp+0h] [rbp-48h] BYREF
__int128 v20; // [rsp+10h] [rbp-38h]
v7 = *(_QWORD *)(a2 + 32);
minja::Parser::consumeSpaces(a2, a4);
v20 = 0LL;
v19 = 0LL;
if ( !std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
*(_QWORD *)(a2 + 32),
*(_QWORD *)(a2 + 24),
(void **)&v19,
a3,
0) )
goto LABEL_9;
v8 = v19;
v9 = *((_QWORD *)&v19 + 1) - v19;
if ( *((_QWORD *)&v19 + 1) != (_QWORD)v19 )
{
v10 = *(_QWORD *)v19;
if ( v9 == 72 )
{
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_7;
}
else
{
v11 = v19;
if ( v10 == *((_QWORD *)&v20 + 1) )
goto LABEL_13;
}
LABEL_9:
*(_QWORD *)(a2 + 32) = v7;
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "", (long long)"");
goto LABEL_10;
}
if ( *(_QWORD *)(*((_QWORD *)&v19 + 1) - 72LL) != *((_QWORD *)&v20 + 1) )
goto LABEL_9;
LABEL_7:
v11 = *((_QWORD *)&v19 + 1) - 72LL;
LABEL_13:
v13 = 0LL;
if ( *(_BYTE *)(v11 + 16) )
v13 = *(_QWORD *)(v11 + 8) - *((_QWORD *)&v20 + 1);
*(_QWORD *)(a2 + 32) += v13;
v14 = v9 == 72;
v15 = v8 + v9 - 72;
v16 = v8;
if ( v14 )
v16 = v15;
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
v16 = v15;
if ( *(_BYTE *)(v16 + 16) == 1 )
{
v17 = *(_BYTE **)v16;
v18 = *(_QWORD *)(v16 + 8);
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(a1, v17, v18);
}
else
{
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
}
LABEL_10:
if ( (_QWORD)v19 )
operator delete((void *)v19, v20 - v19);
return a1;
}
| consumeToken:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV R12,qword ptr [RSI + 0x20]
MOV RDI,RSI
MOV ESI,ECX
CALL 0x001a892a
XORPS XMM0,XMM0
MOV RDX,RSP
MOVAPS xmmword ptr [RDX + 0x10],XMM0
MOVAPS xmmword ptr [RDX],XMM0
MOV RSI,qword ptr [R14 + 0x18]
MOV RDI,qword ptr [R14 + 0x20]
LAB_001a7b51:
MOV RCX,R15
XOR R8D,R8D
CALL 0x0019392f
TEST AL,AL
JZ 0x001a7b9f
MOV RSI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV RDX,RCX
SUB RDX,RAX
JZ 0x001a7b86
MOV R8,qword ptr [RAX]
CMP RDX,0x48
JNZ 0x001a7b97
CMP R8,RSI
JNZ 0x001a7b9f
JMP 0x001a7b8d
LAB_001a7b86:
CMP qword ptr [RAX + RDX*0x1 + -0x48],RSI
JNZ 0x001a7b9f
LAB_001a7b8d:
LEA RDI,[RAX + RDX*0x1]
ADD RDI,-0x48
JMP 0x001a7be1
LAB_001a7b97:
MOV RDI,RAX
CMP R8,RSI
JZ 0x001a7be1
LAB_001a7b9f:
MOV qword ptr [R14 + 0x20],R12
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_001a7baa:
LEA RDX,[0x20913a]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x00126926
LAB_001a7bbc:
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x001a7bd2
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x0011dc50
LAB_001a7bd2:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001a7be1:
MOV R8,qword ptr [RDI + 0x8]
SUB R8,RSI
XOR ESI,ESI
CMP byte ptr [RDI + 0x10],0x0
CMOVNZ RSI,R8
ADD qword ptr [R14 + 0x20],RSI
CMP RDX,0x48
LEA RSI,[RAX + RDX*0x1 + -0x48]
MOV RDX,RAX
CMOVZ RDX,RSI
CMP RAX,RCX
CMOVZ RDX,RSI
CMP byte ptr [RDX + 0x10],0x1
JNZ 0x001a7c2b
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LAB_001a7c21:
MOV RDI,RBX
CALL 0x00194760
LAB_001a7c29:
JMP 0x001a7bbc
LAB_001a7c2b:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
JMP 0x001a7bbc
|
/* minja::Parser::consumeToken(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char> >
const&, minja::SpaceHandling) */
long * minja::Parser::consumeToken
(long *param_1,Parser *param_2,int8 param_3,int4 param_4)
{
int8 uVar1;
bool bVar2;
long lVar3;
long *plVar4;
long lVar5;
long *plVar6;
long *local_48;
long *plStack_40;
long local_38;
long lStack_30;
uVar1 = *(int8 *)(param_2 + 0x20);
consumeSpaces(param_2,param_4);
local_38 = 0;
lStack_30 = 0;
local_48 = (long *)0x0;
plStack_40 = (long *)0x0;
/* try { // try from 001a7b51 to 001a7b5b has its CatchHandler @ 001a7c45 */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(*(int8 *)(param_2 + 0x20),*(int8 *)(param_2 + 0x18),&local_48,
param_3,0);
if (bVar2) {
lVar3 = (long)plStack_40 - (long)local_48;
if (lVar3 == 0) {
lVar5 = local_48[-9];
joined_r0x001a7b8b:
if (lVar5 != lStack_30) goto LAB_001a7b9f;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
}
else {
lVar5 = *local_48;
if (lVar3 == 0x48) goto joined_r0x001a7b8b;
plVar6 = local_48;
if (lVar5 != lStack_30) goto LAB_001a7b9f;
}
lVar5 = 0;
if ((char)plVar6[2] != '\0') {
lVar5 = plVar6[1] - lStack_30;
}
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x20) + lVar5;
plVar6 = (long *)((long)local_48 + lVar3 + -0x48);
plVar4 = local_48;
if (lVar3 == 0x48) {
plVar4 = plVar6;
}
if (local_48 == plStack_40) {
plVar4 = plVar6;
}
if ((char)plVar4[2] == '\x01') {
lVar3 = *plVar4;
lVar5 = plVar4[1];
*param_1 = (long)(param_1 + 2);
/* try { // try from 001a7c21 to 001a7c28 has its CatchHandler @ 001a7c45 */
std::__cxx11::string::
_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar3,lVar5);
}
else {
*param_1 = (long)(param_1 + 2);
param_1[1] = 0;
*(int1 *)(param_1 + 2) = 0;
}
}
else {
LAB_001a7b9f:
*(int8 *)(param_2 + 0x20) = uVar1;
*param_1 = (long)(param_1 + 2);
/* try { // try from 001a7baa to 001a7bbb has its CatchHandler @ 001a7c43 */
std::__cxx11::string::_M_construct<char_const*>(param_1,"");
}
if (local_48 != (long *)0x0) {
operator_delete(local_48,local_38 - (long)local_48);
}
return param_1;
}
| |
53,730 | minja::Context::~Context() | monkey531[P]llama/common/minja.hpp | virtual ~Context() {} | O1 | cpp | minja::Context::~Context():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8edba(%rip), %rax # 0x12b130
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x9c38b
callq 0x6c090
leaq 0x58(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x56f38
movq %r14, %rdi
callq 0x5c724
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9c3af
callq 0x6c090
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x9c3bd
callq 0x6c090
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x9c3cb
callq 0x6c090
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9c400
movq 0x8fba5(%rip), %rax # 0x12bf80
cmpb $0x0, (%rax)
je 0x9c3eb
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9c3f5
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9c400
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9c43c
movq 0x8fb70(%rip), %rax # 0x12bf80
cmpb $0x0, (%rax)
je 0x9c420
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9c42a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9c43c
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja7ContextD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+70h]
test rdi, rdi
jz short loc_9C38B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C38B:
lea r14, [rbx+58h]
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, [rbx+50h]
test rdi, rdi
jz short loc_9C3AF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C3AF:
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_9C3BD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C3BD:
mov rdi, [rbx+30h]
test rdi, rdi
jz short loc_9C3CB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C3CB:
mov rdi, [rbx+20h]
test rdi, rdi
jz short loc_9C400
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9C3EB
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9C3F5
loc_9C3EB:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9C3F5:
cmp eax, 1
jnz short loc_9C400
mov rax, [rdi]
call qword ptr [rax+18h]
loc_9C400:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9C43C
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9C420
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9C42A
loc_9C420:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9C42A:
cmp eax, 1
jnz short loc_9C43C
mov rax, [rdi]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rax+18h]
loc_9C43C:
add rsp, 8
pop rbx
pop r14
retn
| void minja::Context::~Context(minja::Context *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
volatile signed __int32 *v6; // rdi
signed __int32 v7; // eax
volatile signed __int32 *v8; // rdi
signed __int32 v9; // eax
*(_QWORD *)this = &`vtable for'minja::Context + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 14);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 88);
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((char *)this + 88);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 10);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
v4 = (volatile signed __int32 *)*((_QWORD *)this + 8);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
v5 = (volatile signed __int32 *)*((_QWORD *)this + 6);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
v6 = (volatile signed __int32 *)*((_QWORD *)this + 4);
if ( v6 )
{
if ( _libc_single_threaded )
{
v7 = *((_DWORD *)v6 + 3);
*((_DWORD *)v6 + 3) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd(v6 + 3, 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
v8 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v8 )
{
if ( _libc_single_threaded )
{
v9 = *((_DWORD *)v8 + 3);
*((_DWORD *)v8 + 3) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd(v8 + 3, 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
| ~Context:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x22b130]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x70]
TEST RDI,RDI
JZ 0x0019c38b
CALL 0x0016c090
LAB_0019c38b:
LEA R14,[RBX + 0x58]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00156f38
MOV RDI,R14
CALL 0x0015c724
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x0019c3af
CALL 0x0016c090
LAB_0019c3af:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x0019c3bd
CALL 0x0016c090
LAB_0019c3bd:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x0019c3cb
CALL 0x0016c090
LAB_0019c3cb:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x0019c400
MOV RAX,qword ptr [0x0022bf80]
CMP byte ptr [RAX],0x0
JZ 0x0019c3eb
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019c3f5
LAB_0019c3eb:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019c3f5:
CMP EAX,0x1
JNZ 0x0019c400
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0019c400:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019c43c
MOV RAX,qword ptr [0x0022bf80]
CMP byte ptr [RAX],0x0
JZ 0x0019c420
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019c42a
LAB_0019c420:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019c42a:
CMP EAX,0x1
JNZ 0x0019c43c
MOV RAX,qword ptr [RDI]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RAX + 0x18]
LAB_0019c43c:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Context::~Context() */
void __thiscall minja::Context::~Context(Context *this)
{
int *piVar1;
long *plVar2;
int iVar3;
*(int ***)this = &PTR__Context_0022b140;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70) !=
(_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 + 0x70));
}
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 *)(this + 0x58),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 *)(this + 0x58));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50) !=
(_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 + 0x50));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40) !=
(_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 + 0x40));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30) !=
(_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 + 0x30));
}
plVar2 = *(long **)(this + 0x20);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*plVar2 + 0x18))();
}
}
plVar2 = *(long **)(this + 0x10);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_0022bf80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
/* WARNING: Could not recover jumptable at 0x0019c439. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*plVar2 + 0x18))();
return;
}
}
return;
}
| |
53,731 | minja::Context::~Context() | monkey531[P]llama/common/minja.hpp | virtual ~Context() {} | O3 | cpp | minja::Context::~Context():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8d440(%rip), %rax # 0x129130
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x9bd05
callq 0x6c8e8
leaq 0x58(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x579d6
movq %r14, %rdi
callq 0x5cec4
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9bd29
callq 0x6c8e8
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x9bd37
callq 0x6c8e8
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x9bd45
callq 0x6c8e8
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9bd7a
movq 0x8e22b(%rip), %rax # 0x129f80
cmpb $0x0, (%rax)
je 0x9bd65
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9bd6f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9bd7a
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9bdb6
movq 0x8e1f6(%rip), %rax # 0x129f80
cmpb $0x0, (%rax)
je 0x9bd9a
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x9bda4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x9bdb6
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja7ContextD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+70h]
test rdi, rdi
jz short loc_9BD05
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BD05:
lea r14, [rbx+58h]
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, [rbx+50h]
test rdi, rdi
jz short loc_9BD29
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BD29:
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_9BD37
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BD37:
mov rdi, [rbx+30h]
test rdi, rdi
jz short loc_9BD45
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BD45:
mov rdi, [rbx+20h]
test rdi, rdi
jz short loc_9BD7A
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9BD65
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9BD6F
loc_9BD65:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9BD6F:
cmp eax, 1
jnz short loc_9BD7A
mov rax, [rdi]
call qword ptr [rax+18h]
loc_9BD7A:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9BDB6
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_9BD9A
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_9BDA4
loc_9BD9A:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_9BDA4:
cmp eax, 1
jnz short loc_9BDB6
mov rax, [rdi]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rax+18h]
loc_9BDB6:
add rsp, 8
pop rbx
pop r14
retn
| void minja::Context::~Context(minja::Context *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
volatile signed __int32 *v6; // rdi
signed __int32 v7; // eax
volatile signed __int32 *v8; // rdi
signed __int32 v9; // eax
*(_QWORD *)this = &`vtable for'minja::Context + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 14);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)this + 88);
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((char *)this + 88);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 10);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
v4 = (volatile signed __int32 *)*((_QWORD *)this + 8);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
v5 = (volatile signed __int32 *)*((_QWORD *)this + 6);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
v6 = (volatile signed __int32 *)*((_QWORD *)this + 4);
if ( v6 )
{
if ( _libc_single_threaded )
{
v7 = *((_DWORD *)v6 + 3);
*((_DWORD *)v6 + 3) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd(v6 + 3, 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
v8 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v8 )
{
if ( _libc_single_threaded )
{
v9 = *((_DWORD *)v8 + 3);
*((_DWORD *)v8 + 3) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd(v8 + 3, 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
| ~Context:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x229130]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x70]
TEST RDI,RDI
JZ 0x0019bd05
CALL 0x0016c8e8
LAB_0019bd05:
LEA R14,[RBX + 0x58]
MOV RDI,R14
XOR ESI,ESI
CALL 0x001579d6
MOV RDI,R14
CALL 0x0015cec4
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x0019bd29
CALL 0x0016c8e8
LAB_0019bd29:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x0019bd37
CALL 0x0016c8e8
LAB_0019bd37:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x0019bd45
CALL 0x0016c8e8
LAB_0019bd45:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x0019bd7a
MOV RAX,qword ptr [0x00229f80]
CMP byte ptr [RAX],0x0
JZ 0x0019bd65
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019bd6f
LAB_0019bd65:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019bd6f:
CMP EAX,0x1
JNZ 0x0019bd7a
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0019bd7a:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019bdb6
MOV RAX,qword ptr [0x00229f80]
CMP byte ptr [RAX],0x0
JZ 0x0019bd9a
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0019bda4
LAB_0019bd9a:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0019bda4:
CMP EAX,0x1
JNZ 0x0019bdb6
MOV RAX,qword ptr [RDI]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RAX + 0x18]
LAB_0019bdb6:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Context::~Context() */
void __thiscall minja::Context::~Context(Context *this)
{
int *piVar1;
long *plVar2;
int iVar3;
*(int ***)this = &PTR__Context_00229140;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70) !=
(_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 + 0x70));
}
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 *)(this + 0x58),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 *)(this + 0x58));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50) !=
(_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 + 0x50));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40) !=
(_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 + 0x40));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30) !=
(_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 + 0x30));
}
plVar2 = *(long **)(this + 0x20);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*plVar2 + 0x18))();
}
}
plVar2 = *(long **)(this + 0x10);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
/* WARNING: Could not recover jumptable at 0x0019bdb3. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*plVar2 + 0x18))();
return;
}
}
return;
}
| |
53,732 | my_dir | eloqsql/mysys/my_lib.c | MY_DIR *my_dir(const char *path, myf MyFlags)
{
MY_DIR_HANDLE *dirh;
FILEINFO finfo;
DIR *dirp;
struct dirent *dp;
char tmp_path[FN_REFLEN + 2], *tmp_file;
char dirent_tmp[sizeof(struct dirent)+_POSIX_PATH_MAX+1];
DBUG_ENTER("my_dir");
DBUG_PRINT("my",("path: '%s' MyFlags: %lu",path,MyFlags));
tmp_file= directory_file_name(tmp_path, path);
if (!(dirp= opendir(tmp_path)))
{
my_errno= errno;
goto err_open;
}
if (!(dirh= my_malloc(key_memory_MY_DIR, sizeof(*dirh),
MYF(MyFlags | MY_ZEROFILL))))
goto err_alloc;
if (my_init_dynamic_array(key_memory_MY_DIR, &dirh->array, sizeof(FILEINFO),
ENTRIES_START_SIZE, ENTRIES_INCREMENT,
MYF(MyFlags)))
goto error;
init_alloc_root(key_memory_MY_DIR, &dirh->root, NAMES_START_SIZE,
NAMES_START_SIZE, MYF(MyFlags));
dp= (struct dirent*) dirent_tmp;
while (!(READDIR(dirp,(struct dirent*) dirent_tmp,dp)))
{
MY_STAT statbuf, *mystat= 0;
if (dp->d_name[0] == '.' &&
(dp->d_name[1] == '\0' ||
(dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
continue; /* . or .. */
if (MyFlags & MY_WANT_STAT)
{
mystat= &statbuf;
bzero(mystat, sizeof(*mystat));
(void) strmov(tmp_file, dp->d_name);
(void) my_stat(tmp_path, mystat, MyFlags);
if (!(mystat->st_mode & MY_S_IREAD))
continue;
}
if (!(finfo.name= strdup_root(&dirh->root, dp->d_name)))
goto error;
if (mystat &&
!((mystat= memdup_root(&dirh->root, mystat, sizeof(*mystat)))))
goto error;
finfo.mystat= mystat;
if (push_dynamic(&dirh->array, (uchar*)&finfo))
goto error;
}
(void) closedir(dirp);
if (MyFlags & MY_WANT_SORT)
sort_dynamic(&dirh->array, (qsort_cmp) comp_names);
dirh->dir.dir_entry= dynamic_element(&dirh->array, 0, FILEINFO *);
dirh->dir.number_of_files= dirh->array.elements;
DBUG_RETURN(&dirh->dir);
error:
my_dirend(&dirh->dir);
err_alloc:
(void) closedir(dirp);
err_open:
if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_DIR, MYF(ME_BELL), path, my_errno);
DBUG_RETURN(NULL);
} | O3 | c | my_dir:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpb $0x0, (%rdi)
movq %rsi, %r15
leaq 0x36202(%rip), %rsi # 0x635f8
cmovneq %rdi, %rsi
leaq -0x240(%rbp), %rdi
movl $0x201, %edx # imm = 0x201
callq 0x610bc
movq %rax, %r12
cmpb $0x2f, -0x1(%rax)
je 0x2d41e
movw $0x2f, (%r12)
incq %r12
leaq -0x240(%rbp), %rdi
callq 0x24520
testq %rax, %rax
je 0x2d4ae
movq %rax, %r13
leaq 0x34e70b(%rip), %rbx # 0x37bb44
movl (%rbx), %edi
movq %r15, -0x248(%rbp)
orq $0x20, %r15
movl $0x78, %esi
movq %r15, %rdx
callq 0x2d775
testq %rax, %rax
je 0x2d49d
movq %rax, %r15
movq %r12, -0x268(%rbp)
movq %rbx, %r12
movl (%rbx), %edi
leaq 0x10(%rax), %rbx
movq -0x248(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
movl $0x200, %r8d # imm = 0x200
movl $0x1000, %r9d # imm = 0x1000
callq 0x27294
testb %al, %al
je 0x2d4ed
movq %r15, %rdi
callq 0x2d394
movq %r13, %rdi
callq 0x245b0
movq -0x248(%rbp), %r15
jmp 0x2d4bc
callq 0x24060
movl (%rax), %ebx
callq 0x2ec32
movl %ebx, (%rax)
testb $0x18, %r15b
je 0x2d4e5
callq 0x2ec32
movl (%rax), %ecx
xorl %r15d, %r15d
movl $0x4, %esi
movl $0xc, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2a00f
jmp 0x2d65e
xorl %r15d, %r15d
jmp 0x2d65e
movq %rbx, -0x260(%rbp)
movq %r14, -0x258(%rbp)
movl (%r12), %edi
movq %r15, %rsi
addq $0x38, %rsi
movl $0x8000, %edx # imm = 0x8000
movl $0x8000, %ecx # imm = 0x8000
movq %rsi, -0x250(%rbp)
movq -0x248(%rbp), %r8
callq 0x32bb8
movq %r13, %rdi
callq 0x241d0
testq %rax, %rax
je 0x2d625
movq %rax, %rbx
movq -0x248(%rbp), %r14
cmpb $0x2e, 0x13(%rbx)
jne 0x2d55f
movzbl 0x14(%rbx), %eax
testl %eax, %eax
je 0x2d611
cmpl $0x2e, %eax
jne 0x2d55f
cmpb $0x0, 0x15(%rbx)
je 0x2d611
addq $0x13, %rbx
btl $0xe, %r14d
jb 0x2d56f
xorl %r12d, %r12d
jmp 0x2d5af
movl $0x90, %edx
leaq -0x308(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x241a0
movq -0x268(%rbp), %rdi
movq %rbx, %rsi
callq 0x242a0
leaq -0x240(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2d693
testb $0x1, -0x2ef(%rbp)
je 0x2d611
movq -0x250(%rbp), %rdi
movq %rbx, %rsi
callq 0x330aa
movq %rax, -0x278(%rbp)
testq %rax, %rax
je 0x2d682
testq %r12, %r12
je 0x2d5f1
movl $0x90, %edx
movq -0x250(%rbp), %rdi
movq %r12, %rsi
callq 0x33118
testq %rax, %rax
jne 0x2d5f3
jmp 0x2d682
xorl %eax, %eax
movq %rax, -0x270(%rbp)
movq -0x260(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x27332
testb %al, %al
jne 0x2d682
movq %r13, %rdi
callq 0x241d0
movq %rax, %rbx
testq %rax, %rax
jne 0x2d53e
movq %r13, %rdi
callq 0x245b0
btl $0xd, -0x248(%rbp)
jae 0x2d64f
movq 0x10(%r15), %rdi
movl 0x18(%r15), %esi
movl 0x24(%r15), %edx
leaq 0xed(%rip), %rcx # 0x2d737
callq 0x32334
movq 0x10(%r15), %rax
movq %rax, (%r15)
movl 0x18(%r15), %eax
movl %eax, 0x8(%r15)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2d68e
movq %r15, %rax
addq $0x2e8, %rsp # imm = 0x2E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x258(%rbp), %r14
jmp 0x2d495
callq 0x24390
| my_dir:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2E8h
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp byte ptr [rdi], 0
mov r15, rsi
lea rsi, asc_635F7+1; "."
cmovnz rsi, rdi
lea rdi, [rbp+var_240]
mov edx, 201h
call strnmov
mov r12, rax
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_2D41E
mov word ptr [r12], 2Fh ; '/'
inc r12
loc_2D41E:
lea rdi, [rbp+var_240]
call _opendir
test rax, rax
jz short loc_2D4AE
mov r13, rax
lea rbx, key_memory_MY_DIR
mov edi, [rbx]
mov [rbp+var_248], r15
or r15, 20h
mov esi, 78h ; 'x'
mov rdx, r15
call my_malloc
test rax, rax
jz short loc_2D49D
mov r15, rax
mov [rbp+var_268], r12
mov r12, rbx
mov edi, [rbx]
lea rbx, [rax+10h]
mov rax, [rbp+var_248]
mov [rsp+310h+var_310], rax
mov rsi, rbx
mov edx, 10h
xor ecx, ecx
mov r8d, 200h
mov r9d, 1000h
call init_dynamic_array2
test al, al
jz short loc_2D4ED
loc_2D495:
mov rdi, r15
call my_dirend
loc_2D49D:
mov rdi, r13
call _closedir
mov r15, [rbp+var_248]
jmp short loc_2D4BC
loc_2D4AE:
call ___errno_location
mov ebx, [rax]
call _my_thread_var
mov [rax], ebx
loc_2D4BC:
test r15b, 18h
jz short loc_2D4E5
call _my_thread_var
mov ecx, [rax]
xor r15d, r15d
mov esi, 4
mov edi, 0Ch
mov rdx, r14
xor eax, eax
call my_error
jmp loc_2D65E
loc_2D4E5:
xor r15d, r15d
jmp loc_2D65E
loc_2D4ED:
mov [rbp+var_260], rbx
mov [rbp+var_258], r14
mov edi, [r12]
mov rsi, r15
add rsi, 38h ; '8'
mov edx, 8000h
mov ecx, 8000h
mov [rbp+var_250], rsi
mov r8, [rbp+var_248]
call init_alloc_root
mov rdi, r13
call _readdir64
test rax, rax
jz loc_2D625
mov rbx, rax
mov r14, [rbp+var_248]
loc_2D53E:
cmp byte ptr [rbx+13h], 2Eh ; '.'
jnz short loc_2D55F
movzx eax, byte ptr [rbx+14h]
test eax, eax
jz loc_2D611
cmp eax, 2Eh ; '.'
jnz short loc_2D55F
cmp byte ptr [rbx+15h], 0
jz loc_2D611
loc_2D55F:
add rbx, 13h
bt r14d, 0Eh
jb short loc_2D56F
xor r12d, r12d
jmp short loc_2D5AF
loc_2D56F:
mov edx, 90h
lea r12, [rbp+var_308]
mov rdi, r12
xor esi, esi
call _memset
mov rdi, [rbp+var_268]
mov rsi, rbx
call _strcpy
lea rdi, [rbp+var_240]
mov rsi, r12
mov rdx, r14
call my_stat
test [rbp+var_2EF], 1
jz short loc_2D611
loc_2D5AF:
mov rdi, [rbp+var_250]
mov rsi, rbx
call strdup_root
mov [rbp+var_278], rax
test rax, rax
jz loc_2D682
test r12, r12
jz short loc_2D5F1
mov edx, 90h
mov rdi, [rbp+var_250]
mov rsi, r12
call memdup_root
test rax, rax
jnz short loc_2D5F3
jmp loc_2D682
loc_2D5F1:
xor eax, eax
loc_2D5F3:
mov [rbp+var_270], rax
mov rdi, [rbp+var_260]
lea rsi, [rbp+var_278]
call insert_dynamic
test al, al
jnz short loc_2D682
loc_2D611:
mov rdi, r13
call _readdir64
mov rbx, rax
test rax, rax
jnz loc_2D53E
loc_2D625:
mov rdi, r13
call _closedir
bt dword ptr [rbp+var_248], 0Dh
jnb short loc_2D64F
mov rdi, [r15+10h]
mov esi, [r15+18h]
mov edx, [r15+24h]
lea rcx, comp_names
call my_qsort
loc_2D64F:
mov rax, [r15+10h]
mov [r15], rax
mov eax, [r15+18h]
mov [r15+8], eax
loc_2D65E:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2D68E
mov rax, r15
add rsp, 2E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2D682:
mov r14, [rbp+var_258]
jmp loc_2D495
loc_2D68E:
call ___stack_chk_fail
| long long my_dir(char *a1, long long a2)
{
char *v2; // r14
char *v4; // rsi
char *v5; // rax
char *v6; // r12
_BYTE *v7; // rdi
long long v8; // rax
_BYTE *v9; // r13
long long v10; // rax
long long v11; // r15
long long v12; // rbx
int v13; // ebx
unsigned int *v14; // rax
long long v15; // rax
_BYTE *v16; // rbx
long long v17; // r14
_BYTE *v18; // rbx
_BYTE *v19; // r12
long long v20; // rax
_BYTE v22[144]; // [rsp+8h] [rbp-308h] BYREF
_QWORD v23[2]; // [rsp+98h] [rbp-278h] BYREF
char *v24; // [rsp+A8h] [rbp-268h]
long long v25; // [rsp+B0h] [rbp-260h]
char *v26; // [rsp+B8h] [rbp-258h]
long long v27; // [rsp+C0h] [rbp-250h]
long long v28; // [rsp+C8h] [rbp-248h] BYREF
_BYTE v29[528]; // [rsp+D0h] [rbp-240h] BYREF
unsigned long long v30; // [rsp+2E0h] [rbp-30h]
v2 = a1;
v30 = __readfsqword(0x28u);
v4 = ".";
if ( *a1 )
v4 = a1;
v5 = (char *)strnmov(v29, v4, 513LL);
v6 = v5;
if ( *(v5 - 1) != 47 )
{
*(_WORD *)v5 = 47;
v6 = v5 + 1;
}
v7 = v29;
v8 = opendir(v29);
if ( !v8 )
{
v13 = *(_DWORD *)__errno_location(v29);
*(_DWORD *)my_thread_var(v29) = v13;
goto LABEL_11;
}
v9 = (_BYTE *)v8;
v28 = a2;
v10 = my_malloc(key_memory_MY_DIR, 120LL);
if ( !v10 )
goto LABEL_9;
v11 = v10;
v24 = v6;
v12 = v10 + 16;
if ( (unsigned __int8)init_dynamic_array2(key_memory_MY_DIR, v10 + 16, 0x10u, 0LL, 0x200u, 0x1000u, v28) )
goto LABEL_8;
v25 = v12;
v26 = v2;
v27 = v11 + 56;
init_alloc_root(key_memory_MY_DIR, v11 + 56, 0x8000LL, 0x8000LL, v28);
v15 = readdir64(v9);
if ( !v15 )
{
LABEL_30:
closedir(v9);
if ( _bittest((const signed __int32 *)&v28, 0xDu) )
my_qsort(*(_QWORD *)(v11 + 16), *(unsigned int *)(v11 + 24), *(unsigned int *)(v11 + 36), comp_names);
*(_QWORD *)v11 = *(_QWORD *)(v11 + 16);
*(_DWORD *)(v11 + 8) = *(_DWORD *)(v11 + 24);
return v11;
}
v16 = (_BYTE *)v15;
v17 = v28;
while ( 1 )
{
if ( v16[19] == 46 && (!v16[20] || v16[20] == 46 && !v16[21]) )
goto LABEL_29;
v18 = v16 + 19;
if ( (v17 & 0x4000) != 0 )
{
v19 = v22;
memset(v22, 0LL, sizeof(v22));
strcpy(v24, v18);
my_stat(v29, v22, v17);
if ( (v22[25] & 1) == 0 )
goto LABEL_29;
}
else
{
v19 = 0LL;
}
v23[0] = strdup_root(v27, v18);
if ( !v23[0] )
break;
if ( v19 )
{
v20 = memdup_root(v27, v19, 144LL);
if ( !v20 )
break;
}
else
{
v20 = 0LL;
}
v23[1] = v20;
if ( (unsigned __int8)insert_dynamic(v25, (long long)v23) )
break;
LABEL_29:
v16 = (_BYTE *)readdir64(v9);
if ( !v16 )
goto LABEL_30;
}
v2 = v26;
LABEL_8:
my_dirend(v11);
LABEL_9:
v7 = v9;
closedir(v9);
LOBYTE(a2) = v28;
LABEL_11:
if ( (a2 & 0x18) == 0 )
return 0LL;
v14 = (unsigned int *)my_thread_var(v7);
v11 = 0LL;
my_error(0xCu, 4LL, v2, *v14);
return v11;
}
| my_dir:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2e8
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP byte ptr [RDI],0x0
MOV R15,RSI
LEA RSI,[0x1635f8]
CMOVNZ RSI,RDI
LEA RDI,[RBP + -0x240]
MOV EDX,0x201
CALL 0x001610bc
MOV R12,RAX
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0012d41e
MOV word ptr [R12],0x2f
INC R12
LAB_0012d41e:
LEA RDI,[RBP + -0x240]
CALL 0x00124520
TEST RAX,RAX
JZ 0x0012d4ae
MOV R13,RAX
LEA RBX,[0x47bb44]
MOV EDI,dword ptr [RBX]
MOV qword ptr [RBP + -0x248],R15
OR R15,0x20
MOV ESI,0x78
MOV RDX,R15
CALL 0x0012d775
TEST RAX,RAX
JZ 0x0012d49d
MOV R15,RAX
MOV qword ptr [RBP + -0x268],R12
MOV R12,RBX
MOV EDI,dword ptr [RBX]
LEA RBX,[RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x248]
MOV qword ptr [RSP],RAX
MOV RSI,RBX
MOV EDX,0x10
XOR ECX,ECX
MOV R8D,0x200
MOV R9D,0x1000
CALL 0x00127294
TEST AL,AL
JZ 0x0012d4ed
LAB_0012d495:
MOV RDI,R15
CALL 0x0012d394
LAB_0012d49d:
MOV RDI,R13
CALL 0x001245b0
MOV R15,qword ptr [RBP + -0x248]
JMP 0x0012d4bc
LAB_0012d4ae:
CALL 0x00124060
MOV EBX,dword ptr [RAX]
CALL 0x0012ec32
MOV dword ptr [RAX],EBX
LAB_0012d4bc:
TEST R15B,0x18
JZ 0x0012d4e5
CALL 0x0012ec32
MOV ECX,dword ptr [RAX]
XOR R15D,R15D
MOV ESI,0x4
MOV EDI,0xc
MOV RDX,R14
XOR EAX,EAX
CALL 0x0012a00f
JMP 0x0012d65e
LAB_0012d4e5:
XOR R15D,R15D
JMP 0x0012d65e
LAB_0012d4ed:
MOV qword ptr [RBP + -0x260],RBX
MOV qword ptr [RBP + -0x258],R14
MOV EDI,dword ptr [R12]
MOV RSI,R15
ADD RSI,0x38
MOV EDX,0x8000
MOV ECX,0x8000
MOV qword ptr [RBP + -0x250],RSI
MOV R8,qword ptr [RBP + -0x248]
CALL 0x00132bb8
MOV RDI,R13
CALL 0x001241d0
TEST RAX,RAX
JZ 0x0012d625
MOV RBX,RAX
MOV R14,qword ptr [RBP + -0x248]
LAB_0012d53e:
CMP byte ptr [RBX + 0x13],0x2e
JNZ 0x0012d55f
MOVZX EAX,byte ptr [RBX + 0x14]
TEST EAX,EAX
JZ 0x0012d611
CMP EAX,0x2e
JNZ 0x0012d55f
CMP byte ptr [RBX + 0x15],0x0
JZ 0x0012d611
LAB_0012d55f:
ADD RBX,0x13
BT R14D,0xe
JC 0x0012d56f
XOR R12D,R12D
JMP 0x0012d5af
LAB_0012d56f:
MOV EDX,0x90
LEA R12,[RBP + -0x308]
MOV RDI,R12
XOR ESI,ESI
CALL 0x001241a0
MOV RDI,qword ptr [RBP + -0x268]
MOV RSI,RBX
CALL 0x001242a0
LEA RDI,[RBP + -0x240]
MOV RSI,R12
MOV RDX,R14
CALL 0x0012d693
TEST byte ptr [RBP + -0x2ef],0x1
JZ 0x0012d611
LAB_0012d5af:
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,RBX
CALL 0x001330aa
MOV qword ptr [RBP + -0x278],RAX
TEST RAX,RAX
JZ 0x0012d682
TEST R12,R12
JZ 0x0012d5f1
MOV EDX,0x90
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,R12
CALL 0x00133118
TEST RAX,RAX
JNZ 0x0012d5f3
JMP 0x0012d682
LAB_0012d5f1:
XOR EAX,EAX
LAB_0012d5f3:
MOV qword ptr [RBP + -0x270],RAX
MOV RDI,qword ptr [RBP + -0x260]
LEA RSI,[RBP + -0x278]
CALL 0x00127332
TEST AL,AL
JNZ 0x0012d682
LAB_0012d611:
MOV RDI,R13
CALL 0x001241d0
MOV RBX,RAX
TEST RAX,RAX
JNZ 0x0012d53e
LAB_0012d625:
MOV RDI,R13
CALL 0x001245b0
BT dword ptr [RBP + -0x248],0xd
JNC 0x0012d64f
MOV RDI,qword ptr [R15 + 0x10]
MOV ESI,dword ptr [R15 + 0x18]
MOV EDX,dword ptr [R15 + 0x24]
LEA RCX,[0x12d737]
CALL 0x00132334
LAB_0012d64f:
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [R15],RAX
MOV EAX,dword ptr [R15 + 0x18]
MOV dword ptr [R15 + 0x8],EAX
LAB_0012d65e:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012d68e
MOV RAX,R15
ADD RSP,0x2e8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012d682:
MOV R14,qword ptr [RBP + -0x258]
JMP 0x0012d495
LAB_0012d68e:
CALL 0x00124390
|
int8 * my_dir(char *param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
char cVar3;
char *pcVar4;
DIR *__dirp;
int8 *puVar5;
int *piVar6;
int4 *puVar7;
dirent64 *pdVar8;
long lVar9;
int1 *__s;
long in_FS_OFFSET;
int1 local_310 [25];
byte local_2f7;
long local_280;
long local_278;
char *local_270;
int8 *local_268;
char *local_260;
int8 *local_258;
ulong local_250;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar4 = ".";
if (*param_1 != '\0') {
pcVar4 = param_1;
}
pcVar4 = (char *)strnmov(local_248,pcVar4,0x201);
if (pcVar4[-1] != '/') {
pcVar4[0] = '/';
pcVar4[1] = '\0';
pcVar4 = pcVar4 + 1;
}
__dirp = opendir(local_248);
if (__dirp == (DIR *)0x0) {
piVar6 = __errno_location();
iVar1 = *piVar6;
piVar6 = (int *)_my_thread_var();
*piVar6 = iVar1;
}
else {
local_250 = param_2;
puVar5 = (int8 *)my_malloc(key_memory_MY_DIR,0x78,param_2 | 0x20);
if (puVar5 != (int8 *)0x0) {
local_270 = pcVar4;
cVar3 = init_dynamic_array2(key_memory_MY_DIR,puVar5 + 2,0x10,0,0x200,0x1000,local_250);
if (cVar3 == '\0') {
local_258 = puVar5 + 7;
local_268 = puVar5 + 2;
local_260 = param_1;
init_alloc_root(key_memory_MY_DIR,local_258,0x8000,0x8000,local_250);
pdVar8 = readdir64(__dirp);
uVar2 = local_250;
while (pdVar8 != (dirent64 *)0x0) {
if ((pdVar8->d_name[0] != '.') ||
((pdVar8->d_name[1] != '\0' &&
((pdVar8->d_name[1] != '.' || (pdVar8->d_name[2] != '\0')))))) {
if (((uint)uVar2 >> 0xe & 1) == 0) {
__s = (int1 *)0x0;
}
else {
__s = local_310;
memset(__s,0,0x90);
strcpy(local_270,pdVar8->d_name);
my_stat(local_248,__s,uVar2);
if ((local_2f7 & 1) == 0) goto LAB_0012d611;
}
local_280 = strdup_root(local_258,pdVar8->d_name);
param_1 = local_260;
if (local_280 == 0) goto LAB_0012d495;
if (__s == (int1 *)0x0) {
lVar9 = 0;
}
else {
lVar9 = memdup_root(local_258,__s,0x90);
param_1 = local_260;
if (lVar9 == 0) goto LAB_0012d495;
}
local_278 = lVar9;
cVar3 = insert_dynamic(local_268);
param_1 = local_260;
if (cVar3 != '\0') goto LAB_0012d495;
}
LAB_0012d611:
pdVar8 = readdir64(__dirp);
}
closedir(__dirp);
if (((uint)local_250 >> 0xd & 1) != 0) {
my_qsort(puVar5[2],*(int4 *)(puVar5 + 3),*(int4 *)((long)puVar5 + 0x24),
comp_names);
}
*puVar5 = puVar5[2];
*(int4 *)(puVar5 + 1) = *(int4 *)(puVar5 + 3);
goto LAB_0012d65e;
}
LAB_0012d495:
my_dirend(puVar5);
}
closedir(__dirp);
param_2 = local_250;
}
if ((param_2 & 0x18) == 0) {
puVar5 = (int8 *)0x0;
}
else {
puVar7 = (int4 *)_my_thread_var();
puVar5 = (int8 *)0x0;
my_error(0xc,4,param_1,*puVar7);
}
LAB_0012d65e:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return puVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
53,733 | common_log_entry::print(_IO_FILE*) const | monkey531[P]llama/common/log.cpp | void print(FILE * file = nullptr) const {
FILE * fcur = file;
if (!fcur) {
// stderr displays DBG messages only when their verbosity level is not higher than the threshold
// these messages will still be logged to a file
if (level == GGML_LOG_LEVEL_DEBUG && common_log_verbosity_thold < LOG_DEFAULT_DEBUG) {
return;
}
fcur = stdout;
if (level != GGML_LOG_LEVEL_NONE) {
fcur = stderr;
}
}
if (level != GGML_LOG_LEVEL_NONE && level != GGML_LOG_LEVEL_CONT && prefix) {
if (timestamp) {
// [M.s.ms.us]
fprintf(fcur, "%s%d.%02d.%03d.%03d%s ",
g_col[COMMON_LOG_COL_BLUE],
(int) (timestamp / 1000000 / 60),
(int) (timestamp / 1000000 % 60),
(int) (timestamp / 1000 % 1000),
(int) (timestamp % 1000),
g_col[COMMON_LOG_COL_DEFAULT]);
}
switch (level) {
case GGML_LOG_LEVEL_INFO: fprintf(fcur, "%sI %s", g_col[COMMON_LOG_COL_GREEN], g_col[COMMON_LOG_COL_DEFAULT]); break;
case GGML_LOG_LEVEL_WARN: fprintf(fcur, "%sW %s", g_col[COMMON_LOG_COL_MAGENTA], "" ); break;
case GGML_LOG_LEVEL_ERROR: fprintf(fcur, "%sE %s", g_col[COMMON_LOG_COL_RED], "" ); break;
case GGML_LOG_LEVEL_DEBUG: fprintf(fcur, "%sD %s", g_col[COMMON_LOG_COL_YELLOW], "" ); break;
default:
break;
}
}
fprintf(fcur, "%s", msg.data());
if (level == GGML_LOG_LEVEL_WARN || level == GGML_LOG_LEVEL_ERROR || level == GGML_LOG_LEVEL_DEBUG) {
fprintf(fcur, "%s", g_col[COMMON_LOG_COL_DEFAULT]);
}
fflush(fcur);
} | O3 | cpp | common_log_entry::print(_IO_FILE*) const:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
testq %rsi, %rsi
jne 0x8624c
cmpl $0x1, %eax
jne 0x86235
leaq 0x6add6(%rip), %rcx # 0xf1000
cmpl $0x0, (%rcx)
jg 0x86235
popq %rbx
popq %r14
popq %r15
retq
testl %eax, %eax
jne 0x86242
movq 0x69cf8(%rip), %rcx # 0xeff38
jmp 0x86249
movq 0x69d5f(%rip), %rcx # 0xeffa8
movq (%rcx), %r14
testl %eax, %eax
je 0x863c9
cmpl $0x5, %eax
je 0x863c9
cmpb $0x1, 0x4(%rbx)
jne 0x863c9
movq 0x8(%rbx), %r10
testq %r10, %r10
je 0x86350
movq 0x6ad8d(%rip), %r15 # 0xf1008
movq 0x28(%r15), %r9
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r10, %rax
imulq %rcx
movq %rdx, %rcx
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x12, %rcx
movabsq $-0x70d59cc6bc5928d7, %rdx # imm = 0x8F2A633943A6D729
movq %r10, %rax
imulq %rdx
addq %rcx, %r8
leaq (%rdx,%r10), %rcx
movq %rcx, %rax
shrq $0x3f, %rax
shrq $0x19, %rcx
addl %eax, %ecx
movabsq $-0x7777777777777777, %rdx # imm = 0x8888888888888889
movq %r8, %rax
imulq %rdx
addq %r8, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x5, %rdx
addl %eax, %edx
imull $0x3c, %edx, %eax
subl %eax, %r8d
movabsq $0x20c49ba5e353f7cf, %rsi # imm = 0x20C49BA5E353F7CF
movq %r10, %rax
imulq %rsi
movq %rdx, %r11
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r11
addq %rax, %r11
movq %r11, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x7, %rdx
addl %eax, %edx
imull $0x3e8, %edx, %eax # imm = 0x3E8
imull $0x3e8, %r11d, %edx # imm = 0x3E8
subl %eax, %r11d
subl %edx, %r10d
leaq 0x3b26f(%rip), %rsi # 0xc15a4
movq %r14, %rdi
movq %r9, %rdx
movl %r11d, %r9d
xorl %eax, %eax
pushq (%r15)
pushq %r10
callq 0x18980
addq $0x10, %rsp
movl (%rbx), %eax
decl %eax
cmpl $0x3, %eax
ja 0x863c9
leaq 0x3b236(%rip), %rcx # 0xc1594
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x6ac9a(%rip), %rax # 0xf1008
movq 0x20(%rax), %rdx
leaq 0x3b257(%rip), %rsi # 0xc15d0
jmp 0x863a1
movq 0x6ac86(%rip), %rax # 0xf1008
movq 0x30(%rax), %rdx
leaq 0x3b235(%rip), %rsi # 0xc15c2
jmp 0x863a1
movq 0x6ac72(%rip), %rax # 0xf1008
movq 0x10(%rax), %rdx
leaq 0x3b228(%rip), %rsi # 0xc15c9
leaq 0x2f093(%rip), %rcx # 0xb543b
jmp 0x863bf
movq 0x6ac57(%rip), %rax # 0xf1008
movq (%rax), %rcx
movq 0x18(%rax), %rdx
leaq 0x3b1fc(%rip), %rsi # 0xc15bb
movq %r14, %rdi
xorl %eax, %eax
callq 0x18980
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x18740
movl (%rbx), %eax
cmpl $0x4, %eax
ja 0x863f8
movl $0x1a, %ecx
btl %eax, %ecx
jae 0x863f8
movq 0x6ac1b(%rip), %rax # 0xf1008
movq (%rax), %rdi
movq %r14, %rsi
callq 0x18740
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x187b0
nop
| _ZNK16common_log_entry5printEP8_IO_FILE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov eax, [rdi]
test rsi, rsi
jnz short loc_8624C
cmp eax, 1
jnz short loc_86235
lea rcx, common_log_verbosity_thold
cmp dword ptr [rcx], 0
jg short loc_86235
pop rbx
pop r14
pop r15
retn
loc_86235:
test eax, eax
jnz short loc_86242
mov rcx, cs:stdout_ptr
jmp short loc_86249
loc_86242:
mov rcx, cs:stderr_ptr
loc_86249:
mov r14, [rcx]
loc_8624C:
test eax, eax
jz def_86365; jumptable 0000000000086365 default case
cmp eax, 5
jz def_86365; jumptable 0000000000086365 default case
cmp byte ptr [rbx+4], 1
jnz def_86365; jumptable 0000000000086365 default case
mov r10, [rbx+8]
test r10, r10
jz loc_86350
mov r15, cs:_ZL5g_col; g_col
mov r9, [r15+28h]
mov rcx, 431BDE82D7B634DBh
mov rax, r10
imul rcx
mov rcx, rdx
mov r8, rdx
shr r8, 3Fh
sar rcx, 12h
mov rdx, 8F2A633943A6D729h
mov rax, r10
imul rdx
add r8, rcx
lea rcx, [rdx+r10]
mov rax, rcx
shr rax, 3Fh
shr rcx, 19h
add ecx, eax
mov rdx, 8888888888888889h
mov rax, r8
imul rdx
add rdx, r8
mov rax, rdx
shr rax, 3Fh
shr rdx, 5
add edx, eax
imul eax, edx, 3Ch ; '<'
sub r8d, eax
mov rsi, 20C49BA5E353F7CFh
mov rax, r10
imul rsi
mov r11, rdx
mov rax, rdx
shr rax, 3Fh
sar r11, 7
add r11, rax
mov rax, r11
imul rsi
mov rax, rdx
shr rax, 3Fh
shr rdx, 7
add edx, eax
imul eax, edx, 3E8h
imul edx, r11d, 3E8h
sub r11d, eax
sub r10d, edx
lea rsi, aSD02d03d03dS; "%s%d.%02d.%03d.%03d%s "
mov rdi, r14
mov rdx, r9
mov r9d, r11d
xor eax, eax
push qword ptr [r15]
push r10
call _fprintf
add rsp, 10h
mov eax, [rbx]
loc_86350:
dec eax; switch 4 cases
cmp eax, 3
ja short def_86365; jumptable 0000000000086365 default case
lea rcx, jpt_86365
movsxd rax, ds:(jpt_86365 - 0C1594h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_86367:
mov rax, cs:_ZL5g_col; jumptable 0000000000086365 case 1
mov rdx, [rax+20h]
lea rsi, aSdS; "%sD %s"
jmp short loc_863A1
loc_8637B:
mov rax, cs:_ZL5g_col; jumptable 0000000000086365 case 3
mov rdx, [rax+30h]
lea rsi, aSwS; "%sW %s"
jmp short loc_863A1
loc_8638F:
mov rax, cs:_ZL5g_col; jumptable 0000000000086365 case 4
mov rdx, [rax+10h]
lea rsi, aSeS; "%sE %s"
loc_863A1:
lea rcx, aSJinja+16h; ""
jmp short loc_863BF
loc_863AA:
mov rax, cs:_ZL5g_col; jumptable 0000000000086365 case 2
mov rcx, [rax]
mov rdx, [rax+18h]
lea rsi, aSiS; "%sI %s"
loc_863BF:
mov rdi, r14
xor eax, eax
call _fprintf
def_86365:
mov rdi, [rbx+10h]; jumptable 0000000000086365 default case
mov rsi, r14
call _fputs
mov eax, [rbx]
cmp eax, 4
ja short loc_863F8
mov ecx, 1Ah
bt ecx, eax
jnb short loc_863F8
mov rax, cs:_ZL5g_col; g_col
mov rdi, [rax]
mov rsi, r14
call _fputs
loc_863F8:
mov rdi, r14
pop rbx
pop r14
pop r15
jmp _fflush
| long long common_log_entry::print(unsigned int *a1, long long a2)
{
long long v2; // r14
long long result; // rax
long long *v4; // rcx
long long v5; // r10
long long v6; // rdx
const char *v7; // rsi
char *v8; // rcx
int v9; // ecx
v2 = a2;
result = *a1;
if ( !a2 )
{
if ( (_DWORD)result == 1 && common_log_verbosity_thold[0] <= 0 )
return result;
if ( (_DWORD)result )
v4 = (long long *)&stderr;
else
v4 = (long long *)&stdout;
v2 = *v4;
}
if ( (_DWORD)result && (_DWORD)result != 5 && *((_BYTE *)a1 + 4) == 1 )
{
v5 = *((_QWORD *)a1 + 1);
if ( v5 )
{
fprintf(
v2,
"%s%d.%02d.%03d.%03d%s ",
*(const char **)(g_col + 40),
(int)v5 / 60000000,
(int)(v5 / 1000000) % 60,
(int)(v5 / 1000) % 1000,
v5 % 1000,
*(const char **)g_col);
LODWORD(result) = *a1;
}
switch ( (int)result )
{
case 1:
v6 = *(_QWORD *)(g_col + 32);
v7 = "%sD %s";
goto LABEL_17;
case 2:
v8 = *(char **)g_col;
v6 = *(_QWORD *)(g_col + 24);
v7 = "%sI %s";
goto LABEL_19;
case 3:
v6 = *(_QWORD *)(g_col + 48);
v7 = "%sW %s";
goto LABEL_17;
case 4:
v6 = *(_QWORD *)(g_col + 16);
v7 = "%sE %s";
LABEL_17:
v8 = "";
LABEL_19:
fprintf(v2, v7, v6, v8);
break;
default:
break;
}
}
fputs(*((_QWORD *)a1 + 2), v2);
if ( *a1 <= 4 )
{
v9 = 26;
if ( _bittest(&v9, *a1) )
fputs(*(_QWORD *)g_col, v2);
}
return fflush(v2);
}
| print:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RDI]
TEST RSI,RSI
JNZ 0x0018624c
CMP EAX,0x1
JNZ 0x00186235
LEA RCX,[0x1f1000]
CMP dword ptr [RCX],0x0
JG 0x00186235
POP RBX
POP R14
POP R15
RET
LAB_00186235:
TEST EAX,EAX
JNZ 0x00186242
MOV RCX,qword ptr [0x001eff38]
JMP 0x00186249
LAB_00186242:
MOV RCX,qword ptr [0x001effa8]
LAB_00186249:
MOV R14,qword ptr [RCX]
LAB_0018624c:
TEST EAX,EAX
JZ 0x001863c9
CMP EAX,0x5
JZ 0x001863c9
CMP byte ptr [RBX + 0x4],0x1
JNZ 0x001863c9
MOV R10,qword ptr [RBX + 0x8]
TEST R10,R10
JZ 0x00186350
MOV R15,qword ptr [0x001f1008]
MOV R9,qword ptr [R15 + 0x28]
MOV RCX,0x431bde82d7b634db
MOV RAX,R10
IMUL RCX
MOV RCX,RDX
MOV R8,RDX
SHR R8,0x3f
SAR RCX,0x12
MOV RDX,-0x70d59cc6bc5928d7
MOV RAX,R10
IMUL RDX
ADD R8,RCX
LEA RCX,[RDX + R10*0x1]
MOV RAX,RCX
SHR RAX,0x3f
SHR RCX,0x19
ADD ECX,EAX
MOV RDX,-0x7777777777777777
MOV RAX,R8
IMUL RDX
ADD RDX,R8
MOV RAX,RDX
SHR RAX,0x3f
SHR RDX,0x5
ADD EDX,EAX
IMUL EAX,EDX,0x3c
SUB R8D,EAX
MOV RSI,0x20c49ba5e353f7cf
MOV RAX,R10
IMUL RSI
MOV R11,RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR R11,0x7
ADD R11,RAX
MOV RAX,R11
IMUL RSI
MOV RAX,RDX
SHR RAX,0x3f
SHR RDX,0x7
ADD EDX,EAX
IMUL EAX,EDX,0x3e8
IMUL EDX,R11D,0x3e8
SUB R11D,EAX
SUB R10D,EDX
LEA RSI,[0x1c15a4]
MOV RDI,R14
MOV RDX,R9
MOV R9D,R11D
XOR EAX,EAX
PUSH qword ptr [R15]
PUSH R10
CALL 0x00118980
ADD RSP,0x10
MOV EAX,dword ptr [RBX]
LAB_00186350:
DEC EAX
CMP EAX,0x3
JA 0x001863c9
LEA RCX,[0x1c1594]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RAX,qword ptr [0x001f1008]
MOV RDX,qword ptr [RAX + 0x20]
LEA RSI,[0x1c15d0]
JMP 0x001863a1
caseD_3:
MOV RAX,qword ptr [0x001f1008]
MOV RDX,qword ptr [RAX + 0x30]
LEA RSI,[0x1c15c2]
JMP 0x001863a1
caseD_4:
MOV RAX,qword ptr [0x001f1008]
MOV RDX,qword ptr [RAX + 0x10]
LEA RSI,[0x1c15c9]
LAB_001863a1:
LEA RCX,[0x1b543b]
JMP 0x001863bf
caseD_2:
MOV RAX,qword ptr [0x001f1008]
MOV RCX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x18]
LEA RSI,[0x1c15bb]
LAB_001863bf:
MOV RDI,R14
XOR EAX,EAX
CALL 0x00118980
default:
MOV RDI,qword ptr [RBX + 0x10]
MOV RSI,R14
CALL 0x00118740
MOV EAX,dword ptr [RBX]
CMP EAX,0x4
JA 0x001863f8
MOV ECX,0x1a
BT ECX,EAX
JNC 0x001863f8
MOV RAX,qword ptr [0x001f1008]
MOV RDI,qword ptr [RAX]
MOV RSI,R14
CALL 0x00118740
LAB_001863f8:
MOV RDI,R14
POP RBX
POP R14
POP R15
JMP 0x001187b0
|
/* common_log_entry::print(_IO_FILE*) const */
void __thiscall common_log_entry::print(common_log_entry *this,_IO_FILE *param_1)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int8 *puVar4;
char *pcVar5;
int8 uVar6;
char *__format;
int iVar7;
iVar7 = *(int *)this;
if (param_1 == (_IO_FILE *)0x0) {
if ((iVar7 == 1) && (common_log_verbosity_thold < 1)) {
return;
}
puVar4 = (int8 *)PTR_stderr_001effa8;
if (iVar7 == 0) {
puVar4 = (int8 *)PTR_stdout_001eff38;
}
param_1 = (_IO_FILE *)*puVar4;
}
if (((iVar7 == 0) || (iVar7 == 5)) || (this[4] != (common_log_entry)0x1))
goto switchD_00186365_default;
lVar1 = *(long *)(this + 8);
if (lVar1 != 0) {
auVar3 = SEXT816(lVar1 / 1000000) * ZEXT816(0x8888888888888889);
auVar2 = SEXT816(lVar1 / 1000) * SEXT816(0x20c49ba5e353f7cf);
iVar7 = (int)(lVar1 / 1000);
fprintf(param_1,"%s%d.%02d.%03d.%03d%s ",g_col[5],
(ulong)(uint)((int)(SUB168(SEXT816(lVar1) * ZEXT816(0x8f2a633943a6d729),8) >> 0x19) -
(SUB164(SEXT816(lVar1) * ZEXT816(0x8f2a633943a6d729),0xc) >> 0x1f)),
(ulong)(uint)((int)(lVar1 / 1000000) +
((int)(auVar3._8_8_ >> 5) - (auVar3._12_4_ >> 0x1f)) * -0x3c),
(ulong)(uint)(iVar7 + ((int)(auVar2._8_8_ >> 7) - (auVar2._12_4_ >> 0x1f)) * -1000),
(ulong)(uint)((int)lVar1 + iVar7 * -1000),*g_col);
iVar7 = *(int *)this;
}
switch(iVar7) {
case 1:
uVar6 = g_col[4];
__format = "%sD %s";
break;
case 2:
pcVar5 = (char *)*g_col;
uVar6 = g_col[3];
__format = "%sI %s";
goto LAB_001863bf;
case 3:
uVar6 = g_col[6];
__format = "%sW %s";
break;
case 4:
uVar6 = g_col[2];
__format = "%sE %s";
break;
default:
goto switchD_00186365_default;
}
pcVar5 = "";
LAB_001863bf:
fprintf(param_1,__format,uVar6,pcVar5);
switchD_00186365_default:
fputs(*(char **)(this + 0x10),param_1);
if ((*(uint *)this < 5) && ((0x1aU >> (*(uint *)this & 0x1f) & 1) != 0)) {
fputs((char *)*g_col,param_1);
}
fflush(param_1);
return;
}
| |
53,734 | ImPlot3D::PopColormap(int) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d.cpp | void PopColormap(int count) {
ImPlot3DContext& gp = *GImPlot3D;
IM_ASSERT_USER_ERROR(count <= gp.ColormapModifiers.Size, "You can't pop more modifiers than have been pushed!");
while (count > 0) {
const ImPlot3DColormap& backup = gp.ColormapModifiers.back();
gp.Style.Colormap = backup;
gp.ColormapModifiers.pop_back();
count--;
}
} | O1 | cpp | ImPlot3D::PopColormap(int):
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x2e29a6(%rip), %r14 # 0x336c98
cmpl %edi, 0x1f8(%r14)
jge 0x54307
leaq 0x241250(%rip), %rdi # 0x295552
callq 0x2161f4
testl %ebx, %ebx
jle 0x54342
movq 0x200(%r14), %rax
movslq 0x1f8(%r14), %rcx
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
decl %ecx
incl %ebx
movl (%rax), %edx
movl %edx, 0x1d0(%r14)
movl %ecx, 0x1f8(%r14)
addq $-0x4, %rax
decl %ecx
decl %ebx
cmpl $0x1, %ebx
jg 0x54325
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN8ImPlot3D11PopColormapEi:
push r14
push rbx
push rax
mov ebx, edi
mov r14, cs:_ZN8ImPlot3D9GImPlot3DE; ImPlot3D::GImPlot3D
cmp [r14+1F8h], edi
jge short loc_54307
lea rdi, aYouCanTPopMore; "You can't pop more modifiers than have "...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_54307:
test ebx, ebx
jle short loc_54342
mov rax, [r14+200h]
movsxd rcx, dword ptr [r14+1F8h]
lea rax, [rax+rcx*4]
add rax, 0FFFFFFFFFFFFFFFCh
dec ecx
inc ebx
loc_54325:
mov edx, [rax]
mov [r14+1D0h], edx
mov [r14+1F8h], ecx
add rax, 0FFFFFFFFFFFFFFFCh
dec ecx
dec ebx
cmp ebx, 1
jg short loc_54325
loc_54342:
add rsp, 8
pop rbx
pop r14
retn
| _DWORD * ImPlot3D::PopColormap(ImPlot3D *this, const char *a2)
{
_DWORD *result; // rax
ImGui *v3; // r14
long long v4; // rcx
int v5; // ecx
int v6; // ebx
v3 = ImPlot3D::GImPlot3D;
if ( *((_DWORD *)ImPlot3D::GImPlot3D + 126) < (int)this )
result = (_DWORD *)ImGui::ErrorLog((ImGui *)"You can't pop more modifiers than have been pushed!", a2);
if ( (int)this > 0 )
{
v4 = *((int *)v3 + 126);
result = (_DWORD *)(*((_QWORD *)v3 + 64) + 4 * v4 - 4);
v5 = v4 - 1;
v6 = (_DWORD)this + 1;
do
{
*((_DWORD *)v3 + 116) = *result;
*((_DWORD *)v3 + 126) = v5;
--result;
--v5;
--v6;
}
while ( v6 > 1 );
}
return result;
}
| PopColormap:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,EDI
MOV R14,qword ptr [0x00436c98]
CMP dword ptr [R14 + 0x1f8],EDI
JGE 0x00154307
LEA RDI,[0x395552]
CALL 0x003161f4
LAB_00154307:
TEST EBX,EBX
JLE 0x00154342
MOV RAX,qword ptr [R14 + 0x200]
MOVSXD RCX,dword ptr [R14 + 0x1f8]
LEA RAX,[RAX + RCX*0x4]
ADD RAX,-0x4
DEC ECX
INC EBX
LAB_00154325:
MOV EDX,dword ptr [RAX]
MOV dword ptr [R14 + 0x1d0],EDX
MOV dword ptr [R14 + 0x1f8],ECX
ADD RAX,-0x4
DEC ECX
DEC EBX
CMP EBX,0x1
JG 0x00154325
LAB_00154342:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ImPlot3D::PopColormap(int) */
void ImPlot3D::PopColormap(int param_1)
{
long lVar1;
int4 *puVar2;
int iVar3;
int iVar4;
lVar1 = GImPlot3D;
if (*(int *)(GImPlot3D + 0x1f8) < param_1) {
ImGui::ErrorLog("You can\'t pop more modifiers than have been pushed!");
}
if (0 < param_1) {
iVar3 = *(int *)(lVar1 + 0x1f8);
puVar2 = (int4 *)(*(long *)(lVar1 + 0x200) + (long)iVar3 * 4);
iVar4 = param_1 + 1;
do {
iVar3 = iVar3 + -1;
puVar2 = puVar2 + -1;
*(int4 *)(lVar1 + 0x1d0) = *puVar2;
*(int *)(lVar1 + 0x1f8) = iVar3;
iVar4 = iVar4 + -1;
} while (1 < iVar4);
}
return;
}
| |
53,735 | JS_WriteSharedArrayBuffer | bluesky950520[P]quickjs/quickjs.c | static int JS_WriteSharedArrayBuffer(BCWriterState *s, JSValue obj)
{
JSObject *p = JS_VALUE_GET_OBJ(obj);
JSArrayBuffer *abuf = p->u.array_buffer;
assert(!abuf->detached); /* SharedArrayBuffer are never detached */
bc_put_u8(s, BC_TAG_SHARED_ARRAY_BUFFER);
bc_put_leb128(s, abuf->byte_length);
bc_put_leb128(s, abuf->max_byte_length);
bc_put_u64(s, (uintptr_t)abuf->data);
if (js_resize_array(s->ctx, (void **)&s->sab_tab, sizeof(s->sab_tab[0]),
&s->sab_tab_size, s->sab_tab_len + 1))
return -1;
/* keep the SAB pointer so that the user can clone it or free it */
s->sab_tab[s->sab_tab_len++] = abuf->data;
return 0;
} | O1 | c | JS_WriteSharedArrayBuffer:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rsi), %r15
leaq 0x8(%rdi), %r14
movq %r14, %rdi
movl $0x10, %esi
callq 0x1a8bc
movl (%r15), %esi
movq %r14, %rdi
callq 0x44c40
movl 0x4(%r15), %esi
movq %r14, %rdi
callq 0x44c40
movq 0x10(%r15), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %r14, %rdi
callq 0x1a80e
movl 0x68(%rbx), %r8d
cmpl %r8d, 0x6c(%rbx)
jle 0x44b60
movq 0x10(%r15), %rax
movq 0x60(%rbx), %rcx
movslq 0x68(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x68(%rbx)
movq %rax, (%rcx,%rdx,8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x60(%rbx), %rsi
leaq 0x6c(%rbx), %rcx
incl %r8d
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x428db
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x44b56
jmp 0x44b3e
| JS_WriteSharedArrayBuffer:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov r15, [rsi+30h]
lea r14, [rdi+8]
mov rdi, r14
mov esi, 10h
call dbuf_putc
mov esi, [r15]
mov rdi, r14
call dbuf_put_leb128
mov esi, [r15+4]
mov rdi, r14
call dbuf_put_leb128
mov rax, [r15+10h]
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
mov edx, 8
mov rdi, r14
call dbuf_put
mov r8d, [rbx+68h]
cmp [rbx+6Ch], r8d
jle short loc_44B60
loc_44B3E:
mov rax, [r15+10h]
mov rcx, [rbx+60h]
movsxd rdx, dword ptr [rbx+68h]
lea esi, [rdx+1]
mov [rbx+68h], esi
mov [rcx+rdx*8], rax
xor eax, eax
loc_44B56:
add rsp, 10h
pop rbx
pop r14
pop r15
retn
loc_44B60:
lea rsi, [rbx+60h]
lea rcx, [rbx+6Ch]
inc r8d
mov rdi, [rbx]
mov edx, 8
call js_realloc_array
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_44B56
jmp short loc_44B3E
| long long JS_WriteSharedArrayBuffer(long long a1, long long a2)
{
unsigned int *v2; // r15
int v3; // r8d
long long v4; // rax
long long v5; // rcx
long long v6; // rdx
long long result; // rax
int v8; // ecx
_QWORD v9[4]; // [rsp+8h] [rbp-20h] BYREF
v2 = *(unsigned int **)(a2 + 48);
dbuf_putc((_QWORD *)(a1 + 8), 16);
dbuf_put_leb128(a1 + 8, *v2);
dbuf_put_leb128(a1 + 8, v2[1]);
v9[0] = *((_QWORD *)v2 + 2);
dbuf_put((_QWORD *)(a1 + 8), (long long)v9, 8LL);
v3 = *(_DWORD *)(a1 + 104);
if ( *(_DWORD *)(a1 + 108) > v3
|| (v8 = js_realloc_array(*(_QWORD *)a1, (long long *)(a1 + 96), 8u, (_DWORD *)(a1 + 108), v3 + 1),
result = 0xFFFFFFFFLL,
!v8) )
{
v4 = *((_QWORD *)v2 + 2);
v5 = *(_QWORD *)(a1 + 96);
v6 = *(int *)(a1 + 104);
*(_DWORD *)(a1 + 104) = v6 + 1;
*(_QWORD *)(v5 + 8 * v6) = v4;
return 0LL;
}
return result;
}
| JS_WriteSharedArrayBuffer:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV R15,qword ptr [RSI + 0x30]
LEA R14,[RDI + 0x8]
MOV RDI,R14
MOV ESI,0x10
CALL 0x0011a8bc
MOV ESI,dword ptr [R15]
MOV RDI,R14
CALL 0x00144c40
MOV ESI,dword ptr [R15 + 0x4]
MOV RDI,R14
CALL 0x00144c40
MOV RAX,qword ptr [R15 + 0x10]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
MOV EDX,0x8
MOV RDI,R14
CALL 0x0011a80e
MOV R8D,dword ptr [RBX + 0x68]
CMP dword ptr [RBX + 0x6c],R8D
JLE 0x00144b60
LAB_00144b3e:
MOV RAX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [RBX + 0x60]
MOVSXD RDX,dword ptr [RBX + 0x68]
LEA ESI,[RDX + 0x1]
MOV dword ptr [RBX + 0x68],ESI
MOV qword ptr [RCX + RDX*0x8],RAX
XOR EAX,EAX
LAB_00144b56:
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
LAB_00144b60:
LEA RSI,[RBX + 0x60]
LEA RCX,[RBX + 0x6c]
INC R8D
MOV RDI,qword ptr [RBX]
MOV EDX,0x8
CALL 0x001428db
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x00144b56
JMP 0x00144b3e
|
int8 JS_WriteSharedArrayBuffer(int8 *param_1,long param_2)
{
int8 *puVar1;
int4 *puVar2;
int8 uVar3;
int iVar4;
int8 local_20;
puVar2 = *(int4 **)(param_2 + 0x30);
puVar1 = param_1 + 1;
dbuf_putc(puVar1,0x10);
dbuf_put_leb128(puVar1,*puVar2);
dbuf_put_leb128(puVar1,puVar2[1]);
local_20 = *(int8 *)(puVar2 + 4);
dbuf_put(puVar1,&local_20,8);
if ((*(int *)((long)param_1 + 0x6c) <= *(int *)(param_1 + 0xd)) &&
(iVar4 = js_realloc_array(*param_1,param_1 + 0xc,8,(long)param_1 + 0x6c,
*(int *)(param_1 + 0xd) + 1), iVar4 != 0)) {
return 0xffffffff;
}
uVar3 = *(int8 *)(puVar2 + 4);
iVar4 = *(int *)(param_1 + 0xd);
*(int *)(param_1 + 0xd) = iVar4 + 1;
*(int8 *)(param_1[0xc] + (long)iVar4 * 8) = uVar3;
return 0;
}
| |
53,736 | pocketflow::BaseNode<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::nullptr_t>::internalExec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | bool hasSuccessors() const override {
return !successors.empty();
} | O3 | c | pocketflow::BaseNode<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::nullptr_t>::internalExec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0xc413
movq %rax, 0x8(%rsp)
movq (%rcx), %rax
movq %rax, 0x18(%rsp)
jmp 0xc41a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rsi), %rdx
leaq 0x8(%rsp), %rax
movq %rdx, 0x8(%rax)
movq %rcx, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x58(%rcx)
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xc459
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5180
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xc47e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5180
movq %rbx, %rdi
callq 0x52a0
| _ZN10pocketflow8BaseNodeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEDnE12internalExecES6_:
push r14
push rbx
sub rsp, 28h
lea r14, [rsp+38h+var_20]
mov [r14-10h], r14
mov rax, [rsi]
lea rcx, [rsi+10h]
cmp rax, rcx
jz short loc_C413
mov [rsp+38h+var_30], rax
mov rax, [rcx]
mov [rsp+38h+var_20], rax
jmp short loc_C41A
loc_C413:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r14], xmm0
loc_C41A:
mov rdx, [rsi+8]
lea rax, [rsp+38h+var_30]
mov [rax+8], rdx
mov [rsi], rcx
mov qword ptr [rsi+8], 0
mov byte ptr [rsi+10h], 0
mov rcx, [rdi]
mov rsi, rax
call qword ptr [rcx+58h]
mov rbx, rax
mov rdi, [rsp+38h+var_30]; void *
cmp rdi, r14
jz short loc_C459
mov rsi, [rsp+38h+var_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C459:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r14
jz short loc_C47E
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C47E:
mov rdi, rbx
call __Unwind_Resume
| long long pocketflow::BaseNode<std::string,decltype(nullptr)>::internalExec(long long a1, long long a2)
{
_OWORD *v2; // rcx
long long v3; // rbx
void *v5[2]; // [rsp+8h] [rbp-30h] BYREF
_OWORD v6[2]; // [rsp+18h] [rbp-20h] BYREF
v5[0] = v6;
v2 = (_OWORD *)(a2 + 16);
if ( *(_QWORD *)a2 == a2 + 16 )
{
v6[0] = *v2;
}
else
{
v5[0] = *(void **)a2;
*(_QWORD *)&v6[0] = *(_QWORD *)v2;
}
v5[1] = *(void **)(a2 + 8);
*(_QWORD *)a2 = v2;
*(_QWORD *)(a2 + 8) = 0LL;
*(_BYTE *)(a2 + 16) = 0;
v3 = (*(long long ( **)(long long, void **))(*(_QWORD *)a1 + 88LL))(a1, v5);
if ( v5[0] != v6 )
operator delete(v5[0], *(_QWORD *)&v6[0] + 1LL);
return v3;
}
| internalExec:
PUSH R14
PUSH RBX
SUB RSP,0x28
LEA R14,[RSP + 0x18]
MOV qword ptr [R14 + -0x10],R14
MOV RAX,qword ptr [RSI]
LEA RCX,[RSI + 0x10]
CMP RAX,RCX
JZ 0x0010c413
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0010c41a
LAB_0010c413:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R14],XMM0
LAB_0010c41a:
MOV RDX,qword ptr [RSI + 0x8]
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RSI],RCX
MOV qword ptr [RSI + 0x8],0x0
MOV byte ptr [RSI + 0x10],0x0
MOV RCX,qword ptr [RDI]
LAB_0010c439:
MOV RSI,RAX
CALL qword ptr [RCX + 0x58]
LAB_0010c43f:
MOV RBX,RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R14
JZ 0x0010c459
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00105180
LAB_0010c459:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* pocketflow::BaseNode<std::__cxx11::string, decltype(nullptr)>::internalExec(std::__cxx11::string)
*/
int8 __thiscall
pocketflow::BaseNode<std::__cxx11::string,decltype(nullptr)>::internalExec
(BaseNode<std::__cxx11::string,decltype(nullptr)> *this,long *param_2)
{
long *plVar1;
int8 uVar2;
long *local_30;
long local_28;
long local_20;
int4 uStack_18;
int4 uStack_14;
plVar1 = param_2 + 2;
if ((long *)*param_2 == plVar1) {
local_20 = *plVar1;
uStack_18 = (int4)param_2[3];
uStack_14 = *(int4 *)((long)param_2 + 0x1c);
local_30 = &local_20;
}
else {
local_20 = *plVar1;
local_30 = (long *)*param_2;
}
local_28 = param_2[1];
*param_2 = (long)plVar1;
param_2[1] = 0;
*(int1 *)(param_2 + 2) = 0;
/* try { // try from 0010c439 to 0010c43e has its CatchHandler @ 0010c464 */
uVar2 = (**(code **)(*(long *)this + 0x58))(this,&local_30);
if (local_30 != &local_20) {
operator_delete(local_30,local_20 + 1);
}
return uVar2;
}
| |
53,737 | cpu_get_num_math() | monkey531[P]llama/common/common.cpp | int32_t cpu_get_num_math() {
#if defined(__x86_64__) && defined(__linux__) && !defined(__ANDROID__)
int n_cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (n_cpu < 1) {
return cpu_get_num_physical_cores();
}
if (is_hybrid_cpu()) {
cpu_set_t affinity;
if (!pthread_getaffinity_np(pthread_self(), sizeof(affinity), &affinity)) {
int result = cpu_count_math_cpus(n_cpu);
pthread_setaffinity_np(pthread_self(), sizeof(affinity), &affinity);
if (result > 0) {
return result;
}
}
}
#endif
return cpu_get_num_physical_cores();
} | O2 | cpp | cpu_get_num_math():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
pushq $0x54
popq %rdi
callq 0x26810
movq %rax, %rbx
testl %ebx, %ebx
jle 0x6f635
pushq $0x7
popq %rax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
testw %dx, %dx
jns 0x6f61a
callq 0x26ac0
movq %rax, %r14
leaq 0x88(%rsp), %rdx
movl $0x80, %esi
movq %rax, %rdi
callq 0x276a0
testl %eax, %eax
je 0x6f64b
callq 0x6f404
movl %eax, %ebp
movl %ebp, %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6f404
xorl %ebp, %ebp
movq %rsp, %r15
pushq $0x1a
popq %r12
xorl %r13d, %r13d
cmpl %ebx, %r13d
jge 0x6f6e6
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %r13d # imm = 0x3FF
ja 0x6f6a6
pushq $0x1
popq %rax
movl %r13d, %ecx
shlq %cl, %rax
movl %r13d, %ecx
shrl $0x6, %ecx
orq %rax, (%rsp,%rcx,8)
movl $0x80, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x27610
testl %eax, %eax
jne 0x6f6e3
movl %r12d, %eax
xorl %ecx, %ecx
movq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
andl $0xff000000, %eax # imm = 0xFF000000
xorl %ecx, %ecx
cmpl $0x20000000, %eax # imm = 0x20000000
setne %cl
addl %ecx, %ebp
addl %ecx, %r13d
incl %r13d
jmp 0x6f657
pushq $-0x1
popq %rbp
leaq 0x88(%rsp), %rdx
movl $0x80, %esi
movq %r14, %rdi
callq 0x27610
testl %ebp, %ebp
jg 0x6f621
jmp 0x6f61a
| _Z16cpu_get_num_mathv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
push 54h ; 'T'
pop rdi
call _sysconf
mov rbx, rax
test ebx, ebx
jle short loc_6F635
push 7
pop rax
xor ecx, ecx
mov rsi, rbx
cpuid
xchg rsi, rbx
test dx, dx
jns short loc_6F61A
call _pthread_self
mov r14, rax
lea rdx, [rsp+138h+var_B0]
mov esi, 80h
mov rdi, rax
call _pthread_getaffinity_np
test eax, eax
jz short loc_6F64B
loc_6F61A:
call _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
mov ebp, eax
loc_6F621:
mov eax, ebp
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6F635:
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _Z26cpu_get_num_physical_coresv; cpu_get_num_physical_cores(void)
loc_6F64B:
xor ebp, ebp
mov r15, rsp
push 1Ah
pop r12
xor r13d, r13d
loc_6F657:
cmp r13d, ebx
jge loc_6F6E6
xorps xmm0, xmm0
movaps [rsp+138h+var_C8], xmm0
movaps [rsp+138h+var_D8], xmm0
movaps [rsp+138h+var_E8], xmm0
movaps [rsp+138h+var_F8], xmm0
movaps [rsp+138h+var_108], xmm0
movaps [rsp+138h+var_118], xmm0
movaps [rsp+138h+var_128], xmm0
movaps [rsp+138h+var_138], xmm0
cmp r13d, 3FFh
ja short loc_6F6A6
push 1
pop rax
mov ecx, r13d
shl rax, cl
mov ecx, r13d
shr ecx, 6
or qword ptr [rsp+rcx*8+138h+var_138], rax
loc_6F6A6:
mov esi, 80h
mov rdi, r14
mov rdx, r15
call _pthread_setaffinity_np
test eax, eax
jnz short loc_6F6E3
mov eax, r12d
xor ecx, ecx
mov rsi, rbx
cpuid
xchg rsi, rbx
and eax, 0FF000000h
xor ecx, ecx
cmp eax, 20000000h
setnz cl
add ebp, ecx
add r13d, ecx
inc r13d
jmp loc_6F657
loc_6F6E3:
push 0FFFFFFFFFFFFFFFFh
pop rbp
loc_6F6E6:
lea rdx, [rsp+138h+var_B0]
mov esi, 80h
mov rdi, r14
call _pthread_setaffinity_np
test ebp, ebp
jg loc_6F621
jmp loc_6F61A
| long long cpu_get_num_math(void)
{
std::thread *v0; // rdi
long long v1; // rbx
long long v3; // rsi
long long v8; // rbx
long long v9; // rsi
long long v10; // rt0
long long v11; // r14
long long v12; // rcx
long long v13; // r8
long long v14; // r9
int v15; // ebp
unsigned int i; // r13d
long long v19; // rsi
__int128 v24; // [rsp+0h] [rbp-138h] BYREF
__int128 v25; // [rsp+10h] [rbp-128h]
__int128 v26; // [rsp+20h] [rbp-118h]
__int128 v27; // [rsp+30h] [rbp-108h]
__int128 v28; // [rsp+40h] [rbp-F8h]
__int128 v29; // [rsp+50h] [rbp-E8h]
__int128 v30; // [rsp+60h] [rbp-D8h]
__int128 v31; // [rsp+70h] [rbp-C8h]
_BYTE v32[176]; // [rsp+88h] [rbp-B0h] BYREF
v0 = (std::thread *)(off_50 + 4);
v1 = sysconf(84LL);
if ( (int)v1 <= 0 )
return cpu_get_num_physical_cores((std::thread *)((char *)off_50 + 4));
_RAX = 7LL;
v3 = v1;
__asm { cpuid }
v10 = v3;
v9 = _RBX;
v8 = v10;
if ( (_RDX & 0x8000u) == 0LL )
return (unsigned int)cpu_get_num_physical_cores(v0);
v11 = pthread_self(84LL, v9, _RDX, _RCX);
v0 = (std::thread *)v11;
if ( (unsigned int)pthread_getaffinity_np(v11, 128LL, v32) )
return (unsigned int)cpu_get_num_physical_cores(v0);
v15 = 0;
for ( i = 0; (int)i < (int)v8; i += v12 + 1 )
{
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v28 = 0LL;
v27 = 0LL;
v26 = 0LL;
v25 = 0LL;
v24 = 0LL;
if ( i <= 0x3FF )
*((_QWORD *)&v24 + (i >> 6)) |= 1LL << i;
if ( (unsigned int)((long long ( *)(long long, long long, __int128 *))pthread_setaffinity_np)(v11, 128LL, &v24) )
{
v15 = -1;
break;
}
_RAX = 26LL;
v19 = v8;
__asm { cpuid }
v8 = v19;
v12 = (_RAX & 0xFF000000) != 0x20000000;
v15 += v12;
}
v0 = (std::thread *)v11;
pthread_setaffinity_np(
v11,
128LL,
v32,
v12,
v13,
v14,
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26,
*((_QWORD *)&v26 + 1),
v27,
*((_QWORD *)&v27 + 1),
v28,
*((_QWORD *)&v28 + 1),
v29,
*((_QWORD *)&v29 + 1),
v30,
*((_QWORD *)&v30 + 1),
v31,
*((_QWORD *)&v31 + 1));
if ( v15 <= 0 )
return (unsigned int)cpu_get_num_physical_cores(v0);
return (unsigned int)v15;
}
| cpu_get_num_math:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
PUSH 0x54
POP RDI
CALL 0x00126810
MOV RBX,RAX
TEST EBX,EBX
JLE 0x0016f635
PUSH 0x7
POP RAX
XOR ECX,ECX
MOV RSI,RBX
CPUID
XCHG RBX,RSI
TEST DX,DX
JNS 0x0016f61a
CALL 0x00126ac0
MOV R14,RAX
LEA RDX,[RSP + 0x88]
MOV ESI,0x80
MOV RDI,RAX
CALL 0x001276a0
TEST EAX,EAX
JZ 0x0016f64b
LAB_0016f61a:
CALL 0x0016f404
MOV EBP,EAX
LAB_0016f621:
MOV EAX,EBP
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016f635:
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0016f404
LAB_0016f64b:
XOR EBP,EBP
MOV R15,RSP
PUSH 0x1a
POP R12
XOR R13D,R13D
LAB_0016f657:
CMP R13D,EBX
JGE 0x0016f6e6
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
CMP R13D,0x3ff
JA 0x0016f6a6
PUSH 0x1
POP RAX
MOV ECX,R13D
SHL RAX,CL
MOV ECX,R13D
SHR ECX,0x6
OR qword ptr [RSP + RCX*0x8],RAX
LAB_0016f6a6:
MOV ESI,0x80
MOV RDI,R14
MOV RDX,R15
CALL 0x00127610
TEST EAX,EAX
JNZ 0x0016f6e3
MOV EAX,R12D
XOR ECX,ECX
MOV RSI,RBX
CPUID
XCHG RBX,RSI
AND EAX,0xff000000
XOR ECX,ECX
CMP EAX,0x20000000
SETNZ CL
ADD EBP,ECX
ADD R13D,ECX
INC R13D
JMP 0x0016f657
LAB_0016f6e3:
PUSH -0x1
POP RBP
LAB_0016f6e6:
LEA RDX,[RSP + 0x88]
MOV ESI,0x80
MOV RDI,R14
CALL 0x00127610
TEST EBP,EBP
JG 0x0016f621
JMP 0x0016f61a
|
/* WARNING: Removing unreachable block (ram,0x0016f6c2) */
/* WARNING: Removing unreachable block (ram,0x0016f5ef) */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* cpu_get_num_math() */
ulong cpu_get_num_math(void)
{
long lVar1;
uint *puVar2;
uint uVar3;
int iVar4;
uint uVar5;
long lVar6;
pthread_t __th;
ulong uVar7;
uint uVar8;
cpu_set_t local_138;
cpu_set_t local_b0;
lVar6 = sysconf(0x54);
if ((int)lVar6 < 1) {
uVar7 = cpu_get_num_physical_cores();
return uVar7;
}
lVar1 = cpuid_Extended_Feature_Enumeration_info(7);
if ((short)*(int4 *)(lVar1 + 8) < 0) {
__th = pthread_self();
iVar4 = pthread_getaffinity_np(__th,0x80,&local_b0);
if (iVar4 == 0) {
uVar5 = 0;
for (uVar8 = 0; (int)uVar8 < (int)lVar6; uVar8 = uVar8 + uVar3 + 1) {
local_138.__bits[0xe] = 0;
local_138.__bits[0xf] = 0;
local_138.__bits[0xc] = 0;
local_138.__bits[0xd] = 0;
local_138.__bits[10] = 0;
local_138.__bits[0xb] = 0;
local_138.__bits[8] = 0;
local_138.__bits[9] = 0;
local_138.__bits[6] = 0;
local_138.__bits[7] = 0;
local_138.__bits[4] = 0;
local_138.__bits[5] = 0;
local_138.__bits[2] = 0;
local_138.__bits[3] = 0;
local_138.__bits[0] = 0;
local_138.__bits[1] = 0;
if (uVar8 < 0x400) {
local_138.__bits[uVar8 >> 6] = local_138.__bits[uVar8 >> 6] | 1L << ((byte)uVar8 & 0x3f);
}
iVar4 = pthread_setaffinity_np(__th,0x80,&local_138);
if (iVar4 != 0) {
uVar5 = 0xffffffff;
break;
}
puVar2 = (uint *)cpuid(0x1a);
uVar3 = (uint)((*puVar2 & 0xff000000) != 0x20000000);
uVar5 = uVar5 + uVar3;
}
pthread_setaffinity_np(__th,0x80,&local_b0);
if (0 < (int)uVar5) goto LAB_0016f621;
}
}
uVar5 = cpu_get_num_physical_cores();
LAB_0016f621:
return (ulong)uVar5;
}
| |
53,738 | httplib::ClientImpl::handle_request(httplib::Stream&, httplib::Request&, httplib::Response&, bool, httplib::Error&) | hkr04[P]cpp-mcp/common/httplib.h | inline bool ClientImpl::handle_request(Stream &strm, Request &req,
Response &res, bool close_connection,
Error &error) {
if (req.path.empty()) {
error = Error::Connection;
return false;
}
auto req_save = req;
bool ret;
if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) {
auto req2 = req;
req2.path = "http://" + host_and_port_ + req.path;
ret = process_request(strm, req2, res, close_connection, error);
req = req2;
req.path = req_save.path;
} else {
ret = process_request(strm, req, res, close_connection, error);
}
if (!ret) { return false; }
if (res.get_header_value("Connection") == "close" ||
(res.version == "HTTP/1.0" && res.reason != "Connection established")) {
// TODO this requires a not-entirely-obvious chain of calls to be correct
// for this to be safe.
// This is safe to call because handle_request is only called by send_
// which locks the request mutex during the process. It would be a bug
// to call it from a different thread since it's a thread-safety issue
// to do these things to the socket if another thread is using the socket.
std::lock_guard<std::mutex> guard(socket_mutex_);
shutdown_ssl(socket_, true);
shutdown_socket(socket_);
close_socket(socket_);
}
if (300 < res.status && res.status < 400 && follow_location_) {
req = req_save;
ret = redirect(req, res, error);
}
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
if ((res.status == StatusCode::Unauthorized_401 ||
res.status == StatusCode::ProxyAuthenticationRequired_407) &&
req.authorization_count_ < 5) {
auto is_proxy = res.status == StatusCode::ProxyAuthenticationRequired_407;
const auto &username =
is_proxy ? proxy_digest_auth_username_ : digest_auth_username_;
const auto &password =
is_proxy ? proxy_digest_auth_password_ : digest_auth_password_;
if (!username.empty() && !password.empty()) {
std::map<std::string, std::string> auth;
if (detail::parse_www_authenticate(res, auth, is_proxy)) {
Request new_req = req;
new_req.authorization_count_ += 1;
new_req.headers.erase(is_proxy ? "Proxy-Authorization"
: "Authorization");
new_req.headers.insert(detail::make_digest_authentication_header(
req, auth, new_req.authorization_count_, detail::random_string(10),
username, password, is_proxy));
Response new_res;
ret = send(new_req, new_res, error);
if (ret) { res = new_res; }
}
}
}
#endif
return ret;
} | O0 | c | httplib::ClientImpl::handle_request(httplib::Stream&, httplib::Request&, httplib::Response&, bool, httplib::Error&):
subq $0x6a8, %rsp # imm = 0x6A8
movb %r8b, %al
movq %rdi, 0x698(%rsp)
movq %rsi, 0x690(%rsp)
movq %rdx, 0x688(%rsp)
movq %rcx, 0x680(%rsp)
andb $0x1, %al
movb %al, 0x67f(%rsp)
movq %r9, 0x670(%rsp)
movq 0x698(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x688(%rsp), %rdi
addq $0x20, %rdi
callq 0xbce0
testb $0x1, %al
jne 0x8d4ff
jmp 0x8d51a
movq 0x670(%rsp), %rax
movl $0x2, (%rax)
movb $0x0, 0x6a7(%rsp)
jmp 0x8da10
movq 0x688(%rsp), %rsi
leaq 0x3b0(%rsp), %rdi
callq 0x8da30
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movb %al, 0x37(%rsp)
jmp 0x8d543
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x8d6f6
jmp 0x8d551
movq 0x38(%rsp), %rdi
addq $0x278, %rdi # imm = 0x278
callq 0xbce0
testb $0x1, %al
jne 0x8d6f6
movq 0x38(%rsp), %rax
cmpl $-0x1, 0x298(%rax)
je 0x8d6f6
movq 0x688(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x8da30
jmp 0x8d593
movq 0x38(%rsp), %rdx
addq $0x30, %rdx
leaq 0x45f03(%rip), %rsi # 0xd34a6
leaq 0x98(%rsp), %rdi
callq 0x218f0
jmp 0x8d5b2
movq 0x688(%rsp), %rdx
addq $0x20, %rdx
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x293d0
jmp 0x8d5d5
leaq 0xf8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
movq %rsi, 0x28(%rsp)
callq 0xb9e0
movq 0x28(%rsp), %rdi
callq 0xbfb0
leaq 0x98(%rsp), %rdi
callq 0xbfb0
movq 0x38(%rsp), %rdi
movq 0x690(%rsp), %rsi
movq 0x680(%rsp), %rcx
movq 0x670(%rsp), %r9
movzbl 0x67f(%rsp), %r8d
andl $0x1, %r8d
leaq 0xd8(%rsp), %rdx
callq 0x8e000
movb %al, 0x36(%rsp)
jmp 0x8d643
movb 0x36(%rsp), %al
andb $0x1, %al
movb %al, 0x3af(%rsp)
movq 0x688(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x8e6c0
jmp 0x8d667
leaq 0x3d0(%rsp), %rsi
movq 0x688(%rsp), %rdi
addq $0x20, %rdi
callq 0xb080
jmp 0x8d682
leaq 0xd8(%rsp), %rdi
callq 0x1a9f0
jmp 0x8d740
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
jmp 0x8da01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
jmp 0x8d6e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xbfb0
leaq 0xd8(%rsp), %rdi
callq 0x1a9f0
jmp 0x8da01
movq 0x38(%rsp), %rdi
movq 0x690(%rsp), %rsi
movq 0x688(%rsp), %rdx
movq 0x680(%rsp), %rcx
movq 0x670(%rsp), %r9
movzbl 0x67f(%rsp), %r8d
andl $0x1, %r8d
callq 0x8e000
movb %al, 0x27(%rsp)
jmp 0x8d733
movb 0x27(%rsp), %al
andb $0x1, %al
movb %al, 0x3af(%rsp)
testb $0x1, 0x3af(%rsp)
jne 0x8d762
movb $0x0, 0x6a7(%rsp)
movl $0x1, 0x94(%rsp)
jmp 0x8d9f2
movq 0x680(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xbe20
movq 0x18(%rsp), %rdx
leaq 0x406e0(%rip), %rsi # 0xcde6a
leaq 0x50(%rsp), %rdi
callq 0xf160
jmp 0x8d796
movq 0x10(%rsp), %rsi
leaq 0x4631e(%rip), %rcx # 0xd3ac0
xorl %eax, %eax
movl %eax, %r8d
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x24590
jmp 0x8d7b8
leaq 0x406b6(%rip), %rsi # 0xcde75
leaq 0x70(%rsp), %rdi
callq 0x17b50
movb %al, 0xf(%rsp)
jmp 0x8d7cf
movb 0xf(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x8d83b
jmp 0x8d7e0
movq 0x680(%rsp), %rdi
leaq 0x4068c(%rip), %rsi # 0xcde7b
callq 0x17b50
movb %al, 0xd(%rsp)
jmp 0x8d7fa
movb 0xd(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xc(%rsp)
jne 0x8d80b
jmp 0x8d833
movq 0x680(%rsp), %rdi
addq $0x28, %rdi
leaq 0x45c90(%rip), %rsi # 0xd34ae
callq 0x17c30
movb %al, 0xb(%rsp)
jmp 0x8d829
movb 0xb(%rsp), %al
movb %al, 0xc(%rsp)
jmp 0x8d833
movb 0xc(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xa(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xbfb0
leaq 0x50(%rsp), %rdi
callq 0xbfb0
leaq 0x4f(%rsp), %rdi
callq 0xb8e0
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x8d86e
jmp 0x8d95a
movq 0x38(%rsp), %rsi
addq $0x58, %rsi
leaq 0x40(%rsp), %rdi
callq 0xeee0
jmp 0x8d883
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
addq $0x50, %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0x8d89f
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
addq $0x50, %rsi
callq 0xef20
jmp 0x8d8b2
movq 0x38(%rsp), %rdi
movq %rdi, %rsi
addq $0x50, %rsi
callq 0xef50
jmp 0x8d8c5
leaq 0x40(%rsp), %rdi
callq 0xef90
jmp 0x8d95a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
jmp 0x8d928
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
jmp 0x8d91e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xbfb0
leaq 0x50(%rsp), %rdi
callq 0xbfb0
leaq 0x4f(%rsp), %rdi
callq 0xb8e0
jmp 0x8da01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x3a0(%rsp)
movl %eax, 0x39c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xef90
jmp 0x8da01
movq 0x680(%rsp), %rcx
movl $0x12c, %eax # imm = 0x12C
cmpl 0x20(%rcx), %eax
jge 0x8d9d7
movq 0x680(%rsp), %rax
cmpl $0x190, 0x20(%rax) # imm = 0x190
jge 0x8d9d7
movq 0x38(%rsp), %rax
testb $0x1, 0x221(%rax)
je 0x8d9d7
movq 0x688(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
callq 0x8e6c0
jmp 0x8d9a2
movq 0x38(%rsp), %rdi
movq 0x688(%rsp), %rsi
movq 0x680(%rsp), %rdx
movq 0x670(%rsp), %rcx
callq 0x8e930
movb %al, 0x9(%rsp)
jmp 0x8d9ca
movb 0x9(%rsp), %al
andb $0x1, %al
movb %al, 0x3af(%rsp)
movb 0x3af(%rsp), %al
andb $0x1, %al
movb %al, 0x6a7(%rsp)
movl $0x1, 0x94(%rsp)
leaq 0x3b0(%rsp), %rdi
callq 0x1a9f0
jmp 0x8da10
leaq 0x3b0(%rsp), %rdi
callq 0x1a9f0
jmp 0x8da21
movb 0x6a7(%rsp), %al
andb $0x1, %al
addq $0x6a8, %rsp # imm = 0x6A8
retq
movq 0x3a0(%rsp), %rdi
callq 0xbe10
nop
| _ZN7httplib10ClientImpl14handle_requestERNS_6StreamERNS_7RequestERNS_8ResponseEbRNS_5ErrorE:
sub rsp, 6A8h
mov al, r8b
mov qword ptr [rsp+6A8h+var_10], rdi
mov [rsp+6A8h+var_18], rsi
mov [rsp+6A8h+var_20], rdx
mov [rsp+6A8h+var_28], rcx
and al, 1
mov [rsp+6A8h+var_29], al
mov [rsp+6A8h+var_38], r9
mov rax, qword ptr [rsp+6A8h+var_10]
mov [rsp+6A8h+var_670], rax; int
mov rdi, [rsp+6A8h+var_20]
add rdi, 20h ; ' '
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_8D4FF
jmp short loc_8D51A
loc_8D4FF:
mov rax, [rsp+6A8h+var_38]
mov dword ptr [rax], 2
mov [rsp+6A8h+var_1], 0
jmp loc_8DA10
loc_8D51A:
mov rsi, [rsp+6A8h+var_20]; httplib::Request *
lea rdi, [rsp+6A8h+var_2F8]; this
call _ZN7httplib7RequestC2ERKS0_; httplib::Request::Request(httplib::Request const&)
mov rdi, [rsp+6A8h+var_670]
mov rax, [rdi]
mov rax, [rax+30h]
call rax
mov [rsp+6A8h+var_671], al
jmp short $+2
loc_8D543:
mov al, [rsp+6A8h+var_671]
test al, 1
jnz loc_8D6F6
jmp short $+2
loc_8D551:
mov rdi, [rsp+6A8h+var_670]
add rdi, 278h
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz loc_8D6F6
mov rax, [rsp+6A8h+var_670]
cmp dword ptr [rax+298h], 0FFFFFFFFh
jz loc_8D6F6
mov rsi, [rsp+6A8h+var_20]; httplib::Request *
lea rdi, [rsp+6A8h+var_5D0]; this
call _ZN7httplib7RequestC2ERKS0_; httplib::Request::Request(httplib::Request const&)
jmp short $+2
loc_8D593:
mov rdx, [rsp+6A8h+var_670]
add rdx, 30h ; '0'; int
lea rsi, aHttp; "http://"
lea rdi, [rsp+6A8h+var_610]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
jmp short $+2
loc_8D5B2:
mov rdx, [rsp+6A8h+var_20]
add rdx, 20h ; ' '
lea rdi, [rsp+6A8h+var_5F0]
lea rsi, [rsp+6A8h+var_610]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
jmp short $+2
loc_8D5D5:
lea rdi, [rsp+6A8h+var_5B0]
lea rsi, [rsp+6A8h+var_5F0]
mov [rsp+6A8h+var_680], rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+6A8h+var_680]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+6A8h+var_610]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+6A8h+var_670]
mov rsi, [rsp+6A8h+var_18]
mov rcx, [rsp+6A8h+var_28]
mov r9, [rsp+6A8h+var_38]
movzx r8d, [rsp+6A8h+var_29]
and r8d, 1
lea rdx, [rsp+6A8h+var_5D0]
call _ZN7httplib10ClientImpl15process_requestERNS_6StreamERNS_7RequestERNS_8ResponseEbRNS_5ErrorE; httplib::ClientImpl::process_request(httplib::Stream &,httplib::Request &,httplib::Response &,bool,httplib::Error &)
mov [rsp+6A8h+var_672], al
jmp short $+2
loc_8D643:
mov al, [rsp+6A8h+var_672]
and al, 1
mov [rsp+6A8h+var_2F9], al
mov rdi, [rsp+6A8h+var_20]
lea rsi, [rsp+6A8h+var_5D0]
call _ZN7httplib7RequestaSERKS0_; httplib::Request::operator=(httplib::Request const&)
jmp short $+2
loc_8D667:
lea rsi, [rsp+6A8h+var_2D8]
mov rdi, [rsp+6A8h+var_20]
add rdi, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_8D682:
lea rdi, [rsp+6A8h+var_5D0]; this
call _ZN7httplib7RequestD2Ev; httplib::Request::~Request()
jmp loc_8D740
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
jmp loc_8DA01
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
jmp short loc_8D6E4
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_8D6E4:
lea rdi, [rsp+arg_D0]; this
call _ZN7httplib7RequestD2Ev; httplib::Request::~Request()
jmp loc_8DA01
loc_8D6F6:
mov rdi, [rsp+6A8h+var_670]
mov rsi, [rsp+6A8h+var_18]
mov rdx, [rsp+6A8h+var_20]
mov rcx, [rsp+6A8h+var_28]
mov r9, [rsp+6A8h+var_38]
movzx r8d, [rsp+6A8h+var_29]
and r8d, 1
call _ZN7httplib10ClientImpl15process_requestERNS_6StreamERNS_7RequestERNS_8ResponseEbRNS_5ErrorE; httplib::ClientImpl::process_request(httplib::Stream &,httplib::Request &,httplib::Response &,bool,httplib::Error &)
mov [rsp+6A8h+var_681], al
jmp short $+2
loc_8D733:
mov al, [rsp+6A8h+var_681]
and al, 1
mov [rsp+6A8h+var_2F9], al
loc_8D740:
test [rsp+6A8h+var_2F9], 1
jnz short loc_8D762
mov [rsp+6A8h+var_1], 0
mov [rsp+6A8h+var_614], 1
jmp loc_8D9F2
loc_8D762:
mov rax, [rsp+6A8h+var_28]
mov [rsp+6A8h+var_698], rax
lea rdi, [rsp+6A8h+var_659]
mov [rsp+6A8h+var_690], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+6A8h+var_690]
lea rsi, aConnection; "Connection"
lea rdi, [rsp+6A8h+var_658]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_8D796:
mov rsi, [rsp+6A8h+var_698]
lea rcx, asc_D3ABE+2; ""
xor eax, eax
mov r8d, eax
lea rdi, [rsp+6A8h+var_638]
lea rdx, [rsp+6A8h+var_658]
call _ZNK7httplib8Response16get_header_valueERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcm; httplib::Response::get_header_value(std::string const&,char const*,ulong)
jmp short $+2
loc_8D7B8:
lea rsi, aClose_0; "close"
lea rdi, [rsp+6A8h+var_638]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+6A8h+var_699], al
jmp short $+2
loc_8D7CF:
mov cl, [rsp+6A8h+var_699]
mov al, 1
test cl, 1
mov [rsp+6A8h+var_69A], al
jnz short loc_8D83B
jmp short $+2
loc_8D7E0:
mov rdi, [rsp+6A8h+var_28]
lea rsi, aHttp10; "HTTP/1.0"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+6A8h+var_69B], al
jmp short $+2
loc_8D7FA:
mov cl, [rsp+6A8h+var_69B]
xor eax, eax
test cl, 1
mov [rsp+6A8h+var_69C], al
jnz short loc_8D80B
jmp short loc_8D833
loc_8D80B:
mov rdi, [rsp+6A8h+var_28]
add rdi, 28h ; '('
lea rsi, aConnectionEsta; "Connection established"
call _ZStneIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator!=<char>(std::string const&,char const*)
mov [rsp+6A8h+var_69D], al
jmp short $+2
loc_8D829:
mov al, [rsp+6A8h+var_69D]
mov [rsp+6A8h+var_69C], al
jmp short $+2
loc_8D833:
mov al, [rsp+6A8h+var_69C]
mov [rsp+6A8h+var_69A], al
loc_8D83B:
mov al, [rsp+6A8h+var_69A]
mov [rsp+6A8h+var_69E], al
lea rdi, [rsp+6A8h+var_638]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+6A8h+var_658]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+6A8h+var_659]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov al, [rsp+6A8h+var_69E]
test al, 1
jnz short loc_8D86E
jmp loc_8D95A
loc_8D86E:
mov rsi, [rsp+6A8h+var_670]
add rsi, 58h ; 'X'
lea rdi, [rsp+6A8h+var_668]
call _ZNSt10lock_guardISt5mutexEC2ERS0_; std::lock_guard<std::mutex>::lock_guard(std::mutex&)
jmp short $+2
loc_8D883:
mov rdi, [rsp+6A8h+var_670]
mov rsi, rdi
add rsi, 50h ; 'P'
mov rax, [rdi]
mov rax, [rax+20h]
mov edx, 1
call rax
jmp short $+2
loc_8D89F:
mov rdi, [rsp+6A8h+var_670]; this
mov rsi, rdi
add rsi, 50h ; 'P'; httplib::ClientImpl::Socket *
call _ZNK7httplib10ClientImpl15shutdown_socketERNS0_6SocketE; httplib::ClientImpl::shutdown_socket(httplib::ClientImpl::Socket &)
jmp short $+2
loc_8D8B2:
mov rdi, [rsp+6A8h+var_670]; this
mov rsi, rdi
add rsi, 50h ; 'P'; httplib::ClientImpl::Socket *
call _ZN7httplib10ClientImpl12close_socketERNS0_6SocketE; httplib::ClientImpl::close_socket(httplib::ClientImpl::Socket &)
jmp short $+2
loc_8D8C5:
lea rdi, [rsp+6A8h+var_668]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
jmp loc_8D95A
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
jmp short loc_8D928
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
jmp short loc_8D91E
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_8D91E:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_8D928:
lea rdi, [rsp+arg_47]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_8DA01
mov rcx, rax
mov eax, edx
mov [rsp+arg_398], rcx
mov [rsp+arg_394], eax
lea rdi, [rsp+arg_38]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
jmp loc_8DA01
loc_8D95A:
mov rcx, [rsp+6A8h+var_28]
mov eax, 12Ch
cmp eax, [rcx+20h]
jge short loc_8D9D7
mov rax, [rsp+6A8h+var_28]
cmp dword ptr [rax+20h], 190h
jge short loc_8D9D7
mov rax, [rsp+6A8h+var_670]
test byte ptr [rax+221h], 1
jz short loc_8D9D7
mov rdi, [rsp+6A8h+var_20]
lea rsi, [rsp+6A8h+var_2F8]
call _ZN7httplib7RequestaSERKS0_; httplib::Request::operator=(httplib::Request const&)
jmp short $+2
loc_8D9A2:
mov rdi, [rsp+6A8h+var_670]
mov rsi, [rsp+6A8h+var_20]
mov rdx, [rsp+6A8h+var_28]
mov rcx, [rsp+6A8h+var_38]
call _ZN7httplib10ClientImpl8redirectERNS_7RequestERNS_8ResponseERNS_5ErrorE; httplib::ClientImpl::redirect(httplib::Request &,httplib::Response &,httplib::Error &)
mov [rsp+6A8h+var_69F], al
jmp short $+2
loc_8D9CA:
mov al, [rsp+6A8h+var_69F]
and al, 1
mov [rsp+6A8h+var_2F9], al
loc_8D9D7:
mov al, [rsp+6A8h+var_2F9]
and al, 1
mov [rsp+6A8h+var_1], al
mov [rsp+6A8h+var_614], 1
loc_8D9F2:
lea rdi, [rsp+6A8h+var_2F8]; this
call _ZN7httplib7RequestD2Ev; httplib::Request::~Request()
jmp short loc_8DA10
loc_8DA01:
lea rdi, [rsp+arg_3A8]; this
call _ZN7httplib7RequestD2Ev; httplib::Request::~Request()
jmp short loc_8DA21
loc_8DA10:
mov al, [rsp+6A8h+var_1]
and al, 1
add rsp, 6A8h
retn
loc_8DA21:
mov rdi, [rsp+arg_398]
call __Unwind_Resume
| char httplib::ClientImpl::handle_request(
_BYTE *a1,
_BYTE *a2,
httplib::Request *a3,
long long a4,
char a5,
_DWORD *a6)
{
_BYTE *v6; // rsi
long long v7; // rdx
bool v9; // [rsp+Ch] [rbp-69Ch]
char v10; // [rsp+Eh] [rbp-69Ah]
long long v11; // [rsp+10h] [rbp-698h]
std::mutex *v12; // [rsp+40h] [rbp-668h] BYREF
char v13; // [rsp+4Fh] [rbp-659h] BYREF
_BYTE v14[32]; // [rsp+50h] [rbp-658h] BYREF
_BYTE v15[36]; // [rsp+70h] [rbp-638h] BYREF
int v16; // [rsp+94h] [rbp-614h]
int v17[8]; // [rsp+98h] [rbp-610h] BYREF
_BYTE v18[32]; // [rsp+B8h] [rbp-5F0h] BYREF
_BYTE v19[32]; // [rsp+D8h] [rbp-5D0h] BYREF
char v20[695]; // [rsp+F8h] [rbp-5B0h] BYREF
char v21; // [rsp+3AFh] [rbp-2F9h]
_BYTE v22[32]; // [rsp+3B0h] [rbp-2F8h] BYREF
_BYTE v23[672]; // [rsp+3D0h] [rbp-2D8h] BYREF
_DWORD *v24; // [rsp+670h] [rbp-38h]
char v25; // [rsp+67Fh] [rbp-29h]
long long v26; // [rsp+680h] [rbp-28h]
httplib::Request *v27; // [rsp+688h] [rbp-20h]
_BYTE *v28; // [rsp+690h] [rbp-18h]
int v29[2]; // [rsp+698h] [rbp-10h]
char v30; // [rsp+6A7h] [rbp-1h]
*(_QWORD *)v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5 & 1;
v24 = a6;
if ( (std::string::empty((char *)a3 + 32) & 1) != 0 )
{
*v24 = 2;
v30 = 0;
}
else
{
httplib::Request::Request((httplib::Request *)v22, v27);
if ( ((*(long long ( **)(_BYTE *))(*(_QWORD *)a1 + 48LL))(a1) & 1) != 0
|| (std::string::empty(a1 + 632) & 1) != 0
|| *((_DWORD *)a1 + 166) == -1 )
{
v6 = v28;
v21 = httplib::ClientImpl::process_request((_DWORD)a1, (_DWORD)v28, (_DWORD)v27, v26, v25 & 1, (_DWORD)v24) & 1;
}
else
{
httplib::Request::Request((httplib::Request *)v19, v27);
std::operator+<char>((long long)v17, (long long)"http://", (long long)(a1 + 48));
std::operator+<char>((long long)v18, (long long)v17, (long long)v27 + 32);
std::string::operator=(v20, v18);
std::string::~string(v18);
std::string::~string(v17);
v21 = httplib::ClientImpl::process_request((_DWORD)a1, (_DWORD)v28, (unsigned int)v19, v26, v25 & 1, (_DWORD)v24) & 1;
httplib::Request::operator=(v27, v19);
v6 = v23;
std::string::operator=((char *)v27 + 32, v23);
httplib::Request::~Request((httplib::Request *)v19);
}
if ( (v21 & 1) != 0 )
{
v11 = v26;
std::allocator<char>::allocator(&v13, v6, v7);
std::string::basic_string<std::allocator<char>>((long long)v14, (long long)"Connection", (long long)&v13);
httplib::Response::get_header_value((long long)v15, v11, (long long)v14, (long long)"", 0LL);
v10 = 1;
if ( !std::operator==<char>((long long)v15, (long long)"close") )
{
v9 = 0;
if ( std::operator==<char>(v26, (long long)"HTTP/1.0") )
v9 = std::operator!=<char>(v26 + 40, (long long)"Connection established");
v10 = v9;
}
std::string::~string(v15);
std::string::~string(v14);
std::allocator<char>::~allocator(&v13);
if ( (v10 & 1) != 0 )
{
std::lock_guard<std::mutex>::lock_guard(&v12, (std::mutex *)(a1 + 88));
(*(void ( **)(_BYTE *, _BYTE *, long long))(*(_QWORD *)a1 + 32LL))(a1, a1 + 80, 1LL);
httplib::ClientImpl::shutdown_socket((httplib::ClientImpl *)a1, (httplib::ClientImpl::Socket *)(a1 + 80));
httplib::ClientImpl::close_socket((httplib::ClientImpl *)a1, (httplib::ClientImpl::Socket *)(a1 + 80));
std::lock_guard<std::mutex>::~lock_guard(&v12);
}
if ( *(int *)(v26 + 32) > 300 && *(int *)(v26 + 32) < 400 && (a1[545] & 1) != 0 )
{
httplib::Request::operator=(v27, v22);
v21 = httplib::ClientImpl::redirect(a1, v27, v26, v24) & 1;
}
v30 = v21 & 1;
v16 = 1;
}
else
{
v30 = 0;
v16 = 1;
}
httplib::Request::~Request((httplib::Request *)v22);
}
return v30 & 1;
}
| handle_request:
SUB RSP,0x6a8
MOV AL,R8B
MOV qword ptr [RSP + 0x698],RDI
MOV qword ptr [RSP + 0x690],RSI
MOV qword ptr [RSP + 0x688],RDX
MOV qword ptr [RSP + 0x680],RCX
AND AL,0x1
MOV byte ptr [RSP + 0x67f],AL
MOV qword ptr [RSP + 0x670],R9
MOV RAX,qword ptr [RSP + 0x698]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x688]
ADD RDI,0x20
CALL 0x0010bce0
TEST AL,0x1
JNZ 0x0018d4ff
JMP 0x0018d51a
LAB_0018d4ff:
MOV RAX,qword ptr [RSP + 0x670]
MOV dword ptr [RAX],0x2
MOV byte ptr [RSP + 0x6a7],0x0
JMP 0x0018da10
LAB_0018d51a:
MOV RSI,qword ptr [RSP + 0x688]
LEA RDI,[RSP + 0x3b0]
CALL 0x0018da30
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x30]
LAB_0018d53b:
CALL RAX
MOV byte ptr [RSP + 0x37],AL
JMP 0x0018d543
LAB_0018d543:
MOV AL,byte ptr [RSP + 0x37]
TEST AL,0x1
JNZ 0x0018d6f6
JMP 0x0018d551
LAB_0018d551:
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,0x278
CALL 0x0010bce0
TEST AL,0x1
JNZ 0x0018d6f6
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x298],-0x1
JZ 0x0018d6f6
MOV RSI,qword ptr [RSP + 0x688]
LEA RDI,[RSP + 0xd8]
CALL 0x0018da30
JMP 0x0018d593
LAB_0018d593:
MOV RDX,qword ptr [RSP + 0x38]
ADD RDX,0x30
LAB_0018d59c:
LEA RSI,[0x1d34a6]
LEA RDI,[RSP + 0x98]
CALL 0x001218f0
JMP 0x0018d5b2
LAB_0018d5b2:
MOV RDX,qword ptr [RSP + 0x688]
ADD RDX,0x20
LAB_0018d5be:
LEA RDI,[RSP + 0xb8]
LEA RSI,[RSP + 0x98]
CALL 0x001293d0
JMP 0x0018d5d5
LAB_0018d5d5:
LEA RDI,[RSP + 0xf8]
LEA RSI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RSI
CALL 0x0010b9e0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0010bfb0
LEA RDI,[RSP + 0x98]
CALL 0x0010bfb0
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x690]
MOV RCX,qword ptr [RSP + 0x680]
MOV R9,qword ptr [RSP + 0x670]
MOVZX R8D,byte ptr [RSP + 0x67f]
LAB_0018d62c:
AND R8D,0x1
LEA RDX,[RSP + 0xd8]
CALL 0x0018e000
MOV byte ptr [RSP + 0x36],AL
JMP 0x0018d643
LAB_0018d643:
MOV AL,byte ptr [RSP + 0x36]
AND AL,0x1
MOV byte ptr [RSP + 0x3af],AL
MOV RDI,qword ptr [RSP + 0x688]
LEA RSI,[RSP + 0xd8]
CALL 0x0018e6c0
JMP 0x0018d667
LAB_0018d667:
LEA RSI,[RSP + 0x3d0]
MOV RDI,qword ptr [RSP + 0x688]
ADD RDI,0x20
CALL 0x0010b080
JMP 0x0018d682
LAB_0018d682:
LEA RDI,[RSP + 0xd8]
CALL 0x0011a9f0
JMP 0x0018d740
LAB_0018d6f6:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x690]
MOV RDX,qword ptr [RSP + 0x688]
MOV RCX,qword ptr [RSP + 0x680]
MOV R9,qword ptr [RSP + 0x670]
MOVZX R8D,byte ptr [RSP + 0x67f]
LAB_0018d724:
AND R8D,0x1
CALL 0x0018e000
MOV byte ptr [RSP + 0x27],AL
JMP 0x0018d733
LAB_0018d733:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
MOV byte ptr [RSP + 0x3af],AL
LAB_0018d740:
TEST byte ptr [RSP + 0x3af],0x1
JNZ 0x0018d762
MOV byte ptr [RSP + 0x6a7],0x0
MOV dword ptr [RSP + 0x94],0x1
JMP 0x0018d9f2
LAB_0018d762:
MOV RAX,qword ptr [RSP + 0x680]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0x4f]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0010be20
MOV RDX,qword ptr [RSP + 0x18]
LAB_0018d783:
LEA RSI,[0x1cde6a]
LEA RDI,[RSP + 0x50]
CALL 0x0010f160
JMP 0x0018d796
LAB_0018d796:
MOV RSI,qword ptr [RSP + 0x10]
LEA RCX,[0x1d3ac0]
XOR EAX,EAX
MOV R8D,EAX
LEA RDI,[RSP + 0x70]
LEA RDX,[RSP + 0x50]
CALL 0x00124590
JMP 0x0018d7b8
LAB_0018d7b8:
LEA RSI,[0x1cde75]
LEA RDI,[RSP + 0x70]
CALL 0x00117b50
MOV byte ptr [RSP + 0xf],AL
JMP 0x0018d7cf
LAB_0018d7cf:
MOV CL,byte ptr [RSP + 0xf]
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0xe],AL
JNZ 0x0018d83b
JMP 0x0018d7e0
LAB_0018d7e0:
MOV RDI,qword ptr [RSP + 0x680]
LEA RSI,[0x1cde7b]
CALL 0x00117b50
MOV byte ptr [RSP + 0xd],AL
JMP 0x0018d7fa
LAB_0018d7fa:
MOV CL,byte ptr [RSP + 0xd]
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0xc],AL
JNZ 0x0018d80b
JMP 0x0018d833
LAB_0018d80b:
MOV RDI,qword ptr [RSP + 0x680]
ADD RDI,0x28
LEA RSI,[0x1d34ae]
CALL 0x00117c30
MOV byte ptr [RSP + 0xb],AL
JMP 0x0018d829
LAB_0018d829:
MOV AL,byte ptr [RSP + 0xb]
MOV byte ptr [RSP + 0xc],AL
JMP 0x0018d833
LAB_0018d833:
MOV AL,byte ptr [RSP + 0xc]
MOV byte ptr [RSP + 0xe],AL
LAB_0018d83b:
MOV AL,byte ptr [RSP + 0xe]
MOV byte ptr [RSP + 0xa],AL
LEA RDI,[RSP + 0x70]
CALL 0x0010bfb0
LEA RDI,[RSP + 0x50]
CALL 0x0010bfb0
LEA RDI,[RSP + 0x4f]
CALL 0x0010b8e0
MOV AL,byte ptr [RSP + 0xa]
TEST AL,0x1
JNZ 0x0018d86e
JMP 0x0018d95a
LAB_0018d86e:
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x58
LAB_0018d877:
LEA RDI,[RSP + 0x40]
CALL 0x0010eee0
JMP 0x0018d883
LAB_0018d883:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RDI
ADD RSI,0x50
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x20]
LAB_0018d896:
MOV EDX,0x1
CALL RAX
JMP 0x0018d89f
LAB_0018d89f:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RDI
ADD RSI,0x50
CALL 0x0010ef20
JMP 0x0018d8b2
LAB_0018d8b2:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RDI
ADD RSI,0x50
CALL 0x0010ef50
JMP 0x0018d8c5
LAB_0018d8c5:
LEA RDI,[RSP + 0x40]
CALL 0x0010ef90
JMP 0x0018d95a
LAB_0018d95a:
MOV RCX,qword ptr [RSP + 0x680]
MOV EAX,0x12c
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x0018d9d7
MOV RAX,qword ptr [RSP + 0x680]
CMP dword ptr [RAX + 0x20],0x190
JGE 0x0018d9d7
MOV RAX,qword ptr [RSP + 0x38]
TEST byte ptr [RAX + 0x221],0x1
JZ 0x0018d9d7
MOV RDI,qword ptr [RSP + 0x688]
LAB_0018d993:
LEA RSI,[RSP + 0x3b0]
CALL 0x0018e6c0
JMP 0x0018d9a2
LAB_0018d9a2:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x688]
MOV RDX,qword ptr [RSP + 0x680]
MOV RCX,qword ptr [RSP + 0x670]
CALL 0x0018e930
LAB_0018d9c4:
MOV byte ptr [RSP + 0x9],AL
JMP 0x0018d9ca
LAB_0018d9ca:
MOV AL,byte ptr [RSP + 0x9]
AND AL,0x1
MOV byte ptr [RSP + 0x3af],AL
LAB_0018d9d7:
MOV AL,byte ptr [RSP + 0x3af]
AND AL,0x1
MOV byte ptr [RSP + 0x6a7],AL
MOV dword ptr [RSP + 0x94],0x1
LAB_0018d9f2:
LEA RDI,[RSP + 0x3b0]
CALL 0x0011a9f0
JMP 0x0018da10
LAB_0018da10:
MOV AL,byte ptr [RSP + 0x6a7]
AND AL,0x1
ADD RSP,0x6a8
RET
|
/* httplib::ClientImpl::handle_request(httplib::Stream&, httplib::Request&, httplib::Response&,
bool, httplib::Error&) */
ulong __thiscall
httplib::ClientImpl::handle_request
(ClientImpl *this,Stream *param_1,Request *param_2,Response *param_3,bool param_4,
Error *param_5)
{
Response *pRVar1;
byte bVar2;
bool bVar3;
ulong uVar4;
bool local_69c;
bool local_69a;
lock_guard<std::mutex> local_668 [15];
allocator local_659;
string local_658 [32];
string local_638 [36];
int4 local_614;
string local_610 [32];
string local_5f0 [32];
Request local_5d0 [32];
string local_5b0 [695];
byte local_2f9;
Request local_2f8 [32];
string local_2d8 [672];
Error *local_38;
byte local_29;
Response *local_28;
Request *local_20;
Stream *local_18;
ClientImpl *local_10;
byte local_1;
local_38 = param_5;
local_29 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
uVar4 = std::__cxx11::string::empty();
if ((uVar4 & 1) == 0) {
Request::Request(local_2f8,local_20);
/* try { // try from 0018d53b to 0018d590 has its CatchHandler @ 0018d694 */
bVar2 = (**(code **)(*(long *)this + 0x30))();
if ((((bVar2 & 1) == 0) && (uVar4 = std::__cxx11::string::empty(), (uVar4 & 1) == 0)) &&
(*(int *)(this + 0x298) != -1)) {
Request::Request(local_5d0,local_20);
/* try { // try from 0018d59c to 0018d5af has its CatchHandler @ 0018d6ad */
std::operator+((char *)local_610,(string *)"http://");
/* try { // try from 0018d5be to 0018d5d2 has its CatchHandler @ 0018d6c3 */
std::operator+(local_5f0,local_610);
std::__cxx11::string::operator=(local_5b0,local_5f0);
std::__cxx11::string::~string(local_5f0);
std::__cxx11::string::~string(local_610);
/* try { // try from 0018d62c to 0018d67f has its CatchHandler @ 0018d6ad */
local_2f9 = process_request(this,local_18,local_5d0,local_28,(bool)(local_29 & 1),local_38);
local_2f9 = local_2f9 & 1;
Request::operator=(local_20,local_5d0);
std::__cxx11::string::operator=((string *)(local_20 + 0x20),local_2d8);
Request::~Request(local_5d0);
}
else {
/* try { // try from 0018d724 to 0018d72c has its CatchHandler @ 0018d694 */
local_2f9 = process_request(this,local_18,local_20,local_28,(bool)(local_29 & 1),local_38);
local_2f9 = local_2f9 & 1;
}
pRVar1 = local_28;
if ((local_2f9 & 1) == 0) {
local_1 = 0;
}
else {
std::allocator<char>::allocator();
/* try { // try from 0018d783 to 0018d793 has its CatchHandler @ 0018d8d4 */
std::__cxx11::string::string<std::allocator<char>>(local_658,"Connection",&local_659);
/* try { // try from 0018d796 to 0018d7b5 has its CatchHandler @ 0018d8ea */
Response::get_header_value(local_638,(char *)pRVar1,(ulong)local_658);
/* try { // try from 0018d7b8 to 0018d822 has its CatchHandler @ 0018d900 */
bVar3 = std::operator==(local_638,"close");
local_69a = true;
if (!bVar3) {
bVar3 = std::operator==((string *)local_28,"HTTP/1.0");
local_69c = false;
if (bVar3) {
local_69c = std::operator!=((string *)(local_28 + 0x28),"Connection established");
}
local_69a = local_69c;
}
std::__cxx11::string::~string(local_638);
std::__cxx11::string::~string(local_658);
std::allocator<char>::~allocator((allocator<char> *)&local_659);
if (local_69a != false) {
/* try { // try from 0018d877 to 0018d880 has its CatchHandler @ 0018d694 */
std::lock_guard<std::mutex>::lock_guard(local_668,(mutex *)(this + 0x58));
/* try { // try from 0018d896 to 0018d8c2 has its CatchHandler @ 0018d937 */
(**(code **)(*(long *)this + 0x20))(this,this + 0x50,1);
shutdown_socket(this,(Socket *)(this + 0x50));
close_socket(this,(Socket *)(this + 0x50));
std::lock_guard<std::mutex>::~lock_guard(local_668);
}
if (((300 < *(int *)(local_28 + 0x20)) && (*(int *)(local_28 + 0x20) < 400)) &&
(((byte)this[0x221] & 1) != 0)) {
/* try { // try from 0018d993 to 0018d9c3 has its CatchHandler @ 0018d694 */
Request::operator=(local_20,local_2f8);
local_2f9 = redirect(this,local_20,local_28,local_38);
local_2f9 = local_2f9 & 1;
}
local_1 = local_2f9 & 1;
}
local_614 = 1;
local_38 = (Error *)Request::~Request(local_2f8);
}
else {
*(int4 *)local_38 = 2;
local_1 = 0;
}
return CONCAT71((int7)((ulong)local_38 >> 8),local_1) & 0xffffffffffffff01;
}
| |
53,739 | pfs_set_prepared_stmt_text_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_prepared_stmt_text_v1(PSI_prepared_stmt *prepared_stmt,
const char *text,
uint text_len)
{
PFS_prepared_stmt *pfs_prepared_stmt =
reinterpret_cast<PFS_prepared_stmt *>(prepared_stmt);
DBUG_ASSERT(pfs_prepared_stmt != NULL);
uint max_len = COL_INFO_SIZE;
if (text_len > max_len)
{
text_len = max_len;
}
memcpy(pfs_prepared_stmt->m_sqltext, text, text_len);
pfs_prepared_stmt->m_sqltext_length = text_len;
return;
} | O0 | cpp | pfs_set_prepared_stmt_text_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5629d
movl $0x400, -0x24(%rbp) # imm = 0x400
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x562b2
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
addq $0xe4, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x26280
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4e4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
| pfs_set_prepared_stmt_text_v1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
jmp short $+2
loc_5629D:
mov [rbp+var_24], 400h
mov eax, [rbp+var_14]
cmp eax, [rbp+var_24]
jbe short loc_562B2
mov eax, [rbp+var_24]
mov [rbp+var_14], eax
loc_562B2:
mov rdi, [rbp+var_20]
add rdi, 0E4h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+4E4h], ecx
add rsp, 30h
pop rbp
retn
| long long pfs_set_prepared_stmt_text_v1(long long a1, long long a2, unsigned int a3)
{
long long result; // rax
unsigned int v4; // [rsp+1Ch] [rbp-14h]
v4 = a3;
if ( a3 > 0x400 )
v4 = 1024;
memcpy(a1 + 228, a2, v4);
result = a1;
*(_DWORD *)(a1 + 1252) = v4;
return result;
}
| pfs_set_prepared_stmt_text_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015629d
LAB_0015629d:
MOV dword ptr [RBP + -0x24],0x400
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x24]
JBE 0x001562b2
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x14],EAX
LAB_001562b2:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0xe4
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x00126280
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x4e4],ECX
ADD RSP,0x30
POP RBP
RET
|
void pfs_set_prepared_stmt_text_v1(long param_1,void *param_2,uint param_3)
{
int4 local_1c;
local_1c = param_3;
if (0x400 < param_3) {
local_1c = 0x400;
}
memcpy((void *)(param_1 + 0xe4),param_2,(ulong)local_1c);
*(uint *)(param_1 + 0x4e4) = local_1c;
return;
}
| |
53,740 | find_line_num | bluesky950520[P]quickjs/quickjs.c | static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
uint32_t pc_value, int *col)
{
const uint8_t *p_end, *p;
int new_line_num, new_col_num, line_num, col_num, pc, v, ret;
unsigned int op;
*col = 1;
p = b->pc2line_buf;
if (!p)
goto fail;
p_end = p + b->pc2line_len;
pc = 0;
line_num = b->line_num;
col_num = b->col_num;
while (p < p_end) {
op = *p++;
if (op == 0) {
uint32_t val;
ret = get_leb128(&val, p, p_end);
if (ret < 0)
goto fail;
pc += val;
p += ret;
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_line_num = line_num + v;
} else {
op -= PC2LINE_OP_FIRST;
pc += (op / PC2LINE_RANGE);
new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
}
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_col_num = col_num + v;
if (pc_value < pc)
break;
line_num = new_line_num;
col_num = new_col_num;
}
*col = col_num;
return line_num;
fail:
/* should never happen */
return b->line_num;
} | O0 | c | find_line_num:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl $0x1, (%rax)
movq 0x50(%rsp), %rax
movq 0x80(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x72d10
jmp 0x72ebc
movq 0x30(%rsp), %rax
movq 0x50(%rsp), %rcx
movslq 0x78(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x50(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
movl 0x70(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x72ea7
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rsp)
movzbl (%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x72e03
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0xc(%rsp), %rdi
callq 0x72ff0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x72d9d
jmp 0x72ebc
movl 0xc(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x730d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x72de1
jmp 0x72ebc
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x24(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x2c(%rsp)
jmp 0x72e45
movl 0x10(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl 0x8(%rsp), %eax
addl %edx, %eax
addl $-0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x730d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x72e66
jmp 0x72ebc
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x20(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x72e92
jmp 0x72ea7
movl 0x2c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x72d46
movl 0x20(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movl 0x24(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x72ec8
movq 0x50(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| find_line_num:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov [rsp+68h+var_1C], edx
mov [rsp+68h+var_28], rcx
mov rax, [rsp+68h+var_28]
mov dword ptr [rax], 1
mov rax, [rsp+68h+var_18]
mov rax, [rax+80h]
mov [rsp+68h+var_38], rax
cmp [rsp+68h+var_38], 0
jnz short loc_72D10
jmp loc_72EBC
loc_72D10:
mov rax, [rsp+68h+var_38]
mov rcx, [rsp+68h+var_18]
movsxd rcx, dword ptr [rcx+78h]
add rax, rcx
mov [rsp+68h+var_30], rax
mov [rsp+68h+var_4C], 0
mov rax, [rsp+68h+var_18]
mov eax, [rax+6Ch]
mov [rsp+68h+var_44], eax
mov rax, [rsp+68h+var_18]
mov eax, [rax+70h]
mov [rsp+68h+var_48], eax
loc_72D46:
mov rax, [rsp+68h+var_38]
cmp rax, [rsp+68h+var_30]
jnb loc_72EA7
mov rax, [rsp+68h+var_38]
mov rcx, rax
add rcx, 1
mov [rsp+68h+var_38], rcx
movzx eax, byte ptr [rax]
mov [rsp+68h+var_58], eax
cmp [rsp+68h+var_58], 0
jnz loc_72E03
mov rsi, [rsp+68h+var_38]
mov rdx, [rsp+68h+var_30]
lea rdi, [rsp+68h+var_5C]
call get_leb128
mov [rsp+68h+var_54], eax
cmp [rsp+68h+var_54], 0
jge short loc_72D9D
jmp loc_72EBC
loc_72D9D:
mov eax, [rsp+68h+var_5C]
add eax, [rsp+68h+var_4C]
mov [rsp+68h+var_4C], eax
mov ecx, [rsp+68h+var_54]
mov rax, [rsp+68h+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rsp+68h+var_38], rax
mov rsi, [rsp+68h+var_38]
mov rdx, [rsp+68h+var_30]
lea rdi, [rsp+68h+var_50]
call get_sleb128
mov [rsp+68h+var_54], eax
cmp [rsp+68h+var_54], 0
jge short loc_72DE1
jmp loc_72EBC
loc_72DE1:
mov ecx, [rsp+68h+var_54]
mov rax, [rsp+68h+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rsp+68h+var_38], rax
mov eax, [rsp+68h+var_44]
add eax, [rsp+68h+var_50]
mov [rsp+68h+var_3C], eax
jmp short loc_72E45
loc_72E03:
mov eax, [rsp+68h+var_58]
sub eax, 1
mov [rsp+68h+var_58], eax
mov eax, [rsp+68h+var_58]
mov ecx, 5
xor edx, edx
div ecx
add eax, [rsp+68h+var_4C]
mov [rsp+68h+var_4C], eax
mov eax, [rsp+68h+var_44]
mov [rsp+68h+var_60], eax
mov eax, [rsp+68h+var_58]
mov ecx, 5
xor edx, edx
div ecx
mov eax, [rsp+68h+var_60]
add eax, edx
add eax, 0FFFFFFFFh
mov [rsp+68h+var_3C], eax
loc_72E45:
mov rsi, [rsp+68h+var_38]
mov rdx, [rsp+68h+var_30]
lea rdi, [rsp+68h+var_50]
call get_sleb128
mov [rsp+68h+var_54], eax
cmp [rsp+68h+var_54], 0
jge short loc_72E66
jmp short loc_72EBC
loc_72E66:
mov ecx, [rsp+68h+var_54]
mov rax, [rsp+68h+var_38]
movsxd rcx, ecx
add rax, rcx
mov [rsp+68h+var_38], rax
mov eax, [rsp+68h+var_48]
add eax, [rsp+68h+var_50]
mov [rsp+68h+var_40], eax
mov eax, [rsp+68h+var_1C]
cmp eax, [rsp+68h+var_4C]
jnb short loc_72E92
jmp short loc_72EA7
loc_72E92:
mov eax, [rsp+68h+var_3C]
mov [rsp+68h+var_44], eax
mov eax, [rsp+68h+var_40]
mov [rsp+68h+var_48], eax
jmp loc_72D46
loc_72EA7:
mov ecx, [rsp+68h+var_48]
mov rax, [rsp+68h+var_28]
mov [rax], ecx
mov eax, [rsp+68h+var_44]
mov [rsp+68h+var_4], eax
jmp short loc_72EC8
loc_72EBC:
mov rax, [rsp+68h+var_18]
mov eax, [rax+6Ch]
mov [rsp+68h+var_4], eax
loc_72EC8:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
| long long find_line_num(long long a1, long long a2, unsigned int a3, _DWORD *a4)
{
unsigned __int8 *v4; // rax
int v6; // [rsp+Ch] [rbp-5Ch] BYREF
unsigned int v7; // [rsp+10h] [rbp-58h]
int leb128; // [rsp+14h] [rbp-54h]
int v9; // [rsp+18h] [rbp-50h] BYREF
unsigned int v10; // [rsp+1Ch] [rbp-4Ch]
long long v11; // [rsp+20h] [rbp-48h]
long long v12; // [rsp+28h] [rbp-40h]
unsigned __int8 *v13; // [rsp+30h] [rbp-38h]
unsigned __int8 *v14; // [rsp+38h] [rbp-30h]
_DWORD *v15; // [rsp+40h] [rbp-28h]
unsigned int v16; // [rsp+4Ch] [rbp-1Ch]
long long v17; // [rsp+50h] [rbp-18h]
long long v18; // [rsp+58h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
*a4 = 1;
v13 = *(unsigned __int8 **)(v17 + 128);
if ( v13 )
{
v14 = &v13[*(int *)(v17 + 120)];
v10 = 0;
HIDWORD(v11) = *(_DWORD *)(v17 + 108);
LODWORD(v11) = *(_DWORD *)(v17 + 112);
while ( v13 < v14 )
{
v4 = v13++;
v7 = *v4;
if ( v7 )
{
v10 += --v7 / 5;
HIDWORD(v12) = v7 % 5 + HIDWORD(v11) - 1;
}
else
{
leb128 = get_leb128(&v6, v13, v14);
if ( leb128 < 0 )
return *(unsigned int *)(v17 + 108);
v10 += v6;
v13 += leb128;
leb128 = get_sleb128(&v9, v13, v14);
if ( leb128 < 0 )
return *(unsigned int *)(v17 + 108);
v13 += leb128;
HIDWORD(v12) = v9 + HIDWORD(v11);
}
leb128 = get_sleb128(&v9, v13, v14);
if ( leb128 < 0 )
return *(unsigned int *)(v17 + 108);
v13 += leb128;
LODWORD(v12) = v9 + v11;
if ( v16 < v10 )
break;
v11 = v12;
}
*v15 = v11;
return (unsigned int)HIDWORD(v11);
}
else
{
return *(unsigned int *)(v17 + 108);
}
}
| find_line_num:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV dword ptr [RSP + 0x4c],EDX
MOV qword ptr [RSP + 0x40],RCX
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RSP + 0x30],RAX
CMP qword ptr [RSP + 0x30],0x0
JNZ 0x00172d10
JMP 0x00172ebc
LAB_00172d10:
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x50]
MOVSXD RCX,dword ptr [RCX + 0x78]
ADD RAX,RCX
MOV qword ptr [RSP + 0x38],RAX
MOV dword ptr [RSP + 0x1c],0x0
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x6c]
MOV dword ptr [RSP + 0x24],EAX
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x70]
MOV dword ptr [RSP + 0x20],EAX
LAB_00172d46:
MOV RAX,qword ptr [RSP + 0x30]
CMP RAX,qword ptr [RSP + 0x38]
JNC 0x00172ea7
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x30],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x10],EAX
CMP dword ptr [RSP + 0x10],0x0
JNZ 0x00172e03
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LEA RDI,[RSP + 0xc]
CALL 0x00172ff0
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x0
JGE 0x00172d9d
JMP 0x00172ebc
LAB_00172d9d:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x1c],EAX
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LEA RDI,[RSP + 0x18]
CALL 0x001730d0
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x0
JGE 0x00172de1
JMP 0x00172ebc
LAB_00172de1:
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00172e45
LAB_00172e03:
MOV EAX,dword ptr [RSP + 0x10]
SUB EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
MOV EAX,dword ptr [RSP + 0x10]
MOV ECX,0x5
XOR EDX,EDX
DIV ECX
ADD EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x1c],EAX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x8],EAX
MOV EAX,dword ptr [RSP + 0x10]
MOV ECX,0x5
XOR EDX,EDX
DIV ECX
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,EDX
ADD EAX,-0x1
MOV dword ptr [RSP + 0x2c],EAX
LAB_00172e45:
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LEA RDI,[RSP + 0x18]
CALL 0x001730d0
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0x0
JGE 0x00172e66
JMP 0x00172ebc
LAB_00172e66:
MOV ECX,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV EAX,dword ptr [RSP + 0x20]
ADD EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x28],EAX
MOV EAX,dword ptr [RSP + 0x4c]
CMP EAX,dword ptr [RSP + 0x1c]
JNC 0x00172e92
JMP 0x00172ea7
LAB_00172e92:
MOV EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x24],EAX
MOV EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x00172d46
LAB_00172ea7:
MOV ECX,dword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x40]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0x64],EAX
JMP 0x00172ec8
LAB_00172ebc:
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x6c]
MOV dword ptr [RSP + 0x64],EAX
LAB_00172ec8:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
int find_line_num(int8 param_1,long param_2,uint param_3,int *param_4)
{
byte *pbVar1;
int local_5c;
uint local_58;
int local_54;
int local_50;
uint local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
byte *local_38;
byte *local_30;
int *local_28;
uint local_1c;
long local_18;
int8 local_10;
int local_4;
*param_4 = 1;
local_38 = *(byte **)(param_2 + 0x80);
local_18 = param_2;
if (local_38 == (byte *)0x0) {
LAB_00172ebc:
local_4 = *(int *)(local_18 + 0x6c);
}
else {
local_30 = local_38 + *(int *)(param_2 + 0x78);
local_4c = 0;
local_44 = *(int *)(param_2 + 0x6c);
local_48 = *(int *)(param_2 + 0x70);
local_28 = param_4;
local_1c = param_3;
local_10 = param_1;
while (local_38 < local_30) {
pbVar1 = local_38 + 1;
local_58 = (uint)*local_38;
local_38 = pbVar1;
if (local_58 == 0) {
local_54 = get_leb128(&local_5c,pbVar1,local_30);
if (local_54 < 0) goto LAB_00172ebc;
local_4c = local_5c + local_4c;
local_38 = local_38 + local_54;
local_54 = get_sleb128(&local_50,local_38,local_30);
if (local_54 < 0) goto LAB_00172ebc;
local_3c = local_44 + local_50;
local_38 = local_38 + local_54;
}
else {
local_58 = local_58 - 1;
local_4c = local_58 / 5 + local_4c;
local_3c = local_44 + local_58 % 5 + -1;
}
local_54 = get_sleb128(&local_50,local_38,local_30);
if (local_54 < 0) goto LAB_00172ebc;
local_38 = local_38 + local_54;
local_40 = local_48 + local_50;
if (local_1c < local_4c) break;
local_44 = local_3c;
local_48 = local_40;
}
*local_28 = local_48;
local_4 = local_44;
}
return local_4;
}
| |
53,741 | find_line_num | bluesky950520[P]quickjs/quickjs.c | static int find_line_num(JSContext *ctx, JSFunctionBytecode *b,
uint32_t pc_value, int *col)
{
const uint8_t *p_end, *p;
int new_line_num, new_col_num, line_num, col_num, pc, v, ret;
unsigned int op;
*col = 1;
p = b->pc2line_buf;
if (!p)
goto fail;
p_end = p + b->pc2line_len;
pc = 0;
line_num = b->line_num;
col_num = b->col_num;
while (p < p_end) {
op = *p++;
if (op == 0) {
uint32_t val;
ret = get_leb128(&val, p, p_end);
if (ret < 0)
goto fail;
pc += val;
p += ret;
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_line_num = line_num + v;
} else {
op -= PC2LINE_OP_FIRST;
pc += (op / PC2LINE_RANGE);
new_line_num = line_num + (op % PC2LINE_RANGE) + PC2LINE_BASE;
}
ret = get_sleb128(&v, p, p_end);
if (ret < 0)
goto fail;
p += ret;
new_col_num = col_num + v;
if (pc_value < pc)
break;
line_num = new_line_num;
col_num = new_col_num;
}
*col = col_num;
return line_num;
fail:
/* should never happen */
return b->line_num;
} | O1 | c | find_line_num:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rdx, 0x20(%rsp)
movl $0x1, (%rdx)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x434c3
movslq 0x78(%r14), %r15
movl 0x6c(%r14), %ecx
movl 0x70(%r14), %ebp
testq %r15, %r15
jle 0x434c9
movl %esi, %ebx
movq %rcx, 0x18(%rsp)
addq %rax, %r15
movl $0x0, 0xc(%rsp)
leaq 0x1(%rax), %r12
movzbl (%rax), %ecx
testl %ecx, %ecx
jne 0x43452
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %r15, %r12
jae 0x43401
addq $0x2, %rax
xorl %ecx, %ecx
xorl %edi, %edi
xorl %esi, %esi
movl %esi, %r8d
movzbl -0x1(%rax), %r9d
movl %r9d, %esi
andl $0x7f, %esi
shll %cl, %esi
orl %r8d, %esi
testb %r9b, %r9b
jns 0x434af
cmpl $0x3, %edi
ja 0x43401
incl %edi
addl $0x7, %ecx
leaq 0x1(%rax), %r8
cmpq %r15, %rax
movq %r8, %rax
jb 0x433cf
xorl %esi, %esi
testl %edx, %edx
jns 0x4347b
xorl %eax, %eax
testb %al, %al
je 0x434c3
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10d68
testl %eax, %eax
js 0x434c3
cmpl %ebx, 0xc(%rsp)
ja 0x434e5
addl 0x10(%rsp), %ebp
movl %eax, %eax
addq %rax, %r12
movl %r13d, %eax
movq %rax, 0x18(%rsp)
movq %r12, %rax
cmpq %r15, %r12
jb 0x433ac
jmp 0x434cc
decl %ecx
movq %rcx, %rax
movl $0xcccccccd, %edx # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x22, %rax
addl %eax, 0xc(%rsp)
leal (%rax,%rax,4), %eax
subl %eax, %ecx
movq 0x18(%rsp), %rax
leal (%rax,%rcx), %r13d
decl %r13d
jmp 0x43411
movl %ebx, 0x14(%rsp)
addl %esi, 0xc(%rsp)
movl %edx, %eax
addq %rax, %r12
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10d68
testl %eax, %eax
js 0x434b8
movl %eax, %eax
addq %rax, %r12
movl 0x10(%rsp), %r13d
addl 0x18(%rsp), %r13d
movb $0x1, %al
jmp 0x434ba
incl %edi
movl %edi, %edx
jmp 0x43403
xorl %eax, %eax
movl 0x14(%rsp), %ebx
jmp 0x43409
movl 0x6c(%r14), %r13d
jmp 0x434d3
movl %ecx, %r13d
movq 0x20(%rsp), %rax
movl %ebp, (%rax)
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rsp), %rax
movl %eax, %r13d
jmp 0x434cc
| find_line_num:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rdi
mov [rsp+58h+var_38], rdx
mov dword ptr [rdx], 1
mov rax, [rdi+80h]
test rax, rax
jz loc_434C3
movsxd r15, dword ptr [r14+78h]
mov ecx, [r14+6Ch]
mov ebp, [r14+70h]
test r15, r15
jle loc_434C9
mov ebx, esi
mov [rsp+58h+var_40], rcx
add r15, rax
mov [rsp+58h+var_4C], 0
loc_433AC:
lea r12, [rax+1]
movzx ecx, byte ptr [rax]
test ecx, ecx
jnz loc_43452
mov edx, 0FFFFFFFFh
cmp r12, r15
jnb short loc_43401
add rax, 2
xor ecx, ecx
xor edi, edi
xor esi, esi
loc_433CF:
mov r8d, esi
movzx r9d, byte ptr [rax-1]
mov esi, r9d
and esi, 7Fh
shl esi, cl
or esi, r8d
test r9b, r9b
jns loc_434AF
cmp edi, 3
ja short loc_43401
inc edi
add ecx, 7
lea r8, [rax+1]
cmp rax, r15
mov rax, r8
jb short loc_433CF
loc_43401:
xor esi, esi
loc_43403:
test edx, edx
jns short loc_4347B
xor eax, eax
loc_43409:
test al, al
jz loc_434C3
loc_43411:
lea rdi, [rsp+58h+var_48]
mov rsi, r12
mov rdx, r15
call get_sleb128
test eax, eax
js loc_434C3
cmp [rsp+58h+var_4C], ebx
ja loc_434E5
add ebp, [rsp+58h+var_48]
mov eax, eax
add r12, rax
mov eax, r13d
mov [rsp+58h+var_40], rax
mov rax, r12
cmp r12, r15
jb loc_433AC
jmp short loc_434CC
loc_43452:
dec ecx
mov rax, rcx
mov edx, 0CCCCCCCDh
imul rax, rdx
shr rax, 22h
add [rsp+58h+var_4C], eax
lea eax, [rax+rax*4]
sub ecx, eax
mov rax, [rsp+58h+var_40]
lea r13d, [rax+rcx]
dec r13d
jmp short loc_43411
loc_4347B:
mov [rsp+58h+var_44], ebx
add [rsp+58h+var_4C], esi
mov eax, edx
add r12, rax
lea rdi, [rsp+58h+var_48]
mov rsi, r12
mov rdx, r15
call get_sleb128
test eax, eax
js short loc_434B8
mov eax, eax
add r12, rax
mov r13d, [rsp+58h+var_48]
add r13d, dword ptr [rsp+58h+var_40]
mov al, 1
jmp short loc_434BA
loc_434AF:
inc edi
mov edx, edi
jmp loc_43403
loc_434B8:
xor eax, eax
loc_434BA:
mov ebx, [rsp+58h+var_44]
jmp loc_43409
loc_434C3:
mov r13d, [r14+6Ch]
jmp short loc_434D3
loc_434C9:
mov r13d, ecx
loc_434CC:
mov rax, [rsp+58h+var_38]
mov [rax], ebp
loc_434D3:
mov eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_434E5:
mov rax, [rsp+58h+var_40]
mov r13d, eax
jmp short loc_434CC
| long long find_line_num(long long a1, unsigned int a2, _DWORD *a3)
{
unsigned int v3; // r13d
_BYTE *v5; // rax
long long v6; // r15
int v7; // ebp
unsigned long long v9; // r15
unsigned long long v10; // r12
int v11; // edx
_BYTE *v12; // rax
char v13; // cl
unsigned int v14; // edi
int v15; // esi
char v17; // al
int v18; // eax
unsigned int v19; // ecx
int sleb128; // eax
unsigned int v22; // [rsp+Ch] [rbp-4Ch]
int v23; // [rsp+10h] [rbp-48h] BYREF
unsigned int v24; // [rsp+14h] [rbp-44h]
long long v25; // [rsp+18h] [rbp-40h]
_DWORD *v26; // [rsp+20h] [rbp-38h]
v26 = a3;
*a3 = 1;
v5 = *(_BYTE **)(a1 + 128);
if ( v5 )
{
v6 = *(int *)(a1 + 120);
v7 = *(_DWORD *)(a1 + 112);
if ( v6 <= 0 )
{
v3 = *(_DWORD *)(a1 + 108);
}
else
{
v25 = *(unsigned int *)(a1 + 108);
v9 = (unsigned long long)&v5[v6];
v22 = 0;
while ( 1 )
{
v10 = (unsigned long long)(v5 + 1);
if ( *v5 )
{
v19 = (unsigned __int8)*v5 - 1;
v22 += v19 / 5;
v3 = v25 + v19 % 5 - 1;
}
else
{
v11 = -1;
if ( v10 >= v9 )
{
LABEL_10:
v15 = 0;
}
else
{
v12 = v5 + 2;
v13 = 0;
v14 = 0;
v15 = 0;
while ( 1 )
{
v15 |= (*(v12 - 1) & 0x7F) << v13;
if ( (char)*(v12 - 1) >= 0 )
break;
if ( v14 <= 3 )
{
++v14;
v13 += 7;
if ( (unsigned long long)v12++ < v9 )
continue;
}
goto LABEL_10;
}
v11 = v14 + 1;
}
if ( v11 >= 0 )
{
v24 = a2;
v22 += v15;
v10 += (unsigned int)v11;
sleb128 = get_sleb128(&v23, v10, v9);
if ( sleb128 < 0 )
{
v17 = 0;
}
else
{
v10 += (unsigned int)sleb128;
v3 = v25 + v23;
v17 = 1;
}
a2 = v24;
}
else
{
v17 = 0;
}
if ( !v17 )
return *(unsigned int *)(a1 + 108);
}
v18 = get_sleb128(&v23, v10, v9);
if ( v18 < 0 )
return *(unsigned int *)(a1 + 108);
if ( v22 > a2 )
break;
v7 += v23;
v25 = v3;
v5 = (_BYTE *)((unsigned int)v18 + v10);
if ( (unsigned long long)v5 >= v9 )
goto LABEL_26;
}
v3 = v25;
}
LABEL_26:
*v26 = v7;
}
else
{
return *(unsigned int *)(a1 + 108);
}
return v3;
}
| |||
53,742 | myisam_log_command | eloqsql/storage/myisam/mi_log.c | void _myisam_log_command(enum myisam_log_commands command, MI_INFO *info,
const uchar *buffert, uint length, int result)
{
uchar buff[9];
int error,old_errno;
ulong pid=(ulong) GETPID();
old_errno=my_errno;
buff[0]=(char) command;
mi_int2store(buff+1,info->dfile);
mi_int4store(buff+3,pid);
mi_int2store(buff+7,result);
mysql_mutex_lock(&THR_LOCK_myisam);
error=my_lock(myisam_log_file,F_WRLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
(void) mysql_file_write(myisam_log_file, buff, sizeof(buff), MYF(0));
if (buffert)
(void) mysql_file_write(myisam_log_file, buffert, length, MYF(0));
if (!error)
error=my_lock(myisam_log_file,F_UNLCK,0L,F_TO_EOF,MYF(MY_SEEK_NOT_DONE));
mysql_mutex_unlock(&THR_LOCK_myisam);
my_errno=old_errno;
} | O3 | c | myisam_log_command:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, -0x40(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movl %r8d, %r14d
movl %edi, %r13d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, 0xb88ae2(%rip) # 0xc087d8
jne 0x7fd01
movq 0xb88ad1(%rip), %rbx # 0xc087d0
jmp 0x7fd09
callq 0xa8620
movq %rax, %rbx
callq 0xa8156
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movb %r13b, -0x39(%rbp)
movl 0x1c0(%r15), %eax
movb %al, -0x37(%rbp)
movb %ah, -0x38(%rbp)
movb %bl, -0x33(%rbp)
movb %bh, -0x34(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0x35(%rbp)
shrl $0x18, %ebx
movb %bl, -0x36(%rbp)
movl %r14d, %eax
movb %al, -0x31(%rbp)
movb %ah, -0x32(%rbp)
leaq 0xb91c88(%rip), %rax # 0xc119d0
cmpq $0x0, 0x40(%rax)
jne 0x7fe62
leaq 0xb91c76(%rip), %rdi # 0xc119d0
callq 0x2a220
leaq 0x30e79a(%rip), %r13 # 0x38e500
movl (%r13), %edi
movl $0x20, %r8d
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa6188
movl %eax, %r15d
movl (%r13), %ebx
leaq 0x30f4cc(%rip), %rax # 0x38f258
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7fe6c
leaq -0x39(%rbp), %rsi
movl $0x9, %edx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x30a78
testq %r12, %r12
je 0x7fe01
movl (%r13), %ebx
movl -0x40(%rbp), %r14d
leaq 0x30f486(%rip), %rax # 0x38f258
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x7, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7fe91
movl %ebx, %edi
movq %r12, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x30a78
testl %r15d, %r15d
jne 0x7fe1e
movl (%r13), %edi
movl $0x20, %r8d
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa6188
leaq 0xb91bab(%rip), %rax # 0xc119d0
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0x7fe7f
leaq 0xb91b9b(%rip), %rdi # 0xc119d0
callq 0x2a1e0
callq 0xa8156
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x7fea6
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2edd6
jmp 0x7fd5f
leaq -0x39(%rbp), %rdx
movq %rax, %rdi
movl %ebx, %esi
callq 0x2edf3
jmp 0x7fdbe
leaq 0x30f3d2(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x7fe2e
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x2ee6b
jmp 0x7fe01
callq 0x2a270
| _myisam_log_command:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_40], ecx
mov r12, rdx
mov r15, rsi
mov r14d, r8d
mov r13d, edi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp cs:log_type, 1
jnz short loc_7FD01
mov rbx, cs:myisam_pid
jmp short loc_7FD09
loc_7FD01:
call my_thread_dbug_id
mov rbx, rax
loc_7FD09:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_44], eax
mov [rbp+var_39], r13b
mov eax, [r15+1C0h]
mov [rbp+var_37], al
mov [rbp+var_38], ah
mov [rbp+var_33], bl
mov [rbp+var_34], bh
mov eax, ebx
shr eax, 10h
mov [rbp+var_35], al
shr ebx, 18h
mov [rbp+var_36], bl
mov eax, r14d
mov [rbp+var_31], al
mov [rbp+var_32], ah
lea rax, THR_LOCK_myisam
cmp qword ptr [rax+40h], 0
jnz loc_7FE62
lea rdi, THR_LOCK_myisam
call _pthread_mutex_lock
loc_7FD5F:
lea r13, myisam_log_file
mov edi, [r13+0]
mov r8d, 20h ; ' '
mov esi, 1
xor edx, edx
xor ecx, ecx
call my_lock
mov r15d, eax
mov ebx, [r13+0]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_7FE6C
lea rsi, [rbp+var_39]
mov edx, 9
mov edi, ebx
xor ecx, ecx
call my_write
loc_7FDBE:
test r12, r12
jz short loc_7FE01
mov ebx, [r13+0]
mov r14d, [rbp+var_40]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 7
call qword ptr [rax+158h]
test rax, rax
jnz loc_7FE91
mov edi, ebx
mov rsi, r12
mov rdx, r14
xor ecx, ecx
call my_write
loc_7FE01:
test r15d, r15d
jnz short loc_7FE1E
mov edi, [r13+0]
mov r8d, 20h ; ' '
mov esi, 2
xor edx, edx
xor ecx, ecx
call my_lock
loc_7FE1E:
lea rax, THR_LOCK_myisam
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_7FE7F
loc_7FE2E:
lea rdi, THR_LOCK_myisam
call _pthread_mutex_unlock
call _my_thread_var
mov ecx, [rbp+var_44]
mov [rax], ecx
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_7FEA6
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7FE62:
call _myisam_log_command_cold_1
jmp loc_7FD5F
loc_7FE6C:
lea rdx, [rbp+var_39]
mov rdi, rax
mov esi, ebx
call _myisam_log_command_cold_2
jmp loc_7FDBE
loc_7FE7F:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_7FE2E
loc_7FE91:
mov rdi, rax
mov rsi, r14
mov edx, ebx
mov rcx, r12
call _myisam_log_command_cold_3
jmp loc_7FE01
loc_7FEA6:
call ___stack_chk_fail
| unsigned long long myisam_log_command(long long a1, long long a2, long long a3, unsigned int a4, __int16 a5)
{
int v7; // ebx
__int16 v8; // kr00_2
int v9; // r15d
unsigned int v10; // ebx
long long v11; // rax
unsigned int v12; // ebx
long long v13; // r14
long long v14; // rax
_DWORD *v15; // rax
_BYTE v17[76]; // [rsp+0h] [rbp-90h] BYREF
int v18; // [rsp+4Ch] [rbp-44h]
unsigned int v19; // [rsp+50h] [rbp-40h]
_BYTE v20[9]; // [rsp+57h] [rbp-39h] BYREF
unsigned long long v21; // [rsp+60h] [rbp-30h]
v19 = a4;
v21 = __readfsqword(0x28u);
if ( log_type == 1 )
v7 = myisam_pid;
else
v7 = my_thread_dbug_id();
v18 = *(_DWORD *)my_thread_var(a1);
v20[0] = a1;
v8 = *(_DWORD *)(a2 + 448);
v20[1] = HIBYTE(v8);
v20[2] = v8;
v20[5] = BYTE1(v7);
v20[6] = v7;
v20[4] = BYTE2(v7);
v20[3] = HIBYTE(v7);
v20[7] = HIBYTE(a5);
v20[8] = a5;
if ( THR_LOCK_myisam[8] )
myisam_log_command_cold_1();
else
pthread_mutex_lock(THR_LOCK_myisam);
v9 = my_lock(myisam_log_file, 1LL, 0LL, 0LL, 32LL);
v10 = myisam_log_file;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v17, myisam_log_file, 7LL);
if ( v11 )
myisam_log_command_cold_2(v11, v10, (long long)v20);
else
my_write(v10, (long long)v20, 9LL, 0LL);
if ( a3 )
{
v12 = myisam_log_file;
v13 = v19;
v14 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v17, myisam_log_file, 7LL);
if ( v14 )
myisam_log_command_cold_3(v14, v13, v12, a3);
else
my_write(v12, a3, v13, 0LL);
}
if ( !v9 )
my_lock(myisam_log_file, 2LL, 0LL, 0LL, 32LL);
if ( THR_LOCK_myisam[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_myisam);
v15 = (_DWORD *)my_thread_var(THR_LOCK_myisam);
*v15 = v18;
return __readfsqword(0x28u);
}
| _myisam_log_command:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RBP + -0x40],ECX
MOV R12,RDX
MOV R15,RSI
MOV R14D,R8D
MOV R13D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [0x00d087d8],0x1
JNZ 0x0017fd01
MOV RBX,qword ptr [0x00d087d0]
JMP 0x0017fd09
LAB_0017fd01:
CALL 0x001a8620
MOV RBX,RAX
LAB_0017fd09:
CALL 0x001a8156
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV byte ptr [RBP + -0x39],R13B
MOV EAX,dword ptr [R15 + 0x1c0]
MOV byte ptr [RBP + -0x37],AL
MOV byte ptr [RBP + -0x38],AH
MOV byte ptr [RBP + -0x33],BL
MOV byte ptr [RBP + -0x34],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RBP + -0x35],AL
SHR EBX,0x18
MOV byte ptr [RBP + -0x36],BL
MOV EAX,R14D
MOV byte ptr [RBP + -0x31],AL
MOV byte ptr [RBP + -0x32],AH
LEA RAX,[0xd119d0]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x0017fe62
LEA RDI,[0xd119d0]
CALL 0x0012a220
LAB_0017fd5f:
LEA R13,[0x48e500]
MOV EDI,dword ptr [R13]
MOV R8D,0x20
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a6188
MOV R15D,EAX
MOV EBX,dword ptr [R13]
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017fe6c
LEA RSI,[RBP + -0x39]
MOV EDX,0x9
MOV EDI,EBX
XOR ECX,ECX
CALL 0x00130a78
LAB_0017fdbe:
TEST R12,R12
JZ 0x0017fe01
MOV EBX,dword ptr [R13]
MOV R14D,dword ptr [RBP + -0x40]
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017fe91
MOV EDI,EBX
MOV RSI,R12
MOV RDX,R14
XOR ECX,ECX
CALL 0x00130a78
LAB_0017fe01:
TEST R15D,R15D
JNZ 0x0017fe1e
MOV EDI,dword ptr [R13]
MOV R8D,0x20
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a6188
LAB_0017fe1e:
LEA RAX,[0xd119d0]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x0017fe7f
LAB_0017fe2e:
LEA RDI,[0xd119d0]
CALL 0x0012a1e0
CALL 0x001a8156
MOV ECX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0017fea6
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017fe62:
CALL 0x0012edd6
JMP 0x0017fd5f
LAB_0017fe6c:
LEA RDX,[RBP + -0x39]
MOV RDI,RAX
MOV ESI,EBX
CALL 0x0012edf3
JMP 0x0017fdbe
LAB_0017fe7f:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0017fe2e
LAB_0017fe91:
MOV RDI,RAX
MOV RSI,R14
MOV EDX,EBX
MOV RCX,R12
CALL 0x0012ee6b
JMP 0x0017fe01
LAB_0017fea6:
CALL 0x0012a270
|
void _myisam_log_command(int1 param_1,long param_2,long param_3,int4 param_4,
ulong param_5)
{
int4 uVar1;
int4 uVar2;
int iVar3;
int4 *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_98 [76];
int4 local_4c;
int4 local_48;
int1 local_41;
int1 local_40;
int1 local_3f;
int1 local_3e;
int1 local_3d;
int1 local_3c;
int1 local_3b;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = param_4;
if (log_type == 1) {
uVar2 = (int4)myisam_pid;
}
else {
uVar2 = my_thread_dbug_id();
}
puVar4 = (int4 *)_my_thread_var();
local_4c = *puVar4;
local_3f = (int1)*(int4 *)(param_2 + 0x1c0);
local_40 = (int1)((uint)*(int4 *)(param_2 + 0x1c0) >> 8);
local_3b = (int1)uVar2;
local_3c = (int1)((uint)uVar2 >> 8);
local_3d = (int1)((uint)uVar2 >> 0x10);
local_3e = (int1)((uint)uVar2 >> 0x18);
local_39 = (int1)(param_5 & 0xffffffff);
local_3a = (int1)((param_5 & 0xffffffff) >> 8);
local_41 = param_1;
if (THR_LOCK_myisam._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_myisam);
}
else {
_myisam_log_command_cold_1();
}
iVar3 = my_lock(myisam_log_file,1,0,0,0x20);
uVar2 = myisam_log_file;
lVar5 = (**(code **)(PSI_server + 0x158))(local_98,myisam_log_file,7);
if (lVar5 == 0) {
my_write(uVar2,&local_41,9,0);
}
else {
_myisam_log_command_cold_2(lVar5,uVar2,&local_41);
}
uVar1 = local_48;
uVar2 = myisam_log_file;
if (param_3 != 0) {
lVar5 = (**(code **)(PSI_server + 0x158))(local_98,myisam_log_file,7);
if (lVar5 == 0) {
my_write(uVar2,param_3,uVar1,0);
}
else {
_myisam_log_command_cold_3(lVar5,uVar1,uVar2,param_3);
}
}
if (iVar3 == 0) {
my_lock(myisam_log_file,2,0,0,0x20);
}
if (THR_LOCK_myisam._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_myisam);
puVar4 = (int4 *)_my_thread_var();
*puVar4 = local_4c;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
53,743 | inline_mysql_file_fopen | eloqsql/include/mysql/psi/mysql_file.h | static inline MYSQL_FILE*
inline_mysql_file_fopen(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int flags, myf myFlags)
{
MYSQL_FILE *that;
that= (MYSQL_FILE*) my_malloc(PSI_NOT_INSTRUMENTED,
sizeof(MYSQL_FILE), MYF(MY_WME));
if (likely(that != NULL))
{
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_STREAM_OPEN,
filename, that);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
that->m_file= my_fopen(filename, flags, myFlags);
that->m_psi= PSI_FILE_CALL(end_file_open_wait)(locker, that->m_file);
if (unlikely(that->m_file == NULL))
{
my_free(that);
return NULL;
}
return that;
}
#endif
that->m_psi= NULL;
that->m_file= my_fopen(filename, flags, myFlags);
if (unlikely(that->m_file == NULL))
{
my_free(that);
return NULL;
}
}
return that;
} | O0 | c | inline_mysql_file_fopen:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
xorl %edi, %edi
movl $0x10, %edx
movq %rdx, %rsi
callq 0x37090
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2e279
leaq 0x218d69(%rip), %rax # 0x246e98
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
leaq -0x90(%rbp), %rdi
movl $0x3, %edx
callq *%rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2e21b
leaq 0x218d17(%rip), %rax # 0x246e98
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x31af0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
leaq 0x218cdf(%rip), %rax # 0x246e98
movq (%rax), %rax
movq 0x1f8(%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2e211
movq -0x40(%rbp), %rdi
callq 0x37410
movq $0x0, -0x8(%rbp)
jmp 0x2e281
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e281
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x31af0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2e277
movq -0x40(%rbp), %rdi
callq 0x37410
movq $0x0, -0x8(%rbp)
jmp 0x2e281
jmp 0x2e279
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
| inline_mysql_file_fopen:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_38], r9
xor edi, edi
mov edx, 10h
mov rsi, rdx
call my_malloc
mov [rbp+var_40], rax
cmp [rbp+var_40], 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 loc_2E279
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_C]
mov rcx, [rbp+var_28]
mov r8, [rbp+var_40]
lea rdi, [rbp+var_90]
mov edx, 3
call rax
mov [rbp+var_48], rax
cmp [rbp+var_48], 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 loc_2E21B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
call rax
mov rdi, [rbp+var_28]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_38]
call my_fopen
mov rcx, rax
mov rax, [rbp+var_40]
mov [rax], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F8h]
mov rdi, [rbp+var_48]
mov rcx, [rbp+var_40]
mov rsi, [rcx]
call rax
mov rcx, rax
mov rax, [rbp+var_40]
mov [rax+8], rcx
mov rax, [rbp+var_40]
cmp qword ptr [rax], 0
setz 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_2E211
mov rdi, [rbp+var_40]
call my_free
mov [rbp+var_8], 0
jmp short loc_2E281
loc_2E211:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
jmp short loc_2E281
loc_2E21B:
mov rax, [rbp+var_40]
mov qword ptr [rax+8], 0
mov rdi, [rbp+var_28]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_38]
call my_fopen
mov rcx, rax
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_40]
cmp qword ptr [rax], 0
setz 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_2E277
mov rdi, [rbp+var_40]
call my_free
mov [rbp+var_8], 0
jmp short loc_2E281
loc_2E277:
jmp short $+2
loc_2E279:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_2E281:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| long long * inline_mysql_file_fopen(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6)
{
long long v6; // rax
long long v7; // rcx
long long v8; // rcx
char v10[72]; // [rsp+0h] [rbp-90h] BYREF
long long v11; // [rsp+48h] [rbp-48h]
long long *v12; // [rsp+50h] [rbp-40h]
long long v13; // [rsp+58h] [rbp-38h]
unsigned int v14; // [rsp+64h] [rbp-2Ch]
long long v15; // [rsp+68h] [rbp-28h]
unsigned int v16; // [rsp+74h] [rbp-1Ch]
long long v17; // [rsp+78h] [rbp-18h]
unsigned int v18; // [rsp+84h] [rbp-Ch]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v12 = (long long *)my_malloc(0LL, 16LL);
if ( !v12 )
return v12;
v11 = (*((long long ( **)(char *, _QWORD, long long, long long, long long *))PSI_server[0] + 41))(
v10,
v18,
3LL,
v15,
v12);
if ( !v11 )
{
v12[1] = 0LL;
v8 = my_fopen(v15, v14, v13);
*v12 = v8;
if ( !*v12 )
goto LABEL_4;
return v12;
}
(*((void ( **)(long long, long long, _QWORD))PSI_server[0] + 62))(v11, v17, v16);
v6 = my_fopen(v15, v14, v13);
*v12 = v6;
v7 = (*((long long ( **)(long long, long long))PSI_server[0] + 63))(v11, *v12);
v12[1] = v7;
if ( *v12 )
return v12;
LABEL_4:
my_free(v12);
return 0LL;
}
| inline_mysql_file_fopen:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],R9
XOR EDI,EDI
MOV EDX,0x10
MOV RSI,RDX
CALL 0x00137090
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],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 0x0012e279
LEA RAX,[0x346e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,qword ptr [RBP + -0x40]
LEA RDI,[RBP + -0x90]
MOV EDX,0x3
CALL RAX
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],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 0x0012e21b
LEA RAX,[0x346e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL RAX
MOV RDI,qword ptr [RBP + -0x28]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00131af0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
LEA RAX,[0x346e98]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f8]
MOV RDI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RCX]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012e211
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00137410
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012e281
LAB_0012e211:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012e281
LAB_0012e21b:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x8],0x0
MOV RDI,qword ptr [RBP + -0x28]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00131af0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RAX],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012e277
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00137410
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012e281
LAB_0012e277:
JMP 0x0012e279
LAB_0012e279:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012e281:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
long * inline_mysql_file_fopen
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6)
{
long lVar1;
int1 local_98 [72];
long local_50;
long *local_48;
int8 local_40;
int4 local_34;
int8 local_30;
int4 local_24;
int8 local_20;
int4 local_14;
local_40 = param_6;
local_34 = param_5;
local_30 = param_4;
local_24 = param_3;
local_20 = param_2;
local_14 = param_1;
local_48 = (long *)my_malloc(0,0x10);
if (local_48 != (long *)0x0) {
local_50 = (**(code **)(PSI_server + 0x148))(local_98,local_14,3,local_30,local_48);
if (local_50 != 0) {
(**(code **)(PSI_server + 0x1f0))(local_50,local_20,local_24);
lVar1 = my_fopen(local_30,local_34,local_40);
*local_48 = lVar1;
lVar1 = (**(code **)(PSI_server + 0x1f8))(local_50,*local_48);
local_48[1] = lVar1;
if (*local_48 == 0) {
my_free(local_48);
return (long *)0x0;
}
return local_48;
}
local_48[1] = 0;
lVar1 = my_fopen(local_30,local_34,local_40);
*local_48 = lVar1;
if (*local_48 == 0) {
my_free(local_48);
return (long *)0x0;
}
}
return local_48;
}
| |
53,744 | set_date_fields | bluesky950520[P]quickjs/quickjs.c | static double set_date_fields(double fields[minimum_length(7)], int is_local) {
double y, m, dt, ym, mn, day, h, s, milli, time, tv;
int yi, mi, i;
int64_t days;
volatile double temp; /* enforce evaluation order */
/* emulate 21.4.1.15 MakeDay ( year, month, date ) */
y = fields[0];
m = fields[1];
dt = fields[2];
ym = y + floor(m / 12);
mn = fmod(m, 12);
if (mn < 0)
mn += 12;
if (ym < -271821 || ym > 275760)
return NAN;
yi = ym;
mi = mn;
days = days_from_year(yi);
for(i = 0; i < mi; i++) {
days += month_days[i];
if (i == 1)
days += days_in_year(yi) - 365;
}
day = days + dt - 1;
/* emulate 21.4.1.14 MakeTime ( hour, min, sec, ms ) */
h = fields[3];
m = fields[4];
s = fields[5];
milli = fields[6];
/* Use a volatile intermediary variable to ensure order of evaluation
* as specified in ECMA. This fixes a test262 error on
* test262/test/built-ins/Date/UTC/fp-evaluation-order.js.
* Without the volatile qualifier, the compile can generate code
* that performs the computation in a different order or with instructions
* that produce a different result such as FMA (float multiply and add).
*/
time = h * 3600000;
time += (temp = m * 60000);
time += (temp = s * 1000);
time += milli;
/* emulate 21.4.1.16 MakeDate ( day, time ) */
tv = (temp = day * 86400000) + time; /* prevent generation of FMA */
if (!isfinite(tv))
return NAN;
/* adjust for local time and clip */
if (is_local) {
int64_t ti = tv < INT64_MIN ? INT64_MIN : tv >= 0x1p63 ? INT64_MAX : (int64_t)tv;
tv += getTimezoneOffset(ti) * 60000;
}
return time_clip(tv);
} | O1 | c | set_date_fields:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movapd %xmm1, %xmm0
divsd 0x46e3a(%rip), %xmm0 # 0x9d218
callq 0xe830
addsd (%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x46e1c(%rip), %xmm1 # 0x9d218
callq 0xe3d0
movsd 0x28(%rsp), %xmm5
movsd 0x46e11(%rip), %xmm1 # 0x9d220
ucomisd %xmm5, %xmm1
movsd 0x46dc5(%rip), %xmm4 # 0x9d1e0
ja 0x56743
ucomisd 0x46dff(%rip), %xmm5 # 0x9d228
ja 0x56743
movsd 0x46de1(%rip), %xmm1 # 0x9d218
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
cvttsd2si %xmm5, %eax
cvttsd2si %xmm3, %edi
movslq %eax, %r8
imulq $0x16d, %r8, %rax # imm = 0x16D
leaq -0x7b1(%r8), %r10
sarq $0x2, %r10
addq %rax, %r10
leaq -0x76d(%r8), %rsi
movabsq $-0x5c28f5c28f5c28f5, %r9 # imm = 0xA3D70A3D70A3D70B
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x76d, %rax # imm = 0xF893
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x6, %rax
addq %rcx, %rax
imulq $0x64, %rax, %rax
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x64, %rsi
addq %rax, %rsi
movabsq $0x5c28f5c28f5c28f5, %rcx # imm = 0x5C28F5C28F5C28F5
movq %rsi, %rax
imulq %rcx
movq %rdx, %rcx
subq %rsi, %rcx
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x6, %rcx
addq %rax, %rcx
addq %r10, %rcx
leaq -0x641(%r8), %rsi
movq %rsi, %rax
imulq %r9
leaq (%rdx,%r8), %rax
addq $-0x641, %rax # imm = 0xF9BF
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x8, %rax
addq %rdx, %rax
imulq $0x190, %rax, %rax # imm = 0x190
subq %rax, %rsi
sarq $0x3f, %rsi
andq $-0x190, %rsi # imm = 0xFE70
addq %rax, %rsi
movq %rsi, %rax
imulq %r9
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x8, %rdx
addq %rax, %rdx
addq %rdx, %rcx
addq $-0xaf8ca, %rcx # imm = 0xFFF50736
testl %edi, %edi
jle 0x565de
xorl %eax, %eax
testb $0x3, %r8b
sete %al
movabsq $-0x70a3d70a3d70a3d7, %rdx # imm = 0x8F5C28F5C28F5C29
imulq %r8, %rdx
movabsq $0x51eb851eb851eb8, %rsi # imm = 0x51EB851EB851EB8
addq %rdx, %rsi
rorq $0x2, %rsi
movabsq $0x28f5c28f5c28f5d, %r8 # imm = 0x28F5C28F5C28F5D
cmpq %r8, %rsi
sbbl $0x0, %eax
movabsq $0x51eb851eb851eb0, %rsi # imm = 0x51EB851EB851EB0
addq %rdx, %rsi
rorq $0x4, %rsi
movabsq $0xa3d70a3d70a3d7, %rdx # imm = 0xA3D70A3D70A3D7
cmpq %rdx, %rsi
adcl $0x16d, %eax # imm = 0x16D
addq $-0x16d, %rax # imm = 0xFE93
movl %edi, %edx
shlq $0x2, %rdx
xorl %esi, %esi
leaq 0x4690e(%rip), %rdi # 0x9cec0
movapd 0x10(%rsp), %xmm0
movslq (%rsi,%rdi), %r9
cmpq $0x4, %rsi
movl $0x0, %r8d
cmoveq %rax, %r8
addq %rcx, %r8
addq %r9, %r8
addq $0x4, %rsi
movq %r8, %rcx
cmpq %rsi, %rdx
jne 0x565b8
jmp 0x565e7
movq %rcx, %r8
movapd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r8, %xmm1
addsd %xmm1, %xmm0
addsd 0x46b7d(%rip), %xmm0 # 0x9d178
movsd 0x18(%r14), %xmm3
mulsd 0x46c27(%rip), %xmm3 # 0x9d230
movupd 0x20(%r14), %xmm1
mulpd 0x46a69(%rip), %xmm1 # 0x9d080
addsd %xmm1, %xmm3
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm3, %xmm2
addsd 0x30(%r14), %xmm2
movlpd %xmm1, 0x8(%rsp)
movhpd %xmm1, 0x8(%rsp)
mulsd 0x46bf7(%rip), %xmm0 # 0x9d238
movsd %xmm0, 0x8(%rsp)
addsd %xmm2, %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jg 0x56743
testl %ebx, %ebx
je 0x5671c
cvttsd2si %xmm0, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
ucomisd 0x46b18(%rip), %xmm0 # 0x9d1b0
movabsq $0x20c49ba5e353f7, %rax # imm = 0x20C49BA5E353F7
cmovbq %rdx, %rax
movsd 0x46afa(%rip), %xmm1 # 0x9d1a8
ucomisd %xmm0, %xmm1
movabsq $-0x20c49ba5e353f7, %rcx # imm = 0xFFDF3B645A1CAC09
cmovbeq %rax, %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, (%rdi)
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
movaps %xmm0, 0x10(%rsp)
callq 0xe0e0
movsd 0x46afe(%rip), %xmm4 # 0x9d1e0
movapd 0x10(%rsp), %xmm0
movq 0x28(%rbx), %rcx
movabsq $0x7777777777777777, %rdx # imm = 0x7777777777777777
movq %rcx, %rax
imulq %rdx
subq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x5, %edx
addl %eax, %edx
imull $0xea60, %edx, %eax # imm = 0xEA60
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movapd 0x4693c(%rip), %xmm2 # 0x9d060
andpd %xmm0, %xmm2
movsd 0x46aa8(%rip), %xmm1 # 0x9d1d8
ucomisd %xmm2, %xmm1
jb 0x56743
callq 0xe140
xorpd %xmm4, %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
| set_date_fields:
push r14
push rbx
sub rsp, 78h
mov ebx, esi
mov r14, rdi
movsd xmm1, qword ptr [rdi+8]
movsd [rsp+88h+var_58], xmm1
movsd xmm0, qword ptr [rdi+10h]
movaps [rsp+88h+var_78], xmm0
movapd xmm0, xmm1
divsd xmm0, cs:qword_9D218
call _floor
addsd xmm0, qword ptr [r14]
movsd [rsp+88h+var_60], xmm0
movsd xmm0, [rsp+88h+var_58]
movsd xmm1, cs:qword_9D218
call _fmod
movsd xmm5, [rsp+88h+var_60]
movsd xmm1, cs:qword_9D220
ucomisd xmm1, xmm5
movsd xmm4, cs:qword_9D1E0
ja loc_56743
ucomisd xmm5, cs:qword_9D228
ja loc_56743
movsd xmm1, cs:qword_9D218
addsd xmm1, xmm0
xorpd xmm2, xmm2
movapd xmm3, xmm0
cmpltsd xmm3, xmm2
andpd xmm1, xmm3
andnpd xmm3, xmm0
orpd xmm3, xmm1
cvttsd2si eax, xmm5
cvttsd2si edi, xmm3
movsxd r8, eax
imul rax, r8, 16Dh
lea r10, [r8-7B1h]
sar r10, 2
add r10, rax
lea rsi, [r8-76Dh]
mov r9, 0A3D70A3D70A3D70Bh
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF893h
mov rcx, rax
shr rcx, 3Fh
sar rax, 6
add rax, rcx
imul rax, 64h ; 'd'
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFF9Ch
add rsi, rax
mov rcx, 5C28F5C28F5C28F5h
mov rax, rsi
imul rcx
mov rcx, rdx
sub rcx, rsi
mov rax, rcx
shr rax, 3Fh
sar rcx, 6
add rcx, rax
add rcx, r10
lea rsi, [r8-641h]
mov rax, rsi
imul r9
lea rax, [rdx+r8]
add rax, 0FFFFFFFFFFFFF9BFh
mov rdx, rax
shr rdx, 3Fh
sar rax, 8
add rax, rdx
imul rax, 190h
sub rsi, rax
sar rsi, 3Fh
and rsi, 0FFFFFFFFFFFFFE70h
add rsi, rax
mov rax, rsi
imul r9
add rdx, rsi
mov rax, rdx
shr rax, 3Fh
sar rdx, 8
add rdx, rax
add rcx, rdx
add rcx, 0FFFFFFFFFFF50736h
test edi, edi
jle loc_565DE
xor eax, eax
test r8b, 3
setz al
mov rdx, 8F5C28F5C28F5C29h
imul rdx, r8
mov rsi, 51EB851EB851EB8h
add rsi, rdx
ror rsi, 2
mov r8, 28F5C28F5C28F5Dh
cmp rsi, r8
sbb eax, 0
mov rsi, 51EB851EB851EB0h
add rsi, rdx
ror rsi, 4
mov rdx, 0A3D70A3D70A3D7h
cmp rsi, rdx
adc eax, 16Dh
add rax, 0FFFFFFFFFFFFFE93h
mov edx, edi
shl rdx, 2
xor esi, esi
lea rdi, month_days
movapd xmm0, [rsp+88h+var_78]
loc_565B8:
movsxd r9, dword ptr [rsi+rdi]
cmp rsi, 4
mov r8d, 0
cmovz r8, rax
add r8, rcx
add r8, r9
add rsi, 4
mov rcx, r8
cmp rdx, rsi
jnz short loc_565B8
jmp short loc_565E7
loc_565DE:
mov r8, rcx
movapd xmm0, [rsp+88h+var_78]
loc_565E7:
xorps xmm1, xmm1
cvtsi2sd xmm1, r8
addsd xmm0, xmm1
addsd xmm0, cs:qword_9D178
movsd xmm3, qword ptr [r14+18h]
mulsd xmm3, cs:qword_9D230
movupd xmm1, xmmword ptr [r14+20h]
mulpd xmm1, cs:xmmword_9D080
addsd xmm3, xmm1
movapd xmm2, xmm1
unpckhpd xmm2, xmm1
addsd xmm2, xmm3
addsd xmm2, qword ptr [r14+30h]
movlpd [rsp+88h+var_80], xmm1
movhpd [rsp+88h+var_80], xmm1
mulsd xmm0, cs:qword_9D238
movsd [rsp+88h+var_80], xmm0
addsd xmm0, xmm2
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FEFFFFFFFFFFFFFh
cmp rax, rcx
jg loc_56743
test ebx, ebx
jz loc_5671C
cvttsd2si rax, xmm0
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
ucomisd xmm0, cs:qword_9D1B0
mov rax, 20C49BA5E353F7h
cmovb rax, rdx
movsd xmm1, cs:qword_9D1A8
ucomisd xmm1, xmm0
mov rcx, 0FFDF3B645A1CAC09h
cmovbe rcx, rax
lea rdi, [rsp+88h+var_50]
mov [rdi], rcx
lea rbx, [rsp+88h+var_48]
mov rsi, rbx
movaps [rsp+88h+var_78], xmm0
call _localtime_r
movsd xmm4, cs:qword_9D1E0
movapd xmm0, [rsp+88h+var_78]
mov rcx, [rbx+28h]
mov rdx, 7777777777777777h
mov rax, rcx
imul rdx
sub rdx, rcx
mov rax, rdx
shr rax, 3Fh
shr edx, 5
add edx, eax
imul eax, edx, 0EA60h
xorps xmm1, xmm1
cvtsi2sd xmm1, eax
addsd xmm0, xmm1
loc_5671C:
movapd xmm2, cs:xmmword_9D060
andpd xmm2, xmm0
movsd xmm1, cs:qword_9D1D8
ucomisd xmm1, xmm2
jb short loc_56743
call _trunc
xorpd xmm4, xmm4
addsd xmm4, xmm0
loc_56743:
movapd xmm0, xmm4
add rsp, 78h
pop rbx
pop r14
retn
| __int128 __usercall set_date_fields@<xmm0>(__m128d *a1@<rdi>, int a2@<esi>)
{
__m128d v4; // xmm0
__int128 v5; // xmm4
double v6; // xmm3_8
unsigned long long v7; // rdi
long long v8; // r8
unsigned long long v9; // rax
signed long long v10; // rax
unsigned long long v11; // rcx
unsigned long long v12; // rax
signed long long v13; // rsi
long long v14; // rdx
long long v15; // rcx
long long v16; // rax
double v17; // xmm0_8
long long v18; // r8
long long v19; // r8
__m128d v20; // xmm1
double v21; // xmm0_8
unsigned long long v22; // rax
unsigned long long v23; // rcx
double v24; // xmm0_8
double v26; // [rsp+10h] [rbp-78h]
double v27; // [rsp+28h] [rbp-60h]
double v28; // [rsp+30h] [rbp-58h]
unsigned long long v29; // [rsp+38h] [rbp-50h] BYREF
char v30; // [rsp+40h] [rbp-48h] BYREF
long long v31; // [rsp+68h] [rbp-20h]
v28 = a1->m128d_f64[1];
v26 = a1[1].m128d_f64[0];
v27 = floor(v28 / 12.0) + a1->m128d_f64[0];
v4 = (__m128d)*(unsigned long long *)&v28;
v4.m128d_f64[0] = fmod(v28, 12.0);
v5 = 0x7FF8000000000000uLL;
if ( v27 >= -271821.0 && v27 <= 275760.0 )
{
v6 = _mm_cmplt_sd(v4, (__m128d)0LL).m128d_f64[0];
v7 = (unsigned int)(int)COERCE_DOUBLE(~*(_QWORD *)&v6 & *(_QWORD *)&v4.m128d_f64[0] | COERCE_UNSIGNED_INT64(v4.m128d_f64[0] + 12.0) & *(_QWORD *)&v6);
v8 = (int)v27;
v9 = 100
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64)
+ v8
- 1901) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1901)) >> 64) + v8 - 1901) >> 6));
v10 = v9 + (((long long)(v8 - 1901 - v9) >> 63) & 0xFFFFFFFFFFFFFF9CLL);
v11 = 365 * v8
+ ((v8 - 1969) >> 2)
+ ((unsigned long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 63)
+ ((long long)(((unsigned __int128)(0x5C28F5C28F5C28F5LL * (__int128)v10) >> 64) - v10) >> 6);
v12 = 400
* (((unsigned long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64)
+ v8
- 1601) >> 63)
+ ((long long)(((unsigned __int128)((long long)0xA3D70A3D70A3D70BLL * (__int128)(v8 - 1601)) >> 64) + v8 - 1601) >> 8));
v13 = v12 + (((long long)(v8 - 1601 - v12) >> 63) & 0xFFFFFFFFFFFFFE70LL);
v14 = v13 / 400;
v15 = v13 / 400 + v11 - 719050;
if ( (int)v7 <= 0 )
{
LODWORD(v19) = v15;
v17 = v26;
}
else
{
v16 = (__ROR8__(0x8F5C28F5C28F5C29LL * v8 + 0x51EB851EB851EB0LL, 4) < 0xA3D70A3D70A3D7uLL)
+ ((v8 & 3) == 0)
- (unsigned int)(__ROR8__(0x8F5C28F5C28F5C29LL * v8 + 0x51EB851EB851EB8LL, 2) < 0x28F5C28F5C28F5DuLL)
+ 365
- 365LL;
v14 = 4LL * (unsigned int)v7;
v13 = 0LL;
v7 = (unsigned long long)&month_days;
v17 = v26;
do
{
v18 = 0LL;
if ( v13 == 4 )
v18 = v16;
v19 = *(int *)((char *)&month_days + v13) + v15 + v18;
v13 += 4LL;
v15 = v19;
}
while ( v14 != v13 );
}
v20 = _mm_mul_pd(a1[2], (__m128d)xmmword_9D080);
v21 = (v17 + (double)(int)v19 + -1.0) * 86400000.0
+ _mm_unpackhi_pd(v20, v20).m128d_f64[0]
+ a1[1].m128d_f64[1] * 3600000.0
+ v20.m128d_f64[0]
+ a1[3].m128d_f64[0];
if ( COERCE__INT64(fabs(v21)) <= 0x7FEFFFFFFFFFFFFFLL )
{
if ( a2 )
{
v22 = 0x20C49BA5E353F7LL;
if ( v21 < 9.223372036854776e18 )
v22 = ((unsigned long long)((0x20C49BA5E353F7CFLL * (unsigned __int128)(unsigned int)(int)v21) >> 64) >> 63)
+ (unsigned int)(int)v21 / 1000LL;
v23 = 0xFFDF3B645A1CAC09LL;
if ( v21 >= -9.223372036854776e18 )
v23 = v22;
v7 = (unsigned long long)&v29;
v29 = v23;
v13 = (signed long long)&v30;
localtime_r(&v29, &v30);
v5 = 0x7FF8000000000000uLL;
v14 = ((unsigned long long)(((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - v31) >> 63)
+ (((unsigned int)((unsigned __int128)(0x7777777777777777LL * (__int128)v31) >> 64) - (unsigned int)v31) >> 5);
v21 = v21 + (double)(60000 * (int)v14);
}
if ( fabs(v21) <= 8.64e15 )
{
v24 = trunc(v7, v13, v14);
v5 = 0LL;
*(double *)&v5 = v24 + 0.0;
}
}
}
return v5;
}
| set_date_fields:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV EBX,ESI
MOV R14,RDI
MOVSD XMM1,qword ptr [RDI + 0x8]
MOVSD qword ptr [RSP + 0x30],XMM1
MOVSD XMM0,qword ptr [RDI + 0x10]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPD XMM0,XMM1
DIVSD XMM0,qword ptr [0x0019d218]
CALL 0x0010e830
ADDSD XMM0,qword ptr [R14]
MOVSD qword ptr [RSP + 0x28],XMM0
MOVSD XMM0,qword ptr [RSP + 0x30]
MOVSD XMM1,qword ptr [0x0019d218]
CALL 0x0010e3d0
MOVSD XMM5,qword ptr [RSP + 0x28]
MOVSD XMM1,qword ptr [0x0019d220]
UCOMISD XMM1,XMM5
MOVSD XMM4,qword ptr [0x0019d1e0]
JA 0x00156743
UCOMISD XMM5,qword ptr [0x0019d228]
JA 0x00156743
MOVSD XMM1,qword ptr [0x0019d218]
ADDSD XMM1,XMM0
XORPD XMM2,XMM2
MOVAPD XMM3,XMM0
CMPLTSD XMM3,XMM2
ANDPD XMM1,XMM3
ANDNPD XMM3,XMM0
ORPD XMM3,XMM1
CVTTSD2SI EAX,XMM5
CVTTSD2SI EDI,XMM3
MOVSXD R8,EAX
IMUL RAX,R8,0x16d
LEA R10,[R8 + -0x7b1]
SAR R10,0x2
ADD R10,RAX
LEA RSI,[R8 + -0x76d]
MOV R9,-0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x76d
MOV RCX,RAX
SHR RCX,0x3f
SAR RAX,0x6
ADD RAX,RCX
IMUL RAX,RAX,0x64
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x64
ADD RSI,RAX
MOV RCX,0x5c28f5c28f5c28f5
MOV RAX,RSI
IMUL RCX
MOV RCX,RDX
SUB RCX,RSI
MOV RAX,RCX
SHR RAX,0x3f
SAR RCX,0x6
ADD RCX,RAX
ADD RCX,R10
LEA RSI,[R8 + -0x641]
MOV RAX,RSI
IMUL R9
LEA RAX,[RDX + R8*0x1]
ADD RAX,-0x641
MOV RDX,RAX
SHR RDX,0x3f
SAR RAX,0x8
ADD RAX,RDX
IMUL RAX,RAX,0x190
SUB RSI,RAX
SAR RSI,0x3f
AND RSI,-0x190
ADD RSI,RAX
MOV RAX,RSI
IMUL R9
ADD RDX,RSI
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x8
ADD RDX,RAX
ADD RCX,RDX
ADD RCX,-0xaf8ca
TEST EDI,EDI
JLE 0x001565de
XOR EAX,EAX
TEST R8B,0x3
SETZ AL
MOV RDX,-0x70a3d70a3d70a3d7
IMUL RDX,R8
MOV RSI,0x51eb851eb851eb8
ADD RSI,RDX
ROR RSI,0x2
MOV R8,0x28f5c28f5c28f5d
CMP RSI,R8
SBB EAX,0x0
MOV RSI,0x51eb851eb851eb0
ADD RSI,RDX
ROR RSI,0x4
MOV RDX,0xa3d70a3d70a3d7
CMP RSI,RDX
ADC EAX,0x16d
ADD RAX,-0x16d
MOV EDX,EDI
SHL RDX,0x2
XOR ESI,ESI
LEA RDI,[0x19cec0]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_001565b8:
MOVSXD R9,dword ptr [RSI + RDI*0x1]
CMP RSI,0x4
MOV R8D,0x0
CMOVZ R8,RAX
ADD R8,RCX
ADD R8,R9
ADD RSI,0x4
MOV RCX,R8
CMP RDX,RSI
JNZ 0x001565b8
JMP 0x001565e7
LAB_001565de:
MOV R8,RCX
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
LAB_001565e7:
XORPS XMM1,XMM1
CVTSI2SD XMM1,R8
ADDSD XMM0,XMM1
ADDSD XMM0,qword ptr [0x0019d178]
MOVSD XMM3,qword ptr [R14 + 0x18]
MULSD XMM3,qword ptr [0x0019d230]
MOVUPD XMM1,xmmword ptr [R14 + 0x20]
MULPD XMM1,xmmword ptr [0x0019d080]
ADDSD XMM3,XMM1
MOVAPD XMM2,XMM1
UNPCKHPD XMM2,XMM1
ADDSD XMM2,XMM3
ADDSD XMM2,qword ptr [R14 + 0x30]
MOVLPD qword ptr [RSP + 0x8],XMM1
MOVHPD qword ptr [RSP + 0x8],XMM1
MULSD XMM0,qword ptr [0x0019d238]
MOVSD qword ptr [RSP + 0x8],XMM0
ADDSD XMM0,XMM2
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7fefffffffffffff
CMP RAX,RCX
JG 0x00156743
TEST EBX,EBX
JZ 0x0015671c
CVTTSD2SI RAX,XMM0
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
UCOMISD XMM0,qword ptr [0x0019d1b0]
MOV RAX,0x20c49ba5e353f7
CMOVC RAX,RDX
MOVSD XMM1,qword ptr [0x0019d1a8]
UCOMISD XMM1,XMM0
MOV RCX,-0x20c49ba5e353f7
CMOVBE RCX,RAX
LEA RDI,[RSP + 0x38]
MOV qword ptr [RDI],RCX
LEA RBX,[RSP + 0x40]
MOV RSI,RBX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CALL 0x0010e0e0
MOVSD XMM4,qword ptr [0x0019d1e0]
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
MOV RCX,qword ptr [RBX + 0x28]
MOV RDX,0x7777777777777777
MOV RAX,RCX
IMUL RDX
SUB RDX,RCX
MOV RAX,RDX
SHR RAX,0x3f
SHR EDX,0x5
ADD EDX,EAX
IMUL EAX,EDX,0xea60
XORPS XMM1,XMM1
CVTSI2SD XMM1,EAX
ADDSD XMM0,XMM1
LAB_0015671c:
MOVAPD XMM2,xmmword ptr [0x0019d060]
ANDPD XMM2,XMM0
MOVSD XMM1,qword ptr [0x0019d1d8]
UCOMISD XMM1,XMM2
JC 0x00156743
CALL 0x0010e140
XORPD XMM4,XMM4
ADDSD XMM4,XMM0
LAB_00156743:
MOVAPD XMM0,XMM4
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double set_date_fields(double *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
uint uVar4;
ulong uVar5;
long lVar6;
double dVar7;
double dVar8;
double dVar9;
double dVar10;
long local_50;
tm local_48;
dVar10 = param_1[1];
dVar9 = param_1[2];
dVar7 = floor(dVar10 / DAT_0019d218);
dVar7 = dVar7 + *param_1;
dVar8 = fmod(dVar10,DAT_0019d218);
dVar10 = DAT_0019d1e0;
if ((DAT_0019d220 <= dVar7) && (dVar7 <= _DAT_0019d228)) {
uVar4 = (uint)(double)(~-(ulong)(dVar8 < 0.0) & (ulong)dVar8 |
(ulong)(DAT_0019d218 + dVar8) & -(ulong)(dVar8 < 0.0));
uVar5 = (ulong)(int)dVar7;
lVar1 = SUB168(SEXT816((long)(uVar5 - 0x76d)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar5 + -0x76d
;
lVar1 = (lVar1 >> 6) - (lVar1 >> 0x3f);
lVar2 = ((long)((uVar5 - 0x76d) + lVar1 * -100) >> 0x3f & 0xffffffffffffff9cU) + lVar1 * 100;
lVar2 = SUB168(SEXT816(lVar2) * SEXT816(0x5c28f5c28f5c28f5),8) - lVar2;
lVar1 = SUB168(SEXT816((long)(uVar5 - 0x641)) * SEXT816(-0x5c28f5c28f5c28f5),8) + uVar5 + -0x641
;
lVar1 = (lVar1 >> 8) - (lVar1 >> 0x3f);
lVar1 = ((lVar2 >> 6) - (lVar2 >> 0x3f)) + ((long)(uVar5 - 0x7b1) >> 2) + uVar5 * 0x16d +
(long)(((long)((uVar5 - 0x641) + lVar1 * -400) >> 0x3f & 0xfffffffffffffe70U) +
lVar1 * 400) / 400 + -0xaf8ca;
if (0 < (int)uVar4) {
lVar2 = uVar5 * -0x70a3d70a3d70a3d7;
lVar3 = 0;
do {
lVar6 = 0;
if (lVar3 == 4) {
lVar6 = (ulong)(((uint)((uVar5 & 3) == 0) -
(uint)((lVar2 + 0x51eb851eb851eb8U >> 2 | lVar2 << 0x3e) <
0x28f5c28f5c28f5d)) + 0x16d +
(uint)((lVar2 + 0x51eb851eb851eb0U >> 4 | lVar2 << 0x3c) < 0xa3d70a3d70a3d7
)) - 0x16d;
}
lVar1 = lVar6 + lVar1 + (long)*(int *)((long)&month_days + lVar3);
lVar3 = lVar3 + 4;
} while ((ulong)uVar4 << 2 != lVar3);
}
dVar9 = (dVar9 + (double)lVar1 + _DAT_0019d178) * _DAT_0019d238 +
param_1[5] * _UNK_0019d088 + param_1[3] * _DAT_0019d230 + param_1[4] * _DAT_0019d080 +
param_1[6];
if ((long)ABS(dVar9) < 0x7ff0000000000000) {
if (param_2 != 0) {
lVar1 = 0x20c49ba5e353f7;
if (dVar9 < DAT_0019d1b0) {
lVar1 = (long)dVar9 / 1000;
}
local_50 = -0x20c49ba5e353f7;
if (DAT_0019d1a8 <= dVar9) {
local_50 = lVar1;
}
localtime_r(&local_50,&local_48);
uVar5 = SUB168(SEXT816(local_48.tm_gmtoff) * SEXT816(0x7777777777777777),8) -
local_48.tm_gmtoff;
dVar9 = dVar9 + (double)(int)((((uint)(uVar5 >> 5) & 0x7ffffff) - (int)((long)uVar5 >> 0x3f)
) * 60000);
}
dVar10 = DAT_0019d1e0;
if ((double)(_DAT_0019d060 & (ulong)dVar9) <= DAT_0019d1d8) {
dVar10 = trunc(dVar9);
dVar10 = dVar10 + 0.0;
}
}
}
return dVar10;
}
| |
53,745 | my_like_range_win1250ch | eloqsql/strings/ctype-win1250ch.c | static my_bool
my_like_range_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str, char *max_str,
size_t *min_length, size_t *max_length)
{
int only_min_found= 1;
const char *end = ptr + ptr_length;
char *min_org = min_str;
char *min_end = min_str + res_length;
/* return 1; */
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == escape && ptr+1 != end)
ptr++; /* Skip escape */
else if (*ptr == w_one || *ptr == w_many) /* '_' or '%' in SQL */
break;
*min_str= like_range_prefix_min_win1250ch[(uint) (uchar) (*ptr)];
if (*min_str != min_sort_char)
only_min_found= 0;
min_str++;
*max_str++= like_range_prefix_max_win1250ch[(uint) (uchar) (*ptr)];
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char;
*max_str++ = max_sort_char;
}
return (only_min_found);
} | O3 | c | my_like_range_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r13
movq 0x10(%rbp), %r8
leaq (%r8,%r13), %r11
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %dil
orb %al, %dil
movb $0x1, %al
jne 0xd0b6a
addq %rsi, %rdx
leaq -0x1(%r8), %rbx
movb $0x1, %al
leaq 0x28ad7d(%rip), %r12 # 0x35b870
leaq 0x28ae76(%rip), %rdi # 0x35b970
movb (%rsi), %r14b
cmpb %cl, %r14b
setne %r9b
leaq 0x1(%rsi), %r15
cmpq %rdx, %r15
sete %r8b
orb %r9b, %r8b
cmpb $0x1, %r8b
jne 0xd0b27
cmpb -0x30(%rbp), %r14b
je 0xd0b6a
movq %rsi, %r15
cmpb -0x2c(%rbp), %r14b
je 0xd0b6a
movzbl (%r15), %esi
cmpq $0x20, %rsi
movb (%rsi,%r12), %sil
movb %sil, (%r13)
movzbl %al, %eax
movl $0x0, %esi
cmovnel %esi, %eax
incq %r13
movzbl (%r15), %esi
movb (%rsi,%rdi), %sil
movb %sil, (%r10)
incq %r10
movq %r15, %rsi
incq %rsi
cmpq %rdx, %rsi
je 0xd0b6a
leaq -0x1(%rbx), %r8
testq %rbx, %rbx
movq %r8, %rbx
jne 0xd0afa
movq %r13, %rcx
subq 0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
testb $0x10, 0xc(%rdx)
movq 0x10(%rbp), %rsi
cmoveq %rsi, %rcx
movq 0x28(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x30(%rbp), %rcx
movq %rsi, (%rcx)
cmpq %r11, %r13
je 0xd0ba5
movb $0x20, (%r13)
incq %r13
movb $-0x1, (%r10)
incq %r10
jmp 0xd0b8f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_like_range_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov [rbp+var_2C], r9d
mov [rbp+var_30], r8d
mov [rbp+var_38], rdi
mov r10, [rbp+arg_10]
mov r13, [rbp+arg_8]
mov r8, [rbp+arg_0]
lea r11, [r8+r13]
test rdx, rdx
setz al
test r8, r8
setz dil
or dil, al
mov al, 1
jnz loc_D0B6A
add rdx, rsi
lea rbx, [r8-1]
mov al, 1
lea r12, like_range_prefix_min_win1250ch
lea rdi, like_range_prefix_max_win1250ch
loc_D0AFA:
mov r14b, [rsi]
cmp r14b, cl
setnz r9b
lea r15, [rsi+1]
cmp r15, rdx
setz r8b
or r8b, r9b
cmp r8b, 1
jnz short loc_D0B27
cmp r14b, byte ptr [rbp+var_30]
jz short loc_D0B6A
mov r15, rsi
cmp r14b, byte ptr [rbp+var_2C]
jz short loc_D0B6A
loc_D0B27:
movzx esi, byte ptr [r15]
cmp rsi, 20h ; ' '
mov sil, [rsi+r12]
mov [r13+0], sil
movzx eax, al
mov esi, 0
cmovnz eax, esi
inc r13
movzx esi, byte ptr [r15]
mov sil, [rsi+rdi]
mov [r10], sil
inc r10
mov rsi, r15
inc rsi
cmp rsi, rdx
jz short loc_D0B6A
lea r8, [rbx-1]
test rbx, rbx
mov rbx, r8
jnz short loc_D0AFA
loc_D0B6A:
mov rcx, r13
sub rcx, [rbp+arg_8]
mov rdx, [rbp+var_38]
test byte ptr [rdx+0Ch], 10h
mov rsi, [rbp+arg_0]
cmovz rcx, rsi
mov rdx, [rbp+arg_18]
mov [rdx], rcx
mov rcx, [rbp+arg_20]
mov [rcx], rsi
loc_D0B8F:
cmp r13, r11
jz short loc_D0BA5
mov byte ptr [r13+0], 20h ; ' '
inc r13
mov byte ptr [r10], 0FFh
inc r10
jmp short loc_D0B8F
loc_D0BA5:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char my_like_range_win1250ch(
long long a1,
unsigned __int8 *a2,
long long a3,
unsigned __int8 a4,
char a5,
char a6,
long long a7,
long long a8,
_BYTE *a9,
long long *a10,
_QWORD *a11)
{
_BYTE *v12; // r13
char result; // al
unsigned __int8 *v14; // rdx
long long v15; // rbx
unsigned __int8 v16; // r14
unsigned __int8 *v17; // r15
long long v18; // rsi
long long v20; // rcx
v12 = (_BYTE *)a8;
result = 1;
if ( a3 != 0 && a7 != 0 )
{
v14 = &a2[a3];
v15 = a7 - 1;
result = 1;
do
{
v16 = *a2;
v17 = a2 + 1;
if ( *a2 != a4 || a2 + 1 == v14 )
{
if ( v16 == a5 )
break;
v17 = a2;
if ( v16 == a6 )
break;
}
v18 = *v17;
*v12 = like_range_prefix_min_win1250ch[v18];
if ( v18 != 32 )
result = 0;
++v12;
*a9++ = like_range_prefix_max_win1250ch[*v17];
a2 = v17 + 1;
if ( v17 + 1 == v14 )
break;
}
while ( v15-- != 0 );
}
v20 = (long long)&v12[-a8];
if ( (*(_BYTE *)(a1 + 12) & 0x10) == 0 )
v20 = a7;
*a10 = v20;
*a11 = a7;
while ( v12 != (_BYTE *)(a7 + a8) )
{
*v12++ = 32;
*a9++ = -1;
}
return result;
}
| my_like_range_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [RBP + -0x2c],R9D
MOV dword ptr [RBP + -0x30],R8D
MOV qword ptr [RBP + -0x38],RDI
MOV R10,qword ptr [RBP + 0x20]
MOV R13,qword ptr [RBP + 0x18]
MOV R8,qword ptr [RBP + 0x10]
LEA R11,[R8 + R13*0x1]
TEST RDX,RDX
SETZ AL
TEST R8,R8
SETZ DIL
OR DIL,AL
MOV AL,0x1
JNZ 0x001d0b6a
ADD RDX,RSI
LEA RBX,[R8 + -0x1]
MOV AL,0x1
LEA R12,[0x45b870]
LEA RDI,[0x45b970]
LAB_001d0afa:
MOV R14B,byte ptr [RSI]
CMP R14B,CL
SETNZ R9B
LEA R15,[RSI + 0x1]
CMP R15,RDX
SETZ R8B
OR R8B,R9B
CMP R8B,0x1
JNZ 0x001d0b27
CMP R14B,byte ptr [RBP + -0x30]
JZ 0x001d0b6a
MOV R15,RSI
CMP R14B,byte ptr [RBP + -0x2c]
JZ 0x001d0b6a
LAB_001d0b27:
MOVZX ESI,byte ptr [R15]
CMP RSI,0x20
MOV SIL,byte ptr [RSI + R12*0x1]
MOV byte ptr [R13],SIL
MOVZX EAX,AL
MOV ESI,0x0
CMOVNZ EAX,ESI
INC R13
MOVZX ESI,byte ptr [R15]
MOV SIL,byte ptr [RSI + RDI*0x1]
MOV byte ptr [R10],SIL
INC R10
MOV RSI,R15
INC RSI
CMP RSI,RDX
JZ 0x001d0b6a
LEA R8,[RBX + -0x1]
TEST RBX,RBX
MOV RBX,R8
JNZ 0x001d0afa
LAB_001d0b6a:
MOV RCX,R13
SUB RCX,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + -0x38]
TEST byte ptr [RDX + 0xc],0x10
MOV RSI,qword ptr [RBP + 0x10]
CMOVZ RCX,RSI
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [RDX],RCX
MOV RCX,qword ptr [RBP + 0x30]
MOV qword ptr [RCX],RSI
LAB_001d0b8f:
CMP R13,R11
JZ 0x001d0ba5
MOV byte ptr [R13],0x20
INC R13
MOV byte ptr [R10],0xff
INC R10
JMP 0x001d0b8f
LAB_001d0ba5:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
my_like_range_win1250ch
(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,int1 *param_8,int1 *param_9,long *param_10,long *param_11)
{
byte bVar1;
int8 uVar2;
byte *pbVar3;
long lVar4;
int1 *puVar5;
byte *pbVar6;
uVar2 = 1;
puVar5 = param_8;
if (param_7 != 0 && param_3 != 0) {
pbVar3 = param_2 + param_3;
uVar2 = 1;
lVar4 = param_7;
while( true ) {
lVar4 = lVar4 + -1;
bVar1 = *param_2;
pbVar6 = param_2 + 1;
if ((param_2 + 1 == pbVar3 || bVar1 != param_4) &&
((bVar1 == param_5 || (pbVar6 = param_2, bVar1 == param_6)))) break;
bVar1 = *pbVar6;
*puVar5 = like_range_prefix_min_win1250ch[bVar1];
if ((ulong)bVar1 != 0x20) {
uVar2 = 0;
}
puVar5 = puVar5 + 1;
*param_9 = like_range_prefix_max_win1250ch[*pbVar6];
param_9 = param_9 + 1;
param_2 = pbVar6 + 1;
if ((param_2 == pbVar3) || (lVar4 == 0)) break;
}
}
lVar4 = (long)puVar5 - (long)param_8;
if ((*(byte *)(param_1 + 0xc) & 0x10) == 0) {
lVar4 = param_7;
}
*param_10 = lVar4;
*param_11 = param_7;
for (; puVar5 != param_8 + param_7; puVar5 = puVar5 + 1) {
*puVar5 = 0x20;
*param_9 = 0xff;
param_9 = param_9 + 1;
}
return uVar2;
}
| |
53,746 | mysql_stmt_fetch_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_fetch_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_fetch,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_fetch(stmt);
return 0;
})
} | O0 | c | mysql_stmt_fetch_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x41ad8
movq -0x18(%rbp), %rdi
callq 0x2e3e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x41be9
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xf2(%rip), %rsi # 0x41c00
leaq -0x30(%rbp), %rdx
callq 0x43ed0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x41b46
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x41be9
cmpl $0x0, -0x1c(%rbp)
jge 0x41bd5
jmp 0x41b52
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x255d6(%rip), %rax # 0x67150
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x255b4(%rip), %rax # 0x67160
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x41be2
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_stmt_fetch_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_41AD8
mov rdi, [rbp+var_18]
call mysql_stmt_fetch
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 0
jmp loc_41BE9
loc_41AD8:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_fetch_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_41B46
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_41BE9
loc_41B46:
cmp [rbp+var_1C], 0
jge loc_41BD5
jmp short $+2
loc_41B52:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_41BE2
loc_41BD5:
mov rax, [rbp+var_28]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
loc_41BE2:
mov [rbp+var_4], 0
loc_41BE9:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_stmt_fetch_start(_DWORD *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
unsigned int *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
_DWORD *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(unsigned int **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_fetch_start_internal, &v3);
*((_BYTE *)v4 + 21) = 0;
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[2];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
}
else
{
*v7 = mysql_stmt_fetch(v6);
return 0;
}
}
| mysql_stmt_fetch_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00141ad8
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012e3e0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00141be9
LAB_00141ad8:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x141c00]
LEA RDX,[RBP + -0x30]
CALL 0x00143ed0
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00141b46
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00141be9
LAB_00141b46:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x00141bd5
JMP 0x00141b52
LAB_00141b52:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x167150]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x167160]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x00141be2
LAB_00141bd5:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
LAB_00141be2:
MOV dword ptr [RBP + -0x4],0x0
LAB_00141be9:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_fetch_start(int4 *param_1,long param_2)
{
int4 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int4 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_fetch(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_fetch_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_001671a0,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = local_30[2];
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
| |
53,747 | func_uni_big5_onechar | eloqsql/strings/ctype-big5.c | static int func_uni_big5_onechar(int code){
if ((code>=0x00A2)&&(code<=0x00F7))
return(tab_uni_big50[code-0x00A2]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_big51[code-0x02C7]);
if ((code>=0x2013)&&(code<=0x22BF))
return(tab_uni_big52[code-0x2013]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_big53[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_big54[code-0x3000]);
if ((code>=0x32A3)&&(code<=0x32A3))
return(tab_uni_big55[code-0x32A3]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_big56[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9483))
return(tab_uni_big57[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9FA4))
return(tab_uni_big58[code-0x9577]);
if ((code>=0xFA0C)&&(code<=0xFA0D))
return(tab_uni_big59[code-0xFA0C]);
if ((code>=0xFE30)&&(code<=0xFFFD))
return(tab_uni_big510[code-0xFE30]);
return(0);
} | O0 | c | func_uni_big5_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa2, -0x8(%rbp)
jl 0x36b07
cmpl $0xf7, -0x8(%rbp)
jg 0x36b07
movl -0x8(%rbp), %eax
subl $0xa2, %eax
movslq %eax, %rcx
leaq 0x547b5(%rip), %rax # 0x8b2b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x36b37
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x36b37
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0x54835(%rip), %rax # 0x8b360
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x2013, -0x8(%rbp) # imm = 0x2013
jl 0x36b67
cmpl $0x22bf, -0x8(%rbp) # imm = 0x22BF
jg 0x36b67
movl -0x8(%rbp), %eax
subl $0x2013, %eax # imm = 0x2013
movslq %eax, %rcx
leaq 0x54b25(%rip), %rax # 0x8b680
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x36b97
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x36b97
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0x55055(%rip), %rax # 0x8bbe0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x36bc7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x36bc7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0x553f5(%rip), %rax # 0x8bfb0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jl 0x36bf7
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x36bf7
movl -0x8(%rbp), %eax
subl $0x32a3, %eax # imm = 0x32A3
movslq %eax, %rcx
leaq 0x55619(%rip), %rax # 0x8c204
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x36c27
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x36c27
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0x555f5(%rip), %rax # 0x8c210
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x36c57
cmpl $0x9483, -0x8(%rbp) # imm = 0x9483
jg 0x36c57
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0x55655(%rip), %rax # 0x8c2a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x36c84
cmpl $0x9fa4, -0x8(%rbp) # imm = 0x9FA4
jg 0x36c84
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0x5e335(%rip), %rax # 0x94fb0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0xfa0c, -0x8(%rbp) # imm = 0xFA0C
jl 0x36cb1
cmpl $0xfa0d, -0x8(%rbp) # imm = 0xFA0D
jg 0x36cb1
movl -0x8(%rbp), %eax
subl $0xfa0c, %eax # imm = 0xFA0C
movslq %eax, %rcx
leaq 0x5f764(%rip), %rax # 0x9640c
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x36cde
cmpl $0xfffd, -0x8(%rbp) # imm = 0xFFFD
jg 0x36cde
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0x5f73b(%rip), %rax # 0x96410
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36ce5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_big5_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A2h
jl short loc_36B07
cmp [rbp+var_8], 0F7h
jg short loc_36B07
mov eax, [rbp+var_8]
sub eax, 0A2h
movsxd rcx, eax
lea rax, tab_uni_big50
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36B07:
cmp [rbp+var_8], 2C7h
jl short loc_36B37
cmp [rbp+var_8], 451h
jg short loc_36B37
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_big51
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36B37:
cmp [rbp+var_8], 2013h
jl short loc_36B67
cmp [rbp+var_8], 22BFh
jg short loc_36B67
mov eax, [rbp+var_8]
sub eax, 2013h
movsxd rcx, eax
lea rax, tab_uni_big52
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36B67:
cmp [rbp+var_8], 2460h
jl short loc_36B97
cmp [rbp+var_8], 2642h
jg short loc_36B97
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_big53
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36B97:
cmp [rbp+var_8], 3000h
jl short loc_36BC7
cmp [rbp+var_8], 3129h
jg short loc_36BC7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_big54
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36BC7:
cmp [rbp+var_8], 32A3h
jl short loc_36BF7
cmp [rbp+var_8], 32A3h
jg short loc_36BF7
mov eax, [rbp+var_8]
sub eax, 32A3h
movsxd rcx, eax
lea rax, tab_uni_big55
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36BF7:
cmp [rbp+var_8], 338Eh
jl short loc_36C27
cmp [rbp+var_8], 33D5h
jg short loc_36C27
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_big56
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36C27:
cmp [rbp+var_8], 4E00h
jl short loc_36C57
cmp [rbp+var_8], 9483h
jg short loc_36C57
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_big57
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36CE5
loc_36C57:
cmp [rbp+var_8], 9577h
jl short loc_36C84
cmp [rbp+var_8], 9FA4h
jg short loc_36C84
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_big58
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36CE5
loc_36C84:
cmp [rbp+var_8], 0FA0Ch
jl short loc_36CB1
cmp [rbp+var_8], 0FA0Dh
jg short loc_36CB1
mov eax, [rbp+var_8]
sub eax, 0FA0Ch
movsxd rcx, eax
lea rax, tab_uni_big59
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36CE5
loc_36CB1:
cmp [rbp+var_8], 0FE30h
jl short loc_36CDE
cmp [rbp+var_8], 0FFFDh
jg short loc_36CDE
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_big510
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36CE5
loc_36CDE:
mov [rbp+var_4], 0
loc_36CE5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_big5_onechar(int a1)
{
if ( a1 < 162 || a1 > 247 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8211 || a1 > 8895 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 == 12963 )
{
return tab_uni_big55;
}
else if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 38019 )
{
if ( a1 < 38263 || a1 > 40868 )
{
if ( a1 < 64012 || a1 > 64013 )
{
if ( a1 < 65072 || a1 > 65533 )
return 0;
else
return tab_uni_big510[a1 - 65072];
}
else
{
return tab_uni_big59[a1 - 64012];
}
}
else
{
return tab_uni_big58[a1 - 38263];
}
}
else
{
return tab_uni_big57[a1 - 19968];
}
}
else
{
return tab_uni_big56[a1 - 13198];
}
}
else
{
return tab_uni_big54[a1 - 12288];
}
}
else
{
return tab_uni_big53[a1 - 9312];
}
}
else
{
return tab_uni_big52[a1 - 8211];
}
}
else
{
return tab_uni_big51[a1 - 711];
}
}
else
{
return tab_uni_big50[a1 - 162];
}
}
| func_uni_big5_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa2
JL 0x00136b07
CMP dword ptr [RBP + -0x8],0xf7
JG 0x00136b07
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa2
MOVSXD RCX,EAX
LEA RAX,[0x18b2b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136b07:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x00136b37
CMP dword ptr [RBP + -0x8],0x451
JG 0x00136b37
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x18b360]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136b37:
CMP dword ptr [RBP + -0x8],0x2013
JL 0x00136b67
CMP dword ptr [RBP + -0x8],0x22bf
JG 0x00136b67
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2013
MOVSXD RCX,EAX
LEA RAX,[0x18b680]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136b67:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x00136b97
CMP dword ptr [RBP + -0x8],0x2642
JG 0x00136b97
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x18bbe0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136b97:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x00136bc7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x00136bc7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x18bfb0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136bc7:
CMP dword ptr [RBP + -0x8],0x32a3
JL 0x00136bf7
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x00136bf7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x32a3
MOVSXD RCX,EAX
LEA RAX,[0x18c204]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136bf7:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x00136c27
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x00136c27
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x18c210]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136c27:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x00136c57
CMP dword ptr [RBP + -0x8],0x9483
JG 0x00136c57
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x18c2a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136c57:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x00136c84
CMP dword ptr [RBP + -0x8],0x9fa4
JG 0x00136c84
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x194fb0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136c84:
CMP dword ptr [RBP + -0x8],0xfa0c
JL 0x00136cb1
CMP dword ptr [RBP + -0x8],0xfa0d
JG 0x00136cb1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfa0c
MOVSXD RCX,EAX
LEA RAX,[0x19640c]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136cb1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x00136cde
CMP dword ptr [RBP + -0x8],0xfffd
JG 0x00136cde
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x196410]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136ce5
LAB_00136cde:
MOV dword ptr [RBP + -0x4],0x0
LAB_00136ce5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_big5_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa2) || (0xf7 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2013) || (0x22bf < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x32a3) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9483 < param_1)) {
if ((param_1 < 0x9577) || (0x9fa4 < param_1)) {
if ((param_1 < 0xfa0c) || (0xfa0d < param_1)) {
if ((param_1 < 0xfe30) || (0xfffd < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_big510 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)((long)&tab_uni_big59 + (long)(param_1 + -0xfa0c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big58 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big57 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big56 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = (&tab_uni_big55)[param_1 + -0x32a3];
}
}
else {
uVar1 = *(int2 *)(tab_uni_big54 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big53 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big52 + (long)(param_1 + -0x2013) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big51 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big50 + (long)(param_1 + -0xa2) * 2);
}
return uVar1;
}
| |
53,748 | my_longlong10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_longlong10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix,
longlong val)
{
char buffer[65];
register char *p, *e;
long long_val;
uint sign= 0;
ulonglong uval = (ulonglong)val;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (uval == 0)
{
*--p= '0';
len= 1;
goto cnv;
}
while (uval > (ulonglong) LONG_MAX)
{
ulonglong quo= uval/(uint) 10;
uint rem= (uint) (uval- quo* (uint) 10);
*--p = '0' + rem;
uval= quo;
}
long_val= (long) uval;
while (long_val != 0)
{
long quo= long_val/10;
*--p = (char) ('0' + (long_val - quo*10));
long_val= quo;
}
len= MY_MIN(len, (size_t) (e-p));
cnv:
memcpy(dst, p, len);
return len+sign;
} | O3 | c | my_longlong10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r9
movq %rsi, %rdi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %cl
orb %al, %cl
jne 0x72666
negq %r8
movb $0x2d, (%rdi)
incq %rdi
decq %r9
leaq -0x20(%rbp), %rbx
movb $0x0, (%rbx)
movl $0x1, %r14d
jmp 0x7267a
movb $0x0, -0x20(%rbp)
testq %r8, %r8
je 0x72706
leaq -0x20(%rbp), %rbx
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
testq %r8, %r8
js 0x7268e
movq %rbx, %rsi
jmp 0x726af
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
leaq -0x21(%rbp), %rsi
imull $0xf6, %edx, %eax
addl %eax, %r8d
addb $0x30, %r8b
movb %r8b, (%rsi)
movq %rdx, %r8
subq %rsi, %rbx
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %r8d, %eax
addb $0x30, %al
movb %al, -0x1(%rsi)
decq %rsi
incq %rbx
cmpq $0x9, %r8
movq %rdx, %r8
ja 0x726b2
cmpq %rbx, %r9
cmovbq %r9, %rbx
movq %rbx, %rdx
callq 0x282c0
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x72717
addq %r14, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x21(%rbp), %rsi
movb $0x30, (%rsi)
movl $0x1, %ebx
xorl %r14d, %r14d
jmp 0x726e0
callq 0x28430
| my_longlong10_to_str_8bit:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r9, rdx
mov rdi, rsi
mov rax, fs:28h
mov [rbp+var_18], rax
test ecx, ecx
setns al
test r8, r8
setns cl
or cl, al
jnz short loc_72666
neg r8
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
dec r9
lea rbx, [rbp+var_20]
mov byte ptr [rbx], 0
mov r14d, 1
jmp short loc_7267A
loc_72666:
mov [rbp+var_20], 0
test r8, r8
jz loc_72706
lea rbx, [rbp+var_20]
xor r14d, r14d
loc_7267A:
mov rcx, 0CCCCCCCCCCCCCCCDh
test r8, r8
js short loc_7268E
mov rsi, rbx
jmp short loc_726AF
loc_7268E:
mov rax, r8
mul rcx
shr rdx, 3
lea rsi, [rbp+var_21]
imul eax, edx, 0F6h
add r8d, eax
add r8b, 30h ; '0'
mov [rsi], r8b
mov r8, rdx
loc_726AF:
sub rbx, rsi
loc_726B2:
mov rax, r8
mul rcx
shr rdx, 3
imul eax, edx, 0F6h
add eax, r8d
add al, 30h ; '0'
mov [rsi-1], al
dec rsi
inc rbx
cmp r8, 9
mov r8, rdx
ja short loc_726B2
cmp r9, rbx
cmovb rbx, r9
loc_726E0:
mov rdx, rbx
call _memcpy
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_72717
add rbx, r14
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_72706:
lea rsi, [rbp+var_21]
mov byte ptr [rsi], 30h ; '0'
mov ebx, 1
xor r14d, r14d
jmp short loc_726E0
loc_72717:
call ___stack_chk_fail
| _BYTE * my_longlong10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, unsigned long long a5)
{
_BYTE *v5; // r9
_BYTE *v6; // rdi
long long v7; // r14
char *v8; // rsi
_BYTE *v9; // rbx
bool v10; // cc
char v12; // [rsp+3Fh] [rbp-21h] BYREF
_BYTE v13[8]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v14; // [rsp+48h] [rbp-18h]
v5 = a3;
v6 = a2;
v14 = __readfsqword(0x28u);
if ( a4 >= 0 || (a5 & 0x8000000000000000LL) == 0LL )
{
v13[0] = 0;
if ( !a5 )
{
v8 = &v12;
v12 = 48;
v9 = (_BYTE *)(&dword_0 + 1);
v7 = 0LL;
goto LABEL_12;
}
v7 = 0LL;
}
else
{
a5 = -(long long)a5;
*a2 = 45;
v6 = a2 + 1;
v5 = a3 - 1;
v13[0] = 0;
v7 = 1LL;
}
if ( (a5 & 0x8000000000000000LL) != 0LL )
{
v8 = &v12;
v12 = a5 % 0xA + 48;
a5 /= 0xAuLL;
}
else
{
v8 = v13;
}
v9 = (_BYTE *)(v13 - v8);
do
{
*--v8 = a5 % 0xA + 48;
++v9;
v10 = a5 <= 9;
a5 /= 0xAuLL;
}
while ( !v10 );
if ( v5 < v9 )
v9 = v5;
LABEL_12:
memcpy(v6, v8, v9);
return &v9[v7];
}
| my_longlong10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R9,RDX
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS CL
OR CL,AL
JNZ 0x00172666
NEG R8
MOV byte ptr [RDI],0x2d
INC RDI
DEC R9
LEA RBX,[RBP + -0x20]
MOV byte ptr [RBX],0x0
MOV R14D,0x1
JMP 0x0017267a
LAB_00172666:
MOV byte ptr [RBP + -0x20],0x0
TEST R8,R8
JZ 0x00172706
LEA RBX,[RBP + -0x20]
XOR R14D,R14D
LAB_0017267a:
MOV RCX,-0x3333333333333333
TEST R8,R8
JS 0x0017268e
MOV RSI,RBX
JMP 0x001726af
LAB_0017268e:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
LEA RSI,[RBP + -0x21]
IMUL EAX,EDX,0xf6
ADD R8D,EAX
ADD R8B,0x30
MOV byte ptr [RSI],R8B
MOV R8,RDX
LAB_001726af:
SUB RBX,RSI
LAB_001726b2:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,R8D
ADD AL,0x30
MOV byte ptr [RSI + -0x1],AL
DEC RSI
INC RBX
CMP R8,0x9
MOV R8,RDX
JA 0x001726b2
CMP R9,RBX
CMOVC RBX,R9
LAB_001726e0:
MOV RDX,RBX
CALL 0x001282c0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x00172717
ADD RBX,R14
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_00172706:
LEA RSI,[RBP + -0x21]
MOV byte ptr [RSI],0x30
MOV EBX,0x1
XOR R14D,R14D
JMP 0x001726e0
LAB_00172717:
CALL 0x00128430
|
long my_longlong10_to_str_8bit
(int8 param_1,int1 *param_2,ulong param_3,int param_4,ulong param_5)
{
bool bVar1;
ulong __n;
char *__src;
long lVar2;
long in_FS_OFFSET;
char local_29 [9];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_5 < 0 && param_4 < 0) {
param_5 = -param_5;
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_3 = param_3 - 1;
lVar2 = 1;
}
else {
if (param_5 == 0) {
__src = local_29;
local_29[0] = '0';
__n = 1;
lVar2 = 0;
goto LAB_001726e0;
}
lVar2 = 0;
}
__src = local_29 + 1;
if ((long)param_5 < 0) {
local_29[0] = (char)param_5 + (char)(param_5 / 10) * -10 + '0';
__src = local_29;
param_5 = param_5 / 10;
}
__n = (long)(local_29 + 1) - (long)__src;
do {
__src[-1] = (char)(param_5 / 10) * -10 + (char)param_5 + '0';
__src = __src + -1;
__n = __n + 1;
bVar1 = 9 < param_5;
param_5 = param_5 / 10;
} while (bVar1);
if (param_3 < __n) {
__n = param_3;
}
LAB_001726e0:
local_29[1] = 0;
memcpy(param_2,__src,__n);
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __n + lVar2;
}
| |
53,749 | reset_weak_ref | bluesky950520[P]quickjs/quickjs.c | static void reset_weak_ref(JSRuntime *rt, JSWeakRefRecord **first_weak_ref)
{
JSWeakRefRecord *wr, *wr_next;
JSWeakRefData *wrd;
JSMapRecord *mr;
JSMapState *s;
JSFinRecEntry *fre;
/* first pass to remove the records from the WeakMap/WeakSet
lists */
for(wr = *first_weak_ref; wr != NULL; wr = wr->next_weak_ref) {
switch(wr->kind) {
case JS_WEAK_REF_KIND_MAP:
mr = wr->u.map_record;
s = mr->map;
assert(s->is_weak);
assert(!mr->empty); /* no iterator on WeakMap/WeakSet */
list_del(&mr->hash_link);
list_del(&mr->link);
break;
case JS_WEAK_REF_KIND_WEAK_REF:
wrd = wr->u.weak_ref_data;
wrd->target = JS_UNDEFINED;
break;
case JS_WEAK_REF_KIND_FINALIZATION_REGISTRY_ENTRY:
fre = wr->u.fin_rec_entry;
list_del(&fre->link);
break;
default:
abort();
}
}
/* second pass to free the values to avoid modifying the weak
reference list while traversing it. */
for(wr = *first_weak_ref; wr != NULL; wr = wr_next) {
wr_next = wr->next_weak_ref;
switch(wr->kind) {
case JS_WEAK_REF_KIND_MAP:
mr = wr->u.map_record;
JS_FreeValueRT(rt, mr->value);
js_free_rt(rt, mr);
break;
case JS_WEAK_REF_KIND_WEAK_REF:
wrd = wr->u.weak_ref_data;
JS_SetOpaqueInternal(wrd->obj, &js_weakref_sentinel);
js_free_rt(rt, wrd);
break;
case JS_WEAK_REF_KIND_FINALIZATION_REGISTRY_ENTRY: {
fre = wr->u.fin_rec_entry;
JSFinalizationRegistryData *frd = JS_GetOpaque(fre->obj, JS_CLASS_FINALIZATION_REGISTRY);
assert(frd != NULL);
/**
* During the GC sweep phase the held object might be collected first.
*/
if (!rt->in_free && (!JS_IsObject(fre->held_val) || JS_IsLiveObject(rt, fre->held_val))) {
JSValue args[2];
args[0] = frd->cb;
args[1] = fre->held_val;
JS_EnqueueJob(frd->ctx, js_finrec_job, 2, args);
}
JS_FreeValueRT(rt, fre->held_val);
JS_FreeValueRT(rt, fre->token);
js_free_rt(rt, fre);
break;
}
default:
abort();
}
js_free_rt(rt, wr);
}
*first_weak_ref = NULL; /* fail safe */
} | O2 | c | reset_weak_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsi, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x34838
movl (%rax), %ecx
cmpl $0x2, %ecx
je 0x3481d
cmpl $0x1, %ecx
je 0x3480c
testl %ecx, %ecx
jne 0x3493c
movq 0x10(%rax), %rcx
movq 0x20(%rcx), %rdx
movq 0x28(%rcx), %rsi
movq %rsi, 0x8(%rdx)
movq %rdx, (%rsi)
movups %xmm0, 0x20(%rcx)
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq %rsi, 0x8(%rdx)
movq %rdx, (%rsi)
movups %xmm0, 0x10(%rcx)
jmp 0x34832
movq 0x10(%rax), %rcx
andl $0x0, (%rcx)
movq $0x3, 0x8(%rcx)
jmp 0x34832
movq 0x10(%rax), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rdx)
movq %rdx, (%rsi)
movups %xmm0, (%rcx)
addq $0x8, %rax
jmp 0x347c4
movq (%rbx), %r12
leaq 0x86dd6(%rip), %rbp # 0xbb618
testq %r12, %r12
je 0x34929
movq 0x8(%r12), %r13
movl (%r12), %eax
cmpl $0x2, %eax
je 0x34885
cmpl $0x1, %eax
je 0x34870
testl %eax, %eax
jne 0x3493c
movq 0x10(%r12), %r15
jmp 0x348fb
movq 0x10(%r12), %rsi
movq 0x10(%rsi), %rax
movq %rbp, 0x30(%rax)
movq %r14, %rdi
jmp 0x34911
movq 0x10(%r12), %r15
cmpl $-0x1, 0x18(%r15)
jne 0x348a2
movq 0x10(%r15), %rax
cmpw $0x3b, 0x6(%rax)
jne 0x348a2
movq 0x30(%rax), %rax
jmp 0x348a4
xorl %eax, %eax
cmpb $0x0, 0x102(%r14)
jne 0x348eb
leaq 0x30(%r15), %rcx
cmpl $-0x1, 0x38(%r15)
jne 0x348c2
movq (%rcx), %rdx
testb $0x2, 0x5(%rdx)
jne 0x348eb
movups 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rcx
movups %xmm0, (%rcx)
movq 0x10(%rax), %rdi
leaq 0x61(%rip), %rsi # 0x34941
pushq $0x2
popq %rdx
movq %rsp, %rcx
callq 0x17ea9
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
movq %r14, %rdi
callq 0x18031
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
movq %r14, %rdi
callq 0x18031
movq %r14, %rdi
movq %r15, %rsi
callq 0x170cb
movq %r14, %rdi
movq %r12, %rsi
callq 0x170cb
movq %r13, %r12
jmp 0x34842
andq $0x0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
| reset_weak_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
xorps xmm0, xmm0
mov rax, rsi
loc_347C4:
mov rax, [rax]
test rax, rax
jz short loc_34838
mov ecx, [rax]
cmp ecx, 2
jz short loc_3481D
cmp ecx, 1
jz short loc_3480C
test ecx, ecx
jnz loc_3493C
mov rcx, [rax+10h]
mov rdx, [rcx+20h]
mov rsi, [rcx+28h]
mov [rdx+8], rsi
mov [rsi], rdx
movups xmmword ptr [rcx+20h], xmm0
mov rdx, [rcx+10h]
mov rsi, [rcx+18h]
mov [rdx+8], rsi
mov [rsi], rdx
movups xmmword ptr [rcx+10h], xmm0
jmp short loc_34832
loc_3480C:
mov rcx, [rax+10h]
and dword ptr [rcx], 0
mov qword ptr [rcx+8], 3
jmp short loc_34832
loc_3481D:
mov rcx, [rax+10h]
mov rdx, [rcx]
mov rsi, [rcx+8]
mov [rdx+8], rsi
mov [rsi], rdx
movups xmmword ptr [rcx], xmm0
loc_34832:
add rax, 8
jmp short loc_347C4
loc_34838:
mov r12, [rbx]
lea rbp, js_weakref_sentinel
loc_34842:
test r12, r12
jz loc_34929
mov r13, [r12+8]
mov eax, [r12]
cmp eax, 2
jz short loc_34885
cmp eax, 1
jz short loc_34870
test eax, eax
jnz loc_3493C
mov r15, [r12+10h]
jmp loc_348FB
loc_34870:
mov rsi, [r12+10h]
mov rax, [rsi+10h]
mov [rax+30h], rbp
mov rdi, r14
jmp loc_34911
loc_34885:
mov r15, [r12+10h]
cmp dword ptr [r15+18h], 0FFFFFFFFh
jnz short loc_348A2
mov rax, [r15+10h]
cmp word ptr [rax+6], 3Bh ; ';'
jnz short loc_348A2
mov rax, [rax+30h]
jmp short loc_348A4
loc_348A2:
xor eax, eax
loc_348A4:
cmp byte ptr [r14+102h], 0
jnz short loc_348EB
lea rcx, [r15+30h]
cmp dword ptr [r15+38h], 0FFFFFFFFh
jnz short loc_348C2
mov rdx, [rcx]
test byte ptr [rdx+5], 2
jnz short loc_348EB
loc_348C2:
movups xmm0, xmmword ptr [rax+18h]
movaps [rsp+58h+var_58], xmm0
movups xmm0, xmmword ptr [rcx]
lea rcx, [rsp+58h+var_48]
movups xmmword ptr [rcx], xmm0
mov rdi, [rax+10h]
lea rsi, js_finrec_job
push 2
pop rdx
mov rcx, rsp
call JS_EnqueueJob
loc_348EB:
mov rsi, [r15+30h]
mov rdx, [r15+38h]
mov rdi, r14
call JS_FreeValueRT
loc_348FB:
mov rsi, [r15+40h]
mov rdx, [r15+48h]
mov rdi, r14
call JS_FreeValueRT
mov rdi, r14
mov rsi, r15
loc_34911:
call js_free_rt
mov rdi, r14
mov rsi, r12
call js_free_rt
mov r12, r13
jmp loc_34842
loc_34929:
and qword ptr [rbx], 0
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3493C:
call _abort
| long long reset_weak_ref(const char *a1, long long *a2)
{
long long v3; // r14
__int128 v4; // xmm0
long long *i; // rax
long long result; // rax
int v7; // ecx
_QWORD *v8; // rcx
long long v9; // rdx
_QWORD *v10; // rsi
long long v11; // rdx
_QWORD *v12; // rsi
long long v13; // rcx
long long *v14; // rcx
long long v15; // rdx
_QWORD *v16; // rsi
long long j; // r12
long long v18; // r13
int v19; // eax
long long v20; // r15
long long v21; // rsi
long long v22; // rdi
long long v23; // rax
long long v24; // rax
long long v25; // rcx
_OWORD v26[5]; // [rsp+0h] [rbp-58h] BYREF
v3 = (long long)a1;
*(_QWORD *)&v4 = 0LL;
for ( i = a2; ; i = (long long *)(result + 8) )
{
result = *i;
if ( !result )
break;
v7 = *(_DWORD *)result;
if ( *(_DWORD *)result == 2 )
{
v14 = *(long long **)(result + 16);
v15 = *v14;
v16 = (_QWORD *)v14[1];
*(_QWORD *)(v15 + 8) = v16;
*v16 = v15;
*(_OWORD *)v14 = 0LL;
}
else if ( v7 == 1 )
{
v13 = *(_QWORD *)(result + 16);
*(_DWORD *)v13 = 0;
*(_QWORD *)(v13 + 8) = 3LL;
}
else
{
if ( v7 )
LABEL_29:
abort(a1, *(double *)&v4);
v8 = *(_QWORD **)(result + 16);
v9 = v8[4];
v10 = (_QWORD *)v8[5];
*(_QWORD *)(v9 + 8) = v10;
*v10 = v9;
*((_OWORD *)v8 + 2) = 0LL;
v11 = v8[2];
v12 = (_QWORD *)v8[3];
*(_QWORD *)(v11 + 8) = v12;
*v12 = v11;
*((_OWORD *)v8 + 1) = 0LL;
}
}
for ( j = *a2; j; j = v18 )
{
v18 = *(_QWORD *)(j + 8);
v19 = *(_DWORD *)j;
if ( *(_DWORD *)j == 2 )
{
v20 = *(_QWORD *)(j + 16);
if ( *(_DWORD *)(v20 + 24) == -1 && (v23 = *(_QWORD *)(v20 + 16), *(_WORD *)(v23 + 6) == 59) )
v24 = *(_QWORD *)(v23 + 48);
else
v24 = 0LL;
if ( !*(_BYTE *)(v3 + 258) )
{
v25 = v20 + 48;
if ( *(_DWORD *)(v20 + 56) != -1 || (*(_BYTE *)(*(_QWORD *)v25 + 5LL) & 2) == 0 )
{
v26[0] = *(_OWORD *)(v24 + 24);
v4 = *(_OWORD *)v25;
v26[1] = *(_OWORD *)v25;
JS_EnqueueJob(*(_QWORD *)(v24 + 16), (long long)js_finrec_job, 2u, (long long)v26);
}
}
JS_FreeValueRT(v3, *(unsigned int **)(v20 + 48), *(_QWORD *)(v20 + 56));
}
else
{
if ( v19 == 1 )
{
v21 = *(_QWORD *)(j + 16);
*(_QWORD *)(*(_QWORD *)(v21 + 16) + 48LL) = &js_weakref_sentinel;
v22 = v3;
goto LABEL_27;
}
if ( v19 )
goto LABEL_29;
v20 = *(_QWORD *)(j + 16);
}
JS_FreeValueRT(v3, *(unsigned int **)(v20 + 64), *(_QWORD *)(v20 + 72));
v22 = v3;
v21 = v20;
LABEL_27:
js_free_rt(v22, v21);
a1 = (const char *)v3;
result = js_free_rt(v3, j);
}
*a2 = 0LL;
return result;
}
| reset_weak_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
XORPS XMM0,XMM0
MOV RAX,RSI
LAB_001347c4:
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00134838
MOV ECX,dword ptr [RAX]
CMP ECX,0x2
JZ 0x0013481d
CMP ECX,0x1
JZ 0x0013480c
TEST ECX,ECX
JNZ 0x0013493c
MOV RCX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RCX + 0x20]
MOV RSI,qword ptr [RCX + 0x28]
MOV qword ptr [RDX + 0x8],RSI
MOV qword ptr [RSI],RDX
MOVUPS xmmword ptr [RCX + 0x20],XMM0
MOV RDX,qword ptr [RCX + 0x10]
MOV RSI,qword ptr [RCX + 0x18]
MOV qword ptr [RDX + 0x8],RSI
MOV qword ptr [RSI],RDX
MOVUPS xmmword ptr [RCX + 0x10],XMM0
JMP 0x00134832
LAB_0013480c:
MOV RCX,qword ptr [RAX + 0x10]
AND dword ptr [RCX],0x0
MOV qword ptr [RCX + 0x8],0x3
JMP 0x00134832
LAB_0013481d:
MOV RCX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x8]
MOV qword ptr [RDX + 0x8],RSI
MOV qword ptr [RSI],RDX
MOVUPS xmmword ptr [RCX],XMM0
LAB_00134832:
ADD RAX,0x8
JMP 0x001347c4
LAB_00134838:
MOV R12,qword ptr [RBX]
LEA RBP,[0x1bb618]
LAB_00134842:
TEST R12,R12
JZ 0x00134929
MOV R13,qword ptr [R12 + 0x8]
MOV EAX,dword ptr [R12]
CMP EAX,0x2
JZ 0x00134885
CMP EAX,0x1
JZ 0x00134870
TEST EAX,EAX
JNZ 0x0013493c
MOV R15,qword ptr [R12 + 0x10]
JMP 0x001348fb
LAB_00134870:
MOV RSI,qword ptr [R12 + 0x10]
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RAX + 0x30],RBP
MOV RDI,R14
JMP 0x00134911
LAB_00134885:
MOV R15,qword ptr [R12 + 0x10]
CMP dword ptr [R15 + 0x18],-0x1
JNZ 0x001348a2
MOV RAX,qword ptr [R15 + 0x10]
CMP word ptr [RAX + 0x6],0x3b
JNZ 0x001348a2
MOV RAX,qword ptr [RAX + 0x30]
JMP 0x001348a4
LAB_001348a2:
XOR EAX,EAX
LAB_001348a4:
CMP byte ptr [R14 + 0x102],0x0
JNZ 0x001348eb
LEA RCX,[R15 + 0x30]
CMP dword ptr [R15 + 0x38],-0x1
JNZ 0x001348c2
MOV RDX,qword ptr [RCX]
TEST byte ptr [RDX + 0x5],0x2
JNZ 0x001348eb
LAB_001348c2:
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVAPS xmmword ptr [RSP],XMM0
MOVUPS XMM0,xmmword ptr [RCX]
LEA RCX,[RSP + 0x10]
MOVUPS xmmword ptr [RCX],XMM0
MOV RDI,qword ptr [RAX + 0x10]
LEA RSI,[0x134941]
PUSH 0x2
POP RDX
MOV RCX,RSP
CALL 0x00117ea9
LAB_001348eb:
MOV RSI,qword ptr [R15 + 0x30]
MOV RDX,qword ptr [R15 + 0x38]
MOV RDI,R14
CALL 0x00118031
LAB_001348fb:
MOV RSI,qword ptr [R15 + 0x40]
MOV RDX,qword ptr [R15 + 0x48]
MOV RDI,R14
CALL 0x00118031
MOV RDI,R14
MOV RSI,R15
LAB_00134911:
CALL 0x001170cb
MOV RDI,R14
MOV RSI,R12
CALL 0x001170cb
MOV R12,R13
JMP 0x00134842
LAB_00134929:
AND qword ptr [RBX],0x0
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013493c:
CALL 0x0010e090
|
void reset_weak_ref(long param_1,int *param_2)
{
int iVar1;
long *plVar2;
int4 *puVar3;
long *plVar4;
int *piVar5;
int *piVar6;
long lVar7;
long lVar8;
int8 local_58;
int8 uStack_50;
int4 local_48;
int4 uStack_44;
int4 uStack_40;
int4 uStack_3c;
for (piVar6 = param_2; piVar6 = *(int **)piVar6, piVar6 != (int *)0x0; piVar6 = piVar6 + 2) {
iVar1 = *piVar6;
if (iVar1 == 2) {
plVar2 = *(long **)(piVar6 + 4);
lVar8 = *plVar2;
plVar4 = (long *)plVar2[1];
*(long **)(lVar8 + 8) = plVar4;
*plVar4 = lVar8;
*plVar2 = 0;
plVar2[1] = 0;
}
else if (iVar1 == 1) {
puVar3 = *(int4 **)(piVar6 + 4);
*puVar3 = 0;
*(int8 *)(puVar3 + 2) = 3;
}
else {
if (iVar1 != 0) goto LAB_0013493c;
lVar8 = *(long *)(piVar6 + 4);
lVar7 = *(long *)(lVar8 + 0x20);
plVar2 = *(long **)(lVar8 + 0x28);
*(long **)(lVar7 + 8) = plVar2;
*plVar2 = lVar7;
*(int8 *)(lVar8 + 0x20) = 0;
*(int8 *)(lVar8 + 0x28) = 0;
lVar7 = *(long *)(lVar8 + 0x10);
plVar2 = *(long **)(lVar8 + 0x18);
*(long **)(lVar7 + 8) = plVar2;
*plVar2 = lVar7;
*(int8 *)(lVar8 + 0x10) = 0;
*(int8 *)(lVar8 + 0x18) = 0;
}
}
piVar6 = *(int **)param_2;
do {
if (piVar6 == (int *)0x0) {
param_2[0] = 0;
param_2[1] = 0;
return;
}
piVar5 = *(int **)(piVar6 + 2);
iVar1 = *piVar6;
if (iVar1 == 2) {
lVar8 = *(long *)(piVar6 + 4);
if ((*(int *)(lVar8 + 0x18) == -1) && (*(short *)(*(long *)(lVar8 + 0x10) + 6) == 0x3b)) {
lVar7 = *(long *)(*(long *)(lVar8 + 0x10) + 0x30);
}
else {
lVar7 = 0;
}
if ((*(char *)(param_1 + 0x102) == '\0') &&
((*(int *)(lVar8 + 0x38) != -1 || ((*(byte *)(*(long *)(lVar8 + 0x30) + 5) & 2) == 0)))) {
local_58 = *(int8 *)(lVar7 + 0x18);
uStack_50 = *(int8 *)(lVar7 + 0x20);
local_48 = *(int4 *)(lVar8 + 0x30);
uStack_44 = *(int4 *)(lVar8 + 0x34);
uStack_40 = *(int4 *)(lVar8 + 0x38);
uStack_3c = *(int4 *)(lVar8 + 0x3c);
JS_EnqueueJob(*(int8 *)(lVar7 + 0x10),js_finrec_job,2,&local_58);
}
JS_FreeValueRT(param_1,*(int8 *)(lVar8 + 0x30),*(int8 *)(lVar8 + 0x38));
LAB_001348fb:
JS_FreeValueRT(param_1,*(int8 *)(lVar8 + 0x40),*(int8 *)(lVar8 + 0x48));
}
else {
if (iVar1 != 1) {
if (iVar1 != 0) {
LAB_0013493c:
/* WARNING: Subroutine does not return */
abort();
}
lVar8 = *(long *)(piVar6 + 4);
goto LAB_001348fb;
}
lVar8 = *(long *)(piVar6 + 4);
*(int1 **)(*(long *)(lVar8 + 0x10) + 0x30) = js_weakref_sentinel;
}
js_free_rt(param_1,lVar8);
js_free_rt(param_1,piVar6);
piVar6 = piVar5;
} while( true );
}
| |
53,750 | cr_realloc | bluesky950520[P]quickjs/libunicode.c | int cr_realloc(CharRange *cr, int size)
{
int new_size;
uint32_t *new_buf;
if (size > cr->size) {
new_size = max_int(size, cr->size * 3 / 2);
new_buf = cr->realloc_func(cr->mem_opaque, cr->points,
new_size * sizeof(cr->points[0]));
if (!new_buf)
return -1;
cr->points = new_buf;
cr->size = new_size;
}
return 0;
} | O1 | c | cr_realloc:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x4(%rdi), %eax
xorl %ebx, %ebx
cmpl %esi, %eax
jge 0x97aa4
movq %rdi, %r14
leal (%rax,%rax,2), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
cmpl %ebp, %esi
cmovgl %esi, %ebp
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
movslq %ebp, %rdx
shlq $0x2, %rdx
callq *0x18(%r14)
testq %rax, %rax
je 0x97a9f
movq %rax, 0x8(%r14)
movl %ebp, 0x4(%r14)
jmp 0x97aa4
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| cr_realloc:
push rbp
push r14
push rbx
mov eax, [rdi+4]
xor ebx, ebx
cmp eax, esi
jge short loc_97AA4
mov r14, rdi
lea eax, [rax+rax*2]
mov ebp, eax
shr ebp, 1Fh
add ebp, eax
sar ebp, 1
cmp esi, ebp
cmovg ebp, esi
mov rsi, [rdi+8]
mov rdi, [rdi+10h]
movsxd rdx, ebp
shl rdx, 2
call qword ptr [r14+18h]
test rax, rax
jz short loc_97A9F
mov [r14+8], rax
mov [r14+4], ebp
jmp short loc_97AA4
loc_97A9F:
mov ebx, 0FFFFFFFFh
loc_97AA4:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
| long long cr_realloc(long long a1, int a2)
{
int v2; // eax
unsigned int v3; // ebx
int v4; // ebp
long long v5; // rax
v2 = *(_DWORD *)(a1 + 4);
v3 = 0;
if ( v2 < a2 )
{
v4 = 3 * v2 / 2;
if ( a2 > v4 )
v4 = a2;
v5 = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 24))(
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 8),
4LL * v4);
if ( v5 )
{
*(_QWORD *)(a1 + 8) = v5;
*(_DWORD *)(a1 + 4) = v4;
}
else
{
return (unsigned int)-1;
}
}
return v3;
}
| cr_realloc:
PUSH RBP
PUSH R14
PUSH RBX
MOV EAX,dword ptr [RDI + 0x4]
XOR EBX,EBX
CMP EAX,ESI
JGE 0x00197aa4
MOV R14,RDI
LEA EAX,[RAX + RAX*0x2]
MOV EBP,EAX
SHR EBP,0x1f
ADD EBP,EAX
SAR EBP,0x1
CMP ESI,EBP
CMOVG EBP,ESI
MOV RSI,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
MOVSXD RDX,EBP
SHL RDX,0x2
CALL qword ptr [R14 + 0x18]
TEST RAX,RAX
JZ 0x00197a9f
MOV qword ptr [R14 + 0x8],RAX
MOV dword ptr [R14 + 0x4],EBP
JMP 0x00197aa4
LAB_00197a9f:
MOV EBX,0xffffffff
LAB_00197aa4:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
int8 cr_realloc(long param_1,int param_2)
{
long lVar1;
int8 uVar2;
int iVar3;
uVar2 = 0;
if (*(int *)(param_1 + 4) < param_2) {
iVar3 = (*(int *)(param_1 + 4) * 3) / 2;
if (iVar3 < param_2) {
iVar3 = param_2;
}
lVar1 = (**(code **)(param_1 + 0x18))
(*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 8),(long)iVar3 << 2
);
if (lVar1 == 0) {
uVar2 = 0xffffffff;
}
else {
*(long *)(param_1 + 8) = lVar1;
*(int *)(param_1 + 4) = iVar3;
}
}
return uVar2;
}
| |
53,751 | cr_realloc | bluesky950520[P]quickjs/libunicode.c | int cr_realloc(CharRange *cr, int size)
{
int new_size;
uint32_t *new_buf;
if (size > cr->size) {
new_size = max_int(size, cr->size * 3 / 2);
new_buf = cr->realloc_func(cr->mem_opaque, cr->points,
new_size * sizeof(cr->points[0]));
if (!new_buf)
return -1;
cr->points = new_buf;
cr->size = new_size;
}
return 0;
} | O3 | c | cr_realloc:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x4(%rdi), %eax
xorl %ebx, %ebx
cmpl %esi, %eax
jge 0x9a37b
movq %rdi, %r14
leal (%rax,%rax,2), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
cmpl %ebp, %esi
cmovgl %esi, %ebp
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
movslq %ebp, %rdx
shlq $0x2, %rdx
callq *0x18(%r14)
testq %rax, %rax
je 0x9a376
movq %rax, 0x8(%r14)
movl %ebp, 0x4(%r14)
jmp 0x9a37b
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| cr_realloc:
push rbp
push r14
push rbx
mov eax, [rdi+4]
xor ebx, ebx
cmp eax, esi
jge short loc_9A37B
mov r14, rdi
lea eax, [rax+rax*2]
mov ebp, eax
shr ebp, 1Fh
add ebp, eax
sar ebp, 1
cmp esi, ebp
cmovg ebp, esi
mov rsi, [rdi+8]
mov rdi, [rdi+10h]
movsxd rdx, ebp
shl rdx, 2
call qword ptr [r14+18h]
test rax, rax
jz short loc_9A376
mov [r14+8], rax
mov [r14+4], ebp
jmp short loc_9A37B
loc_9A376:
mov ebx, 0FFFFFFFFh
loc_9A37B:
mov eax, ebx
pop rbx
pop r14
pop rbp
retn
| long long cr_realloc(long long a1, int a2)
{
int v2; // eax
unsigned int v3; // ebx
int v4; // ebp
long long v5; // rax
v2 = *(_DWORD *)(a1 + 4);
v3 = 0;
if ( v2 < a2 )
{
v4 = 3 * v2 / 2;
if ( a2 > v4 )
v4 = a2;
v5 = (*(long long ( **)(_QWORD, _QWORD, long long))(a1 + 24))(
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 8),
4LL * v4);
if ( v5 )
{
*(_QWORD *)(a1 + 8) = v5;
*(_DWORD *)(a1 + 4) = v4;
}
else
{
return (unsigned int)-1;
}
}
return v3;
}
| cr_realloc:
PUSH RBP
PUSH R14
PUSH RBX
MOV EAX,dword ptr [RDI + 0x4]
XOR EBX,EBX
CMP EAX,ESI
JGE 0x0019a37b
MOV R14,RDI
LEA EAX,[RAX + RAX*0x2]
MOV EBP,EAX
SHR EBP,0x1f
ADD EBP,EAX
SAR EBP,0x1
CMP ESI,EBP
CMOVG EBP,ESI
MOV RSI,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI + 0x10]
MOVSXD RDX,EBP
SHL RDX,0x2
CALL qword ptr [R14 + 0x18]
TEST RAX,RAX
JZ 0x0019a376
MOV qword ptr [R14 + 0x8],RAX
MOV dword ptr [R14 + 0x4],EBP
JMP 0x0019a37b
LAB_0019a376:
MOV EBX,0xffffffff
LAB_0019a37b:
MOV EAX,EBX
POP RBX
POP R14
POP RBP
RET
|
int8 cr_realloc(long param_1,int param_2)
{
long lVar1;
int8 uVar2;
int iVar3;
uVar2 = 0;
if (*(int *)(param_1 + 4) < param_2) {
iVar3 = (*(int *)(param_1 + 4) * 3) / 2;
if (iVar3 < param_2) {
iVar3 = param_2;
}
lVar1 = (**(code **)(param_1 + 0x18))
(*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 8),(long)iVar3 << 2
);
if (lVar1 == 0) {
uVar2 = 0xffffffff;
}
else {
*(long *)(param_1 + 8) = lVar1;
*(int *)(param_1 + 4) = iVar3;
}
}
return uVar2;
}
| |
53,752 | ankerl::nanobench::Bench::complexityBigO() const | BadAccessGuards/build_O0/_deps/nanobench-src/src/include/nanobench.h | std::vector<BigO> Bench::complexityBigO() const {
std::vector<BigO> bigOs;
auto rangeMeasure = BigO::collectRangeMeasure(mResults);
bigOs.emplace_back("O(1)", rangeMeasure, [](double) {
return 1.0;
});
bigOs.emplace_back("O(n)", rangeMeasure, [](double n) {
return n;
});
bigOs.emplace_back("O(log n)", rangeMeasure, [](double n) {
return std::log2(n);
});
bigOs.emplace_back("O(n log n)", rangeMeasure, [](double n) {
return n * std::log2(n);
});
bigOs.emplace_back("O(n^2)", rangeMeasure, [](double n) {
return n * n;
});
bigOs.emplace_back("O(n^3)", rangeMeasure, [](double n) {
return n * n * n;
});
std::sort(bigOs.begin(), bigOs.end());
return bigOs;
} | O0 | c | ankerl::nanobench::Bench::complexityBigO() const:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1ec30
movq -0x60(%rbp), %rsi
addq $0x118, %rsi # imm = 0x118
leaq -0x30(%rbp), %rdi
callq 0x18ae0
jmp 0x189b2
movq -0x70(%rbp), %rdi
leaq 0x1db1f(%rip), %rsi # 0x364dc
leaq -0x30(%rbp), %rdx
leaq -0x3d(%rbp), %rcx
callq 0x18c00
jmp 0x189cc
movq -0x70(%rbp), %rdi
leaq 0x1db0a(%rip), %rsi # 0x364e1
leaq -0x30(%rbp), %rdx
leaq -0x3e(%rbp), %rcx
callq 0x18c90
jmp 0x189e6
movq -0x70(%rbp), %rdi
leaq 0x1daf5(%rip), %rsi # 0x364e6
leaq -0x30(%rbp), %rdx
leaq -0x3f(%rbp), %rcx
callq 0x18d20
jmp 0x18a00
movq -0x70(%rbp), %rdi
leaq 0x1dae4(%rip), %rsi # 0x364ef
leaq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x18db0
jmp 0x18a1a
movq -0x70(%rbp), %rdi
leaq 0x1dad5(%rip), %rsi # 0x364fa
leaq -0x30(%rbp), %rdx
leaq -0x41(%rbp), %rcx
callq 0x18e40
jmp 0x18a34
movq -0x70(%rbp), %rdi
leaq 0x1dac2(%rip), %rsi # 0x36501
leaq -0x30(%rbp), %rdx
leaq -0x42(%rbp), %rcx
callq 0x18ed0
jmp 0x18a4e
movq -0x70(%rbp), %rdi
callq 0x1ec90
movq -0x70(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x1ecc0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1ec50
jmp 0x18a77
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ecf0
testb $0x1, -0x11(%rbp)
jne 0x18aba
jmp 0x18ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x18ac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ecf0
jmp 0x18ac4
movq -0x70(%rbp), %rdi
callq 0x1ed50
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1ed50
movq -0x38(%rbp), %rdi
callq 0x47a0
nopw %cs:(%rax,%rax)
| _ZNK6ankerl9nanobench5Bench14complexityBigOEv:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_70], rdi
mov rax, rdi
mov [rbp+var_68], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_60], rax
mov [rbp+var_11], 0
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EEC2Ev; std::vector<ankerl::nanobench::BigO>::vector(void)
mov rsi, [rbp+var_60]
add rsi, 118h
lea rdi, [rbp+var_30]
call _ZN6ankerl9nanobench4BigO19collectRangeMeasureERKSt6vectorINS0_6ResultESaIS3_EE; ankerl::nanobench::BigO::collectRangeMeasure(std::vector<ankerl::nanobench::Result> const&)
jmp short $+2
loc_189B2:
mov rdi, [rbp+var_70]
lea rsi, aO1; "O(1)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_3D]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA5_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_0EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_0>(char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_0 &&)
jmp short $+2
loc_189CC:
mov rdi, [rbp+var_70]
lea rsi, aON; "O(n)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_3E]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA5_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_1EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_1>(char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_1 &&)
jmp short $+2
loc_189E6:
mov rdi, [rbp+var_70]
lea rsi, aOLogN; "O(log n)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_3F]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA9_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_2EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[9],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_2>(char const(&)[9],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_2 &&)
jmp short $+2
loc_18A00:
mov rdi, [rbp+var_70]
lea rsi, aONLogN; "O(n log n)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_40]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA11_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_3EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[11],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_3>(char const(&)[11],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_3 &&)
jmp short $+2
loc_18A1A:
mov rdi, [rbp+var_70]
lea rsi, aON2; "O(n^2)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_41]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA7_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_4EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_4>(char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_4 &&)
jmp short $+2
loc_18A34:
mov rdi, [rbp+var_70]
lea rsi, aON3; "O(n^3)"
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_42]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE12emplace_backIJRA7_KcRS_ISt4pairIddESaISA_EEZNKS1_5Bench14complexityBigOEvE3$_5EEERS2_DpOT_; std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_5>(char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_5 &&)
jmp short $+2
loc_18A4E:
mov rdi, [rbp+var_70]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE5beginEv; std::vector<ankerl::nanobench::BigO>::begin(void)
mov rdi, [rbp+var_70]
mov [rbp+var_50], rax
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EE3endEv; std::vector<ankerl::nanobench::BigO>::end(void)
mov [rbp+var_58], rax
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_58]
call _ZSt4sortIN9__gnu_cxx17__normal_iteratorIPN6ankerl9nanobench4BigOESt6vectorIS4_SaIS4_EEEEEvT_SA_; std::sort<__gnu_cxx::__normal_iterator<ankerl::nanobench::BigO *,std::vector<ankerl::nanobench::BigO>>>(__gnu_cxx::__normal_iterator<ankerl::nanobench::BigO *,std::vector<ankerl::nanobench::BigO>>,__gnu_cxx::__normal_iterator<ankerl::nanobench::BigO *,std::vector<ankerl::nanobench::BigO>>)
jmp short $+2
loc_18A77:
mov [rbp+var_11], 1
lea rdi, [rbp+var_30]
call _ZNSt6vectorISt4pairIddESaIS1_EED2Ev; std::vector<std::pair<double,double>>::~vector()
test [rbp+var_11], 1
jnz short loc_18ABA
jmp short loc_18AB1
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
jmp short loc_18AC4
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
lea rdi, [rbp+var_30]
call _ZNSt6vectorISt4pairIddESaIS1_EED2Ev; std::vector<std::pair<double,double>>::~vector()
jmp short loc_18AC4
loc_18AB1:
mov rdi, [rbp+var_70]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EED2Ev; std::vector<ankerl::nanobench::BigO>::~vector()
loc_18ABA:
mov rax, [rbp+var_68]
add rsp, 70h
pop rbp
retn
loc_18AC4:
mov rdi, [rbp+var_70]
call _ZNSt6vectorIN6ankerl9nanobench4BigOESaIS2_EED2Ev; std::vector<ankerl::nanobench::BigO>::~vector()
mov rdi, [rbp+var_38]
call __Unwind_Resume
| ankerl::nanobench::Bench * ankerl::nanobench::Bench::complexityBigO(
ankerl::nanobench::Bench *this,
long long a2)
{
long long v3; // [rsp+18h] [rbp-58h]
long long v4; // [rsp+20h] [rbp-50h]
char v5; // [rsp+2Eh] [rbp-42h] BYREF
char v6; // [rsp+2Fh] [rbp-41h] BYREF
char v7; // [rsp+30h] [rbp-40h] BYREF
char v8; // [rsp+31h] [rbp-3Fh] BYREF
char v9; // [rsp+32h] [rbp-3Eh] BYREF
char v10; // [rsp+33h] [rbp-3Dh] BYREF
_BYTE v11[31]; // [rsp+40h] [rbp-30h] BYREF
char v12; // [rsp+5Fh] [rbp-11h]
long long v13; // [rsp+60h] [rbp-10h]
ankerl::nanobench::Bench *v14; // [rsp+68h] [rbp-8h]
v14 = this;
v13 = a2;
v12 = 0;
std::vector<ankerl::nanobench::BigO>::vector();
ankerl::nanobench::BigO::collectRangeMeasure(v11, a2 + 280);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_0>(
this,
"O(1)",
v11,
&v10);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[5],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_1>(
this,
"O(n)",
v11,
&v9);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[9],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_2>(
this,
"O(log n)",
v11,
&v8);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[11],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_3>(
this,
"O(n log n)",
v11,
&v7);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_4>(
this,
"O(n^2)",
v11,
&v6);
std::vector<ankerl::nanobench::BigO>::emplace_back<char const(&)[7],std::vector&<std::pair<double,double>,std::allocator<std::pair>>,ankerl::nanobench::Bench::complexityBigO(void)::$_5>(
this,
"O(n^3)",
v11,
&v5);
v4 = std::vector<ankerl::nanobench::BigO>::begin(this);
v3 = std::vector<ankerl::nanobench::BigO>::end(this);
std::sort<__gnu_cxx::__normal_iterator<ankerl::nanobench::BigO *,std::vector<ankerl::nanobench::BigO>>>(v4, v3);
v12 = 1;
std::vector<std::pair<double,double>>::~vector(v11);
if ( (v12 & 1) == 0 )
std::vector<ankerl::nanobench::BigO>::~vector(this);
return this;
}
| complexityBigO:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x70],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x68],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV byte ptr [RBP + -0x11],0x0
CALL 0x0011ec30
MOV RSI,qword ptr [RBP + -0x60]
ADD RSI,0x118
LAB_001189a7:
LEA RDI,[RBP + -0x30]
CALL 0x00118ae0
JMP 0x001189b2
LAB_001189b2:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x1364dc]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x3d]
CALL 0x00118c00
JMP 0x001189cc
LAB_001189cc:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x1364e1]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x3e]
CALL 0x00118c90
JMP 0x001189e6
LAB_001189e6:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x1364e6]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x3f]
CALL 0x00118d20
JMP 0x00118a00
LAB_00118a00:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x1364ef]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x40]
CALL 0x00118db0
JMP 0x00118a1a
LAB_00118a1a:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x1364fa]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x41]
CALL 0x00118e40
JMP 0x00118a34
LAB_00118a34:
MOV RDI,qword ptr [RBP + -0x70]
LEA RSI,[0x136501]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x42]
CALL 0x00118ed0
JMP 0x00118a4e
LAB_00118a4e:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x0011ec90
MOV RDI,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x50],RAX
CALL 0x0011ecc0
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x58]
CALL 0x0011ec50
LAB_00118a75:
JMP 0x00118a77
LAB_00118a77:
MOV byte ptr [RBP + -0x11],0x1
LEA RDI,[RBP + -0x30]
CALL 0x0011ecf0
TEST byte ptr [RBP + -0x11],0x1
JNZ 0x00118aba
JMP 0x00118ab1
LAB_00118ab1:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x0011ed50
LAB_00118aba:
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x70
POP RBP
RET
|
/* ankerl::nanobench::Bench::complexityBigO() const */
vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>> *
ankerl::nanobench::Bench::complexityBigO(void)
{
int8 uVar1;
int8 uVar2;
long in_RSI;
vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>> *in_RDI;
__5 local_4a;
__4 local_49;
__3 local_48;
__2 local_47;
__1 local_46;
__0 local_45 [13];
BigO local_38 [31];
byte local_19;
local_19 = 0;
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::vector(in_RDI);
/* try { // try from 001189a7 to 001189af has its CatchHandler @ 00118a8c */
BigO::collectRangeMeasure(local_38,(vector *)(in_RSI + 0x118));
/* try { // try from 001189b2 to 00118a74 has its CatchHandler @ 00118a9a */
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[5],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__0>
(in_RDI,"O(1)",(vector *)local_38,local_45);
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[5],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__1>
(in_RDI,"O(n)",(vector *)local_38,&local_46);
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[9],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__2>
(in_RDI,"O(log n)",(vector *)local_38,&local_47);
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[11],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__3>
(in_RDI,"O(n log n)",(vector *)local_38,&local_48);
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[7],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__4>
(in_RDI,"O(n^2)",(vector *)local_38,&local_49);
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::
emplace_back<char_const(&)[7],std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>&,ankerl::nanobench::Bench::complexityBigO()const::__5>
(in_RDI,"O(n^3)",(vector *)local_38,&local_4a);
uVar1 = std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::begin
(in_RDI);
uVar2 = std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::end(in_RDI);
std::
sort<__gnu_cxx::__normal_iterator<ankerl::nanobench::BigO*,std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>>>
(uVar1,uVar2);
local_19 = 1;
std::vector<std::pair<double,double>,std::allocator<std::pair<double,double>>>::~vector
((vector<std::pair<double,double>,std::allocator<std::pair<double,double>>> *)local_38);
if ((local_19 & 1) == 0) {
std::vector<ankerl::nanobench::BigO,std::allocator<ankerl::nanobench::BigO>>::~vector(in_RDI);
}
return in_RDI;
}
| |
53,753 | composition_destination_out | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-blend.c | static void composition_destination_out(uint32_t* dest, int length, const uint32_t* src, uint32_t const_alpha)
{
if(const_alpha == 255) {
for(int i = 0; i < length; i++) {
dest[i] = BYTE_MUL(dest[i], plutovg_alpha(~src[i]));
}
} else {
uint32_t cia = 255 - const_alpha;
for(int i = 0; i < length; i++) {
uint32_t sia = BYTE_MUL(plutovg_alpha(~src[i]), const_alpha) + cia;
dest[i] = BYTE_MUL(dest[i], sia);
}
}
} | O0 | c | composition_destination_out:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0xff, -0x1c(%rbp)
jne 0x386af
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x386ad
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
xorl $-0x1, %esi
shrl $0x18, %esi
andl $0xff, %esi
callq 0x37670
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x38666
jmp 0x3871b
movl $0xff, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x38719
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edi
xorl $-0x1, %edi
shrl $0x18, %edi
andl $0xff, %edi
movl -0x1c(%rbp), %esi
callq 0x37670
addl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x2c(%rbp), %esi
callq 0x37670
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x386c1
jmp 0x3871b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| composition_destination_out:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
cmp [rbp+var_1C], 0FFh
jnz short loc_386AF
mov [rbp+var_20], 0
loc_38666:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_C]
jge short loc_386AD
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov edi, [rax+rcx*4]
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_20]
mov esi, [rax+rcx*4]
xor esi, 0FFFFFFFFh
shr esi, 18h
and esi, 0FFh
call BYTE_MUL
mov edx, eax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov [rax+rcx*4], edx
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_38666
loc_386AD:
jmp short loc_3871B
loc_386AF:
mov eax, 0FFh
sub eax, [rbp+var_1C]
mov [rbp+var_24], eax
mov [rbp+var_28], 0
loc_386C1:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_C]
jge short loc_38719
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_28]
mov edi, [rax+rcx*4]
xor edi, 0FFFFFFFFh
shr edi, 18h
and edi, 0FFh
mov esi, [rbp+var_1C]
call BYTE_MUL
add eax, [rbp+var_24]
mov [rbp+var_2C], eax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_28]
mov edi, [rax+rcx*4]
mov esi, [rbp+var_2C]
call BYTE_MUL
mov edx, eax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_28]
mov [rax+rcx*4], edx
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_386C1
loc_38719:
jmp short $+2
loc_3871B:
add rsp, 30h
pop rbp
retn
| long long composition_destination_out(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
int v5; // eax
unsigned int j; // [rsp+8h] [rbp-28h]
int v7; // [rsp+Ch] [rbp-24h]
unsigned int i; // [rsp+10h] [rbp-20h]
if ( a4 == 255 )
{
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
*(_DWORD *)(a1 + 4LL * (int)i) = BYTE_MUL(
*(_DWORD *)(a1 + 4LL * (int)i),
(unsigned int)~*(_DWORD *)(a3 + 4LL * (int)i) >> 24);
}
}
else
{
v7 = 255 - a4;
for ( j = 0; ; ++j )
{
result = j;
if ( (int)j >= a2 )
break;
v5 = BYTE_MUL((unsigned int)~*(_DWORD *)(a3 + 4LL * (int)j) >> 24, a4);
*(_DWORD *)(a1 + 4LL * (int)j) = BYTE_MUL(*(_DWORD *)(a1 + 4LL * (int)j), v7 + v5);
}
}
return result;
}
| composition_destination_out:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
CMP dword ptr [RBP + -0x1c],0xff
JNZ 0x001386af
MOV dword ptr [RBP + -0x20],0x0
LAB_00138666:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0xc]
JGE 0x001386ad
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV ESI,dword ptr [RAX + RCX*0x4]
XOR ESI,0xffffffff
SHR ESI,0x18
AND ESI,0xff
CALL 0x00137670
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00138666
LAB_001386ad:
JMP 0x0013871b
LAB_001386af:
MOV EAX,0xff
SUB EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
LAB_001386c1:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0xc]
JGE 0x00138719
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + RCX*0x4]
XOR EDI,0xffffffff
SHR EDI,0x18
AND EDI,0xff
MOV ESI,dword ptr [RBP + -0x1c]
CALL 0x00137670
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + RCX*0x4]
MOV ESI,dword ptr [RBP + -0x2c]
CALL 0x00137670
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x28]
MOV dword ptr [RAX + RCX*0x4],EDX
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001386c1
LAB_00138719:
JMP 0x0013871b
LAB_0013871b:
ADD RSP,0x30
POP RBP
RET
|
void composition_destination_out(long param_1,int param_2,long param_3,int param_4)
{
int4 uVar1;
int iVar2;
int4 local_30;
int4 local_28;
if (param_4 == 0xff) {
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
uVar1 = BYTE_MUL(*(int4 *)(param_1 + (long)local_28 * 4),
(*(uint *)(param_3 + (long)local_28 * 4) ^ 0xffffffff) >> 0x18);
*(int4 *)(param_1 + (long)local_28 * 4) = uVar1;
}
}
else {
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
iVar2 = BYTE_MUL((*(uint *)(param_3 + (long)local_30 * 4) ^ 0xffffffff) >> 0x18,param_4);
uVar1 = BYTE_MUL(*(int4 *)(param_1 + (long)local_30 * 4),iVar2 + (0xff - param_4));
*(int4 *)(param_1 + (long)local_30 * 4) = uVar1;
}
}
return;
}
| |
53,754 | my_cset_init_8bit | eloqsql/strings/ctype-simple.c | static my_bool
my_cset_init_8bit(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
cs->state|= my_8bit_charset_flags_from_data(cs);
cs->caseup_multiply= 1;
cs->casedn_multiply= 1;
cs->pad_char= ' ';
if (!cs->to_lower || !cs->to_upper || !cs->m_ctype || !cs->tab_to_uni)
return TRUE;
return create_fromuni(cs, loader);
} | O3 | c | my_cset_init_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1808, %rsp # imm = 0x1808
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movq 0x68(%rdi), %r15
xorl %eax, %eax
testq %r15, %r15
je 0x5a8f1
xorl %ecx, %ecx
cmpw $0x80, (%r15,%rcx,2)
jae 0x5a8d2
incq %rcx
cmpq $0x100, %rcx # imm = 0x100
jne 0x5a8b8
movl $0x1000, %eax # imm = 0x1000
xorl %ecx, %ecx
movzwl (%r15,%rcx,2), %edx
cmpq %rdx, %rcx
jne 0x5a8ec
incq %rcx
cmpq $0x80, %rcx
jne 0x5a8d4
jmp 0x5a8f1
orl $0x2000, %eax # imm = 0x2000
orl %eax, 0xc(%rbx)
movw $0x101, 0x94(%rbx) # imm = 0x101
movb $0x20, 0xb0(%rbx)
movb $0x1, %al
cmpq $0x0, 0x48(%rbx)
je 0x5aae1
cmpq $0x0, 0x50(%rbx)
je 0x5aae1
testq %r15, %r15
je 0x5aae1
cmpq $0x0, 0x40(%rbx)
je 0x5aae1
leaq -0x1830(%rbp), %rdi
xorl %r12d, %r12d
movl $0x1800, %edx # imm = 0x1800
xorl %esi, %esi
callq 0x261c0
movzwl (%r15,%r12,2), %eax
testq %rax, %rax
sete %cl
testq %r12, %r12
setne %dl
testb %cl, %dl
jne 0x5a99e
movl %eax, %ecx
shrl $0x8, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq -0x1830(,%rcx,8), %rcx
addq %rbp, %rcx
movl (%rcx), %edx
testl %edx, %edx
je 0x5a992
movl 0x8(%rcx), %esi
movl %eax, %edi
cmpw %si, %ax
jb 0x5a981
movl %esi, %edi
movw %di, 0x8(%rcx)
movzwl 0xa(%rcx), %esi
cmpw %si, %ax
ja 0x5a996
movl %esi, %eax
jmp 0x5a996
movw %ax, 0x8(%rcx)
movw %ax, 0xa(%rcx)
incl %edx
movl %edx, (%rcx)
incq %r12
cmpq $0x100, %r12 # imm = 0x100
jne 0x5a946
leaq 0x1b0(%rip), %rcx # 0x5ab61
leaq -0x1830(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x18, %edx
callq 0x26670
xorl %r13d, %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
cmpl $0x0, -0x1830(%rbp,%rax,8)
je 0x5aa78
leaq -0x1830(,%rax,8), %r14
addq %rbp, %r14
movzwl 0xa(%r14), %r12d
movzwl 0x8(%r14), %eax
subq %rax, %r12
incq %r12
movq %r12, %rdi
movq -0x30(%rbp), %rax
callq *0x80(%rax)
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x5aacc
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x261c0
movl $0x1, %eax
movq 0x68(%rbx), %rcx
movzwl (%rcx,%rax,2), %ecx
movzwl 0x8(%r14), %edx
cmpw %dx, %cx
jb 0x5aa57
leal -0x1(%rcx), %esi
cmpw 0xa(%r14), %si
jae 0x5aa57
subq %rdx, %rcx
cmpb $0x0, (%r15,%rcx)
jg 0x5aa57
movb %al, (%r15,%rcx)
incq %rax
cmpq $0x100, %rax # imm = 0x100
jne 0x5aa2d
incq %r13
cmpq $0x100, %r13 # imm = 0x100
jne 0x5a9ca
movl $0x100, %r13d # imm = 0x100
movl %r13d, %r14d
movq %r14, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
movq -0x30(%rbp), %rax
callq *0x80(%rax)
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x5aacc
testl %r13d, %r13d
je 0x5aad0
movq %r14, %rax
shlq $0x4, %rax
leaq -0x1828(%rbp), %rcx
xorl %edx, %edx
movq 0x70(%rbx), %rsi
movups (%rcx), %xmm0
movups %xmm0, (%rsi,%rdx)
addq $0x10, %rdx
addq $0x18, %rcx
cmpq %rdx, %rax
jne 0x5aaae
movq 0x70(%rbx), %rax
jmp 0x5aad3
movb $0x1, %al
jmp 0x5aae1
xorl %r14d, %r14d
shlq $0x4, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r14)
xorl %eax, %eax
addq $0x1808, %rsp # imm = 0x1808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_cset_init_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1808h
mov [rbp+var_30], rsi
mov rbx, rdi
mov r15, [rdi+68h]
xor eax, eax
test r15, r15
jz short loc_5A8F1
xor ecx, ecx
loc_5A8B8:
cmp word ptr [r15+rcx*2], 80h
jnb short loc_5A8D2
inc rcx
cmp rcx, 100h
jnz short loc_5A8B8
mov eax, 1000h
loc_5A8D2:
xor ecx, ecx
loc_5A8D4:
movzx edx, word ptr [r15+rcx*2]
cmp rcx, rdx
jnz short loc_5A8EC
inc rcx
cmp rcx, 80h
jnz short loc_5A8D4
jmp short loc_5A8F1
loc_5A8EC:
or eax, 2000h
loc_5A8F1:
or [rbx+0Ch], eax
mov word ptr [rbx+94h], 101h
mov byte ptr [rbx+0B0h], 20h ; ' '
mov al, 1
cmp qword ptr [rbx+48h], 0
jz loc_5AAE1
cmp qword ptr [rbx+50h], 0
jz loc_5AAE1
test r15, r15
jz loc_5AAE1
cmp qword ptr [rbx+40h], 0
jz loc_5AAE1
lea rdi, [rbp+var_1830]
xor r12d, r12d
mov edx, 1800h
xor esi, esi
call _memset
loc_5A946:
movzx eax, word ptr [r15+r12*2]
test rax, rax
setz cl
test r12, r12
setnz dl
test dl, cl
jnz short loc_5A99E
mov ecx, eax
shr ecx, 8
lea rcx, [rcx+rcx*2]
lea rcx, ds:0FFFFFFFFFFFFE7D0h[rcx*8]
add rcx, rbp
mov edx, [rcx]
test edx, edx
jz short loc_5A992
mov esi, [rcx+8]
mov edi, eax
cmp ax, si
jb short loc_5A981
mov edi, esi
loc_5A981:
mov [rcx+8], di
movzx esi, word ptr [rcx+0Ah]
cmp ax, si
ja short loc_5A996
mov eax, esi
jmp short loc_5A996
loc_5A992:
mov [rcx+8], ax
loc_5A996:
mov [rcx+0Ah], ax
inc edx
mov [rcx], edx
loc_5A99E:
inc r12
cmp r12, 100h
jnz short loc_5A946
lea rcx, pcmp
lea rdi, [rbp+var_1830]
mov esi, 100h
mov edx, 18h
call _qsort
xor r13d, r13d
loc_5A9CA:
lea rax, ds:0[r13*2]
add rax, r13
cmp [rbp+rax*8+var_1830], 0
jz loc_5AA78
lea r14, ds:0FFFFFFFFFFFFE7D0h[rax*8]
add r14, rbp
movzx r12d, word ptr [r14+0Ah]
movzx eax, word ptr [r14+8]
sub r12, rax
inc r12
mov rdi, r12
mov rax, [rbp+var_30]
call qword ptr [rax+80h]
mov [r14+10h], rax
test rax, rax
jz loc_5AACC
mov r15, rax
mov rdi, rax
xor esi, esi
mov rdx, r12
call _memset
mov eax, 1
loc_5AA2D:
mov rcx, [rbx+68h]
movzx ecx, word ptr [rcx+rax*2]
movzx edx, word ptr [r14+8]
cmp cx, dx
jb short loc_5AA57
lea esi, [rcx-1]
cmp si, [r14+0Ah]
jnb short loc_5AA57
sub rcx, rdx
cmp byte ptr [r15+rcx], 0
jg short loc_5AA57
mov [r15+rcx], al
loc_5AA57:
inc rax
cmp rax, 100h
jnz short loc_5AA2D
inc r13
cmp r13, 100h
jnz loc_5A9CA
mov r13d, 100h
loc_5AA78:
mov r14d, r13d
mov rdi, r14
shl rdi, 4
add rdi, 10h
mov rax, [rbp+var_30]
call qword ptr [rax+80h]
mov [rbx+70h], rax
test rax, rax
jz short loc_5AACC
test r13d, r13d
jz short loc_5AAD0
mov rax, r14
shl rax, 4
lea rcx, [rbp+var_1828]
xor edx, edx
loc_5AAAE:
mov rsi, [rbx+70h]
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi+rdx], xmm0
add rdx, 10h
add rcx, 18h
cmp rax, rdx
jnz short loc_5AAAE
mov rax, [rbx+70h]
jmp short loc_5AAD3
loc_5AACC:
mov al, 1
jmp short loc_5AAE1
loc_5AAD0:
xor r14d, r14d
loc_5AAD3:
shl r14, 4
xorps xmm0, xmm0
movups xmmword ptr [rax+r14], xmm0
xor eax, eax
loc_5AAE1:
add rsp, 1808h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char my_cset_init_8bit(long long a1, long long a2)
{
long long v3; // r15
int v4; // eax
long long v5; // rcx
long long v6; // rcx
char result; // al
long long v8; // r12
long long v9; // rax
long long *v10; // rcx
int v11; // edx
__int16 v12; // di
long long v13; // r13
long long *v14; // r14
unsigned long long v15; // r12
long long v16; // rax
long long v17; // r15
long long i; // rax
long long v19; // rcx
long long v20; // rdx
long long v21; // rcx
long long v22; // r14
long long v23; // rax
char *v24; // rcx
long long v25; // rdx
_DWORD v26[2]; // [rsp+0h] [rbp-1830h] BYREF
char v27; // [rsp+8h] [rbp-1828h] BYREF
long long v28; // [rsp+1800h] [rbp-30h]
long long savedregs; // [rsp+1830h] [rbp+0h] BYREF
_UNKNOWN *retaddr; // [rsp+1838h] [rbp+8h]
v28 = a2;
v3 = *(_QWORD *)(a1 + 104);
v4 = 0;
if ( v3 )
{
v5 = 0LL;
while ( *(_WORD *)(v3 + 2 * v5) < 0x80u )
{
if ( ++v5 == 256 )
{
v4 = 4096;
break;
}
}
v6 = 0LL;
while ( v6 == *(unsigned __int16 *)(v3 + 2 * v6) )
{
if ( ++v6 == 128 )
goto LABEL_11;
}
v4 |= 0x2000u;
}
LABEL_11:
*(_DWORD *)(a1 + 12) |= v4;
*(_WORD *)(a1 + 148) = 257;
*(_BYTE *)(a1 + 176) = 32;
result = 1;
if ( *(_QWORD *)(a1 + 72) && *(_QWORD *)(a1 + 80) && v3 && *(_QWORD *)(a1 + 64) )
{
v8 = 0LL;
memset(v26, 0LL, 6144LL);
do
{
v9 = *(unsigned __int16 *)(v3 + 2 * v8);
if ( v9 != 0 || v8 == 0 )
{
v10 = &savedregs + 3 * ((unsigned int)v9 >> 8) - 774;
v11 = *(_DWORD *)v10;
if ( *(_DWORD *)v10 )
{
v12 = *(_WORD *)(v3 + 2 * v8);
if ( (unsigned __int16)v9 >= (unsigned __int16)*((_DWORD *)v10 + 2) )
v12 = *((_DWORD *)v10 + 2);
*((_WORD *)v10 + 4) = v12;
if ( (unsigned __int16)v9 <= *((_WORD *)v10 + 5) )
LOWORD(v9) = *((_WORD *)v10 + 5);
}
else
{
*((_WORD *)v10 + 4) = v9;
}
*((_WORD *)v10 + 5) = v9;
*(_DWORD *)v10 = v11 + 1;
}
++v8;
}
while ( v8 != 256 );
qsort(v26, 256LL, 24LL, pcmp);
v13 = 0LL;
while ( v26[6 * v13] )
{
v14 = &savedregs + 3 * v13 - 774;
v15 = *((unsigned __int16 *)&retaddr + 12 * v13 - 3095)
- (unsigned long long)*((unsigned __int16 *)&retaddr + 12 * v13 - 3096)
+ 1;
v16 = (*(long long ( **)(unsigned long long))(v28 + 128))(v15);
v14[2] = v16;
if ( !v16 )
return 1;
v17 = v16;
memset(v16, 0LL, v15);
for ( i = 1LL; i != 256; ++i )
{
v19 = *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 2 * i);
v20 = *((unsigned __int16 *)v14 + 4);
if ( (unsigned __int16)v19 >= (unsigned __int16)v20 && (unsigned __int16)(v19 - 1) < *((_WORD *)v14 + 5) )
{
v21 = v19 - v20;
if ( *(char *)(v17 + v21) <= 0 )
*(_BYTE *)(v17 + v21) = i;
}
}
if ( ++v13 == 256 )
{
LODWORD(v13) = 256;
break;
}
}
v22 = (unsigned int)v13;
v23 = (*(long long ( **)(long long))(v28 + 128))(16LL * (unsigned int)v13 + 16);
*(_QWORD *)(a1 + 112) = v23;
if ( !v23 )
return 1;
if ( (_DWORD)v13 )
{
v24 = &v27;
v25 = 0LL;
do
{
*(_OWORD *)(*(_QWORD *)(a1 + 112) + v25) = *(_OWORD *)v24;
v25 += 16LL;
v24 += 24;
}
while ( 16LL * (unsigned int)v13 != v25 );
v23 = *(_QWORD *)(a1 + 112);
}
else
{
v22 = 0LL;
}
*(_OWORD *)(v23 + 16 * v22) = 0LL;
return 0;
}
return result;
}
| my_cset_init_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1808
MOV qword ptr [RBP + -0x30],RSI
MOV RBX,RDI
MOV R15,qword ptr [RDI + 0x68]
XOR EAX,EAX
TEST R15,R15
JZ 0x0015a8f1
XOR ECX,ECX
LAB_0015a8b8:
CMP word ptr [R15 + RCX*0x2],0x80
JNC 0x0015a8d2
INC RCX
CMP RCX,0x100
JNZ 0x0015a8b8
MOV EAX,0x1000
LAB_0015a8d2:
XOR ECX,ECX
LAB_0015a8d4:
MOVZX EDX,word ptr [R15 + RCX*0x2]
CMP RCX,RDX
JNZ 0x0015a8ec
INC RCX
CMP RCX,0x80
JNZ 0x0015a8d4
JMP 0x0015a8f1
LAB_0015a8ec:
OR EAX,0x2000
LAB_0015a8f1:
OR dword ptr [RBX + 0xc],EAX
MOV word ptr [RBX + 0x94],0x101
MOV byte ptr [RBX + 0xb0],0x20
MOV AL,0x1
CMP qword ptr [RBX + 0x48],0x0
JZ 0x0015aae1
CMP qword ptr [RBX + 0x50],0x0
JZ 0x0015aae1
TEST R15,R15
JZ 0x0015aae1
CMP qword ptr [RBX + 0x40],0x0
JZ 0x0015aae1
LEA RDI,[RBP + -0x1830]
XOR R12D,R12D
MOV EDX,0x1800
XOR ESI,ESI
CALL 0x001261c0
LAB_0015a946:
MOVZX EAX,word ptr [R15 + R12*0x2]
TEST RAX,RAX
SETZ CL
TEST R12,R12
SETNZ DL
TEST DL,CL
JNZ 0x0015a99e
MOV ECX,EAX
SHR ECX,0x8
LEA RCX,[RCX + RCX*0x2]
LEA RCX,[-0x1830 + RCX*0x8]
ADD RCX,RBP
MOV EDX,dword ptr [RCX]
TEST EDX,EDX
JZ 0x0015a992
MOV ESI,dword ptr [RCX + 0x8]
MOV EDI,EAX
CMP AX,SI
JC 0x0015a981
MOV EDI,ESI
LAB_0015a981:
MOV word ptr [RCX + 0x8],DI
MOVZX ESI,word ptr [RCX + 0xa]
CMP AX,SI
JA 0x0015a996
MOV EAX,ESI
JMP 0x0015a996
LAB_0015a992:
MOV word ptr [RCX + 0x8],AX
LAB_0015a996:
MOV word ptr [RCX + 0xa],AX
INC EDX
MOV dword ptr [RCX],EDX
LAB_0015a99e:
INC R12
CMP R12,0x100
JNZ 0x0015a946
LEA RCX,[0x15ab61]
LEA RDI,[RBP + -0x1830]
MOV ESI,0x100
MOV EDX,0x18
CALL 0x00126670
XOR R13D,R13D
LAB_0015a9ca:
LEA RAX,[R13*0x2]
ADD RAX,R13
CMP dword ptr [RBP + RAX*0x8 + -0x1830],0x0
JZ 0x0015aa78
LEA R14,[-0x1830 + RAX*0x8]
ADD R14,RBP
MOVZX R12D,word ptr [R14 + 0xa]
MOVZX EAX,word ptr [R14 + 0x8]
SUB R12,RAX
INC R12
MOV RDI,R12
MOV RAX,qword ptr [RBP + -0x30]
CALL qword ptr [RAX + 0x80]
MOV qword ptr [R14 + 0x10],RAX
TEST RAX,RAX
JZ 0x0015aacc
MOV R15,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV RDX,R12
CALL 0x001261c0
MOV EAX,0x1
LAB_0015aa2d:
MOV RCX,qword ptr [RBX + 0x68]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOVZX EDX,word ptr [R14 + 0x8]
CMP CX,DX
JC 0x0015aa57
LEA ESI,[RCX + -0x1]
CMP SI,word ptr [R14 + 0xa]
JNC 0x0015aa57
SUB RCX,RDX
CMP byte ptr [R15 + RCX*0x1],0x0
JG 0x0015aa57
MOV byte ptr [R15 + RCX*0x1],AL
LAB_0015aa57:
INC RAX
CMP RAX,0x100
JNZ 0x0015aa2d
INC R13
CMP R13,0x100
JNZ 0x0015a9ca
MOV R13D,0x100
LAB_0015aa78:
MOV R14D,R13D
MOV RDI,R14
SHL RDI,0x4
ADD RDI,0x10
MOV RAX,qword ptr [RBP + -0x30]
CALL qword ptr [RAX + 0x80]
MOV qword ptr [RBX + 0x70],RAX
TEST RAX,RAX
JZ 0x0015aacc
TEST R13D,R13D
JZ 0x0015aad0
MOV RAX,R14
SHL RAX,0x4
LEA RCX,[RBP + -0x1828]
XOR EDX,EDX
LAB_0015aaae:
MOV RSI,qword ptr [RBX + 0x70]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI + RDX*0x1],XMM0
ADD RDX,0x10
ADD RCX,0x18
CMP RAX,RDX
JNZ 0x0015aaae
MOV RAX,qword ptr [RBX + 0x70]
JMP 0x0015aad3
LAB_0015aacc:
MOV AL,0x1
JMP 0x0015aae1
LAB_0015aad0:
XOR R14D,R14D
LAB_0015aad3:
SHL R14,0x4
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + R14*0x1],XMM0
XOR EAX,EAX
LAB_0015aae1:
ADD RSP,0x1808
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_cset_init_8bit(long param_1,long param_2)
{
int8 *puVar1;
int iVar2;
ushort uVar3;
uint uVar4;
int8 uVar5;
void *__s;
long lVar6;
long lVar7;
ulong uVar8;
ushort *puVar9;
ushort uVar10;
size_t __n;
ulong uVar11;
int local_1838 [2];
ushort local_1830 [4];
int8 auStack_1828 [766];
long local_38;
lVar6 = *(long *)(param_1 + 0x68);
uVar4 = 0;
if (lVar6 != 0) {
lVar7 = 0;
do {
if (0x7f < *(ushort *)(lVar6 + lVar7 * 2)) goto LAB_0015a8d2;
lVar7 = lVar7 + 1;
} while (lVar7 != 0x100);
uVar4 = 0x1000;
LAB_0015a8d2:
uVar8 = 0;
do {
if (uVar8 != *(ushort *)(lVar6 + uVar8 * 2)) {
uVar4 = uVar4 | 0x2000;
break;
}
uVar8 = uVar8 + 1;
} while (uVar8 != 0x80);
}
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | uVar4;
*(int2 *)(param_1 + 0x94) = 0x101;
*(int1 *)(param_1 + 0xb0) = 0x20;
uVar5 = 1;
if ((((*(long *)(param_1 + 0x48) != 0) && (*(long *)(param_1 + 0x50) != 0)) && (lVar6 != 0)) &&
(*(long *)(param_1 + 0x40) != 0)) {
lVar7 = 0;
local_38 = param_2;
memset(local_1838,0,0x1800);
do {
uVar3 = *(ushort *)(lVar6 + lVar7 * 2);
if (lVar7 == 0 || uVar3 != 0) {
uVar8 = (ulong)(uVar3 >> 8);
iVar2 = local_1838[uVar8 * 6];
if (iVar2 == 0) {
local_1830[uVar8 * 0xc] = uVar3;
}
else {
uVar10 = uVar3;
if ((ushort)*(int4 *)(local_1830 + uVar8 * 0xc) <= uVar3) {
uVar10 = (ushort)*(int4 *)(local_1830 + uVar8 * 0xc);
}
local_1830[uVar8 * 0xc] = uVar10;
if (uVar3 <= local_1830[uVar8 * 0xc + 1]) {
uVar3 = local_1830[uVar8 * 0xc + 1];
}
}
local_1830[uVar8 * 0xc + 1] = uVar3;
local_1838[uVar8 * 6] = iVar2 + 1;
}
lVar7 = lVar7 + 1;
} while (lVar7 != 0x100);
qsort(local_1838,0x100,0x18,pcmp);
uVar8 = 0;
do {
if (local_1838[uVar8 * 6] == 0) goto LAB_0015aa78;
__n = ((ulong)local_1830[uVar8 * 0xc + 1] - (ulong)local_1830[uVar8 * 0xc]) + 1;
__s = (void *)(**(code **)(local_38 + 0x80))(__n);
auStack_1828[uVar8 * 3] = __s;
if (__s == (void *)0x0) goto LAB_0015aacc;
memset(__s,0,__n);
lVar6 = 1;
do {
uVar3 = *(ushort *)(*(long *)(param_1 + 0x68) + lVar6 * 2);
if (((local_1830[uVar8 * 0xc] <= uVar3) &&
((ushort)(uVar3 - 1) < local_1830[uVar8 * 0xc + 1])) &&
(lVar7 = (ulong)uVar3 - (ulong)local_1830[uVar8 * 0xc],
*(char *)((long)__s + lVar7) < '\x01')) {
*(char *)((long)__s + lVar7) = (char)lVar6;
}
lVar6 = lVar6 + 1;
} while (lVar6 != 0x100);
uVar8 = uVar8 + 1;
} while (uVar8 != 0x100);
uVar8 = 0x100;
LAB_0015aa78:
uVar11 = uVar8 & 0xffffffff;
lVar6 = (**(code **)(local_38 + 0x80))(uVar11 * 0x10 + 0x10);
*(long *)(param_1 + 0x70) = lVar6;
if (lVar6 == 0) {
LAB_0015aacc:
uVar5 = 1;
}
else {
if ((int)uVar8 == 0) {
uVar11 = 0;
}
else {
puVar9 = local_1830;
lVar6 = 0;
do {
uVar5 = *(int8 *)(puVar9 + 4);
puVar1 = (int8 *)(*(long *)(param_1 + 0x70) + lVar6);
*puVar1 = *(int8 *)puVar9;
puVar1[1] = uVar5;
lVar6 = lVar6 + 0x10;
puVar9 = puVar9 + 0xc;
} while (uVar11 << 4 != lVar6);
lVar6 = *(long *)(param_1 + 0x70);
}
puVar1 = (int8 *)(lVar6 + uVar11 * 0x10);
*puVar1 = 0;
puVar1[1] = 0;
uVar5 = 0;
}
}
return uVar5;
}
| |
53,755 | my_hash_iterate | eloqsql/mysys/hash.c | my_bool my_hash_iterate(HASH *hash, my_hash_walk_action action, void *argument)
{
uint records, i;
records= hash->records;
for (i= 0 ; i < records ; i++)
{
if ((*action)(dynamic_element(&hash->array, i, HASH_LINK *)->data,
argument))
return 1;
}
return 0;
} | O3 | c | my_hash_iterate:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x18(%rdi), %r12d
testq %r12, %r12
je 0x29dac
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x4, %r12
xorl %r13d, %r13d
movq 0x28(%r15), %rax
movq 0x8(%rax,%r13), %rdi
movq %rbx, %rsi
callq *%r14
testb %al, %al
jne 0x29db0
addq $0x10, %r13
cmpq %r13, %r12
jne 0x29d90
xorl %eax, %eax
jmp 0x29db2
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| my_hash_iterate:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12d, [rdi+18h]
test r12, r12
jz short loc_29DAC
mov rbx, rdx
mov r14, rsi
mov r15, rdi
shl r12, 4
xor r13d, r13d
loc_29D90:
mov rax, [r15+28h]
mov rdi, [rax+r13+8]
mov rsi, rbx
call r14
test al, al
jnz short loc_29DB0
add r13, 10h
cmp r12, r13
jnz short loc_29D90
loc_29DAC:
xor eax, eax
jmp short loc_29DB2
loc_29DB0:
mov al, 1
loc_29DB2:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char my_hash_iterate(long long a1, unsigned __int8 ( *a2)(_QWORD, long long), long long a3)
{
long long v4; // r12
long long v5; // r13
if ( !*(_DWORD *)(a1 + 24) )
return 0;
v4 = 16LL * *(unsigned int *)(a1 + 24);
v5 = 0LL;
while ( !a2(*(_QWORD *)(*(_QWORD *)(a1 + 40) + v5 + 8), a3) )
{
v5 += 16LL;
if ( v4 == v5 )
return 0;
}
return 1;
}
| my_hash_iterate:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12D,dword ptr [RDI + 0x18]
TEST R12,R12
JZ 0x00129dac
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
SHL R12,0x4
XOR R13D,R13D
LAB_00129d90:
MOV RAX,qword ptr [R15 + 0x28]
MOV RDI,qword ptr [RAX + R13*0x1 + 0x8]
MOV RSI,RBX
CALL R14
TEST AL,AL
JNZ 0x00129db0
ADD R13,0x10
CMP R12,R13
JNZ 0x00129d90
LAB_00129dac:
XOR EAX,EAX
JMP 0x00129db2
LAB_00129db0:
MOV AL,0x1
LAB_00129db2:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_hash_iterate(long param_1,code *param_2,int8 param_3)
{
uint uVar1;
char cVar2;
long lVar3;
uVar1 = *(uint *)(param_1 + 0x18);
if ((ulong)uVar1 != 0) {
lVar3 = 0;
do {
cVar2 = (*param_2)(*(int8 *)(*(long *)(param_1 + 0x28) + 8 + lVar3),param_3);
if (cVar2 != '\0') {
return 1;
}
lVar3 = lVar3 + 0x10;
} while ((ulong)uVar1 << 4 != lVar3);
}
return 0;
}
| |
53,756 | find_or_create_account(PFS_thread*, char const*, unsigned int, char const*, unsigned int) | eloqsql/storage/perfschema/pfs_account.cc | PFS_account *
find_or_create_account(PFS_thread *thread,
const char *username, uint username_length,
const char *hostname, uint hostname_length)
{
LF_PINS *pins= get_account_hash_pins(thread);
if (unlikely(pins == NULL))
{
global_account_container.m_lost++;
return NULL;
}
PFS_account_key key;
set_account_key(&key, username, username_length,
hostname, hostname_length);
PFS_account **entry;
PFS_account *pfs;
uint retry_count= 0;
const uint retry_max= 3;
pfs_dirty_state dirty_state;
search:
entry= reinterpret_cast<PFS_account**>
(lf_hash_search(&account_hash, pins,
key.m_hash_key, key.m_key_length));
if (entry && (entry != MY_ERRPTR))
{
pfs= *entry;
pfs->inc_refcount();
lf_hash_search_unpin(pins);
return pfs;
}
lf_hash_search_unpin(pins);
pfs= global_account_container.allocate(& dirty_state);
if (pfs != NULL)
{
pfs->m_key= key;
if (username_length > 0)
pfs->m_username= &pfs->m_key.m_hash_key[0];
else
pfs->m_username= NULL;
pfs->m_username_length= username_length;
if (hostname_length > 0)
pfs->m_hostname= &pfs->m_key.m_hash_key[username_length + 1];
else
pfs->m_hostname= NULL;
pfs->m_hostname_length= hostname_length;
pfs->m_user= find_or_create_user(thread, username, username_length);
pfs->m_host= find_or_create_host(thread, hostname, hostname_length);
pfs->init_refcount();
pfs->reset_stats();
pfs->m_disconnected_count= 0;
if (username_length > 0 && hostname_length > 0)
{
lookup_setup_actor(thread, username, username_length, hostname, hostname_length,
& pfs->m_enabled, & pfs->m_history);
}
else
{
pfs->m_enabled= true;
pfs->m_history= true;
}
int res;
pfs->m_lock.dirty_to_allocated(& dirty_state);
res= lf_hash_insert(&account_hash, pins, &pfs);
if (likely(res == 0))
{
return pfs;
}
if (pfs->m_user)
{
pfs->m_user->release();
pfs->m_user= NULL;
}
if (pfs->m_host)
{
pfs->m_host->release();
pfs->m_host= NULL;
}
global_account_container.deallocate(pfs);
if (res > 0)
{
if (++retry_count > retry_max)
{
global_account_container.m_lost++;
return NULL;
}
goto search;
}
global_account_container.m_lost++;
return NULL;
}
return NULL;
} | O3 | cpp | find_or_create_account(PFS_thread*, char const*, unsigned int, char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movl %r8d, %ebx
movq %rcx, -0x2d0(%rbp)
movl %edx, %r15d
movq %rsi, %r13
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x2e0(%rbp)
movq 0x838(%rdi), %rcx
testq %rcx, %rcx
je 0x4178b
movq %rcx, -0x2e8(%rbp)
testl %r15d, %r15d
je 0x4148e
movl %r15d, %r12d
leaq -0x2b8(%rbp), %rdi
movl $0x288, %ecx # imm = 0x288
movq %r13, %rsi
movq %r12, %rdx
callq 0x26600
addq %rbp, %r12
addq $-0x2b8, %r12 # imm = 0xFD48
jmp 0x41495
leaq -0x2b8(%rbp), %r12
movq %r13, -0x2f8(%rbp)
movb $0x0, (%r12)
incq %r12
testl %ebx, %ebx
je 0x414c0
movl %ebx, %r13d
movq %r12, %rdi
movq -0x2d0(%rbp), %rsi
movq %r13, %rdx
callq 0x26290
addq %r13, %r12
movb $0x0, (%r12)
leaq -0x2b8(%rbp), %rdx
subl %edx, %r12d
incl %r12d
movl %r12d, 0x284(%rdx)
testl %r15d, %r15d
setne %al
testl %ebx, %ebx
setne %cl
leal 0x1(%r15), %esi
movq %rsi, -0x2f0(%rbp)
andb %al, %cl
movb %cl, -0x2b9(%rbp)
movl $0x4, %r13d
leaq 0x391214(%rip), %rdi # 0x3d2718
xorl %r14d, %r14d
movq -0x2e8(%rbp), %r12
movl -0x34(%rbp), %ecx
movq %r12, %rsi
callq 0x2c4e9
cmpq $0x2, %rax
jae 0x41748
movl %r13d, -0x2d4(%rbp)
xorl %eax, %eax
xchgq %rax, 0x10(%r12)
leaq 0x386b68(%rip), %rdi # 0x3c80a0
leaq -0x2d8(%rbp), %rsi
callq 0x420d4
movq %rax, -0x2c8(%rbp)
testq %rax, %rax
je 0x41767
movq %rax, %r13
leaq 0x7e4(%rax), %r14
movl $0x288, %edx # imm = 0x288
movq %r14, %rdi
leaq -0x2b8(%rbp), %rsi
callq 0x26290
testl %r15d, %r15d
movl $0x0, %ecx
cmoveq %rcx, %r14
testl %ebx, %ebx
movq %r14, 0xa70(%r13)
movq -0x2d0(%rbp), %r14
movl %r15d, 0xa78(%r13)
movq -0x2f0(%rbp), %rax
leaq 0x7e4(%r13,%rax), %rax
cmoveq %rcx, %rax
movq %rax, 0xa80(%r13)
movl %ebx, 0xa88(%r13)
movq -0x2e0(%rbp), %r13
movq %r13, %rdi
movq -0x2f8(%rbp), %r12
movq %r12, %rsi
movl %r15d, %edx
callq 0x3d2e8
movq -0x2c8(%rbp), %rcx
movq %rax, 0xa90(%rcx)
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x31274
movq -0x2c8(%rbp), %rcx
movq %rax, 0xa98(%rcx)
movl $0x1, %eax
xchgl %eax, 0xaa8(%rcx)
leaq 0x30(%rcx), %rdi
movb $0x0, 0x4(%rcx)
movl $0x0, (%rcx)
callq 0x3ca28
movq -0x2c8(%rbp), %rax
movq $0x0, 0xaa0(%rax)
cmpb $0x0, -0x2b9(%rbp)
je 0x41666
leaq 0xa6c(%rax), %r9
addq $0xa6d, %rax # imm = 0xA6D
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movq -0x2d0(%rbp), %rcx
movl %ebx, %r8d
callq 0x3ba5f
movq -0x2c8(%rbp), %rax
jmp 0x4166f
movw $0x101, 0xa6c(%rax) # imm = 0x101
leaq 0x3910a2(%rip), %rdi # 0x3d2718
leaq -0x2c8(%rbp), %rdx
movl -0x2d8(%rbp), %ecx
andl $-0x4, %ecx
addl $0x6, %ecx
xchgl %ecx, 0x7e0(%rax)
movq -0x2e8(%rbp), %r12
movq %r12, %rsi
callq 0x2bc8a
movq -0x2c8(%rbp), %r14
testl %eax, %eax
je 0x41767
movl %eax, %r13d
movq 0xa90(%r14), %rdi
testq %rdi, %rdi
je 0x416d3
callq 0x3d5d6
movq -0x2c8(%rbp), %r14
movq $0x0, 0xa90(%r14)
movq 0xa98(%r14), %rdi
testq %rdi, %rdi
je 0x416f6
callq 0x31652
movq -0x2c8(%rbp), %r14
movq $0x0, 0xa98(%r14)
movq 0x7d8(%r14), %rcx
movl 0x7e0(%r14), %edx
andl $-0x4, %edx
xchgl %edx, 0x7e0(%r14)
xorl %eax, %eax
movb %al, (%rcx)
xorl %r14d, %r14d
leaq 0x386984(%rip), %rcx # 0x3c80a0
movb %al, 0x9(%rcx)
testl %r13d, %r13d
movl -0x2d4(%rbp), %r13d
jle 0x417ba
decl %r13d
leaq -0x2b8(%rbp), %rdx
leaq 0x390fd8(%rip), %rdi # 0x3d2718
jne 0x4150e
jmp 0x417ba
movq (%rax), %rax
movq %rax, -0x2c8(%rbp)
lock
incl 0xaa8(%rax)
xorl %eax, %eax
xchgq %rax, 0x10(%r12)
movq -0x2c8(%rbp), %r14
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x417c9
movq %r14, %rax
addq $0x2d8, %rsp # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x39104e(%rip) # 0x3d27e0
jne 0x417ba
leaq 0x390fa5(%rip), %rdi # 0x3d2740
callq 0x2baaf
movq %rax, %rcx
movq -0x2e0(%rbp), %rax
movq %rcx, 0x838(%rax)
testq %rcx, %rcx
jne 0x4145c
leaq 0x3868df(%rip), %rax # 0x3c80a0
incq (%rax)
xorl %r14d, %r14d
jmp 0x41767
callq 0x263b0
| _Z22find_or_create_accountP10PFS_threadPKcjS2_j:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2D8h
mov ebx, r8d
mov [rbp+var_2D0], rcx
mov r15d, edx
mov r13, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_2E0], rdi
mov rcx, [rdi+838h]
test rcx, rcx
jz loc_4178B
loc_4145C:
mov [rbp+var_2E8], rcx
test r15d, r15d
jz short loc_4148E
mov r12d, r15d
lea rdi, [rbp+var_2B8]
mov ecx, 288h
mov rsi, r13
mov rdx, r12
call ___memcpy_chk
add r12, rbp
add r12, 0FFFFFFFFFFFFFD48h
jmp short loc_41495
loc_4148E:
lea r12, [rbp+var_2B8]
loc_41495:
mov [rbp+var_2F8], r13
mov byte ptr [r12], 0
inc r12
test ebx, ebx
jz short loc_414C0
mov r13d, ebx
mov rdi, r12
mov rsi, [rbp+var_2D0]
mov rdx, r13
call _memcpy
add r12, r13
loc_414C0:
mov byte ptr [r12], 0
lea rdx, [rbp+var_2B8]
sub r12d, edx
inc r12d
mov [rdx+284h], r12d
test r15d, r15d
setnz al
test ebx, ebx
setnz cl
lea esi, [r15+1]
mov [rbp+var_2F0], rsi
and cl, al
mov [rbp+var_2B9], cl
mov r13d, 4
lea rdi, account_hash
xor r14d, r14d
mov r12, [rbp+var_2E8]
loc_4150E:
mov ecx, [rbp+var_34]
mov rsi, r12
call lf_hash_search
cmp rax, 2
jnb loc_41748
mov [rbp+var_2D4], r13d
xor eax, eax
xchg rax, [r12+10h]
lea rdi, global_account_container
lea rsi, [rbp+var_2D8]
call _ZN29PFS_buffer_scalable_containerI11PFS_accountLi128ELi128E17PFS_account_array21PFS_account_allocatorE8allocateEP15pfs_dirty_state; PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>::allocate(pfs_dirty_state *)
mov [rbp+var_2C8], rax
test rax, rax
jz loc_41767
mov r13, rax
lea r14, [rax+7E4h]
mov edx, 288h
mov rdi, r14
lea rsi, [rbp+var_2B8]
call _memcpy
test r15d, r15d
mov ecx, 0
cmovz r14, rcx
test ebx, ebx
mov [r13+0A70h], r14
mov r14, [rbp+var_2D0]
mov [r13+0A78h], r15d
mov rax, [rbp+var_2F0]
lea rax, [r13+rax+7E4h]
cmovz rax, rcx
mov [r13+0A80h], rax
mov [r13+0A88h], ebx
mov r13, [rbp+var_2E0]
mov rdi, r13; PFS_thread *
mov r12, [rbp+var_2F8]
mov rsi, r12; char *
mov edx, r15d; unsigned int
call _Z19find_or_create_userP10PFS_threadPKcj; find_or_create_user(PFS_thread *,char const*,uint)
mov rcx, [rbp+var_2C8]
mov [rcx+0A90h], rax
mov rdi, r13; PFS_thread *
mov rsi, r14; char *
mov edx, ebx; unsigned int
call _Z19find_or_create_hostP10PFS_threadPKcj; find_or_create_host(PFS_thread *,char const*,uint)
mov rcx, [rbp+var_2C8]
mov [rcx+0A98h], rax
mov eax, 1
xchg eax, [rcx+0AA8h]
lea rdi, [rcx+30h]; this
mov byte ptr [rcx+4], 0
mov dword ptr [rcx], 0
call _ZN16PFS_status_stats5resetEv; PFS_status_stats::reset(void)
mov rax, [rbp+var_2C8]
mov qword ptr [rax+0AA0h], 0
cmp [rbp+var_2B9], 0
jz short loc_41666
lea r9, [rax+0A6Ch]; bool *
add rax, 0A6Dh
mov [rsp+300h+var_300], rax; bool *
mov rdi, r13; PFS_thread *
mov rsi, r12; char *
mov edx, r15d; unsigned int
mov rcx, [rbp+var_2D0]; char *
mov r8d, ebx; unsigned int
call _Z18lookup_setup_actorP10PFS_threadPKcjS2_jPbS3_; lookup_setup_actor(PFS_thread *,char const*,uint,char const*,uint,bool *,bool *)
mov rax, [rbp+var_2C8]
jmp short loc_4166F
loc_41666:
mov word ptr [rax+0A6Ch], 101h
loc_4166F:
lea rdi, account_hash
lea rdx, [rbp+var_2C8]
mov ecx, [rbp+var_2D8]
and ecx, 0FFFFFFFCh
add ecx, 6
xchg ecx, [rax+7E0h]
mov r12, [rbp+var_2E8]
mov rsi, r12
call lf_hash_insert
mov r14, [rbp+var_2C8]
test eax, eax
jz loc_41767
mov r13d, eax
mov rdi, [r14+0A90h]; this
test rdi, rdi
jz short loc_416D3
call _ZN8PFS_user7releaseEv; PFS_user::release(void)
mov r14, [rbp+var_2C8]
mov qword ptr [r14+0A90h], 0
loc_416D3:
mov rdi, [r14+0A98h]; this
test rdi, rdi
jz short loc_416F6
call _ZN8PFS_host7releaseEv; PFS_host::release(void)
mov r14, [rbp+var_2C8]
mov qword ptr [r14+0A98h], 0
loc_416F6:
mov rcx, [r14+7D8h]
mov edx, [r14+7E0h]
and edx, 0FFFFFFFCh
xchg edx, [r14+7E0h]
xor eax, eax
mov [rcx], al
xor r14d, r14d
lea rcx, global_account_container
mov [rcx+9], al
test r13d, r13d
mov r13d, [rbp+var_2D4]
jle loc_417BA
dec r13d
lea rdx, [rbp+var_2B8]
lea rdi, account_hash
jnz loc_4150E
jmp short loc_417BA
loc_41748:
mov rax, [rax]
mov [rbp+var_2C8], rax
lock inc dword ptr [rax+0AA8h]
xor eax, eax
xchg rax, [r12+10h]
mov r14, [rbp+var_2C8]
loc_41767:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_417C9
mov rax, r14
add rsp, 2D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4178B:
cmp cs:_ZL19account_hash_inited, 1; account_hash_inited
jnz short loc_417BA
lea rdi, unk_3D2740
call lf_pinbox_get_pins
mov rcx, rax
mov rax, [rbp+var_2E0]
mov [rax+838h], rcx
test rcx, rcx
jnz loc_4145C
loc_417BA:
lea rax, global_account_container
inc qword ptr [rax]
xor r14d, r14d
jmp short loc_41767
loc_417C9:
call ___stack_chk_fail
| long long find_or_create_account(PFS_thread *a1, const char *a2, unsigned int a3, char *a4, unsigned int a5)
{
long long pins; // rcx
_BYTE *v8; // r12
_BYTE *v9; // r12
int v10; // r13d
long long v11; // r14
volatile long long *v12; // r12
long long *v13; // rax
long long v14; // rax
long long v15; // r13
long long v16; // r14
char *v17; // r14
long long v18; // rax
long long user; // rax
long long host; // rax
long long v21; // rcx
long long v22; // rax
int v23; // eax
int v24; // r13d
PFS_user *v25; // rdi
PFS_host *v26; // rdi
_BYTE *v27; // rcx
long long v29; // [rsp+18h] [rbp-2E8h]
int v31; // [rsp+28h] [rbp-2D8h] BYREF
int v32; // [rsp+2Ch] [rbp-2D4h]
char *v33; // [rsp+30h] [rbp-2D0h]
long long v34; // [rsp+38h] [rbp-2C8h] BYREF
bool v35; // [rsp+47h] [rbp-2B9h]
_BYTE v36[644]; // [rsp+48h] [rbp-2B8h] BYREF
unsigned int v37; // [rsp+2CCh] [rbp-34h]
unsigned long long v38; // [rsp+2D0h] [rbp-30h]
v33 = a4;
v38 = __readfsqword(0x28u);
pins = *((_QWORD *)a1 + 263);
if ( pins
|| account_hash_inited == 1
&& (pins = lf_pinbox_get_pins((long long)&unk_3D2740), (*((_QWORD *)a1 + 263) = pins) != 0LL) )
{
v29 = pins;
if ( a3 )
{
__memcpy_chk(v36, a2, a3, 648LL);
v8 = &v36[a3];
}
else
{
v8 = v36;
}
*v8 = 0;
v9 = v8 + 1;
if ( a5 )
{
memcpy(v9, v33, a5);
v9 += a5;
}
*v9 = 0;
v37 = (_DWORD)v9 - (unsigned int)v36 + 1;
v35 = a3 != 0 && a5 != 0;
v10 = 4;
v11 = 0LL;
v12 = (volatile long long *)v29;
while ( 1 )
{
v13 = (long long *)lf_hash_search((long long)&account_hash, v12, (long long)v36, v37);
if ( (unsigned long long)v13 >= 2 )
break;
v32 = v10;
_InterlockedExchange64(v12 + 2, 0LL);
v14 = PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>::allocate(
global_account_container,
&v31);
v34 = v14;
if ( !v14 )
return v11;
v15 = v14;
v16 = v14 + 2020;
memcpy(v14 + 2020, v36, 648LL);
if ( !a3 )
v16 = 0LL;
*(_QWORD *)(v15 + 2672) = v16;
v17 = v33;
*(_DWORD *)(v15 + 2680) = a3;
v18 = v15 + a3 + 1 + 2020;
if ( !a5 )
v18 = 0LL;
*(_QWORD *)(v15 + 2688) = v18;
*(_DWORD *)(v15 + 2696) = a5;
user = find_or_create_user(a1, a2, a3);
*(_QWORD *)(v34 + 2704) = user;
host = find_or_create_host(a1, v17, a5);
v21 = v34;
*(_QWORD *)(v34 + 2712) = host;
_InterlockedExchange((volatile __int32 *)(v21 + 2728), 1);
*(_BYTE *)(v21 + 4) = 0;
*(_DWORD *)v21 = 0;
PFS_status_stats::reset((PFS_status_stats *)(v21 + 48));
v22 = v34;
*(_QWORD *)(v34 + 2720) = 0LL;
if ( v35 )
{
lookup_setup_actor(a1, a2, a3, v33, a5, (bool *)(v22 + 2668), (bool *)(v22 + 2669));
v22 = v34;
}
else
{
*(_WORD *)(v22 + 2668) = 257;
}
_InterlockedExchange((volatile __int32 *)(v22 + 2016), (v31 & 0xFFFFFFFC) + 6);
v12 = (volatile long long *)v29;
v23 = lf_hash_insert((long long)&account_hash, v29, (long long)&v34);
v11 = v34;
if ( !v23 )
return v11;
v24 = v23;
v25 = *(PFS_user **)(v34 + 2704);
if ( v25 )
{
PFS_user::release(v25);
v11 = v34;
*(_QWORD *)(v34 + 2704) = 0LL;
}
v26 = *(PFS_host **)(v11 + 2712);
if ( v26 )
{
PFS_host::release(v26);
v11 = v34;
*(_QWORD *)(v34 + 2712) = 0LL;
}
v27 = *(_BYTE **)(v11 + 2008);
_InterlockedExchange((volatile __int32 *)(v11 + 2016), *(_DWORD *)(v11 + 2016) & 0xFFFFFFFC);
*v27 = 0;
v11 = 0LL;
BYTE1(global_account_container[1]) = 0;
if ( v24 > 0 )
{
v10 = v32 - 1;
if ( v32 != 1 )
continue;
}
goto LABEL_29;
}
v34 = *v13;
_InterlockedIncrement((volatile signed __int32 *)(v34 + 2728));
_InterlockedExchange64(v12 + 2, 0LL);
return v34;
}
else
{
LABEL_29:
++global_account_container[0];
return 0LL;
}
}
| find_or_create_account:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2d8
MOV EBX,R8D
MOV qword ptr [RBP + -0x2d0],RCX
MOV R15D,EDX
MOV R13,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x2e0],RDI
MOV RCX,qword ptr [RDI + 0x838]
TEST RCX,RCX
JZ 0x0014178b
LAB_0014145c:
MOV qword ptr [RBP + -0x2e8],RCX
TEST R15D,R15D
JZ 0x0014148e
MOV R12D,R15D
LEA RDI,[RBP + -0x2b8]
MOV ECX,0x288
MOV RSI,R13
MOV RDX,R12
CALL 0x00126600
ADD R12,RBP
ADD R12,-0x2b8
JMP 0x00141495
LAB_0014148e:
LEA R12,[RBP + -0x2b8]
LAB_00141495:
MOV qword ptr [RBP + -0x2f8],R13
MOV byte ptr [R12],0x0
INC R12
TEST EBX,EBX
JZ 0x001414c0
MOV R13D,EBX
MOV RDI,R12
MOV RSI,qword ptr [RBP + -0x2d0]
MOV RDX,R13
CALL 0x00126290
ADD R12,R13
LAB_001414c0:
MOV byte ptr [R12],0x0
LEA RDX,[RBP + -0x2b8]
SUB R12D,EDX
INC R12D
MOV dword ptr [RDX + 0x284],R12D
TEST R15D,R15D
SETNZ AL
TEST EBX,EBX
SETNZ CL
LEA ESI,[R15 + 0x1]
MOV qword ptr [RBP + -0x2f0],RSI
AND CL,AL
MOV byte ptr [RBP + -0x2b9],CL
MOV R13D,0x4
LEA RDI,[0x4d2718]
XOR R14D,R14D
MOV R12,qword ptr [RBP + -0x2e8]
LAB_0014150e:
MOV ECX,dword ptr [RBP + -0x34]
MOV RSI,R12
CALL 0x0012c4e9
CMP RAX,0x2
JNC 0x00141748
MOV dword ptr [RBP + -0x2d4],R13D
XOR EAX,EAX
XCHG qword ptr [R12 + 0x10],RAX
LEA RDI,[0x4c80a0]
LEA RSI,[RBP + -0x2d8]
CALL 0x001420d4
MOV qword ptr [RBP + -0x2c8],RAX
TEST RAX,RAX
JZ 0x00141767
MOV R13,RAX
LEA R14,[RAX + 0x7e4]
MOV EDX,0x288
MOV RDI,R14
LEA RSI,[RBP + -0x2b8]
CALL 0x00126290
TEST R15D,R15D
MOV ECX,0x0
CMOVZ R14,RCX
TEST EBX,EBX
MOV qword ptr [R13 + 0xa70],R14
MOV R14,qword ptr [RBP + -0x2d0]
MOV dword ptr [R13 + 0xa78],R15D
MOV RAX,qword ptr [RBP + -0x2f0]
LEA RAX,[R13 + RAX*0x1 + 0x7e4]
CMOVZ RAX,RCX
MOV qword ptr [R13 + 0xa80],RAX
MOV dword ptr [R13 + 0xa88],EBX
MOV R13,qword ptr [RBP + -0x2e0]
MOV RDI,R13
MOV R12,qword ptr [RBP + -0x2f8]
MOV RSI,R12
MOV EDX,R15D
CALL 0x0013d2e8
MOV RCX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RCX + 0xa90],RAX
MOV RDI,R13
MOV RSI,R14
MOV EDX,EBX
CALL 0x00131274
MOV RCX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RCX + 0xa98],RAX
MOV EAX,0x1
XCHG dword ptr [RCX + 0xaa8],EAX
LEA RDI,[RCX + 0x30]
MOV byte ptr [RCX + 0x4],0x0
MOV dword ptr [RCX],0x0
CALL 0x0013ca28
MOV RAX,qword ptr [RBP + -0x2c8]
MOV qword ptr [RAX + 0xaa0],0x0
CMP byte ptr [RBP + -0x2b9],0x0
JZ 0x00141666
LEA R9,[RAX + 0xa6c]
ADD RAX,0xa6d
MOV qword ptr [RSP],RAX
MOV RDI,R13
MOV RSI,R12
MOV EDX,R15D
MOV RCX,qword ptr [RBP + -0x2d0]
MOV R8D,EBX
CALL 0x0013ba5f
MOV RAX,qword ptr [RBP + -0x2c8]
JMP 0x0014166f
LAB_00141666:
MOV word ptr [RAX + 0xa6c],0x101
LAB_0014166f:
LEA RDI,[0x4d2718]
LEA RDX,[RBP + -0x2c8]
MOV ECX,dword ptr [RBP + -0x2d8]
AND ECX,0xfffffffc
ADD ECX,0x6
XCHG dword ptr [RAX + 0x7e0],ECX
MOV R12,qword ptr [RBP + -0x2e8]
MOV RSI,R12
CALL 0x0012bc8a
MOV R14,qword ptr [RBP + -0x2c8]
TEST EAX,EAX
JZ 0x00141767
MOV R13D,EAX
MOV RDI,qword ptr [R14 + 0xa90]
TEST RDI,RDI
JZ 0x001416d3
CALL 0x0013d5d6
MOV R14,qword ptr [RBP + -0x2c8]
MOV qword ptr [R14 + 0xa90],0x0
LAB_001416d3:
MOV RDI,qword ptr [R14 + 0xa98]
TEST RDI,RDI
JZ 0x001416f6
CALL 0x00131652
MOV R14,qword ptr [RBP + -0x2c8]
MOV qword ptr [R14 + 0xa98],0x0
LAB_001416f6:
MOV RCX,qword ptr [R14 + 0x7d8]
MOV EDX,dword ptr [R14 + 0x7e0]
AND EDX,0xfffffffc
XCHG dword ptr [R14 + 0x7e0],EDX
XOR EAX,EAX
MOV byte ptr [RCX],AL
XOR R14D,R14D
LEA RCX,[0x4c80a0]
MOV byte ptr [RCX + 0x9],AL
TEST R13D,R13D
MOV R13D,dword ptr [RBP + -0x2d4]
JLE 0x001417ba
DEC R13D
LEA RDX,[RBP + -0x2b8]
LEA RDI,[0x4d2718]
JNZ 0x0014150e
JMP 0x001417ba
LAB_00141748:
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x2c8],RAX
INC.LOCK dword ptr [RAX + 0xaa8]
XOR EAX,EAX
XCHG qword ptr [R12 + 0x10],RAX
MOV R14,qword ptr [RBP + -0x2c8]
LAB_00141767:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001417c9
MOV RAX,R14
ADD RSP,0x2d8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014178b:
CMP byte ptr [0x004d27e0],0x1
JNZ 0x001417ba
LEA RDI,[0x4d2740]
CALL 0x0012baaf
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x2e0]
MOV qword ptr [RAX + 0x838],RCX
TEST RCX,RCX
JNZ 0x0014145c
LAB_001417ba:
LEA RAX,[0x4c80a0]
INC qword ptr [RAX]
XOR R14D,R14D
JMP 0x00141767
LAB_001417c9:
CALL 0x001263b0
|
/* find_or_create_account(PFS_thread*, char const*, unsigned int, char const*, unsigned int) */
int4 *
find_or_create_account(PFS_thread *param_1,char *param_2,uint param_3,char *param_4,uint param_5)
{
char *pcVar1;
int iVar2;
int8 *puVar3;
int4 *puVar4;
long lVar5;
int8 uVar6;
long lVar7;
int1 *puVar8;
int4 *puVar9;
long in_FS_OFFSET;
uint local_2e0;
int local_2dc;
char *local_2d8;
int4 *local_2d0;
char local_2c1;
int1 local_2c0 [644];
int local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar7 = *(long *)(param_1 + 0x838);
local_2d8 = param_4;
if (lVar7 == 0) {
if (account_hash_inited != '\x01') goto LAB_001417ba;
lVar7 = lf_pinbox_get_pins(0x4d2740);
*(long *)(param_1 + 0x838) = lVar7;
if (lVar7 == 0) goto LAB_001417ba;
}
if (param_3 == 0) {
puVar8 = local_2c0;
}
else {
__memcpy_chk(local_2c0,param_2,(ulong)param_3,0x288);
puVar8 = local_2c0 + param_3;
}
*puVar8 = 0;
puVar8 = puVar8 + 1;
if (param_5 != 0) {
memcpy(puVar8,local_2d8,(ulong)param_5);
puVar8 = puVar8 + param_5;
}
*puVar8 = 0;
local_3c = ((int)puVar8 - (int)local_2c0) + 1;
local_2c1 = param_5 != 0 && param_3 != 0;
iVar2 = 4;
do {
puVar3 = (int8 *)lf_hash_search(account_hash,lVar7,local_2c0,local_3c);
if ((int8 *)0x1 < puVar3) {
puVar9 = (int4 *)*puVar3;
LOCK();
puVar9[0x2aa] = puVar9[0x2aa] + 1;
UNLOCK();
LOCK();
*(int8 *)(lVar7 + 0x10) = 0;
UNLOCK();
local_2d0 = puVar9;
goto LAB_00141767;
}
LOCK();
*(int8 *)(lVar7 + 0x10) = 0;
UNLOCK();
local_2dc = iVar2;
puVar4 = (int4 *)
PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
::allocate((PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
*)&global_account_container,(pfs_dirty_state *)&local_2e0);
puVar9 = (int4 *)0x0;
local_2d0 = puVar4;
if (puVar4 == (int4 *)0x0) goto LAB_00141767;
puVar9 = puVar4 + 0x1f9;
memcpy(puVar9,local_2c0,0x288);
pcVar1 = local_2d8;
if (param_3 == 0) {
puVar9 = (int4 *)0x0;
}
*(int4 **)(puVar4 + 0x29c) = puVar9;
puVar4[0x29e] = param_3;
lVar5 = (long)puVar4 + (ulong)(param_3 + 1) + 0x7e4;
if (param_5 == 0) {
lVar5 = 0;
}
*(long *)(puVar4 + 0x2a0) = lVar5;
puVar4[0x2a2] = param_5;
uVar6 = find_or_create_user(param_1,param_2,param_3);
*(int8 *)(local_2d0 + 0x2a4) = uVar6;
uVar6 = find_or_create_host(param_1,pcVar1,param_5);
*(int8 *)(local_2d0 + 0x2a6) = uVar6;
LOCK();
local_2d0[0x2aa] = 1;
UNLOCK();
*(int1 *)(local_2d0 + 1) = 0;
*local_2d0 = 0;
PFS_status_stats::reset((PFS_status_stats *)(local_2d0 + 0xc));
*(int8 *)(local_2d0 + 0x2a8) = 0;
if (local_2c1 == '\0') {
*(int2 *)(local_2d0 + 0x29b) = 0x101;
}
else {
lookup_setup_actor(param_1,param_2,param_3,local_2d8,param_5,(bool *)(local_2d0 + 0x29b),
(bool *)((long)local_2d0 + 0xa6d));
}
LOCK();
iVar2 = local_2d0[0x1f8];
local_2d0[0x1f8] = (local_2e0 & 0xfffffffc) + 6;
UNLOCK();
iVar2 = lf_hash_insert(account_hash,lVar7,&local_2d0,iVar2);
puVar9 = local_2d0;
if (iVar2 == 0) goto LAB_00141767;
if (*(PFS_user **)(local_2d0 + 0x2a4) != (PFS_user *)0x0) {
PFS_user::release(*(PFS_user **)(local_2d0 + 0x2a4));
*(int8 *)(local_2d0 + 0x2a4) = 0;
}
if (*(PFS_host **)(local_2d0 + 0x2a6) != (PFS_host *)0x0) {
PFS_host::release(*(PFS_host **)(local_2d0 + 0x2a6));
*(int8 *)(local_2d0 + 0x2a6) = 0;
}
LOCK();
local_2d0[0x1f8] = local_2d0[0x1f8] & 0xfffffffc;
UNLOCK();
**(int1 **)(local_2d0 + 0x1f6) = 0;
DAT_004c80a9 = 0;
} while ((0 < iVar2) && (iVar2 = local_2dc + -1, iVar2 != 0));
LAB_001417ba:
global_account_container = global_account_container + 1;
puVar9 = (int4 *)0x0;
LAB_00141767:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar9;
}
| |
53,757 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x6078e
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x60621
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movzbl (%rsi), %esi
movq %r14, %rdi
callq 0x60828
movq %r14, %rdi
movl $0x1, %esi
callq 0x591c0
testb %bpl, %bpl
jne 0x605ce
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x607af
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x60762
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6062b
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x60762
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x60685
cmpl $0x2, %ecx
jne 0x607b4
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5dd82
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x6075e
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x6077e
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x591c0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x591c0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x5b962
movq %r15, %rdi
xorl %esi, %esi
callq 0x591c0
movq %r15, %rdi
callq 0x5e6ae
movq (%rbx), %r14
jmp 0x6075e
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x607c2
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x606f7
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x60762
cmpq $0x0, 0x70(%rbx)
je 0x607e3
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x591c0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x591c0
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x5b962
movq %r15, %rdi
xorl %esi, %esi
callq 0x591c0
movq %r15, %rdi
callq 0x5e6ae
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x60767
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x591c0
movq %r15, %rdi
callq 0x5e6ae
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8bdc4(%rip), %rdi # 0xec559
leaq 0x8be07(%rip), %rdx # 0xec5a3
leaq 0x8cd32(%rip), %rcx # 0xed4d5
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x1aec0
callq 0x1a310
leaq 0x8cd2e(%rip), %rcx # 0xed4e9
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x607ce
leaq 0x8cd5e(%rip), %rcx # 0xed527
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8bd84(%rip), %rdi # 0xec559
leaq 0x8bdc7(%rip), %rdx # 0xec5a3
xorl %eax, %eax
callq 0x1aec0
leaq 0x8bd6f(%rip), %rdi # 0xec559
leaq 0x8bdb2(%rip), %rdx # 0xec5a3
leaq 0x8cd47(%rip), %rcx # 0xed53f
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x1aec0
jmp 0x60806
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x591c0
movq %r14, %rdi
callq 0x5e6ae
movq %rbx, %rdi
callq 0x1afc0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRbEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_6078E
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r15
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_60621
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
movzx esi, byte ptr [rsi]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_605CE
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_607AF
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_60762
loc_605CE:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_6062B
mov rax, [rax-8]
test rax, rax
jz loc_60762
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_60685
cmp ecx, 2
jnz loc_607B4
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_6075E
loc_60621:
xor ebx, ebx
xor r14d, r14d
jmp loc_6077E
loc_6062B:
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
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, 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 r14, [rbx]
jmp loc_6075E
loc_60685:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_607C2
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_606F7
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_606F7:
test rdx, rdx
jz short loc_60762
cmp qword ptr [rbx+70h], 0
jz loc_607E3
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
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, 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 r14, [rbx+70h]
loc_6075E:
mov bl, 1
jmp short loc_60767
loc_60762:
xor ebx, ebx
xor r14d, r14d
loc_60767:
lea r15, [rsp+68h+var_58]
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()
loc_6077E:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6078E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_607AF:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_607B4:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_607CE
loc_607C2:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_607CE:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_607E3:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_60806:
mov rbx, rax
lea r14, [rsp+68h+var_58]
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, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<bool &>(
long long a1,
unsigned __int8 *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rbx
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
v25 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
*a2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
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=(
*(_QWORD *)a1,
(long long)v27);
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 *)v27);
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(v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
return v4;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v21,
"GGML_ASSERT(%s) failed",
v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
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=(
*(_QWORD *)(a1 + 112),
(long long)&v26);
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v4 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<bool&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0016078e
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R15
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x00160621
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOVZX ESI,byte ptr [RSI]
MOV RDI,R14
CALL 0x00160828
MOV RDI,R14
MOV ESI,0x1
CALL 0x001591c0
TEST BPL,BPL
JNZ 0x001605ce
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x001607af
LEA RDI,[RBX + 0x80]
LAB_001605b1:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x00160762
LAB_001605ce:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0016062b
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x00160762
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x00160685
CMP ECX,0x2
JNZ 0x001607b4
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0015dd82
LAB_00160608:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0016075e
LAB_00160621:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0016077e
LAB_0016062b:
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001591c0
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001591c0
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0015b962
MOV RDI,R15
XOR ESI,ESI
CALL 0x001591c0
MOV RDI,R15
CALL 0x0015e6ae
MOV R14,qword ptr [RBX]
JMP 0x0016075e
LAB_00160685:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x001607c2
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x001606f7
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_001606f7:
TEST RDX,RDX
JZ 0x00160762
CMP qword ptr [RBX + 0x70],0x0
JZ 0x001607e3
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001591c0
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001591c0
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x0015b962
MOV RDI,R15
XOR ESI,ESI
CALL 0x001591c0
MOV RDI,R15
CALL 0x0015e6ae
MOV R14,qword ptr [RBX + 0x70]
LAB_0016075e:
MOV BL,0x1
JMP 0x00160767
LAB_00160762:
XOR EBX,EBX
XOR R14D,R14D
LAB_00160767:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x001591c0
MOV RDI,R15
CALL 0x0015e6ae
LAB_0016077e:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016078e:
LEA RDI,[0x1ec559]
LEA RDX,[0x1ec5a3]
LEA RCX,[0x1ed4d5]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x0011aec0
LAB_001607af:
CALL 0x0011a310
LAB_001607b4:
LEA RCX,[0x1ed4e9]
MOV ESI,0x1c4b
JMP 0x001607ce
LAB_001607c2:
LEA RCX,[0x1ed527]
MOV ESI,0x1c57
LAB_001607ce:
LEA RDI,[0x1ec559]
LEA RDX,[0x1ec5a3]
XOR EAX,EAX
CALL 0x0011aec0
LAB_001607e3:
LEA RDI,[0x1ec559]
LEA RDX,[0x1ec5a3]
LEA RCX,[0x1ed53f]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x0011aec0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<bool&>(bool&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<bool&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,bool *param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0016077e;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_58,*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>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_001605ce:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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,(data *)&local_38);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_00160762;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_001607ce;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_00160762;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 001607e3 to 00160803 has its CatchHandler @ 00160804 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
local_48 = local_58;
uStack_40 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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 + 0x70),(data *)&local_48);
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(bVar7);
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_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_001607ce:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),(basic_json *)&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 001607af to 001607e2 has its CatchHandler @ 00160806 */
std::__throw_bad_function_call();
}
/* try { // try from 001605b1 to 00160607 has its CatchHandler @ 00160806 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_001605ce;
LAB_00160762:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0016077e:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
53,758 | my_scan_8bit | eloqsql/strings/ctype-simple.c | size_t my_scan_8bit(CHARSET_INFO *cs, const char *str, const char *end, int sq)
{
const char *str0= str;
switch (sq)
{
case MY_SEQ_INTTAIL:
if (*str == '.')
{
for(str++ ; str != end && *str == '0' ; str++);
return (size_t) (str - str0);
}
return 0;
case MY_SEQ_SPACES:
for ( ; str < end ; str++)
{
if (!my_isspace(cs,*str))
break;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
for ( ; str < end ; str++)
{
if (my_isspace(cs, *str))
break;
}
return (size_t) (str - str0);
default:
return 0;
}
} | O0 | c | my_scan_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0xe8f57
jmp 0xe8f38
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xe8fc8
jmp 0xe8f46
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0xe9013
jmp 0xe905e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xe8fbb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x35(%rbp)
je 0xe8f8e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xe8f97
jmp 0xe8fa7
jmp 0xe8f99
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe8f6f
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xe9066
movq $0x0, -0x8(%rbp)
jmp 0xe9066
jmp 0xe8fca
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe9002
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xe8ff2
jmp 0xe9002
jmp 0xe8ff4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe8fca
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xe9066
jmp 0xe9015
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe904d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xe903d
jmp 0xe904d
jmp 0xe903f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe9015
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xe9066
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| my_scan_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov eax, [rbp+var_24]
mov [rbp+var_34], eax
sub eax, 1
jz short loc_E8F57
jmp short $+2
loc_E8F38:
mov eax, [rbp+var_34]
sub eax, 2
jz loc_E8FC8
jmp short $+2
loc_E8F46:
mov eax, [rbp+var_34]
sub eax, 3
jz loc_E9013
jmp loc_E905E
loc_E8F57:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz short loc_E8FBB
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
loc_E8F6F:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_20]
mov [rbp+var_35], al
jz short loc_E8F8E
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
setz al
mov [rbp+var_35], al
loc_E8F8E:
mov al, [rbp+var_35]
test al, 1
jnz short loc_E8F97
jmp short loc_E8FA7
loc_E8F97:
jmp short $+2
loc_E8F99:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_E8F6F
loc_E8FA7:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp loc_E9066
loc_E8FBB:
mov [rbp+var_8], 0
jmp loc_E9066
loc_E8FC8:
jmp short $+2
loc_E8FCA:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_E9002
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jnz short loc_E8FF2
jmp short loc_E9002
loc_E8FF2:
jmp short $+2
loc_E8FF4:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_E8FCA
loc_E9002:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_E9066
loc_E9013:
jmp short $+2
loc_E9015:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_E904D
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
jz short loc_E903D
jmp short loc_E904D
loc_E903D:
jmp short $+2
loc_E903F:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_E9015
loc_E904D:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_E9066
loc_E905E:
mov [rbp+var_8], 0
loc_E9066:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_scan_8bit(long long a1, unsigned __int8 *a2, unsigned __int8 *a3, int a4)
{
bool v5; // [rsp+1h] [rbp-35h]
unsigned __int8 *v6; // [rsp+1Eh] [rbp-18h]
unsigned __int8 *i; // [rsp+1Eh] [rbp-18h]
v6 = a2;
switch ( a4 )
{
case 1:
if ( *a2 == 46 )
{
for ( i = a2 + 1; ; ++i )
{
v5 = 0;
if ( i != a3 )
v5 = *i == 48;
if ( !v5 )
break;
}
return i - a2;
}
else
{
return 0LL;
}
case 2:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) != 0 )
++v6;
return v6 - a2;
case 3:
while ( v6 < a3 && (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v6 + 1LL) & 8) == 0 )
++v6;
return v6 - a2;
default:
return 0LL;
}
}
| my_scan_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x34],EAX
SUB EAX,0x1
JZ 0x001e8f57
JMP 0x001e8f38
LAB_001e8f38:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x2
JZ 0x001e8fc8
JMP 0x001e8f46
LAB_001e8f46:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x3
JZ 0x001e9013
JMP 0x001e905e
LAB_001e8f57:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x001e8fbb
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
LAB_001e8f6f:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RBP + -0x35],AL
JZ 0x001e8f8e
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
SETZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_001e8f8e:
MOV AL,byte ptr [RBP + -0x35]
TEST AL,0x1
JNZ 0x001e8f97
JMP 0x001e8fa7
LAB_001e8f97:
JMP 0x001e8f99
LAB_001e8f99:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e8f6f
LAB_001e8fa7:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e9066
LAB_001e8fbb:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001e9066
LAB_001e8fc8:
JMP 0x001e8fca
LAB_001e8fca:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e9002
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JNZ 0x001e8ff2
JMP 0x001e9002
LAB_001e8ff2:
JMP 0x001e8ff4
LAB_001e8ff4:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e8fca
LAB_001e9002:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e9066
LAB_001e9013:
JMP 0x001e9015
LAB_001e9015:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e904d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001e903d
JMP 0x001e904d
LAB_001e903d:
JMP 0x001e903f
LAB_001e903f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001e9015
LAB_001e904d:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001e9066
LAB_001e905e:
MOV qword ptr [RBP + -0x8],0x0
LAB_001e9066:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long my_scan_8bit(long param_1,byte *param_2,byte *param_3,int param_4)
{
bool bVar1;
byte *local_20;
long local_10;
if (param_4 == 1) {
if (*param_2 == 0x2e) {
local_20 = param_2 + 1;
while( true ) {
bVar1 = false;
if (local_20 != param_3) {
bVar1 = *local_20 == 0x30;
}
if (!bVar1) break;
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
else {
local_20 = param_2;
if (param_4 == 2) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) != 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else if (param_4 == 3) {
while ((local_20 < param_3 &&
((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_20) & 8) == 0))) {
local_20 = local_20 + 1;
}
local_10 = (long)local_20 - (long)param_2;
}
else {
local_10 = 0;
}
}
return local_10;
}
| |
53,759 | flush_cached_blocks | eloqsql/storage/maria/ma_pagecache.c | static int flush_cached_blocks(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
PAGECACHE_BLOCK_LINK **cache,
PAGECACHE_BLOCK_LINK **end,
enum flush_type type,
int *first_errno)
{
int rc= PCFLUSH_OK;
my_bool error;
uint count= (uint) (end-cache);
DBUG_ENTER("flush_cached_blocks");
*first_errno= 0;
/* Don't lock the cache during the flush */
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
/*
As all blocks referred in 'cache' are marked by PCBLOCK_IN_FLUSH
we are guaranteed that no thread will change them
*/
qsort((uchar*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
for (; cache != end; cache++)
{
PAGECACHE_BLOCK_LINK *block= *cache;
/*
In the case of non_transactional tables we want to flush also
block pinned with reads. This is becasue we may have other
threads reading the block during flush, as non transactional
tables can have many readers while the one writer is doing the
flush.
We don't want to do flush pinned blocks during checkpoint.
We detect the checkpoint case by checking if type is LAZY.
*/
if ((type == FLUSH_KEEP_LAZY && block->pins) || block->wlocks)
{
KEYCACHE_DBUG_PRINT("flush_cached_blocks",
("block: %u (%p) pinned",
PCBLOCK_NUMBER(pagecache, block), block));
DBUG_PRINT("info", ("block: %u (%p) pinned",
PCBLOCK_NUMBER(pagecache, block), block));
PCBLOCK_INFO(block);
/* undo the mark put by flush_pagecache_blocks_int(): */
block->status&= ~PCBLOCK_IN_FLUSH;
rc|= PCFLUSH_PINNED;
DBUG_PRINT("warning", ("Page pinned"));
unreg_request(pagecache, block, 1);
if (!*first_errno)
*first_errno= HA_ERR_INTERNAL_ERROR;
continue;
}
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_READ, PAGECACHE_PIN, FALSE))
DBUG_ASSERT(0);
KEYCACHE_PRINT("flush_cached_blocks",
("block: %u (%p) to be flushed",
PCBLOCK_NUMBER(pagecache, block), block));
DBUG_PRINT("info", ("block: %u (%p) to be flushed",
PCBLOCK_NUMBER(pagecache, block), block));
PCBLOCK_INFO(block);
/**
@todo IO If page is contiguous with next page to flush, group flushes
in one single my_pwrite().
*/
/**
It is important to use block->hash_link->file below and not 'file', as
the first one is right and the second may have different out-of-date
content (see StaleFilePointersInFlush in ma_checkpoint.c).
@todo change argument of functions to be File.
*/
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
error= pagecache_fwrite(pagecache, &block->hash_link->file,
block->buffer,
block->hash_link->pageno,
block->type,
pagecache->readwrite_flags);
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
if (make_lock_and_pin(pagecache, block,
PAGECACHE_LOCK_READ_UNLOCK,
PAGECACHE_UNPIN, FALSE))
DBUG_ASSERT(0);
pagecache->global_cache_write++;
if (error)
{
block->status|= PCBLOCK_ERROR;
block->error= (int16) my_errno;
my_debug_put_break_here();
if (!*first_errno)
*first_errno= my_errno ? my_errno : -1;
rc|= PCFLUSH_ERROR;
}
/*
Let to proceed for possible waiting requests to write to the block page.
It might happen only during an operation to resize the key cache.
*/
if (block->wqueue[COND_FOR_SAVED].last_thread)
wqueue_release_queue(&block->wqueue[COND_FOR_SAVED]);
/* type will never be FLUSH_IGNORE_CHANGED here */
if (! (type == FLUSH_KEEP || type == FLUSH_KEEP_LAZY ||
type == FLUSH_FORCE_WRITE))
{
if (!free_block(pagecache, block, 1))
{
pagecache->blocks_changed--;
pagecache->global_blocks_changed--;
}
else
{
block->status&= ~PCBLOCK_IN_FLUSH;
link_to_file_list(pagecache, block, file, 1);
}
}
else
{
block->status&= ~PCBLOCK_IN_FLUSH;
link_to_file_list(pagecache, block, file, 1);
unreg_request(pagecache, block, 1);
}
}
DBUG_RETURN(rc);
} | O0 | c | flush_cached_blocks:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x94920
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
movl $0x8, %edx
leaq 0x2c8(%rip), %rcx # 0x99d70
callq 0x29510
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xb9cb3(%rip), %rsi # 0x153772
movl $0x12a3, %edx # imm = 0x12A3
callq 0x948b0
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x99d5e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpl $0x4, -0x24(%rbp)
jne 0x99af2
movq -0x48(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x99afc
movq -0x48(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x99b4c
jmp 0x99afe
jmp 0x99b00
jmp 0x99b02
jmp 0x99b04
jmp 0x99b06
jmp 0x99b08
movq -0x48(%rbp), %rax
movzwl 0x74(%rax), %ecx
andl $-0x11, %ecx
movw %cx, 0x74(%rax)
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x99b22
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x95810
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x99b47
movq -0x30(%rbp), %rax
movl $0x7a, (%rax)
jmp 0x99d4d
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x3, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x95670
cmpb $0x0, %al
je 0x99b70
jmp 0x99b6c
jmp 0x99b6e
jmp 0x99b70
jmp 0x99b72
jmp 0x99b74
jmp 0x99b76
jmp 0x99b78
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x94920
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x18, %rsi
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rcx
movq -0x48(%rbp), %rax
movl 0x7c(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x198(%rax), %r9
callq 0x97ac0
movb %al, -0x35(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0xb9b99(%rip), %rsi # 0x153772
movl $0x12dd, %edx # imm = 0x12DD
callq 0x948b0
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x5, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
callq 0x95670
cmpb $0x0, %al
je 0x99c07
jmp 0x99c03
jmp 0x99c05
jmp 0x99c07
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x178(%rax)
cmpb $0x0, -0x35(%rbp)
je 0x99c81
movq -0x48(%rbp), %rax
movzwl 0x74(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x74(%rax)
callq 0xf7b30
movl (%rax), %eax
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, 0x76(%rax)
jmp 0x99c46
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x99c78
callq 0xf7b30
cmpl $0x0, (%rax)
je 0x99c65
callq 0xf7b30
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x99c6f
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x4c(%rbp)
jmp 0x99c6f
movl -0x4c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x99c9d
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
addq $0x8, %rdi
callq 0x1010f0
cmpl $0x0, -0x24(%rbp)
je 0x99d14
cmpl $0x4, -0x24(%rbp)
je 0x99d14
cmpl $0x3, -0x24(%rbp)
je 0x99d14
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x98e20
cmpb $0x0, %al
jne 0x99ced
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x168(%rax)
jmp 0x99d12
movq -0x48(%rbp), %rax
movzwl 0x74(%rax), %ecx
andl $-0x11, %ecx
movw %cx, 0x74(%rax)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x99080
jmp 0x99d4b
movq -0x48(%rbp), %rax
movzwl 0x74(%rax), %ecx
andl $-0x11, %ecx
movw %cx, 0x74(%rax)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x99080
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0x95810
jmp 0x99d4d
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x99ac9
jmp 0x99d60
movl -0x34(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| flush_cached_blocks:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
mov [rbp+var_34], 0
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
sar rax, 3
mov [rbp+var_3C], eax
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_13
mov rdi, [rbp+var_18]
mov eax, [rbp+var_3C]
mov esi, eax
mov edx, 8
lea rcx, cmp_sec_link
call _qsort
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12A3h
call inline_mysql_mutex_lock_12
loc_99AC9:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz loc_99D5E
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_48], rax
cmp [rbp+var_24], 4
jnz short loc_99AF2
mov rax, [rbp+var_48]
cmp dword ptr [rax+64h], 0
jnz short loc_99AFC
loc_99AF2:
mov rax, [rbp+var_48]
cmp dword ptr [rax+68h], 0
jz short loc_99B4C
loc_99AFC:
jmp short $+2
loc_99AFE:
jmp short $+2
loc_99B00:
jmp short $+2
loc_99B02:
jmp short $+2
loc_99B04:
jmp short $+2
loc_99B06:
jmp short $+2
loc_99B08:
mov rax, [rbp+var_48]
movzx ecx, word ptr [rax+74h]
and ecx, 0FFFFFFEFh
mov [rax+74h], cx
mov eax, [rbp+var_34]
or eax, 2
mov [rbp+var_34], eax
jmp short $+2
loc_99B22:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 1
call unreg_request
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_99B47
mov rax, [rbp+var_30]
mov dword ptr [rax], 7Ah ; 'z'
loc_99B47:
jmp loc_99D4D
loc_99B4C:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 3
mov ecx, 2
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_99B70
jmp short $+2
loc_99B6C:
jmp short $+2
loc_99B6E:
jmp short $+2
loc_99B70:
jmp short $+2
loc_99B72:
jmp short $+2
loc_99B74:
jmp short $+2
loc_99B76:
jmp short $+2
loc_99B78:
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_13
mov rdi, [rbp+var_8]
mov rax, [rbp+var_48]
mov rsi, [rax+20h]
add rsi, 18h
mov rax, [rbp+var_48]
mov rdx, [rax+30h]
mov rax, [rbp+var_48]
mov rax, [rax+20h]
mov rcx, [rax+60h]
mov rax, [rbp+var_48]
mov r8d, [rax+7Ch]
mov rax, [rbp+var_8]
mov r9, [rax+198h]
call pagecache_fwrite
mov [rbp+var_35], al
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12DDh
call inline_mysql_mutex_lock_12
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 5
mov ecx, 3
xor r8d, r8d
call make_lock_and_pin
cmp al, 0
jz short loc_99C07
jmp short $+2
loc_99C03:
jmp short $+2
loc_99C05:
jmp short $+2
loc_99C07:
mov rax, [rbp+var_8]
mov rcx, [rax+178h]
add rcx, 1
mov [rax+178h], rcx
cmp [rbp+var_35], 0
jz short loc_99C81
mov rax, [rbp+var_48]
movzx ecx, word ptr [rax+74h]
or ecx, 1
mov [rax+74h], cx
call _my_thread_var
mov eax, [rax]
mov cx, ax
mov rax, [rbp+var_48]
mov [rax+76h], cx
jmp short $+2
loc_99C46:
mov rax, [rbp+var_30]
cmp dword ptr [rax], 0
jnz short loc_99C78
call _my_thread_var
cmp dword ptr [rax], 0
jz short loc_99C65
call _my_thread_var
mov eax, [rax]
mov [rbp+var_4C], eax
jmp short loc_99C6F
loc_99C65:
mov eax, 0FFFFFFFFh
mov [rbp+var_4C], eax
jmp short $+2
loc_99C6F:
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_30]
mov [rax], ecx
loc_99C78:
mov eax, [rbp+var_34]
or eax, 1
mov [rbp+var_34], eax
loc_99C81:
mov rax, [rbp+var_48]
cmp qword ptr [rax+50h], 0
jz short loc_99C9D
mov rdi, [rbp+var_48]
add rdi, 48h ; 'H'
add rdi, 8
call wqueue_release_queue
loc_99C9D:
cmp [rbp+var_24], 0
jz short loc_99D14
cmp [rbp+var_24], 4
jz short loc_99D14
cmp [rbp+var_24], 3
jz short loc_99D14
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 1
call free_block
cmp al, 0
jnz short loc_99CED
mov rax, [rbp+var_8]
mov rcx, [rax+58h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+58h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+168h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+168h], rcx
jmp short loc_99D12
loc_99CED:
mov rax, [rbp+var_48]
movzx ecx, word ptr [rax+74h]
and ecx, 0FFFFFFEFh
mov [rax+74h], cx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_10]
mov ecx, 1
call link_to_file_list
loc_99D12:
jmp short loc_99D4B
loc_99D14:
mov rax, [rbp+var_48]
movzx ecx, word ptr [rax+74h]
and ecx, 0FFFFFFEFh
mov [rax+74h], cx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_10]
mov ecx, 1
call link_to_file_list
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 1
call unreg_request
loc_99D4B:
jmp short $+2
loc_99D4D:
mov rax, [rbp+var_18]
add rax, 8
mov [rbp+var_18], rax
jmp loc_99AC9
loc_99D5E:
jmp short $+2
loc_99D60:
mov eax, [rbp+var_34]
mov [rbp+var_50], eax
mov eax, [rbp+var_50]
add rsp, 50h
pop rbp
retn
| long long flush_cached_blocks(_QWORD *a1, long long a2, long long *a3, long long *a4, int a5, int *a6)
{
int v7; // [rsp+4h] [rbp-4Ch]
long long v8; // [rsp+8h] [rbp-48h]
unsigned int v9; // [rsp+14h] [rbp-3Ch]
char v10; // [rsp+1Bh] [rbp-35h]
unsigned int v11; // [rsp+1Ch] [rbp-34h]
long long *v15; // [rsp+38h] [rbp-18h]
v15 = a3;
v11 = 0;
v9 = a4 - a3;
*a6 = 0;
inline_mysql_mutex_unlock_13((long long)(a1 + 25));
qsort(v15, v9, 8LL, cmp_sec_link);
inline_mysql_mutex_lock_12(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x12A3u);
while ( v15 != a4 )
{
v8 = *v15;
if ( a5 == 4 && *(_DWORD *)(v8 + 100) || *(_DWORD *)(v8 + 104) )
{
*(_WORD *)(v8 + 116) &= ~0x10u;
v11 |= 2u;
unreg_request(a1, v8, 1);
if ( !*a6 )
*a6 = 122;
}
else
{
make_lock_and_pin((long long)a1, v8, 3, 2, 0);
inline_mysql_mutex_unlock_13((long long)(a1 + 25));
v10 = pagecache_fwrite(
(long long)a1,
*(_QWORD *)(v8 + 32) + 24LL,
*(_QWORD *)(v8 + 48),
*(_QWORD *)(*(_QWORD *)(v8 + 32) + 96LL),
*(_DWORD *)(v8 + 124),
a1[51]);
inline_mysql_mutex_lock_12(
(long long)(a1 + 25),
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x12DDu);
make_lock_and_pin((long long)a1, v8, 5, 3, 0);
++a1[47];
if ( v10 )
{
*(_WORD *)(v8 + 116) |= 1u;
*(_WORD *)(v8 + 118) = *(_DWORD *)my_thread_var(a1, (const char *)v8);
if ( !*a6 )
{
if ( *(_DWORD *)my_thread_var(a1, (const char *)v8) )
v7 = *(_DWORD *)my_thread_var(a1, (const char *)v8);
else
v7 = -1;
*a6 = v7;
}
v11 |= 1u;
}
if ( *(_QWORD *)(v8 + 80) )
wqueue_release_queue(v8 + 80);
if ( !a5 || a5 == 4 || a5 == 3 )
{
*(_WORD *)(v8 + 116) &= ~0x10u;
link_to_file_list(a1, v8, a2, 1);
unreg_request(a1, v8, 1);
}
else if ( free_block(a1, v8, 1) )
{
*(_WORD *)(v8 + 116) &= ~0x10u;
link_to_file_list(a1, v8, a2, 1);
}
else
{
--a1[11];
--a1[45];
}
}
++v15;
}
return v11;
}
| flush_cached_blocks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SAR RAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x00194920
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x3c]
MOV ESI,EAX
MOV EDX,0x8
LEA RCX,[0x199d70]
CALL 0x00129510
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x253772]
MOV EDX,0x12a3
CALL 0x001948b0
LAB_00199ac9:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x00199d5e
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
CMP dword ptr [RBP + -0x24],0x4
JNZ 0x00199af2
MOV RAX,qword ptr [RBP + -0x48]
CMP dword ptr [RAX + 0x64],0x0
JNZ 0x00199afc
LAB_00199af2:
MOV RAX,qword ptr [RBP + -0x48]
CMP dword ptr [RAX + 0x68],0x0
JZ 0x00199b4c
LAB_00199afc:
JMP 0x00199afe
LAB_00199afe:
JMP 0x00199b00
LAB_00199b00:
JMP 0x00199b02
LAB_00199b02:
JMP 0x00199b04
LAB_00199b04:
JMP 0x00199b06
LAB_00199b06:
JMP 0x00199b08
LAB_00199b08:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX ECX,word ptr [RAX + 0x74]
AND ECX,0xffffffef
MOV word ptr [RAX + 0x74],CX
MOV EAX,dword ptr [RBP + -0x34]
OR EAX,0x2
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00199b22
LAB_00199b22:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x1
CALL 0x00195810
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x00199b47
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x7a
LAB_00199b47:
JMP 0x00199d4d
LAB_00199b4c:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x3
MOV ECX,0x2
XOR R8D,R8D
CALL 0x00195670
CMP AL,0x0
JZ 0x00199b70
JMP 0x00199b6c
LAB_00199b6c:
JMP 0x00199b6e
LAB_00199b6e:
JMP 0x00199b70
LAB_00199b70:
JMP 0x00199b72
LAB_00199b72:
JMP 0x00199b74
LAB_00199b74:
JMP 0x00199b76
LAB_00199b76:
JMP 0x00199b78
LAB_00199b78:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x00194920
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RAX + 0x20]
ADD RSI,0x18
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x48]
MOV R8D,dword ptr [RAX + 0x7c]
MOV RAX,qword ptr [RBP + -0x8]
MOV R9,qword ptr [RAX + 0x198]
CALL 0x00197ac0
MOV byte ptr [RBP + -0x35],AL
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x253772]
MOV EDX,0x12dd
CALL 0x001948b0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x5
MOV ECX,0x3
XOR R8D,R8D
CALL 0x00195670
CMP AL,0x0
JZ 0x00199c07
JMP 0x00199c03
LAB_00199c03:
JMP 0x00199c05
LAB_00199c05:
JMP 0x00199c07
LAB_00199c07:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x178]
ADD RCX,0x1
MOV qword ptr [RAX + 0x178],RCX
CMP byte ptr [RBP + -0x35],0x0
JZ 0x00199c81
MOV RAX,qword ptr [RBP + -0x48]
MOVZX ECX,word ptr [RAX + 0x74]
OR ECX,0x1
MOV word ptr [RAX + 0x74],CX
CALL 0x001f7b30
MOV EAX,dword ptr [RAX]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x48]
MOV word ptr [RAX + 0x76],CX
JMP 0x00199c46
LAB_00199c46:
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX],0x0
JNZ 0x00199c78
CALL 0x001f7b30
CMP dword ptr [RAX],0x0
JZ 0x00199c65
CALL 0x001f7b30
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00199c6f
LAB_00199c65:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x00199c6f
LAB_00199c6f:
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
LAB_00199c78:
MOV EAX,dword ptr [RBP + -0x34]
OR EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
LAB_00199c81:
MOV RAX,qword ptr [RBP + -0x48]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x00199c9d
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x48
ADD RDI,0x8
CALL 0x002010f0
LAB_00199c9d:
CMP dword ptr [RBP + -0x24],0x0
JZ 0x00199d14
CMP dword ptr [RBP + -0x24],0x4
JZ 0x00199d14
CMP dword ptr [RBP + -0x24],0x3
JZ 0x00199d14
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x1
CALL 0x00198e20
CMP AL,0x0
JNZ 0x00199ced
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x58]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x168]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x168],RCX
JMP 0x00199d12
LAB_00199ced:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX ECX,word ptr [RAX + 0x74]
AND ECX,0xffffffef
MOV word ptr [RAX + 0x74],CX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,0x1
CALL 0x00199080
LAB_00199d12:
JMP 0x00199d4b
LAB_00199d14:
MOV RAX,qword ptr [RBP + -0x48]
MOVZX ECX,word ptr [RAX + 0x74]
AND ECX,0xffffffef
MOV word ptr [RAX + 0x74],CX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,0x1
CALL 0x00199080
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x1
CALL 0x00195810
LAB_00199d4b:
JMP 0x00199d4d
LAB_00199d4d:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00199ac9
LAB_00199d5e:
JMP 0x00199d60
LAB_00199d60:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x50],EAX
MOV EAX,dword ptr [RBP + -0x50]
ADD RSP,0x50
POP RBP
RET
|
uint flush_cached_blocks(long param_1,int8 param_2,long *param_3,long *param_4,int param_5,
int *param_6)
{
long lVar1;
char cVar2;
int4 *puVar3;
int *piVar4;
int local_54;
uint local_3c;
long *local_20;
local_3c = 0;
*param_6 = 0;
inline_mysql_mutex_unlock(param_1 + 200);
qsort(param_3,(long)param_4 - (long)param_3 >> 3 & 0xffffffff,8,cmp_sec_link);
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x12a3);
for (local_20 = param_3; local_20 != param_4; local_20 = local_20 + 1) {
lVar1 = *local_20;
if (((param_5 == 4) && (*(int *)(lVar1 + 100) != 0)) || (*(int *)(lVar1 + 0x68) != 0)) {
*(ushort *)(lVar1 + 0x74) = *(ushort *)(lVar1 + 0x74) & 0xffef;
local_3c = local_3c | 2;
unreg_request(param_1,lVar1,1);
if (*param_6 == 0) {
*param_6 = 0x7a;
}
}
else {
make_lock_and_pin(param_1,lVar1,3,2,0);
inline_mysql_mutex_unlock(param_1 + 200);
cVar2 = pagecache_fwrite(param_1,*(long *)(lVar1 + 0x20) + 0x18,*(int8 *)(lVar1 + 0x30),
*(int8 *)(*(long *)(lVar1 + 0x20) + 0x60),
*(int4 *)(lVar1 + 0x7c),*(int8 *)(param_1 + 0x198));
inline_mysql_mutex_lock
(param_1 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x12dd);
make_lock_and_pin(param_1,lVar1,5,3,0);
*(long *)(param_1 + 0x178) = *(long *)(param_1 + 0x178) + 1;
if (cVar2 != '\0') {
*(ushort *)(lVar1 + 0x74) = *(ushort *)(lVar1 + 0x74) | 1;
puVar3 = (int4 *)_my_thread_var();
*(short *)(lVar1 + 0x76) = (short)*puVar3;
if (*param_6 == 0) {
piVar4 = (int *)_my_thread_var();
if (*piVar4 == 0) {
local_54 = -1;
}
else {
piVar4 = (int *)_my_thread_var();
local_54 = *piVar4;
}
*param_6 = local_54;
}
local_3c = local_3c | 1;
}
if (*(long *)(lVar1 + 0x50) != 0) {
wqueue_release_queue(lVar1 + 0x50);
}
if (((param_5 == 0) || (param_5 == 4)) || (param_5 == 3)) {
*(ushort *)(lVar1 + 0x74) = *(ushort *)(lVar1 + 0x74) & 0xffef;
link_to_file_list(param_1,lVar1,param_2,1);
unreg_request(param_1,lVar1,1);
}
else {
cVar2 = free_block(param_1,lVar1,1);
if (cVar2 == '\0') {
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + -1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + -1;
}
else {
*(ushort *)(lVar1 + 0x74) = *(ushort *)(lVar1 + 0x74) & 0xffef;
link_to_file_list(param_1,lVar1,param_2,1);
}
}
}
}
return local_3c;
}
| |
53,760 | mark_all_entries | eloqsql/storage/maria/ma_rt_split.c | static void mark_all_entries(SplitStruct *node, int n_entries, int n_group)
{
SplitStruct *cur= node;
SplitStruct *end= node + n_entries;
for (; cur < end; cur++)
{
if (cur->n_node)
{
continue;
}
cur->n_node= n_group;
}
} | O0 | c | mark_all_entries:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x86d67
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x86d4f
jmp 0x86d59
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x86d39
popq %rbp
retq
nopl (%rax)
| mark_all_entries:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_C]
shl rcx, 5
add rax, rcx
mov [rbp+var_20], rax
loc_86D39:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_86D67
mov rax, [rbp+var_18]
cmp dword ptr [rax+8], 0
jz short loc_86D4F
jmp short loc_86D59
loc_86D4F:
mov ecx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+8], ecx
loc_86D59:
mov rax, [rbp+var_18]
add rax, 20h ; ' '
mov [rbp+var_18], rax
jmp short loc_86D39
loc_86D67:
pop rbp
retn
| unsigned long long mark_all_entries(unsigned long long a1, int a2, int a3)
{
unsigned long long result; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
for ( i = a1; ; i += 32LL )
{
result = i;
if ( i >= 32LL * a2 + a1 )
break;
if ( !*(_DWORD *)(i + 8) )
*(_DWORD *)(i + 8) = a3;
}
return result;
}
| mark_all_entries:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_00186d39:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00186d67
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00186d4f
JMP 0x00186d59
LAB_00186d4f:
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
LAB_00186d59:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x20
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00186d39
LAB_00186d67:
POP RBP
RET
|
void mark_all_entries(ulong param_1,int param_2,int4 param_3)
{
int8 local_20;
for (local_20 = param_1; local_20 < param_1 + (long)param_2 * 0x20; local_20 = local_20 + 0x20) {
if (*(int *)(local_20 + 8) == 0) {
*(int4 *)(local_20 + 8) = param_3;
}
}
return;
}
| |
53,761 | my_casedn_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_casedn_utf8mb4(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O3 | c | my_casedn_utf8mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, %r13
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x4f01e
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq -0x30(%rbp), %r13
addq %r13, -0x38(%rbp)
movq 0x78(%rdi), %r14
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x52002
testl %eax, %eax
jle 0x4f01e
movl %eax, %ebx
movq -0x40(%rbp), %rsi
cmpq (%r14), %rsi
ja 0x4efff
movq 0x8(%r14), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4efff
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x4(%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdx
movq -0x38(%rbp), %rcx
callq 0x4ecf1
testl %eax, %eax
jle 0x4f01e
movl %ebx, %ecx
addq %rcx, %r12
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r12
jb 0x4efbd
subq -0x30(%rbp), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_casedn_utf8mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], r8
mov r13, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle short loc_4F01E
mov r15, rdx
mov r12, rsi
add r15, rsi
mov r13, [rbp+var_30]
add [rbp+var_38], r13
mov r14, [rdi+78h]
loc_4EFBD:
lea rdi, [rbp+var_40]
mov rsi, r12
mov rdx, r15
call my_mb_wc_utf8mb4_quick_0
test eax, eax
jle short loc_4F01E
mov ebx, eax
mov rsi, [rbp+var_40]
cmp rsi, [r14]
ja short loc_4EFFF
mov rax, [r14+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_4EFFF
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4+4]
mov [rbp+var_40], rsi
loc_4EFFF:
mov rdx, r13
mov rcx, [rbp+var_38]
call my_wc_mb_utf8mb4
test eax, eax
jle short loc_4F01E
mov ecx, ebx
add r12, rcx
mov eax, eax
add r13, rax
cmp r12, r15
jb short loc_4EFBD
loc_4F01E:
sub r13, [rbp+var_30]
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * my_casedn_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, unsigned long long a5)
{
_BYTE *v5; // r13
unsigned long long v6; // r12
unsigned long long v7; // r15
unsigned long long *v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
int v13; // eax
unsigned long long v15; // [rsp+0h] [rbp-40h] BYREF
unsigned long long v16; // [rsp+8h] [rbp-38h]
_BYTE *v17; // [rsp+10h] [rbp-30h]
v16 = a5;
v5 = a4;
v17 = a4;
if ( a3 > 0 )
{
v6 = a2;
v7 = a2 + a3;
v5 = v17;
v16 += (unsigned long long)v17;
v8 = *(unsigned long long **)(a1 + 120);
do
{
v9 = my_mb_wc_utf8mb4_quick_0(&v15, v6, v7);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v15;
if ( v15 <= *v8 )
{
v12 = *(_QWORD *)(v8[1] + 8 * (v15 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v15 + 4);
v15 = v11;
}
}
v13 = my_wc_mb_utf8mb4((long long)&v15, v11, v5, v16);
if ( v13 <= 0 )
break;
v6 += v10;
v5 += (unsigned int)v13;
}
while ( v6 < v7 );
}
return (_BYTE *)(v5 - v17);
}
| my_casedn_utf8mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],R8
MOV R13,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x0014f01e
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV R13,qword ptr [RBP + -0x30]
ADD qword ptr [RBP + -0x38],R13
MOV R14,qword ptr [RDI + 0x78]
LAB_0014efbd:
LEA RDI,[RBP + -0x40]
MOV RSI,R12
MOV RDX,R15
CALL 0x00152002
TEST EAX,EAX
JLE 0x0014f01e
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
CMP RSI,qword ptr [R14]
JA 0x0014efff
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x0014efff
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4 + 0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_0014efff:
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x0014ecf1
TEST EAX,EAX
JLE 0x0014f01e
MOV ECX,EBX
ADD R12,RCX
MOV EAX,EAX
ADD R13,RAX
CMP R12,R15
JC 0x0014efbd
LAB_0014f01e:
SUB R13,qword ptr [RBP + -0x30]
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_casedn_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
ulong local_48;
long local_40;
long local_38;
local_38 = param_4;
if (0 < param_3) {
uVar5 = param_3 + param_2;
local_40 = param_5 + param_4;
puVar1 = *(ulong **)(param_1 + 0x78);
do {
uVar3 = my_mb_wc_utf8mb4_quick(&local_48,param_2,uVar5);
if ((int)uVar3 < 1) break;
if ((local_48 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (local_48 >> 8) * 8), lVar2 != 0))
{
local_48 = (ulong)*(uint *)(lVar2 + 4 + (local_48 & 0xff) * 0xc);
}
uVar4 = my_wc_mb_utf8mb4();
if ((int)uVar4 < 1) break;
param_2 = param_2 + uVar3;
param_4 = param_4 + (ulong)uVar4;
} while (param_2 < uVar5);
}
return param_4 - local_38;
}
| |
53,762 | intx::internal::add(unsigned long*, unsigned long const*, unsigned long const*, int) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline bool add(uint64_t s[], const uint64_t x[], const uint64_t y[], int len) noexcept
{
// OPT: Add MinLen template parameter and unroll first loop iterations.
INTX_REQUIRE(len >= 2);
bool carry = false;
for (int i = 0; i < len; ++i)
std::tie(s[i], carry) = addc(x[i], y[i], carry);
return carry;
} | O0 | cpp | intx::internal::add(unsigned long*, unsigned long const*, unsigned long const*, int):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jl 0x6454f
jmp 0x6456e
leaq 0x7b1fb(%rip), %rdi # 0xdf751
leaq 0x7b14b(%rip), %rsi # 0xdf6a8
movl $0x670, %edx # imm = 0x670
leaq 0x7b385(%rip), %rcx # 0xdf8ee
callq 0x23120
movb $0x0, -0x1d(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x645ee
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x613d0
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x64470
movq -0x8(%rbp), %rsi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x58(%rbp), %rdi
leaq -0x1d(%rbp), %rdx
callq 0x644b0
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x644f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x64579
movb -0x1d(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN4intx8internal3addEPmPKmS3_i:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
cmp [rbp+var_1C], 2
jl short loc_6454F
jmp short loc_6456E
loc_6454F:
lea rdi, aLen2; "len >= 2"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov edx, 670h
lea rcx, aBoolIntxIntern; "bool intx::internal::add(uint64_t *, co"...
call ___assert_fail
loc_6456E:
mov [rbp+var_1D], 0
mov [rbp+var_24], 0
loc_64579:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_1C]
jge short loc_645EE
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_24]
mov rdi, [rax+rcx*8]; this
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_24]; bool
mov rsi, [rax+rcx*8]; unsigned __int64
mov al, [rbp+var_1D]
and al, 1
movzx edx, al; unsigned __int64
call _ZN4intx4addcEmmb; intx::addc(ulong,ulong,bool)
mov [rbp+var_48], rax
mov [rbp+var_40], dl
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_48]
call _ZN4intx17result_with_carryImEcvSt5tupleIJRmRbEEEv; intx::result_with_carry<ulong>::operator std::tuple<ulong &,bool &>(void)
mov rsi, [rbp+var_8]
movsxd rax, [rbp+var_24]
shl rax, 3
add rsi, rax
lea rdi, [rbp+var_58]
lea rdx, [rbp+var_1D]
call _ZSt3tieIJmbEESt5tupleIJDpRT_EES3_; std::tie<ulong,bool>(ulong,bool &)
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_38]
call _ZNSt5tupleIJRmRbEEaSEOS2_; std::tuple<ulong &,bool &>::operator=(std::tuple<ulong &,bool &>&&)
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_64579
loc_645EE:
mov al, [rbp+var_1D]
and al, 1
add rsp, 60h
pop rbp
retn
| char intx::internal::add(
intx::internal *this,
unsigned long long *a2,
const unsigned long long *a3,
const unsigned long long *a4)
{
char v4; // dl
_BYTE v6[16]; // [rsp+8h] [rbp-58h] BYREF
long long v7; // [rsp+18h] [rbp-48h] BYREF
char v8; // [rsp+20h] [rbp-40h]
_BYTE v9[20]; // [rsp+28h] [rbp-38h] BYREF
int i; // [rsp+3Ch] [rbp-24h]
char v11; // [rsp+43h] [rbp-1Dh] BYREF
int v12; // [rsp+44h] [rbp-1Ch]
const unsigned long long *v13; // [rsp+48h] [rbp-18h]
unsigned long long *v14; // [rsp+50h] [rbp-10h]
intx::internal *v15; // [rsp+58h] [rbp-8h]
v15 = this;
v14 = a2;
v13 = a3;
v12 = (int)a4;
if ( (int)a4 < 2 )
__assert_fail(
"len >= 2",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp",
1648LL,
"bool intx::internal::add(uint64_t *, const uint64_t *, const uint64_t *, int)");
v11 = 0;
for ( i = 0; i < v12; ++i )
{
v7 = intx::addc((intx *)v14[i], v13[i], v11 & 1);
v8 = v4;
intx::result_with_carry<unsigned long>::operator std::tuple<unsigned long &,bool &>((long long)v9, (long long)&v7);
std::tie<unsigned long,bool>((long long)v6, (long long)v15 + 8 * i, (long long)&v11);
std::tuple<unsigned long &,bool &>::operator=((long long)v6);
}
return v11 & 1;
}
| add:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
CMP dword ptr [RBP + -0x1c],0x2
JL 0x0016454f
JMP 0x0016456e
LAB_0016454f:
LEA RDI,[0x1df751]
LEA RSI,[0x1df6a8]
MOV EDX,0x670
LEA RCX,[0x1df8ee]
CALL 0x00123120
LAB_0016456e:
MOV byte ptr [RBP + -0x1d],0x0
MOV dword ptr [RBP + -0x24],0x0
LAB_00164579:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001645ee
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV AL,byte ptr [RBP + -0x1d]
AND AL,0x1
MOVZX EDX,AL
CALL 0x001613d0
MOV qword ptr [RBP + -0x48],RAX
MOV byte ptr [RBP + -0x40],DL
LEA RDI,[RBP + -0x38]
LEA RSI,[RBP + -0x48]
CALL 0x00164470
MOV RSI,qword ptr [RBP + -0x8]
MOVSXD RAX,dword ptr [RBP + -0x24]
SHL RAX,0x3
ADD RSI,RAX
LEA RDI,[RBP + -0x58]
LEA RDX,[RBP + -0x1d]
CALL 0x001644b0
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x38]
CALL 0x001644f0
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00164579
LAB_001645ee:
MOV AL,byte ptr [RBP + -0x1d]
AND AL,0x1
ADD RSP,0x60
POP RBP
RET
|
/* intx::internal::add(unsigned long*, unsigned long const*, unsigned long const*, int) */
uint intx::internal::add(ulong *param_1,ulong *param_2,ulong *param_3,int param_4)
{
int1 extraout_DL;
tuple<unsigned_long&,bool&> local_60 [16];
int8 local_50;
int1 local_48;
result_with_carry local_40 [20];
int local_2c;
byte local_25;
int local_24;
ulong *local_20;
ulong *local_18;
ulong *local_10;
local_24 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (1 < param_4) {
local_25 = 0;
for (local_2c = 0; local_2c < local_24; local_2c = local_2c + 1) {
local_50 = addc(local_18[local_2c],local_20[local_2c],(bool)(local_25 & 1));
local_48 = extraout_DL;
result_with_carry::operator_cast_to_tuple(local_40);
std::tie<unsigned_long,bool>((ulong *)local_60,(bool *)(local_10 + local_2c));
std::tuple<unsigned_long&,bool&>::operator=(local_60,(tuple *)local_40);
}
return CONCAT31((int3)((uint)local_2c >> 8),local_25) & 0xffffff01;
}
/* WARNING: Subroutine does not return */
__assert_fail("len >= 2",
"/workspace/llm4binary/github/2025_star3/corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp"
,0x670,
"bool intx::internal::add(uint64_t *, const uint64_t *, const uint64_t *, int)");
}
| |
53,763 | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&) | monkey531[P]llama/common/json.hpp | inline void from_json(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::boolean:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
} | O1 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, int, 0>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, int&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0xb5a92
leaq 0x614e5(%rip), %rcx # 0x116f50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
jmp 0xb5a87
movzbl 0x8(%r14), %eax
jmp 0xb5a87
cvttsd2si 0x8(%r14), %eax
movl %eax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1d5b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x8fd1e
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x62796(%rip), %rsi # 0x11824c
leaq 0x10(%rsp), %rdi
callq 0xab81b
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0xab64c
xorl %ebp, %ebp
leaq 0xa16b7(%rip), %rsi # 0x157198
leaq -0x29bb4(%rip), %rdx # 0x8bf34
movq %rbx, %rdi
callq 0x1e5a0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5b16
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1dc40
jmp 0xb5b16
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb5b23
movq %rbx, %rdi
callq 0x1d8b0
movq %r14, %rdi
callq 0x1e650
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
movzx eax, byte ptr [rdi]
add eax, 0FFFFFFFCh; switch 4 cases
cmp eax, 3
ja short def_B5A72; jumptable 00000000000B5A72 default case
lea rcx, jpt_B5A72
movsxd rax, ds:(jpt_B5A72 - 116F50h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B5A74:
mov eax, [r14+8]; jumptable 00000000000B5A72 cases 5,6
jmp short loc_B5A87
loc_B5A7A:
movzx eax, byte ptr [r14+8]; jumptable 00000000000B5A72 case 4
jmp short loc_B5A87
loc_B5A81:
cvttsd2si eax, qword ptr [r14+8]; jumptable 00000000000B5A72 case 7
loc_B5A87:
mov [rsi], eax
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
def_B5A72:
mov edi, 20h ; ' '; jumptable 00000000000B5A72 default case
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B5B16
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B5B16
mov r14, rax
mov bpl, 1
loc_B5B16:
test bpl, bpl
jz short loc_B5B23
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B5B23:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
unsigned __int8 *a1,
_DWORD *a2)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v4; // [rsp+8h] [rbp-40h] BYREF
_QWORD v5[2]; // [rsp+10h] [rbp-38h] BYREF
switch ( *a1 )
{
case 4u:
result = a1[8];
break;
case 5u:
case 6u:
result = *((unsigned int *)a1 + 2);
break;
case 7u:
result = (unsigned int)(int)*((double *)a1 + 1);
break;
default:
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
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>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v5,
(long long)"type must be number, but is ",
&v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v5);
__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);
}
*a2 = result;
return result;
}
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
ADD EAX,-0x4
CMP EAX,0x3
JA 0x001b5a92
LEA RCX,[0x216f50]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV EAX,dword ptr [R14 + 0x8]
JMP 0x001b5a87
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x001b5a87
caseD_7:
CVTTSD2SI EAX,qword ptr [R14 + 0x8]
LAB_001b5a87:
MOV dword ptr [RSI],EAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
default:
MOV EDI,0x20
CALL 0x0011d5b0
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018fd1e
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001b5aaf:
LEA RSI,[0x21824c]
LEA RDI,[RSP + 0x10]
CALL 0x001ab81b
MOV BPL,0x1
LAB_001b5ac3:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001ab64c
XOR EBP,EBP
LEA RSI,[0x257198]
LEA RDX,[0x18bf34]
MOV RDI,RBX
CALL 0x0011e5a0
|
void _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(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,uint *param_2)
{
uint uVar1;
int8 uVar2;
char *local_40;
detail local_38 [32];
switch(*param_1) {
case (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>
)0x4:
uVar1 = (uint)(byte)param_1[8];
break;
case (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>
)0x5:
case (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>
)0x6:
uVar1 = *(uint *)(param_1 + 8);
break;
case (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>
)0x7:
uVar1 = (uint)*(double *)(param_1 + 8);
break;
default:
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001b5aaf to 001b5abf has its CatchHandler @ 001b5b10 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be number, but is ",&local_40);
/* try { // try from 001b5ac3 to 001b5aef has its CatchHandler @ 001b5af0 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*param_2 = uVar1;
return;
}
| |
53,764 | minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | inline std::shared_ptr<Context> Context::make(Value && values, const std::shared_ptr<Context> & parent) {
return std::make_shared<Context>(values.is_null() ? Value::object() : std::move(values), parent);
} | O2 | cpp | minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3d906
movl %eax, %ebp
testb %al, %al
je 0x589f5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x49da0
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x4c0d0
jmp 0x58a02
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x3cb2c
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x58cad
leaq 0x18(%rsp), %rdi
callq 0x3cc92
testb %bpl, %bpl
je 0x58a2b
leaq 0x10(%rsp), %rdi
callq 0x30a1a
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3cc92
testb %bpl, %bpl
je 0x58a55
leaq 0x10(%rsp), %rdi
callq 0x30a1a
movq %rbx, %rdi
callq 0x20b90
nop
| _ZN5minja7Context4makeEONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push rbx
sub rsp, 68h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, rsi; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
mov ebp, eax
test al, al
jz short loc_589F5
lea r15, [rsp+88h+var_80]
mov rdi, r15
call _ZSt11make_sharedIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>()
lea rdi, [rsp+88h+var_70]
mov rsi, r15
call _ZN5minja5ValueC2ERKSt10shared_ptrIN8nlohmann16json_abi_v3_11_311ordered_mapINS3_10basic_jsonIS4_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES0_St4lessISG_ESaISt4pairIKSG_S0_EEEEE; minja::Value::Value(std::shared_ptr<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>> const&)
jmp short loc_58A02
loc_589F5:
lea rdi, [rsp+88h+var_70]
mov rsi, r15
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
loc_58A02:
lea rsi, [rsp+88h+var_70]
mov rdi, rbx
mov rdx, r14
call _ZSt11make_sharedIN5minja7ContextEJNS0_5ValueERKSt10shared_ptrIS1_EEES3_IT_EDpOT0_; std::make_shared<minja::Context,minja::Value,std::shared_ptr<minja::Context> const&>(minja::Value,std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+88h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jz short loc_58A2B
lea rdi, [rsp+88h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_58A2B:
mov rax, rbx
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_10]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
test bpl, bpl
jz short loc_58A55
lea rdi, [rsp+arg_8]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_58A55:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Context::make(long long a1, minja::Value *a2, long long a3)
{
bool is_null; // bp
long long v6; // [rsp+8h] [rbp-80h] BYREF
long long v7; // [rsp+10h] [rbp-78h] BYREF
_BYTE v8[112]; // [rsp+18h] [rbp-70h] BYREF
is_null = minja::Value::is_null(a2);
if ( is_null )
{
std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>((long long)&v6);
minja::Value::Value((long long)v8, &v6);
}
else
{
minja::Value::Value((long long)v8, (long long)a2);
}
std::make_shared<minja::Context,minja::Value,std::shared_ptr<minja::Context> const&>(a1, v8, a3);
minja::Value::~Value((minja::Value *)v8);
if ( is_null )
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v7);
return a1;
}
| make:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0013d906
MOV EBP,EAX
TEST AL,AL
JZ 0x001589f5
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00149da0
LEA RDI,[RSP + 0x18]
MOV RSI,R15
CALL 0x0014c0d0
JMP 0x00158a02
LAB_001589f5:
LEA RDI,[RSP + 0x18]
MOV RSI,R15
CALL 0x0013cb2c
LAB_00158a02:
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
MOV RDX,R14
CALL 0x00158cad
LAB_00158a12:
LEA RDI,[RSP + 0x18]
CALL 0x0013cc92
TEST BPL,BPL
JZ 0x00158a2b
LEA RDI,[RSP + 0x10]
CALL 0x00130a1a
LAB_00158a2b:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* minja::Context::make(minja::Value&&, std::shared_ptr<minja::Context> const&) */
Value * minja::Context::make(Value *param_1,shared_ptr *param_2)
{
char cVar1;
shared_ptr local_80 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_78 [8];
Value local_70 [80];
cVar1 = Value::is_null((Value *)param_2);
if (cVar1 == '\0') {
Value::Value(local_70,(Value *)param_2);
}
else {
std::
make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
();
Value::Value(local_70,local_80);
}
/* try { // try from 00158a02 to 00158a11 has its CatchHandler @ 00158a39 */
std::make_shared<minja::Context,minja::Value,std::shared_ptr<minja::Context>const&>
(param_1,(shared_ptr *)local_70);
Value::~Value(local_70);
if (cVar1 != '\0') {
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_78);
}
return param_1;
}
| |
53,765 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O2 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x30(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3dca
movl 0x34(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x3de1
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x3e00
movl 0x38(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x3e13
xorl %edx, %edx
divl 0x3c(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x3e33
movl %ebx, %eax
popq %rbx
retq
movq 0x4207(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x15a7(%rip), %rsi # 0x5382
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x3df7
movq 0x41f0(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x15a7(%rip), %rsi # 0x5399
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x3170
jmp 0x3dc6
movq 0x41d1(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x159f(%rip), %rsi # 0x53b0
jmp 0x3e44
movq 0x41be(%rip), %rax # 0x7fd8
movq (%rax), %rcx
leaq 0x15a9(%rip), %rdi # 0x53cd
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x31f0
xorl %ebx, %ebx
jmp 0x3dc6
movq 0x419e(%rip), %rax # 0x7fd8
movq (%rax), %rdi
leaq 0x15ac(%rip), %rsi # 0x53f0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3170
jmp 0x3dc6
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+30h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_3DCA
mov r8d, [rdi+34h]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_3DE1
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_3E00
mov eax, [rdi+38h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_3E13
xor edx, edx
div dword ptr [rdi+3Ch]
mov bl, 1
test edx, edx
jnz short loc_3E33
loc_3DC6:
mov eax, ebx
pop rbx
retn
loc_3DCA:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_3DF7
loc_3DE1:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_3DF7:
xor eax, eax
call _fprintf
jmp short loc_3DC6
loc_3E00:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aCachesizeBlock; "cacheSize %% blockSize != 0\n"
jmp short loc_3E44
loc_3E13:
mov rax, cs:stderr_ptr
mov rcx, [rax]
lea rdi, aBlocknumBlocks; "blockNum * blockSize != cacheSize\n"
push 22h ; '"'
pop rsi
push 1
pop rdx
call _fwrite
xor ebx, ebx
jmp short loc_3DC6
loc_3E33:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aBlocknumAssoci; "blockNum %% associativity != 0\n"
loc_3E44:
xor ebx, ebx
xor eax, eax
call _fprintf
jmp loc_3DC6
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
long long v4; // rdx
unsigned int v5; // eax
long long v7; // rdi
const char *v8; // rsi
long long v9; // rdx
long long v10; // rdi
const char *v11; // rsi
v2 = *((_DWORD *)this + 12);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v7 = stderr;
v8 = "Invalid Cache Size %d\n";
v1 = 0;
v9 = v2;
LABEL_9:
fprintf(v7, v8, v9);
return v1;
}
v3 = *((_DWORD *)this + 13);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v7 = stderr;
v8 = "Invalid Block Size %d\n";
v1 = 0;
v9 = v3;
goto LABEL_9;
}
v4 = v2 % v3;
if ( v2 % v3 )
{
v10 = stderr;
v11 = "cacheSize %% blockSize != 0\n";
LABEL_13:
v1 = 0;
fprintf(v10, v11, v4);
return v1;
}
v5 = *((_DWORD *)this + 14);
if ( v5 * v3 != v2 )
{
fwrite("blockNum * blockSize != cacheSize\n", 34LL, 1LL, stderr);
return 0;
}
v4 = v5 % *((_DWORD *)this + 15);
LOBYTE(v1) = 1;
if ( (_DWORD)v4 )
{
v10 = stderr;
v11 = "blockNum %% associativity != 0\n";
goto LABEL_13;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x30]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103dca
MOV R8D,dword ptr [RDI + 0x34]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00103de1
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00103e00
MOV EAX,dword ptr [RDI + 0x38]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x00103e13
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00103e33
LAB_00103dc6:
MOV EAX,EBX
POP RBX
RET
LAB_00103dca:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105382]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00103df7
LAB_00103de1:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x105399]
XOR EBX,EBX
MOV EDX,R8D
LAB_00103df7:
XOR EAX,EAX
CALL 0x00103170
JMP 0x00103dc6
LAB_00103e00:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1053b0]
JMP 0x00103e44
LAB_00103e13:
MOV RAX,qword ptr [0x00107fd8]
MOV RCX,qword ptr [RAX]
LEA RDI,[0x1053cd]
PUSH 0x22
POP RSI
PUSH 0x1
POP RDX
CALL 0x001031f0
XOR EBX,EBX
JMP 0x00103dc6
LAB_00103e33:
MOV RAX,qword ptr [0x00107fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1053f0]
LAB_00103e44:
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00103170
JMP 0x00103dc6
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *pcVar4;
FILE *pFVar5;
uVar1 = *(uint *)(this + 0x30);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x34);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x38) != uVar1) {
fwrite("blockNum * blockSize != cacheSize\n",0x22,1,*(FILE **)PTR_stderr_00107fd8);
uVar3 = 0;
goto LAB_00103dc6;
}
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) goto LAB_00103dc6;
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "blockNum %% associativity != 0\n";
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "cacheSize %% blockSize != 0\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4);
goto LAB_00103dc6;
}
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
pFVar5 = *(FILE **)PTR_stderr_00107fd8;
pcVar4 = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(pFVar5,pcVar4,(ulong)uVar1);
LAB_00103dc6:
return uVar3 & 0xffffffff;
}
| |
53,766 | Cache::isPolicyValid() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp | bool Cache::isPolicyValid() {
if (!this->isPowerOfTwo(policy.cacheSize)) {
fprintf(stderr, "Invalid Cache Size %d\n", policy.cacheSize);
return false;
}
if (!this->isPowerOfTwo(policy.blockSize)) {
fprintf(stderr, "Invalid Block Size %d\n", policy.blockSize);
return false;
}
if (policy.cacheSize % policy.blockSize != 0) {
fprintf(stderr, "cacheSize %% blockSize != 0\n");
return false;
}
if (policy.blockNum * policy.blockSize != policy.cacheSize) {
fprintf(stderr, "blockNum * blockSize != cacheSize\n");
return false;
}
if (policy.blockNum % policy.associativity != 0) {
fprintf(stderr, "blockNum %% associativity != 0\n");
return false;
}
return true;
} | O3 | cpp | Cache::isPolicyValid():
pushq %rbx
movl 0x30(%rdi), %ecx
leal -0x1(%rcx), %eax
movl %ecx, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x2eb8
movl 0x34(%rdi), %r8d
leal -0x1(%r8), %eax
movl %r8d, %edx
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x2ecf
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
testl %edx, %edx
jne 0x2eee
movl 0x38(%rdi), %eax
imull %eax, %r8d
cmpl %ecx, %r8d
jne 0x2ef5
xorl %edx, %edx
divl 0x3c(%rdi)
movb $0x1, %bl
testl %edx, %edx
jne 0x2efc
movl %ebx, %eax
popq %rbx
retq
movq 0x4119(%rip), %rax # 0x6fd8
movq (%rax), %rdi
leaq 0x14d7(%rip), %rsi # 0x43a0
xorl %ebx, %ebx
movl %ecx, %edx
jmp 0x2ee5
movq 0x4102(%rip), %rax # 0x6fd8
movq (%rax), %rdi
leaq 0x14d7(%rip), %rsi # 0x43b7
xorl %ebx, %ebx
movl %r8d, %edx
xorl %eax, %eax
callq 0x2150
jmp 0x2eb4
callq 0x22d6
jmp 0x2f01
callq 0x22ee
jmp 0x2f01
callq 0x230a
xorl %ebx, %ebx
jmp 0x2eb4
nop
| _ZN5Cache13isPolicyValidEv:
push rbx
mov ecx, [rdi+30h]
lea eax, [rcx-1]
mov edx, ecx
xor edx, eax
cmp edx, eax
jbe short loc_2EB8
mov r8d, [rdi+34h]
lea eax, [r8-1]
mov edx, r8d
xor edx, eax
cmp edx, eax
jbe short loc_2ECF
mov eax, ecx
xor edx, edx
div r8d
test edx, edx
jnz short loc_2EEE
mov eax, [rdi+38h]
imul r8d, eax
cmp r8d, ecx
jnz short loc_2EF5
xor edx, edx
div dword ptr [rdi+3Ch]
mov bl, 1
test edx, edx
jnz short loc_2EFC
loc_2EB4:
mov eax, ebx
pop rbx
retn
loc_2EB8:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidCacheSi; "Invalid Cache Size %d\n"
xor ebx, ebx
mov edx, ecx
jmp short loc_2EE5
loc_2ECF:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aInvalidBlockSi; "Invalid Block Size %d\n"
xor ebx, ebx
mov edx, r8d
loc_2EE5:
xor eax, eax
call _fprintf
jmp short loc_2EB4
loc_2EEE:
call _ZN5Cache13isPolicyValidEv_cold_1; Cache::isPolicyValid(void) [clone]
jmp short loc_2F01
loc_2EF5:
call _ZN5Cache13isPolicyValidEv_cold_2; Cache::isPolicyValid(void) [clone]
jmp short loc_2F01
loc_2EFC:
call _ZN5Cache13isPolicyValidEv_cold_3; Cache::isPolicyValid(void) [clone]
loc_2F01:
xor ebx, ebx
jmp short loc_2EB4
| long long Cache::isPolicyValid(Cache *this)
{
unsigned int v1; // ebx
unsigned int v2; // ecx
unsigned int v3; // r8d
unsigned int v4; // eax
v2 = *((_DWORD *)this + 12);
if ( ((v2 - 1) ^ v2) <= v2 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Cache Size %d\n", v2);
return v1;
}
v3 = *((_DWORD *)this + 13);
if ( ((v3 - 1) ^ v3) <= v3 - 1 )
{
v1 = 0;
fprintf(stderr, "Invalid Block Size %d\n", v3);
return v1;
}
if ( v2 % v3 )
{
Cache::isPolicyValid();
return 0;
}
v4 = *((_DWORD *)this + 14);
if ( v4 * v3 != v2 )
{
Cache::isPolicyValid();
return 0;
}
LOBYTE(v1) = 1;
if ( v4 % *((_DWORD *)this + 15) )
{
Cache::isPolicyValid();
return 0;
}
return v1;
}
| isPolicyValid:
PUSH RBX
MOV ECX,dword ptr [RDI + 0x30]
LEA EAX,[RCX + -0x1]
MOV EDX,ECX
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00102eb8
MOV R8D,dword ptr [RDI + 0x34]
LEA EAX,[R8 + -0x1]
MOV EDX,R8D
XOR EDX,EAX
CMP EDX,EAX
JBE 0x00102ecf
MOV EAX,ECX
XOR EDX,EDX
DIV R8D
TEST EDX,EDX
JNZ 0x00102eee
MOV EAX,dword ptr [RDI + 0x38]
IMUL R8D,EAX
CMP R8D,ECX
JNZ 0x00102ef5
XOR EDX,EDX
DIV dword ptr [RDI + 0x3c]
MOV BL,0x1
TEST EDX,EDX
JNZ 0x00102efc
LAB_00102eb4:
MOV EAX,EBX
POP RBX
RET
LAB_00102eb8:
MOV RAX,qword ptr [0x00106fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1043a0]
XOR EBX,EBX
MOV EDX,ECX
JMP 0x00102ee5
LAB_00102ecf:
MOV RAX,qword ptr [0x00106fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1043b7]
XOR EBX,EBX
MOV EDX,R8D
LAB_00102ee5:
XOR EAX,EAX
CALL 0x00102150
JMP 0x00102eb4
LAB_00102eee:
CALL 0x001022d6
JMP 0x00102f01
LAB_00102ef5:
CALL 0x001022ee
JMP 0x00102f01
LAB_00102efc:
CALL 0x0010230a
LAB_00102f01:
XOR EBX,EBX
JMP 0x00102eb4
|
/* Cache::isPolicyValid() */
ulong __thiscall Cache::isPolicyValid(Cache *this)
{
uint uVar1;
uint uVar2;
int8 unaff_RBX;
ulong uVar3;
char *__format;
FILE *__stream;
uVar1 = *(uint *)(this + 0x30);
if (uVar1 - 1 < (uVar1 ^ uVar1 - 1)) {
uVar2 = *(uint *)(this + 0x34);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
if (uVar1 % uVar2 == 0) {
if (uVar2 * *(uint *)(this + 0x38) == uVar1) {
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (*(uint *)(this + 0x38) % *(uint *)(this + 0x3c) == 0) goto LAB_00102eb4;
isPolicyValid();
}
else {
isPolicyValid();
}
}
else {
isPolicyValid();
}
uVar3 = 0;
goto LAB_00102eb4;
}
__stream = *(FILE **)PTR_stderr_00106fd8;
__format = "Invalid Block Size %d\n";
uVar1 = uVar2;
}
else {
__stream = *(FILE **)PTR_stderr_00106fd8;
__format = "Invalid Cache Size %d\n";
}
uVar3 = 0;
fprintf(__stream,__format,(ulong)uVar1);
LAB_00102eb4:
return uVar3 & 0xffffffff;
}
| |
53,767 | testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | std::string XmlUnitTestResultPrinter::EscapeXml(const std::string& str,
bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&':
m << "&";
break;
case '\'':
if (is_attribute)
m << "'";
else
m << '\'';
break;
case '"':
if (is_attribute)
m << """;
else
m << '"';
break;
default:
if (IsValidXmlCharacter(static_cast<unsigned char>(ch))) {
if (is_attribute &&
IsNormalizableWhitespace(static_cast<unsigned char>(ch)))
m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
<< ";";
else
m << ch;
}
break;
}
}
return m.GetString();
} | O1 | cpp | testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x20c50
cmpq $0x0, 0x8(%r14)
je 0x28ff1
movq 0x8(%rsp), %r15
addq $0x10, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movb (%rax,%rbx), %al
movzbl %al, %r13d
cmpl $0x26, %r13d
jle 0x28eaf
cmpl $0x27, %r13d
je 0x28ec9
movl $0x4, %edx
cmpl $0x3e, %r13d
je 0x28ef1
cmpl $0x3c, %r13d
jne 0x28f29
leaq 0x1a82c(%rip), %rsi # 0x436d9
jmp 0x28f0f
cmpl $0x22, %r13d
je 0x28efa
cmpl $0x26, %r13d
jne 0x28f29
movl $0x5, %edx
leaq 0x1a81c(%rip), %rsi # 0x436e3
jmp 0x28f0f
movl $0x6, %edx
leaq 0x1a814(%rip), %rsi # 0x436e9
testb %bpl, %bpl
jne 0x28f0f
movb $0x27, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x95a0
jmp 0x28f17
leaq 0x1a7e6(%rip), %rsi # 0x436de
jmp 0x28f0f
movl $0x6, %edx
leaq 0x1a7ea(%rip), %rsi # 0x436f0
testb %bpl, %bpl
je 0x28fd7
movq %r15, %rdi
callq 0x95a0
incq %rbx
cmpq 0x8(%r14), %rbx
jb 0x28e7b
jmp 0x28ff1
cmpb $0x1f, %al
ja 0x28f3e
cmpl $0xd, %r13d
ja 0x28f17
movl $0x2600, %ecx # imm = 0x2600
btl %r13d, %ecx
jae 0x28f17
testb %bpl, %bpl
je 0x28fbe
cmpl $0xd, %r13d
ja 0x28fbe
movl $0x2600, %ecx # imm = 0x2600
btl %r13d, %ecx
jae 0x28fbe
movl $0x3, %edx
movq %r15, %rdi
leaq 0x1a794(%rip), %rsi # 0x436f7
callq 0x95a0
movq %r12, %rdi
movl %r13d, %esi
callq 0x2394c
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x95a0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x19bca(%rip), %rsi # 0x42b5e
callq 0x95a0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x28f17
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x28f17
movb %al, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x95a0
jmp 0x28f17
movb $0x22, 0x10(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x95a0
jmp 0x28f17
movq 0x8(%rsp), %r14
movq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20eb3
testq %r14, %r14
je 0x29014
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2904f
jmp 0x2904f
jmp 0x2904f
jmp 0x2904f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x29052
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x29052
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29062
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x99a0
| _ZN7testing8internal24XmlUnitTestResultPrinter9EscapeXmlERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov ebp, edx
mov r14, rsi
mov [rsp+68h+var_38], rdi
lea rdi, [rsp+68h+var_60]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
cmp qword ptr [r14+8], 0
jz loc_28FF1
mov r15, [rsp+68h+var_60]
add r15, 10h
xor ebx, ebx
lea r12, [rsp+68h+var_58]
loc_28E7B:
mov rax, [r14]
mov al, [rax+rbx]
movzx r13d, al
cmp r13d, 26h ; '&'
jle short loc_28EAF
cmp r13d, 27h ; '''
jz short loc_28EC9
mov edx, 4
cmp r13d, 3Eh ; '>'
jz short loc_28EF1
cmp r13d, 3Ch ; '<'
jnz loc_28F29
lea rsi, aLt; "<"
jmp short loc_28F0F
loc_28EAF:
cmp r13d, 22h ; '"'
jz short loc_28EFA
cmp r13d, 26h ; '&'
jnz short loc_28F29
mov edx, 5
lea rsi, aAmp; "&"
jmp short loc_28F0F
loc_28EC9:
mov edx, 6
lea rsi, aApos; "'"
test bpl, bpl
jnz short loc_28F0F
mov byte ptr [rsp+68h+var_58], 27h ; '''
mov edx, 1
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_28F17
loc_28EF1:
lea rsi, aGt; ">"
jmp short loc_28F0F
loc_28EFA:
mov edx, 6
lea rsi, aQuot; """
test bpl, bpl
jz loc_28FD7
loc_28F0F:
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_28F17:
inc rbx
cmp rbx, [r14+8]
jb loc_28E7B
jmp loc_28FF1
loc_28F29:
cmp al, 1Fh
ja short loc_28F3E
cmp r13d, 0Dh
ja short loc_28F17
mov ecx, 2600h
bt ecx, r13d
jnb short loc_28F17
loc_28F3E:
test bpl, bpl
jz short loc_28FBE
cmp r13d, 0Dh
ja short loc_28FBE
mov ecx, 2600h
bt ecx, r13d
jnb short loc_28FBE
mov edx, 3
mov rdi, r15
lea rsi, asc_436F7; "&#x"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, r12
mov esi, r13d
call _ZN7testing8internal6String10FormatByteB5cxx11Eh; testing::internal::String::FormatByte(uchar)
mov rsi, [rsp+68h+var_58]
mov rdx, [rsp+68h+var_50]
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 1
mov rdi, r15
lea rsi, asc_42B5D+1; ";"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, [rsp+68h+var_58]; void *
lea rax, [rsp+68h+var_48]
cmp rdi, rax
jz loc_28F17
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_28F17
loc_28FBE:
mov byte ptr [rsp+68h+var_58], al
mov edx, 1
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_28F17
loc_28FD7:
mov byte ptr [rsp+68h+var_58], 22h ; '"'
mov edx, 1
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_28F17
loc_28FF1:
mov r14, [rsp+68h+var_60]
mov rbx, [rsp+68h+var_38]
mov rdi, rbx
mov rsi, r14
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
test r14, r14
jz short loc_29014
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+8]
loc_29014:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_2904F
jmp short loc_2904F
jmp short loc_2904F
jmp short loc_2904F
mov rbx, rax
mov rdi, [rsp+arg_8]; void *
lea rax, [rsp+arg_18]
cmp rdi, rax
jz short loc_29052
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_29052
loc_2904F:
mov rbx, rax
loc_29052:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_29062
mov rax, [rdi]
call qword ptr [rax+8]
loc_29062:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::XmlUnitTestResultPrinter::EscapeXml(long long a1, _QWORD *a2, char a3)
{
long long v5; // r15
long long v6; // rbx
unsigned __int8 v7; // al
unsigned __int8 v8; // r13
long long v9; // rdx
const char *v10; // rsi
int v11; // ecx
int v12; // ecx
long long v13; // r14
long long v14; // rbx
long long v16; // [rsp+8h] [rbp-60h] BYREF
void *v17[2]; // [rsp+10h] [rbp-58h] BYREF
long long v18; // [rsp+20h] [rbp-48h] BYREF
long long v19; // [rsp+30h] [rbp-38h]
v19 = a1;
testing::Message::Message((testing::Message *)&v16);
if ( a2[1] )
{
v5 = v16 + 16;
v6 = 0LL;
while ( 1 )
{
v7 = *(_BYTE *)(*a2 + v6);
v8 = v7;
if ( v7 <= 0x26u )
break;
if ( v7 != 39 )
{
v9 = 4LL;
if ( v7 == 62 )
{
v10 = ">";
}
else
{
if ( v7 != 60 )
goto LABEL_18;
v10 = "<";
}
LABEL_15:
std::__ostream_insert<char,std::char_traits<char>>(v5, v10, v9);
goto LABEL_16;
}
v9 = 6LL;
v10 = "'";
if ( a3 )
goto LABEL_15;
LOBYTE(v17[0]) = 39;
std::__ostream_insert<char,std::char_traits<char>>(v5, v17, 1LL);
LABEL_16:
if ( (unsigned long long)++v6 >= a2[1] )
goto LABEL_28;
}
if ( v7 == 34 )
{
v9 = 6LL;
v10 = """;
if ( !a3 )
{
LOBYTE(v17[0]) = 34;
std::__ostream_insert<char,std::char_traits<char>>(v5, v17, 1LL);
goto LABEL_16;
}
}
else
{
if ( v7 != 38 )
{
LABEL_18:
if ( v7 > 0x1Fu || v7 <= 0xDu && (v11 = 9728, _bittest(&v11, v7)) )
{
if ( a3 && v7 <= 0xDu && (v12 = 9728, _bittest(&v12, v7)) )
{
std::__ostream_insert<char,std::char_traits<char>>(v5, "&#x", 3LL);
testing::internal::String::FormatByte[abi:cxx11]((long long)v17, v8);
std::__ostream_insert<char,std::char_traits<char>>(v5, v17[0], v17[1]);
std::__ostream_insert<char,std::char_traits<char>>(v5, ";", 1LL);
if ( v17[0] != &v18 )
operator delete(v17[0], v18 + 1);
}
else
{
LOBYTE(v17[0]) = *(_BYTE *)(*a2 + v6);
std::__ostream_insert<char,std::char_traits<char>>(v5, v17, 1LL);
}
}
goto LABEL_16;
}
v9 = 5LL;
v10 = "&";
}
goto LABEL_15;
}
LABEL_28:
v13 = v16;
v14 = v19;
testing::internal::StringStreamToString(v19, v16);
if ( v13 )
(*(void ( **)(long long))(*(_QWORD *)v13 + 8LL))(v13);
return v14;
}
| EscapeXml:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBP,EDX
MOV R14,RSI
MOV qword ptr [RSP + 0x30],RDI
LEA RDI,[RSP + 0x8]
CALL 0x00120c50
CMP qword ptr [R14 + 0x8],0x0
JZ 0x00128ff1
MOV R15,qword ptr [RSP + 0x8]
ADD R15,0x10
XOR EBX,EBX
LEA R12,[RSP + 0x10]
LAB_00128e7b:
MOV RAX,qword ptr [R14]
MOV AL,byte ptr [RAX + RBX*0x1]
MOVZX R13D,AL
CMP R13D,0x26
JLE 0x00128eaf
CMP R13D,0x27
JZ 0x00128ec9
MOV EDX,0x4
CMP R13D,0x3e
JZ 0x00128ef1
CMP R13D,0x3c
JNZ 0x00128f29
LEA RSI,[0x1436d9]
JMP 0x00128f0f
LAB_00128eaf:
CMP R13D,0x22
JZ 0x00128efa
CMP R13D,0x26
JNZ 0x00128f29
MOV EDX,0x5
LEA RSI,[0x1436e3]
JMP 0x00128f0f
LAB_00128ec9:
MOV EDX,0x6
LEA RSI,[0x1436e9]
TEST BPL,BPL
JNZ 0x00128f0f
MOV byte ptr [RSP + 0x10],0x27
LAB_00128edf:
MOV EDX,0x1
MOV RDI,R15
MOV RSI,R12
CALL 0x001095a0
JMP 0x00128f17
LAB_00128ef1:
LEA RSI,[0x1436de]
JMP 0x00128f0f
LAB_00128efa:
MOV EDX,0x6
LEA RSI,[0x1436f0]
TEST BPL,BPL
JZ 0x00128fd7
LAB_00128f0f:
MOV RDI,R15
CALL 0x001095a0
LAB_00128f17:
INC RBX
CMP RBX,qword ptr [R14 + 0x8]
JC 0x00128e7b
JMP 0x00128ff1
LAB_00128f29:
CMP AL,0x1f
JA 0x00128f3e
CMP R13D,0xd
JA 0x00128f17
MOV ECX,0x2600
BT ECX,R13D
JNC 0x00128f17
LAB_00128f3e:
TEST BPL,BPL
JZ 0x00128fbe
CMP R13D,0xd
JA 0x00128fbe
MOV ECX,0x2600
BT ECX,R13D
JNC 0x00128fbe
MOV EDX,0x3
MOV RDI,R15
LEA RSI,[0x1436f7]
CALL 0x001095a0
LAB_00128f68:
MOV RDI,R12
MOV ESI,R13D
CALL 0x0012394c
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_00128f7d:
MOV RDI,R15
CALL 0x001095a0
MOV EDX,0x1
MOV RDI,R15
LEA RSI,[0x142b5e]
CALL 0x001095a0
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x00128f17
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001094c0
JMP 0x00128f17
LAB_00128fbe:
MOV byte ptr [RSP + 0x10],AL
LAB_00128fc2:
MOV EDX,0x1
MOV RDI,R15
MOV RSI,R12
CALL 0x001095a0
JMP 0x00128f17
LAB_00128fd7:
MOV byte ptr [RSP + 0x10],0x22
LAB_00128fdc:
MOV EDX,0x1
MOV RDI,R15
MOV RSI,R12
CALL 0x001095a0
JMP 0x00128f17
LAB_00128ff1:
MOV R14,qword ptr [RSP + 0x8]
LAB_00128ff6:
MOV RBX,qword ptr [RSP + 0x30]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00120eb3
LAB_00129006:
TEST R14,R14
JZ 0x00129014
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x8]
LAB_00129014:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::string const&, bool) */
stringstream * __thiscall
testing::internal::XmlUnitTestResultPrinter::EscapeXml
(XmlUnitTestResultPrinter *this,string *param_1,bool param_2)
{
byte bVar1;
XmlUnitTestResultPrinter *pXVar2;
long lVar3;
ulong uVar4;
char *pcVar5;
uint uVar6;
ostream *poVar8;
long *local_60;
byte local_58;
int7 uStack_57;
long local_50;
long local_48 [2];
XmlUnitTestResultPrinter *local_38;
uint uVar7;
local_38 = this;
Message::Message((Message *)&local_60);
if (*(long *)(param_1 + 8) != 0) {
poVar8 = (ostream *)(local_60 + 2);
uVar4 = 0;
do {
bVar1 = *(byte *)(*(long *)param_1 + uVar4);
uVar6 = (uint)bVar1;
uVar7 = (uint)bVar1;
if (bVar1 < 0x27) {
if (bVar1 == 0x22) {
lVar3 = 6;
pcVar5 = """;
if (param_2) goto LAB_00128f0f;
local_58 = 0x22;
/* try { // try from 00128fdc to 00128feb has its CatchHandler @ 0012902a */
std::__ostream_insert<char,std::char_traits<char>>(poVar8,(char *)&local_58,1);
}
else {
if (uVar6 == 0x26) {
lVar3 = 5;
pcVar5 = "&";
goto LAB_00128f0f;
}
LAB_00128f29:
if ((0x1f < bVar1) || ((uVar7 < 0xe && ((0x2600U >> (uVar7 & 0x1f) & 1) != 0)))) {
if ((param_2) && ((uVar6 < 0xe && ((0x2600U >> (uVar6 & 0x1f) & 1) != 0)))) {
std::__ostream_insert<char,std::char_traits<char>>(poVar8,"&#x",3);
/* try { // try from 00128f68 to 00128f72 has its CatchHandler @ 00129028 */
String::FormatByte_abi_cxx11_((uchar)&local_58);
/* try { // try from 00128f7d to 00128f98 has its CatchHandler @ 0012902e */
std::__ostream_insert<char,std::char_traits<char>>
(poVar8,(char *)CONCAT71(uStack_57,local_58),local_50);
std::__ostream_insert<char,std::char_traits<char>>(poVar8,";",1);
if ((long *)CONCAT71(uStack_57,local_58) != local_48) {
operator_delete((long *)CONCAT71(uStack_57,local_58),local_48[0] + 1);
}
}
else {
local_58 = bVar1;
/* try { // try from 00128fc2 to 00128fd1 has its CatchHandler @ 0012904f */
std::__ostream_insert<char,std::char_traits<char>>(poVar8,(char *)&local_58,1);
}
}
}
}
else {
if (uVar6 == 0x27) {
lVar3 = 6;
pcVar5 = "'";
if (!param_2) {
local_58 = 0x27;
/* try { // try from 00128edf to 00128eee has its CatchHandler @ 0012902c */
std::__ostream_insert<char,std::char_traits<char>>(poVar8,(char *)&local_58,1);
goto LAB_00128f17;
}
}
else {
lVar3 = 4;
if (uVar7 == 0x3e) {
pcVar5 = ">";
}
else {
if (uVar7 != 0x3c) goto LAB_00128f29;
pcVar5 = "<";
}
}
LAB_00128f0f:
/* try { // try from 00128f0f to 00128f67 has its CatchHandler @ 0012904f */
std::__ostream_insert<char,std::char_traits<char>>(poVar8,pcVar5,lVar3);
}
LAB_00128f17:
uVar4 = uVar4 + 1;
} while (uVar4 < *(ulong *)(param_1 + 8));
}
pXVar2 = local_38;
/* try { // try from 00128ff6 to 00129005 has its CatchHandler @ 00129026 */
StringStreamToString((stringstream *)local_38);
if (local_60 != (long *)0x0) {
(**(code **)(*local_60 + 8))(local_60);
}
return (stringstream *)pXVar2;
}
| |
53,768 | minja::ForNode::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 {
// https://jinja.palletsprojects.com/en/3.0.x/templates/#for
if (!iterable) throw std::runtime_error("ForNode.iterable is null");
if (!body) throw std::runtime_error("ForNode.body is null");
auto iterable_value = iterable->evaluate(context);
Value::CallableType loop_function;
std::function<void(Value&)> visit = [&](Value& iter) {
auto filtered_items = Value::array();
if (!iter.is_null()) {
if (!iterable_value.is_iterable()) {
throw std::runtime_error("For loop iterable must be iterable: " + iterable_value.dump());
}
iterable_value.for_each([&](Value & item) {
destructuring_assign(var_names, context, item);
if (!condition || condition->evaluate(context).to_bool()) {
filtered_items.push_back(item);
}
});
}
if (filtered_items.empty()) {
if (else_body) {
else_body->render(out, context);
}
} else {
auto loop = recursive ? Value::callable(loop_function) : Value::object();
loop.set("length", (int64_t) filtered_items.size());
size_t cycle_index = 0;
loop.set("cycle", Value::callable([&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.empty() || !args.kwargs.empty()) {
throw std::runtime_error("cycle() expects at least 1 positional argument and no named arg");
}
auto item = args.args[cycle_index];
cycle_index = (cycle_index + 1) % args.args.size();
return item;
}));
auto loop_context = Context::make(Value::object(), context);
loop_context->set("loop", loop);
for (size_t i = 0, n = filtered_items.size(); i < n; ++i) {
auto & item = filtered_items.at(i);
destructuring_assign(var_names, loop_context, item);
loop.set("index", (int64_t) i + 1);
loop.set("index0", (int64_t) i);
loop.set("revindex", (int64_t) (n - i));
loop.set("revindex0", (int64_t) (n - i - 1));
loop.set("length", (int64_t) n);
loop.set("first", i == 0);
loop.set("last", i == (n - 1));
loop.set("previtem", i > 0 ? filtered_items.at(i - 1) : Value());
loop.set("nextitem", i < n - 1 ? filtered_items.at(i + 1) : Value());
try {
body->render(out, loop_context);
} catch (const LoopControlException & e) {
if (e.control_type == LoopControlType::Break) break;
if (e.control_type == LoopControlType::Continue) continue;
}
}
}
};
if (recursive) {
loop_function = [&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.size() != 1 || !args.kwargs.empty() || !args.args[0].is_array()) {
throw std::runtime_error("loop() expects exactly 1 positional iterable argument");
}
auto & items = args.args[0];
visit(items);
return Value();
};
}
visit(iterable_value);
} | O2 | cpp | minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
je 0x74e30
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x74e4c
movq %rdx, %r15
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x642e8
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x40(%rsp), %rsi
movq %r12, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %r14, 0x18(%rsi)
movq %rax, 0x20(%rsi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x74f18
cmpb $0x1, 0x68(%rbx)
jne 0x74df6
leaq 0x40(%rsp), %rsi
movq %r14, (%rsi)
movq %rsp, %rdi
callq 0x74f60
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6f0c2
leaq 0x20(%rsp), %rdi
callq 0x4970c
movq %rsp, %rdi
callq 0x4970c
leaq 0x68(%rsp), %rdi
callq 0x64578
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x4128c(%rip), %rsi # 0xb60ce
movq %rax, %rdi
callq 0x23330
jmp 0x74e66
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x41289(%rip), %rsi # 0xb60e7
movq %rax, %rdi
callq 0x23330
movq 0x8a17b(%rip), %rsi # 0xfefe8
movq 0x8a0d4(%rip), %rdx # 0xfef48
movq %r14, %rdi
callq 0x23fb0
jmp 0x74e7e
movq %rax, %rbx
movq %r14, %rdi
callq 0x23690
jmp 0x74eaf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4970c
jmp 0x74e9d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4970c
leaq 0x68(%rsp), %rdi
callq 0x64578
movq %rbx, %rdi
callq 0x24030
nop
| _ZNK5minja7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0B8h
mov r14, rsi
mov rsi, [rdi+38h]
test rsi, rsi
jz loc_74E30
mov rbx, rdi
cmp qword ptr [rdi+58h], 0
jz loc_74E4C
mov r15, rdx
lea r12, [rsp+0D8h+var_70]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
xorps xmm0, xmm0
mov rax, rsp
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
lea rsi, [rsp+0D8h+var_98]
mov [rsi], r12
mov [rsi+8], rbx
mov [rsi+10h], r15
mov [rsi+18h], r14
mov [rsi+20h], rax
lea r14, [rsp+0D8h+var_B8]
mov rdi, r14
call _ZNSt8functionIFvRN5minja5ValueEEEC2IZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS0_7ContextEEEUlS2_E_vEEOT_; std::function<void ()(minja::Value &)>::function<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1} &&)
cmp byte ptr [rbx+68h], 1
jnz short loc_74DF6
lea rsi, [rsp+0D8h+var_98]
mov [rsi], r14
mov rdi, rsp
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEaSIZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEES6_EUlS6_S8_E_EENSt9enable_ifIXsrNSA_9_CallableIT_NSL_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISN_E4typeEE4typeESA_EE5valueESt5decayISN_EE4type4typeESt15__invoke_resultIRSY_JS6_S8_EEEE5valueERSA_E4typeEOSN_
loc_74DF6:
lea rdi, [rsp+0D8h+var_B8]
lea rsi, [rsp+0D8h+var_70]
call _ZNKSt8functionIFvRN5minja5ValueEEEclES2_; std::function<void ()(minja::Value &)>::operator()(minja::Value &)
lea rdi, [rsp+0D8h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+0D8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 0B8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_74E30:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeIterabl; "ForNode.iterable is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_74E66
loc_74E4C:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeBodyIsN; "ForNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_74E66:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short $+2
loc_74E7E:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_74EAF
mov rbx, rax
lea rdi, [rsp+0D8h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_74E9D
mov rbx, rax
loc_74E9D:
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+0D8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_74EAF:
mov rdi, rbx
call __Unwind_Resume
| void minja::ForNode::do_render(long long a1, long long a2, long long a3)
{
void (***v4)(void); // rsi
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
std::runtime_error *exception; // r14
_BYTE v11[32]; // [rsp+0h] [rbp-D8h] BYREF
_BYTE v12[32]; // [rsp+20h] [rbp-B8h] BYREF
_QWORD v13[5]; // [rsp+40h] [rbp-98h] BYREF
_BYTE v14[112]; // [rsp+68h] [rbp-70h] BYREF
v4 = *(void (****)(void))(a1 + 56);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.iterable is null");
goto LABEL_8;
}
if ( !*(_QWORD *)(a1 + 88) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.body is null");
LABEL_8:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v14, v4);
v13[0] = v14;
v13[1] = a1;
v13[2] = a3;
v13[3] = a2;
v13[4] = v11;
std::function<void ()(minja::Value &)>::function<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(
v12,
v13,
v6,
v7,
v8,
v9,
0LL,
0LL,
0LL,
0LL);
if ( *(_BYTE *)(a1 + 104) == 1 )
{
v13[0] = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator=<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1}>(v11);
}
std::function<void ()(minja::Value &)>::operator()((long long)v12);
std::_Function_base::~_Function_base((std::_Function_base *)v12);
std::_Function_base::~_Function_base((std::_Function_base *)v11);
minja::Value::~Value((minja::Value *)v14);
}
| do_render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R14,RSI
MOV RSI,qword ptr [RDI + 0x38]
TEST RSI,RSI
JZ 0x00174e30
MOV RBX,RDI
CMP qword ptr [RDI + 0x58],0x0
JZ 0x00174e4c
MOV R15,RDX
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x001642e8
XORPS XMM0,XMM0
MOV RAX,RSP
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],R12
MOV qword ptr [RSI + 0x8],RBX
MOV qword ptr [RSI + 0x10],R15
MOV qword ptr [RSI + 0x18],R14
MOV qword ptr [RSI + 0x20],RAX
LAB_00174dd3:
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x00174f18
CMP byte ptr [RBX + 0x68],0x1
JNZ 0x00174df6
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],R14
MOV RDI,RSP
CALL 0x00174f60
LAB_00174df6:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x68]
CALL 0x0016f0c2
LAB_00174e05:
LEA RDI,[RSP + 0x20]
CALL 0x0014970c
MOV RDI,RSP
CALL 0x0014970c
LEA RDI,[RSP + 0x68]
CALL 0x00164578
ADD RSP,0xb8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00174e30:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_00174e3b:
LEA RSI,[0x1b60ce]
MOV RDI,RAX
CALL 0x00123330
LAB_00174e4a:
JMP 0x00174e66
LAB_00174e4c:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_00174e57:
LEA RSI,[0x1b60e7]
MOV RDI,RAX
CALL 0x00123330
LAB_00174e66:
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,R14
CALL 0x00123fb0
|
/* minja::ForNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void __thiscall minja::ForNode::do_render(ForNode *this,ostringstream *param_1,shared_ptr *param_2)
{
runtime_error *this_00;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
_lambda_minja__Value___1_ local_b8 [32];
Expression *local_98;
ForNode *local_90;
shared_ptr *local_88;
ostringstream *local_80;
int1 *local_78;
Expression local_70 [80];
if (*(shared_ptr **)(this + 0x38) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00174e3b to 00174e49 has its CatchHandler @ 00174e7e */
std::runtime_error::runtime_error(this_00,"ForNode.iterable is null");
}
else {
if (*(long *)(this + 0x58) != 0) {
Expression::evaluate(local_70,*(shared_ptr **)(this + 0x38));
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
/* try { // try from 00174dd3 to 00174ddf has its CatchHandler @ 00174e9a */
local_98 = local_70;
local_90 = this;
local_88 = param_2;
local_80 = param_1;
local_78 = (int1 *)&local_d8;
std::function<void(minja::Value&)>::
function<minja::ForNode::do_render(std::__cxx11::ostringstream&,std::shared_ptr<minja::Context>const&)const::_lambda(minja::Value&)_1_,void>
(local_b8);
if (this[0x68] == (ForNode)0x1) {
local_98 = (Expression *)local_b8;
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
operator=((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>
*)&local_d8,
(_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ *)
&local_98);
}
/* try { // try from 00174df6 to 00174e04 has its CatchHandler @ 00174e8b */
std::function<void(minja::Value&)>::operator()
((function<void(minja::Value&)> *)local_b8,(Value *)local_70);
std::_Function_base::~_Function_base((_Function_base *)local_b8);
std::_Function_base::~_Function_base((_Function_base *)&local_d8);
Value::~Value((Value *)local_70);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00174e57 to 00174e65 has its CatchHandler @ 00174e7c */
std::runtime_error::runtime_error(this_00,"ForNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
| |
53,769 | find_private_class_field | bluesky950520[P]quickjs/quickjs.c | static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
JSAtom name, int scope_level)
{
int idx;
idx = fd->scopes[scope_level].first;
while (idx != -1) {
if (fd->vars[idx].scope_level != scope_level)
break;
if (fd->vars[idx].var_name == name)
return idx;
idx = fd->vars[idx].scope_next;
}
return -1;
} | O2 | c | find_private_class_field:
movq 0xf8(%rdi), %rax
movslq %edx, %rcx
leaq (%rax,%rcx,8), %r9
addq $0x4, %r9
pushq $-0x1
popq %rax
movslq (%r9), %rcx
cmpq $-0x1, %rcx
je 0x5dd5c
movq 0x90(%rdi), %r8
movq %rcx, %r9
shlq $0x4, %r9
cmpl %edx, 0x4(%r8,%r9)
jne 0x5dd5c
addq %r9, %r8
leaq 0x8(%r8), %r9
cmpl %esi, (%r8)
jne 0x5dd30
movl %ecx, %eax
retq
| find_private_class_field:
mov rax, [rdi+0F8h]
movsxd rcx, edx
lea r9, [rax+rcx*8]
add r9, 4
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_5DD30:
movsxd rcx, dword ptr [r9]
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz short locret_5DD5C
mov r8, [rdi+90h]
mov r9, rcx
shl r9, 4
cmp [r8+r9+4], edx
jnz short locret_5DD5C
add r8, r9
lea r9, [r8+8]
cmp [r8], esi
jnz short loc_5DD30
mov eax, ecx
locret_5DD5C:
retn
| long long find_private_class_field(long long a1, int a2, int a3)
{
int *v3; // r9
long long result; // rax
long long v5; // rcx
long long v6; // r8
_DWORD *v7; // r8
v3 = (int *)(*(_QWORD *)(a1 + 248) + 8LL * a3 + 4);
result = -1LL;
while ( 1 )
{
v5 = *v3;
if ( v5 == -1 )
break;
v6 = *(_QWORD *)(a1 + 144);
if ( *(_DWORD *)(v6 + 16 * v5 + 4) != a3 )
break;
v7 = (_DWORD *)(16 * v5 + v6);
v3 = v7 + 2;
if ( *v7 == a2 )
return (unsigned int)v5;
}
return result;
}
| find_private_class_field:
MOV RAX,qword ptr [RDI + 0xf8]
MOVSXD RCX,EDX
LEA R9,[RAX + RCX*0x8]
ADD R9,0x4
PUSH -0x1
POP RAX
LAB_0015dd30:
MOVSXD RCX,dword ptr [R9]
CMP RCX,-0x1
JZ 0x0015dd5c
MOV R8,qword ptr [RDI + 0x90]
MOV R9,RCX
SHL R9,0x4
CMP dword ptr [R8 + R9*0x1 + 0x4],EDX
JNZ 0x0015dd5c
ADD R8,R9
LEA R9,[R8 + 0x8]
CMP dword ptr [R8],ESI
JNZ 0x0015dd30
MOV EAX,ECX
LAB_0015dd5c:
RET
|
ulong find_private_class_field(long param_1,int param_2,int param_3)
{
uint uVar1;
int *piVar2;
uint *puVar3;
long lVar4;
puVar3 = (uint *)(*(long *)(param_1 + 0xf8) + (long)param_3 * 8 + 4);
while( true ) {
uVar1 = *puVar3;
if ((long)(int)uVar1 == -1) {
return 0xffffffffffffffff;
}
lVar4 = (long)(int)uVar1 * 0x10;
if (*(int *)(*(long *)(param_1 + 0x90) + 4 + lVar4) != param_3) break;
piVar2 = (int *)(*(long *)(param_1 + 0x90) + lVar4);
puVar3 = (uint *)(piVar2 + 2);
if (*piVar2 == param_2) {
return (ulong)uVar1;
}
}
return 0xffffffffffffffff;
}
| |
53,770 | my_strxfrm_flag_normalize | eloqsql/strings/ctype-simple.c | uint my_strxfrm_flag_normalize(uint flags, uint maximum)
{
DBUG_ASSERT(maximum >= 1 && maximum <= MY_STRXFRM_NLEVELS);
/* If levels are omitted, then 1-maximum is assumed*/
if (!(flags & MY_STRXFRM_LEVEL_ALL))
{
static uint def_level_flags[]= {0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F };
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
flags= def_level_flags[maximum] | flag_pad;
}
else
{
uint i;
uint flag_lev= flags & MY_STRXFRM_LEVEL_ALL;
uint flag_dsc= (flags >> MY_STRXFRM_DESC_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_rev= (flags >> MY_STRXFRM_REVERSE_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
/*
If any level number is greater than the maximum,
it is treated as the maximum.
*/
for (maximum--, flags= 0, i= 0; i < MY_STRXFRM_NLEVELS; i++)
{
uint src_bit= 1 << i;
if (flag_lev & src_bit)
{
uint dst_bit= 1 << MY_MIN(i, maximum);
flags|= dst_bit;
flags|= (flag_dsc & dst_bit) << MY_STRXFRM_DESC_SHIFT;
flags|= (flag_rev & dst_bit) << MY_STRXFRM_REVERSE_SHIFT;
}
}
flags|= flag_pad;
}
return flags;
} | O0 | c | my_strxfrm_flag_normalize:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
jmp 0x564bc
movl -0x4(%rbp), %eax
andl $0x3f, %eax
cmpl $0x0, %eax
jne 0x564ec
movl -0x4(%rbp), %eax
andl $0xc0, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x233d72(%rip), %rax # 0x28a250
movl (%rax,%rcx,4), %eax
orl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x565ad
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
andl $0xc0, %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jae 0x565a4
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0x56597
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x5655d
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x56563
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
andl -0x28(%rbp), %eax
shll $0x8, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
shll $0x10, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x56599
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5652f
movl -0x20(%rbp), %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strxfrm_flag_normalize:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
jmp short $+2
loc_564BC:
mov eax, [rbp+var_4]
and eax, 3Fh
cmp eax, 0
jnz short loc_564EC
mov eax, [rbp+var_4]
and eax, 0C0h
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
mov ecx, eax
lea rax, my_strxfrm_flag_normalize_def_level_flags
mov eax, [rax+rcx*4]
or eax, [rbp+var_C]
mov [rbp+var_4], eax
jmp loc_565AD
loc_564EC:
mov eax, [rbp+var_4]
and eax, 3Fh
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
shr eax, 8
and eax, 3Fh
mov [rbp+var_18], eax
mov eax, [rbp+var_4]
shr eax, 10h
and eax, 3Fh
mov [rbp+var_1C], eax
mov eax, [rbp+var_4]
and eax, 0C0h
mov [rbp+var_20], eax
mov eax, [rbp+var_8]
add eax, 0FFFFFFFFh
mov [rbp+var_8], eax
mov [rbp+var_4], 0
mov [rbp+var_10], 0
loc_5652F:
cmp [rbp+var_10], 6
jnb short loc_565A4
mov ecx, [rbp+var_10]
mov eax, 1
shl eax, cl
mov [rbp+var_24], eax
mov eax, [rbp+var_14]
and eax, [rbp+var_24]
cmp eax, 0
jz short loc_56597
mov eax, [rbp+var_10]
cmp eax, [rbp+var_8]
jnb short loc_5655D
mov eax, [rbp+var_10]
mov [rbp+var_2C], eax
jmp short loc_56563
loc_5655D:
mov eax, [rbp+var_8]
mov [rbp+var_2C], eax
loc_56563:
mov ecx, [rbp+var_2C]
mov eax, 1
shl eax, cl
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_18]
and eax, [rbp+var_28]
shl eax, 8
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
and eax, [rbp+var_28]
shl eax, 10h
or eax, [rbp+var_4]
mov [rbp+var_4], eax
loc_56597:
jmp short $+2
loc_56599:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_5652F
loc_565A4:
mov eax, [rbp+var_20]
or eax, [rbp+var_4]
mov [rbp+var_4], eax
loc_565AD:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_strxfrm_flag_normalize(unsigned int a1, int a2)
{
char v3; // [rsp+0h] [rbp-2Ch]
unsigned int i; // [rsp+1Ch] [rbp-10h]
int v6; // [rsp+28h] [rbp-4h]
if ( (a1 & 0x3F) != 0 )
{
v6 = 0;
for ( i = 0; i < 6; ++i )
{
if ( ((1 << i) & a1 & 0x3F) != 0 )
{
if ( i >= a2 - 1 )
v3 = a2 - 1;
else
v3 = i;
v6 |= (1 << v3) | (((1 << v3) & (a1 >> 8) & 0x3F) << 8) | (((1 << v3) & HIWORD(a1) & 0x3F) << 16);
}
}
return v6 | a1 & 0xC0;
}
else
{
return a1 & 0xC0 | my_strxfrm_flag_normalize_def_level_flags[a2];
}
}
| my_strxfrm_flag_normalize:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
JMP 0x001564bc
LAB_001564bc:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x3f
CMP EAX,0x0
JNZ 0x001564ec
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xc0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV ECX,EAX
LEA RAX,[0x38a250]
MOV EAX,dword ptr [RAX + RCX*0x4]
OR EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001565ad
LAB_001564ec:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x3f
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x8
AND EAX,0x3f
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x10
AND EAX,0x3f
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xc0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x10],0x0
LAB_0015652f:
CMP dword ptr [RBP + -0x10],0x6
JNC 0x001565a4
MOV ECX,dword ptr [RBP + -0x10]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,dword ptr [RBP + -0x24]
CMP EAX,0x0
JZ 0x00156597
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x8]
JNC 0x0015655d
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00156563
LAB_0015655d:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x2c],EAX
LAB_00156563:
MOV ECX,dword ptr [RBP + -0x2c]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,dword ptr [RBP + -0x28]
SHL EAX,0x8
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,dword ptr [RBP + -0x28]
SHL EAX,0x10
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
LAB_00156597:
JMP 0x00156599
LAB_00156599:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0015652f
LAB_001565a4:
MOV EAX,dword ptr [RBP + -0x20]
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
LAB_001565ad:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint my_strxfrm_flag_normalize(uint param_1,uint param_2)
{
uint uVar1;
uint local_34;
uint local_18;
uint local_c;
if ((param_1 & 0x3f) == 0) {
local_c = *(uint *)(my_strxfrm_flag_normalize_def_level_flags + (ulong)param_2 * 4) |
param_1 & 0xc0;
}
else {
local_c = 0;
for (local_18 = 0; local_18 < 6; local_18 = local_18 + 1) {
if ((param_1 & 0x3f & 1 << ((byte)local_18 & 0x1f)) != 0) {
local_34 = param_2 - 1;
if (local_18 < param_2 - 1) {
local_34 = local_18;
}
uVar1 = 1 << ((byte)local_34 & 0x1f);
local_c = (param_1 >> 0x10 & 0x3f & uVar1) << 0x10 |
(param_1 >> 8 & 0x3f & uVar1) << 8 | uVar1 | local_c;
}
}
local_c = param_1 & 0xc0 | local_c;
}
return local_c;
}
| |
53,771 | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::at<unsigned long&, 0>(unsigned long&) | monkey531[P]llama/common/json.hpp | T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it->second;
}
}
JSON_THROW(std::out_of_range("key not found"));
} | O2 | cpp | minja::Value& nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::at<unsigned long&, 0>(unsigned long&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
cmpq 0x8(%r15), %rbx
je 0x6c8b6
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6c921
testb %al, %al
jne 0x6c8a9
addq $0x60, %rbx
jmp 0x6c88e
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %rbx
leaq 0x491aa(%rip), %rsi # 0xb5a72
movq %rax, %rdi
callq 0x23100
movq 0x926d1(%rip), %rsi # 0xfefa8
movq 0x926aa(%rip), %rdx # 0xfef88
movq %rbx, %rdi
callq 0x23fb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x23690
movq %r14, %rdi
callq 0x24030
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_:
push r15
push r14
push rbx
mov r14, rsi
mov r15, rdi
mov rbx, [rdi]
loc_6C88E:
cmp rbx, [r15+8]
jz short loc_6C8B6
mov rsi, [r14]
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
test al, al
jnz short loc_6C8A9
add rbx, 60h ; '`'
jmp short loc_6C88E
loc_6C8A9:
add rbx, 10h
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_6C8B6:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aKeyNotFound; "key not found"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
long long *a1,
_QWORD *a2)
{
long long i; // rbx
std::out_of_range *exception; // rbx
for ( i = *a1; ; i += 96LL )
{
if ( i == a1[1] )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "key not found");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
if ( (unsigned __int8)ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_(
i,
*a2) )
break;
}
return i + 16;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV R15,RDI
MOV RBX,qword ptr [RDI]
LAB_0016c88e:
CMP RBX,qword ptr [R15 + 0x8]
JZ 0x0016c8b6
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x0016c921
TEST AL,AL
JNZ 0x0016c8a9
ADD RBX,0x60
JMP 0x0016c88e
LAB_0016c8a9:
ADD RBX,0x10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0016c8b6:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV RBX,RAX
LAB_0016c8c1:
LEA RSI,[0x1b5a72]
MOV RDI,RAX
CALL 0x00123100
LAB_0016c8d0:
MOV RSI,qword ptr [0x001fefa8]
MOV RDX,qword ptr [0x001fef88]
MOV RDI,RBX
CALL 0x00123fb0
|
long _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(long *param_1,int8 *param_2)
{
char cVar1;
out_of_range *this;
long lVar2;
lVar2 = *param_1;
while( true ) {
if (lVar2 == param_1[1]) {
this = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 0016c8c1 to 0016c8cf has its CatchHandler @ 0016c8e6 */
std::out_of_range::out_of_range(this,"key not found");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fefa8,PTR__out_of_range_001fef88);
}
cVar1 = _ZN8nlohmann16json_abi_v3_11_3eqImTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEES3_
(lVar2,*param_2);
if (cVar1 != '\0') break;
lVar2 = lVar2 + 0x60;
}
return lVar2 + 0x10;
}
| |
53,772 | 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 0x6d5e7
movq %rdi, %r13
movl $0x0, (%rdx)
cmpb $0x0, (%rdi)
je 0x6d5ec
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 0x6d5a6
cmpl $0x2c, %ecx
je 0x6d599
incq %rax
jmp 0x6d587
leaq -0x1(%rax), %rbx
cmpb $0x0, (%rax)
cmovneq %rax, %rbx
jmp 0x6d5ac
decq %rax
movq %rax, %rbx
movq %r13, -0x38(%rbp)
movq %r13, %rdi
callq 0x37410
addq %rax, %r13
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
movl $0x8, %edx
movq %r13, %rcx
callq 0x6d3a5
testl %eax, %eax
jle 0x6d5e7
decb %al
btsq %rax, %r15
cmpb $0x0, (%rbx)
movq %rbx, %r13
movq -0x30(%rbp), %rdx
jne 0x6d57d
jmp 0x6d5ef
xorl %r15d, %r15d
jmp 0x6d5f5
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_6D5E7
mov r13, rdi
mov dword ptr [rdx], 0
cmp byte ptr [rdi], 0
jz short loc_6D5EC
mov r14, rsi
xor r12d, r12d
xor r15d, r15d
mov [rbp+var_30], rdx
loc_6D57D:
inc r12d
mov [rdx], r12d
lea rax, [r13+1]
loc_6D587:
movzx ecx, byte ptr [rax-1]
test ecx, ecx
jz short loc_6D5A6
cmp ecx, 2Ch ; ','
jz short loc_6D599
inc rax
jmp short loc_6D587
loc_6D599:
lea rbx, [rax-1]
cmp byte ptr [rax], 0
cmovnz rbx, rax
jmp short loc_6D5AC
loc_6D5A6:
dec rax
mov rbx, rax
loc_6D5AC:
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_6D5E7
dec al
bts r15, rax
cmp byte ptr [rbx], 0
mov r13, rbx
mov rdx, [rbp+var_30]
jnz short loc_6D57D
jmp short loc_6D5EF
loc_6D5E7:
xor r15d, r15d
jmp short loc_6D5F5
loc_6D5EC:
xor r15d, r15d
loc_6D5EF:
mov dword ptr [rdx], 0
loc_6D5F5:
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 0x0016d5e7
MOV R13,RDI
MOV dword ptr [RDX],0x0
CMP byte ptr [RDI],0x0
JZ 0x0016d5ec
MOV R14,RSI
XOR R12D,R12D
XOR R15D,R15D
MOV qword ptr [RBP + -0x30],RDX
LAB_0016d57d:
INC R12D
MOV dword ptr [RDX],R12D
LEA RAX,[R13 + 0x1]
LAB_0016d587:
MOVZX ECX,byte ptr [RAX + -0x1]
TEST ECX,ECX
JZ 0x0016d5a6
CMP ECX,0x2c
JZ 0x0016d599
INC RAX
JMP 0x0016d587
LAB_0016d599:
LEA RBX,[RAX + -0x1]
CMP byte ptr [RAX],0x0
CMOVNZ RBX,RAX
JMP 0x0016d5ac
LAB_0016d5a6:
DEC RAX
MOV RBX,RAX
LAB_0016d5ac:
MOV qword ptr [RBP + -0x38],R13
MOV RDI,R13
CALL 0x00137410
ADD R13,RAX
LEA RDI,[RBP + -0x38]
MOV RSI,R14
MOV EDX,0x8
MOV RCX,R13
CALL 0x0016d3a5
TEST EAX,EAX
JLE 0x0016d5e7
DEC AL
BTS R15,RAX
CMP byte ptr [RBX],0x0
MOV R13,RBX
MOV RDX,qword ptr [RBP + -0x30]
JNZ 0x0016d57d
JMP 0x0016d5ef
LAB_0016d5e7:
XOR R15D,R15D
JMP 0x0016d5f5
LAB_0016d5ec:
XOR R15D,R15D
LAB_0016d5ef:
MOV dword ptr [RDX],0x0
LAB_0016d5f5:
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_0016d5e7:
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_0016d5ac;
} while (*pcVar4 != ',');
if (*pcVar2 != '\0') {
pcVar4 = pcVar2;
}
LAB_0016d5ac:
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_0016d5e7;
uVar6 = uVar6 | 1L << ((ulong)(byte)((char)iVar1 - 1) & 0x3f);
param_3 = local_38;
param_1 = pcVar4;
} while (*pcVar4 != '\0');
}
*param_3 = 0;
}
return uVar6;
}
| |
53,773 | minja::Parser::parseMathPow() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseMathPow() {
auto left = parseMathPlusMinus();
if (!left) throw std::runtime_error("Expected left side of 'math pow' expression");
while (!consumeToken("**").empty()) {
auto right = parseMathPlusMinus();
if (!right) throw std::runtime_error("Expected right side of 'math pow' expression");
left = std::make_shared<BinaryOpExpr>(get_location(), std::move(left), std::move(right), BinaryOpExpr::Op::MulMul);
}
return left;
} | O2 | cpp | minja::Parser::parseMathPow():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x68e18
cmpq $0x0, (%rbx)
je 0x68d5d
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r12
leaq 0x38(%rsp), %r13
movq %r14, %rdi
leaq 0x50371(%rip), %rsi # 0xb8fed
movq %r12, %rdx
callq 0x2a75e
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
pushq $0x1
popq %rcx
callq 0x65894
movq 0x40(%rsp), %rbp
movq %r13, %rdi
callq 0x25258
movq %r14, %rdi
callq 0x25258
testq %rbp, %rbp
je 0x68d19
movq %r14, %rdi
movq %r15, %rsi
callq 0x68e18
cmpq $0x0, 0x8(%rsp)
je 0x68d2b
movq %r13, %rdi
movq %r15, %rsi
callq 0x64e64
movl $0x4, 0x4(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
leaq 0x4(%rsp), %r8
callq 0x68df1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x75c5a
leaq 0x30(%rsp), %rdi
callq 0x37354
leaq 0x40(%rsp), %rdi
callq 0x37354
leaq 0x10(%rsp), %rdi
callq 0x37354
jmp 0x68c72
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x502b3(%rip), %rsi # 0xb8ff0
movq %rax, %rdi
callq 0x24330
movq 0x9b2a4(%rip), %rsi # 0x103ff0
movq 0x9b205(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
jmp 0x68d8d
pushq $0x10
popq %rdi
callq 0x24470
movq %rax, %r15
leaq 0x50252(%rip), %rsi # 0xb8fc1
movq %rax, %rdi
callq 0x24330
movq 0x9b272(%rip), %rsi # 0x103ff0
movq 0x9b1d3(%rip), %rdx # 0x103f58
movq %r15, %rdi
callq 0x24f50
jmp 0x68dcb
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x68ddd
jmp 0x68dab
movq %rax, %r14
movq %r15, %rdi
callq 0x246b0
jmp 0x68dbd
movq %rax, %r14
jmp 0x68dbd
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x37354
leaq 0x10(%rsp), %rdi
callq 0x37354
jmp 0x68ddd
jmp 0x68dcb
movq %rax, %r14
jmp 0x68ddd
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x25258
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x37354
movq %r14, %rdi
callq 0x24fe0
| _ZN5minja6Parser12parseMathPowEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rsi
mov rbx, rdi
call _ZN5minja6Parser18parseMathPlusMinusEv; minja::Parser::parseMathPlusMinus(void)
cmp qword ptr [rbx], 0
jz loc_68D5D
lea r14, [rsp+88h+var_80]
lea r12, [rsp+88h+var_60]
lea r13, [rsp+88h+var_50]
loc_68C72:
mov rdi, r14
lea rsi, asc_B8FED; "**"
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r13
mov rsi, r15
mov rdx, r14
push 1
pop rcx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov rbp, [rsp+88h+var_48]
mov rdi, r13; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test rbp, rbp
jz short loc_68D19
mov rdi, r14; this
mov rsi, r15
call _ZN5minja6Parser18parseMathPlusMinusEv; minja::Parser::parseMathPlusMinus(void)
cmp [rsp+88h+var_80], 0
jz short loc_68D2B
mov rdi, r13; this
mov rsi, r15
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
mov [rsp+88h+var_84], 4
mov rdi, r12
mov rsi, r13
mov rdx, rbx
mov rcx, r14
lea r8, [rsp+88h+var_84]
call _ZSt11make_sharedIN5minja12BinaryOpExprEJNS0_8LocationESt10shared_ptrINS0_10ExpressionEES5_NS1_2OpEEES3_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
mov rdi, rbx
mov rsi, r12
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr20__sp_compatible_withIPT_PS1_EE5valueERS4_E4typeEOS_IS8_LS3_2EE
lea rdi, [rsp+88h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+88h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp loc_68C72
loc_68D19:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_68D2B:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_3; "Expected right side of 'math pow' expre"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_68D8D
loc_68D5D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_3; "Expected left side of 'math pow' expres"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_68D8D:
jmp short loc_68DCB
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_68DDD
jmp short loc_68DAB
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_68DBD
loc_68DAB:
mov r14, rax
jmp short loc_68DBD
mov r14, rax
lea rdi, [rsp+88h+var_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_68DBD:
lea rdi, [rsp+88h+var_78]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_68DDD
jmp short $+2
loc_68DCB:
mov r14, rax
jmp short loc_68DDD
mov r14, rax
lea rdi, [rsp+88h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_68DDD:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseMathPow(minja::Parser *this, _QWORD *a2)
{
long long v2; // rbp
std::runtime_error *v4; // r15
std::runtime_error *exception; // r15
int v6; // [rsp+4h] [rbp-84h] BYREF
long long v7; // [rsp+8h] [rbp-80h] BYREF
_QWORD v8[3]; // [rsp+10h] [rbp-78h] BYREF
_BYTE v9[8]; // [rsp+28h] [rbp-60h] BYREF
long long v10; // [rsp+30h] [rbp-58h] BYREF
long long v11; // [rsp+38h] [rbp-50h] BYREF
_QWORD v12[9]; // [rsp+40h] [rbp-48h] BYREF
minja::Parser::parseMathPlusMinus(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'math pow' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
while ( 1 )
{
std::string::basic_string<std::allocator<char>>(&v7, (long long)"**");
minja::Parser::consumeToken(&v11, (long long)a2, &v7, 1u);
v2 = v12[0];
std::string::~string(&v11);
std::string::~string(&v7);
if ( !v2 )
break;
minja::Parser::parseMathPlusMinus((minja::Parser *)&v7);
if ( !v7 )
{
v4 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v4, "Expected right side of 'math pow' expression");
__cxa_throw(
v4,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Parser::get_location((minja::Parser *)&v11, a2);
v6 = 4;
std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
v9,
&v11,
this,
&v7,
&v6);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=<minja::BinaryOpExpr>(this, v9);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v8);
}
return this;
}
| parseMathPow:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RSI
MOV RBX,RDI
CALL 0x00168e18
CMP qword ptr [RBX],0x0
JZ 0x00168d5d
LEA R14,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LEA R13,[RSP + 0x38]
LAB_00168c72:
MOV RDI,R14
LEA RSI,[0x1b8fed]
MOV RDX,R12
CALL 0x0012a75e
LAB_00168c84:
MOV RDI,R13
MOV RSI,R15
MOV RDX,R14
PUSH 0x1
POP RCX
CALL 0x00165894
MOV RBP,qword ptr [RSP + 0x40]
MOV RDI,R13
CALL 0x00125258
MOV RDI,R14
CALL 0x00125258
TEST RBP,RBP
JZ 0x00168d19
LAB_00168caf:
MOV RDI,R14
MOV RSI,R15
CALL 0x00168e18
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00168d2b
LAB_00168cc2:
MOV RDI,R13
MOV RSI,R15
CALL 0x00164e64
MOV dword ptr [RSP + 0x4],0x4
LAB_00168cd5:
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R14
LEA R8,[RSP + 0x4]
CALL 0x00168df1
LAB_00168ceb:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00175c5a
LEA RDI,[RSP + 0x30]
CALL 0x00137354
LEA RDI,[RSP + 0x40]
CALL 0x00137354
LEA RDI,[RSP + 0x10]
CALL 0x00137354
JMP 0x00168c72
LAB_00168d19:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00168d2b:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00168d36:
LEA RSI,[0x1b8ff0]
MOV RDI,RAX
CALL 0x00124330
LAB_00168d45:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
LAB_00168d5d:
PUSH 0x10
POP RDI
CALL 0x00124470
MOV R15,RAX
LAB_00168d68:
LEA RSI,[0x1b8fc1]
MOV RDI,RAX
CALL 0x00124330
LAB_00168d77:
MOV RSI,qword ptr [0x00203ff0]
MOV RDX,qword ptr [0x00203f58]
MOV RDI,R15
CALL 0x00124f50
|
/* minja::Parser::parseMathPow() */
void minja::Parser::parseMathPow(void)
{
long lVar1;
runtime_error *prVar2;
__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *in_RDI;
long local_80;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_78 [24];
Location local_60 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [8];
string local_50 [8];
long local_48 [3];
parseMathPlusMinus();
if (*(long *)in_RDI == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00168d68 to 00168d76 has its CatchHandler @ 00168d8f */
std::runtime_error::runtime_error(prVar2,"Expected left side of \'math pow\' expression");
/* try { // try from 00168d77 to 00168d8c has its CatchHandler @ 00168d8d */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
while( true ) {
/* try { // try from 00168c72 to 00168c83 has its CatchHandler @ 00168dcb */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_80,"**",(allocator *)local_60);
/* try { // try from 00168c84 to 00168c94 has its CatchHandler @ 00168dd0 */
consumeToken(local_50);
lVar1 = local_48[0];
std::__cxx11::string::~string(local_50);
std::__cxx11::string::~string((string *)&local_80);
if (lVar1 == 0) {
return;
}
/* try { // try from 00168caf to 00168cb9 has its CatchHandler @ 00168dc9 */
parseMathPlusMinus();
if (local_80 == 0) break;
/* try { // try from 00168cc2 to 00168ccc has its CatchHandler @ 00168dab */
get_location();
/* try { // try from 00168cd5 to 00168cea has its CatchHandler @ 00168db0 */
std::
make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_60,local_50,in_RDI,(Op *)&local_80);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
(in_RDI,(__shared_ptr *)local_60);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_78);
}
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00168d36 to 00168d44 has its CatchHandler @ 00168d9e */
std::runtime_error::runtime_error(prVar2,"Expected right side of \'math pow\' expression");
/* try { // try from 00168d45 to 00168d5a has its CatchHandler @ 00168d9c */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00203ff0,PTR__runtime_error_00203f58);
}
| |
53,774 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json.hpp | const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto it = m_data.m_value.object->find(key);
JSON_ASSERT(it != m_data.m_value.object->end());
return it->second;
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O0 | 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>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xaf410
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x16c7c7
jmp 0x16c840
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x16c900
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rdi
callq 0xb4c10
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb4c40
xorb $-0x1, %al
testb $0x1, %al
jne 0x16c80c
jmp 0x16c82d
leaq 0xa2b61(%rip), %rdi # 0x20f374
movl $0x53ca, %esi # imm = 0x53CA
leaq 0x9c92b(%rip), %rdx # 0x20914a
leaq 0xa8148(%rip), %rcx # 0x21496e
movb $0x0, %al
callq 0x5aed0
leaq 0x50(%rsp), %rdi
callq 0xb5db0
addq $0x20, %rax
addq $0x68, %rsp
retq
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0x5a680
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
callq 0xb61e0
movq %rax, 0x20(%rsp)
leaq 0xa80d2(%rip), %rsi # 0x21493b
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x16c240
jmp 0x16c87a
movq 0x8(%rsp), %rcx
movq (%rsp), %rdi
movl $0x131, %esi # imm = 0x131
leaq 0x28(%rsp), %rdx
callq 0x113230
jmp 0x16c894
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
leaq 0x1364e4(%rip), %rsi # 0x2a2d88
leaq -0xb661b(%rip), %rdx # 0xb6290
callq 0x5aae0
jmp 0x16c8f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x16c8da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5b588
testb $0x1, 0x13(%rsp)
jne 0x16c8e3
jmp 0x16c8ec
movq (%rsp), %rdi
callq 0x5af70
jmp 0x16c8ee
movq 0x18(%rsp), %rdi
callq 0x5aba0
nopl (%rax,%rax)
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_:
sub rsp, 68h
mov [rsp+68h+var_8], rdi; int
mov qword ptr [rsp+68h+var_10], rsi; int
mov rdi, [rsp+68h+var_8]
mov [rsp+68h+var_60], rdi; int
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_16C7C7
jmp short loc_16C840
loc_16C7C7:
mov rax, [rsp+68h+var_60]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+68h+var_10]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>::find(std::string const&)
mov rcx, rax
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_18], rcx
mov rdi, [rax+8]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; 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>>>::end(void)
mov [rsp+68h+var_20], rax
lea rdi, [rsp+68h+var_18]
lea rsi, [rsp+68h+var_20]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<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>>>>(__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>>>> const&,__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>>>> const&)
xor al, 0FFh
test al, 1
jnz short loc_16C80C
jmp short loc_16C82D
loc_16C80C:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 53CAh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aItMDataMValueO; "it != m_data.m_value.object->end()"
mov al, 0
call _ggml_abort
loc_16C82D:
lea rdi, [rsp+68h+var_18]
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 rax, 20h ; ' '
add rsp, 68h
retn
loc_16C840:
mov [rsp+68h+var_55], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+68h+var_60]
mov [rsp+68h+var_68], rax; int
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 qword ptr [rsp+68h+var_48], rax; int
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
lea rdi, [rsp+68h+var_40]; int
lea rdx, [rsp+68h+var_48]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
jmp short $+2
loc_16C87A:
mov rcx, [rsp+68h+var_60]
mov rdi, [rsp+68h+var_68]; int
mov esi, 131h
lea rdx, [rsp+68h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_16C894:
mov rdi, [rsp+68h+var_68]; void *
mov [rsp+68h+var_55], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long *a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // [rsp+0h] [rbp-68h]
int v4[2]; // [rsp+20h] [rbp-48h] BYREF
int v5[8]; // [rsp+28h] [rbp-40h] BYREF
long long v6; // [rsp+48h] [rbp-20h] BYREF
long long v7; // [rsp+50h] [rbp-18h] BYREF
int v8[2]; // [rsp+58h] [rbp-10h]
void *v9; // [rsp+60h] [rbp-8h]
v9 = a1;
*(_QWORD *)v8 = a2;
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(a1) )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)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>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
(long long)v5,
(long long)"cannot use operator[] with a string argument with ",
(nlohmann::json_abi_v3_11_3::detail **)v4);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
(long long)v5,
(long long)a1);
__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::type_error::~type_error);
}
v7 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>::find(
a1[1],
*(_QWORD *)v8);
v6 = 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>>>::end(a1[1]);
if ( !__gnu_cxx::operator!=<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>>>>(
(long long)&v7,
(long long)&v6) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
21450LL,
"GGML_ASSERT(%s) failed",
"it != m_data.m_value.object->end()");
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)&v7)
+ 32;
}
| erase:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RDI
CALL 0x0016c810
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0017a820
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
CALL 0x0017a7d0
MOV RSI,RAX
LEA RDI,[RSP + 0x10]
CALL 0x00179560
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0017a700
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* std::vector<std::vector<llama_token_data, std::allocator<llama_token_data> >,
std::allocator<std::vector<llama_token_data, std::allocator<llama_token_data> > >
>::erase(__gnu_cxx::__normal_iterator<std::vector<llama_token_data,
std::allocator<llama_token_data> > const*, std::vector<std::vector<llama_token_data,
std::allocator<llama_token_data> >, std::allocator<std::vector<llama_token_data,
std::allocator<llama_token_data> > > > >) */
int8 __thiscall
std::
vector<std::vector<llama_token_data,std::allocator<llama_token_data>>,std::allocator<std::vector<llama_token_data,std::allocator<llama_token_data>>>>
::erase(vector<std::vector<llama_token_data,std::allocator<llama_token_data>>,std::allocator<std::vector<llama_token_data,std::allocator<llama_token_data>>>>
*this,int8 param_2)
{
long lVar1;
int8 uVar2;
int8 local_30;
int8 local_28;
int8 local_20;
vector<std::vector<llama_token_data,std::allocator<llama_token_data>>,std::allocator<std::vector<llama_token_data,std::allocator<llama_token_data>>>>
*local_18;
int8 local_10 [2];
local_18 = this;
local_10[0] = param_2;
local_28 = begin(this);
local_30 = cbegin(this);
lVar1 = __gnu_cxx::operator-((__normal_iterator *)local_10,(__normal_iterator *)&local_30);
local_20 = __gnu_cxx::
__normal_iterator<std::vector<llama_token_data,std::allocator<llama_token_data>>*,std::vector<std::vector<llama_token_data,std::allocator<llama_token_data>>,std::allocator<std::vector<llama_token_data,std::allocator<llama_token_data>>>>>
::operator+((__normal_iterator<std::vector<llama_token_data,std::allocator<llama_token_data>>*,std::vector<std::vector<llama_token_data,std::allocator<llama_token_data>>,std::allocator<std::vector<llama_token_data,std::allocator<llama_token_data>>>>>
*)&local_28,lVar1);
uVar2 = _M_erase(this,local_20);
return uVar2;
}
| |
53,775 | get_grouplength | eloqsql/build_O0/extra/pcre2/src/pcre2/src/pcre2_compile.c | static int
get_grouplength(uint32_t **pptrptr, BOOL isinline, int *errcodeptr, int *lcptr,
int group, parsed_recurse_check *recurses, compile_block *cb)
{
int branchlength;
int grouplength = -1;
/* The cache can be used only if there is no possibility of there being two
groups with the same number. We do not need to set the end pointer for a group
that is being processed as a back reference or recursion, but we must do so for
an inline group. */
if (group > 0 && (cb->external_flags & PCRE2_DUPCAPUSED) == 0)
{
uint32_t groupinfo = cb->groupinfo[group];
if ((groupinfo & GI_NOT_FIXED_LENGTH) != 0) return -1;
if ((groupinfo & GI_SET_FIXED_LENGTH) != 0)
{
if (isinline) *pptrptr = parsed_skip(*pptrptr, PSKIP_KET);
return groupinfo & GI_FIXED_LENGTH_MASK;
}
}
/* Scan the group. In this case we find the end pointer of necessity. */
for(;;)
{
branchlength = get_branchlength(pptrptr, errcodeptr, lcptr, recurses, cb);
if (branchlength < 0) goto ISNOTFIXED;
if (grouplength == -1) grouplength = branchlength;
else if (grouplength != branchlength) goto ISNOTFIXED;
if (**pptrptr == META_KET) break;
*pptrptr += 1; /* Skip META_ALT */
}
if (group > 0)
cb->groupinfo[group] |= (uint32_t)(GI_SET_FIXED_LENGTH | grouplength);
return grouplength;
ISNOTFIXED:
if (group > 0) cb->groupinfo[group] |= GI_NOT_FIXED_LENGTH;
return -1;
} | O0 | c | get_grouplength:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x2c(%rbp)
jle 0xd66f6
movq 0x10(%rbp), %rax
movl 0xd0(%rax), %eax
andl $0x200000, %eax # imm = 0x200000
cmpl $0x0, %eax
jne 0xd66f6
movq 0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
andl $0x40000000, %eax # imm = 0x40000000
cmpl $0x0, %eax
je 0xd66b6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd67ab
movl -0x44(%rbp), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xd66f4
cmpl $0x0, -0x14(%rbp)
je 0xd66e4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0xd6310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
movl %eax, -0x4(%rbp)
jmp 0xd67ab
jmp 0xd66f6
jmp 0xd66f8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0xd56a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0xd671c
jmp 0xd6783
cmpl $-0x1, -0x40(%rbp)
jne 0xd672a
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0xd6736
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
je 0xd6734
jmp 0xd6783
jmp 0xd6736
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x80190000, (%rax) # imm = 0x80190000
jne 0xd6747
jmp 0xd6757
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
jmp 0xd66f8
cmpl $0x0, -0x2c(%rbp)
jle 0xd677b
movl -0x40(%rbp), %edx
orl $0x80000000, %edx # imm = 0x80000000
movq 0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x2c(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd67ab
cmpl $0x0, -0x2c(%rbp)
jle 0xd67a4
movq 0x10(%rbp), %rax
movq 0xf0(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
orl $0x40000000, %edx # imm = 0x40000000
movl %edx, (%rax,%rcx,4)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_grouplength:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_38], r9
mov [rbp+var_40], 0FFFFFFFFh
cmp [rbp+var_2C], 0
jle loc_D66F6
mov rax, [rbp+arg_0]
mov eax, [rax+0D0h]
and eax, 200000h
cmp eax, 0
jnz short loc_D66F6
mov rax, [rbp+arg_0]
mov rax, [rax+0F0h]
movsxd rcx, [rbp+var_2C]
mov eax, [rax+rcx*4]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
and eax, 40000000h
cmp eax, 0
jz short loc_D66B6
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_D67AB
loc_D66B6:
mov eax, [rbp+var_44]
and eax, 80000000h
cmp eax, 0
jz short loc_D66F4
cmp [rbp+var_14], 0
jz short loc_D66E4
mov rax, [rbp+var_10]
mov rdi, [rax]
mov esi, 2
call parsed_skip
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
loc_D66E4:
mov eax, [rbp+var_44]
and eax, 0FFFFh
mov [rbp+var_4], eax
jmp loc_D67AB
loc_D66F4:
jmp short $+2
loc_D66F6:
jmp short $+2
loc_D66F8:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_38]
mov r8, [rbp+arg_0]
call get_branchlength
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jge short loc_D671C
jmp short loc_D6783
loc_D671C:
cmp [rbp+var_40], 0FFFFFFFFh
jnz short loc_D672A
mov eax, [rbp+var_3C]
mov [rbp+var_40], eax
jmp short loc_D6736
loc_D672A:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_3C]
jz short loc_D6734
jmp short loc_D6783
loc_D6734:
jmp short $+2
loc_D6736:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax], 80190000h
jnz short loc_D6747
jmp short loc_D6757
loc_D6747:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
jmp short loc_D66F8
loc_D6757:
cmp [rbp+var_2C], 0
jle short loc_D677B
mov edx, [rbp+var_40]
or edx, 80000000h
mov rax, [rbp+arg_0]
mov rax, [rax+0F0h]
movsxd rcx, [rbp+var_2C]
or edx, [rax+rcx*4]
mov [rax+rcx*4], edx
loc_D677B:
mov eax, [rbp+var_40]
mov [rbp+var_4], eax
jmp short loc_D67AB
loc_D6783:
cmp [rbp+var_2C], 0
jle short loc_D67A4
mov rax, [rbp+arg_0]
mov rax, [rax+0F0h]
movsxd rcx, [rbp+var_2C]
mov edx, [rax+rcx*4]
or edx, 40000000h
mov [rax+rcx*4], edx
loc_D67A4:
mov [rbp+var_4], 0FFFFFFFFh
loc_D67AB:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long get_grouplength(
unsigned __int16 **a1,
int a2,
_DWORD *a3,
_DWORD *a4,
int a5,
long long a6,
long long a7)
{
int v8; // [rsp+Ch] [rbp-44h]
unsigned int v9; // [rsp+10h] [rbp-40h]
int branchlength; // [rsp+14h] [rbp-3Ch]
v9 = -1;
if ( a5 <= 0 || (*(_DWORD *)(a7 + 208) & 0x200000) != 0 )
{
LABEL_9:
while ( 1 )
{
branchlength = get_branchlength((_DWORD **)a1, a3, a4, a6, a7);
if ( branchlength < 0 )
break;
if ( v9 == -1 )
{
v9 = branchlength;
}
else if ( v9 != branchlength )
{
break;
}
if ( *(_DWORD *)*a1 == -2145845248 )
{
if ( a5 > 0 )
*(_DWORD *)(*(_QWORD *)(a7 + 240) + 4LL * a5) |= v9 | 0x80000000;
return v9;
}
*a1 += 2;
}
if ( a5 > 0 )
*(_DWORD *)(*(_QWORD *)(a7 + 240) + 4LL * a5) |= 0x40000000u;
return (unsigned int)-1;
}
else
{
v8 = *(_DWORD *)(*(_QWORD *)(a7 + 240) + 4LL * a5);
if ( (v8 & 0x40000000) != 0 )
{
return (unsigned int)-1;
}
else
{
if ( v8 >= 0 )
goto LABEL_9;
if ( a2 )
*a1 = parsed_skip(*a1, 2);
return (unsigned __int16)v8;
}
}
}
| get_grouplength:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr [RBP + 0x10]
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 dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x40],0xffffffff
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001d66f6
MOV RAX,qword ptr [RBP + 0x10]
MOV EAX,dword ptr [RAX + 0xd0]
AND EAX,0x200000
CMP EAX,0x0
JNZ 0x001d66f6
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
AND EAX,0x40000000
CMP EAX,0x0
JZ 0x001d66b6
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001d67ab
LAB_001d66b6:
MOV EAX,dword ptr [RBP + -0x44]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001d66f4
CMP dword ptr [RBP + -0x14],0x0
JZ 0x001d66e4
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,0x2
CALL 0x001d6310
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
LAB_001d66e4:
MOV EAX,dword ptr [RBP + -0x44]
AND EAX,0xffff
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001d67ab
LAB_001d66f4:
JMP 0x001d66f6
LAB_001d66f6:
JMP 0x001d66f8
LAB_001d66f8:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x001d56a0
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JGE 0x001d671c
JMP 0x001d6783
LAB_001d671c:
CMP dword ptr [RBP + -0x40],-0x1
JNZ 0x001d672a
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001d6736
LAB_001d672a:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x3c]
JZ 0x001d6734
JMP 0x001d6783
LAB_001d6734:
JMP 0x001d6736
LAB_001d6736:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX],0x80190000
JNZ 0x001d6747
JMP 0x001d6757
LAB_001d6747:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
JMP 0x001d66f8
LAB_001d6757:
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001d677b
MOV EDX,dword ptr [RBP + -0x40]
OR EDX,0x80000000
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOVSXD RCX,dword ptr [RBP + -0x2c]
OR EDX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RAX + RCX*0x4],EDX
LAB_001d677b:
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001d67ab
LAB_001d6783:
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001d67a4
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX + 0xf0]
MOVSXD RCX,dword ptr [RBP + -0x2c]
MOV EDX,dword ptr [RAX + RCX*0x4]
OR EDX,0x40000000
MOV dword ptr [RAX + RCX*0x4],EDX
LAB_001d67a4:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_001d67ab:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
uint get_grouplength(long *param_1,int param_2,int8 param_3,int8 param_4,int param_5,
int8 param_6,long param_7)
{
uint uVar1;
uint uVar2;
long lVar3;
uint local_48;
local_48 = 0xffffffff;
if ((0 < param_5) && ((*(uint *)(param_7 + 0xd0) & 0x200000) == 0)) {
uVar2 = *(uint *)(*(long *)(param_7 + 0xf0) + (long)param_5 * 4);
if ((uVar2 & 0x40000000) != 0) {
return 0xffffffff;
}
if ((uVar2 & 0x80000000) != 0) {
if (param_2 != 0) {
lVar3 = parsed_skip(*param_1,2);
*param_1 = lVar3;
}
return uVar2 & 0xffff;
}
}
while ((uVar2 = get_branchlength(param_1,param_3,param_4,param_6,param_7), -1 < (int)uVar2 &&
((uVar1 = uVar2, local_48 == 0xffffffff || (uVar1 = local_48, local_48 == uVar2))))) {
local_48 = uVar1;
if (*(int *)*param_1 == -0x7fe70000) {
if (0 < param_5) {
*(uint *)(*(long *)(param_7 + 0xf0) + (long)param_5 * 4) =
local_48 | 0x80000000 | *(uint *)(*(long *)(param_7 + 0xf0) + (long)param_5 * 4);
}
return local_48;
}
*param_1 = *param_1 + 4;
}
if (0 < param_5) {
*(uint *)(*(long *)(param_7 + 0xf0) + (long)param_5 * 4) =
*(uint *)(*(long *)(param_7 + 0xf0) + (long)param_5 * 4) | 0x40000000;
}
return 0xffffffff;
}
| |
53,776 | tree_search_edge | eloqsql/mysys/tree.c | void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents,
TREE_ELEMENT ***last_pos, int child_offs)
{
TREE_ELEMENT *element= tree->root;
*parents= &null_element;
while (element != &null_element)
{
*++parents= element;
element= ELEMENT_CHILD(element, child_offs);
}
*last_pos= parents;
return **last_pos != &null_element ?
ELEMENT_KEY(tree, **last_pos) : NULL;
} | O0 | c | tree_search_edge:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1c3e37(%rip), %rcx # 0x2bec40
movq %rcx, (%rax)
leaq 0x1c3e2d(%rip), %rax # 0x2bec40
cmpq %rax, -0x28(%rbp)
je 0xfae42
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x10(%rbp)
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
jmp 0xfae0c
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
leaq 0x1c3de5(%rip), %rcx # 0x2bec40
cmpq %rcx, (%rax)
je 0xfaea6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0xfae8a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xfae9c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xfaeae
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xfaeae
movq -0x38(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| tree_search_edge:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
lea rcx, null_element
mov [rax], rcx
loc_FAE0C:
lea rax, null_element
cmp [rbp+var_28], rax
jz short loc_FAE42
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 8
mov [rbp+var_10], rdx
mov [rax+8], rcx
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_1C]
mov rax, [rax+rcx]
mov [rbp+var_28], rax
jmp short loc_FAE0C
loc_FAE42:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
mov rax, [rax]
lea rcx, null_element
cmp [rax], rcx
jz short loc_FAEA6
mov rax, [rbp+var_8]
cmp dword ptr [rax+208h], 0
jz short loc_FAE8A
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax]
mov rcx, [rbp+var_8]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_30], rax
jmp short loc_FAE9C
loc_FAE8A:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+18h]
mov [rbp+var_30], rax
loc_FAE9C:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
jmp short loc_FAEAE
loc_FAEA6:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_FAEAE:
mov rax, [rbp+var_38]
pop rbp
retn
| long long tree_search_edge(char **a1, _QWORD *a2, long long a3, int a4)
{
_QWORD *v4; // rax
char *v8; // [rsp+10h] [rbp-28h]
_QWORD *v9; // [rsp+28h] [rbp-10h]
v9 = a2;
v8 = *a1;
*a2 = &null_element;
while ( v8 != (char *)&null_element )
{
v4 = v9++;
v4[1] = v8;
v8 = *(char **)&v8[a4];
}
*(_QWORD *)a3 = v9;
if ( **(_UNKNOWN ***)a3 == &null_element )
return 0LL;
if ( *((_DWORD *)a1 + 130) )
return *((unsigned int *)a1 + 130) + **(_QWORD **)a3;
else
return *(_QWORD *)(**(_QWORD **)a3 + 24LL);
}
| tree_search_edge:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3bec40]
MOV qword ptr [RAX],RCX
LAB_001fae0c:
LEA RAX,[0x3bec40]
CMP qword ptr [RBP + -0x28],RAX
JZ 0x001fae42
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001fae0c
LAB_001fae42:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
LEA RCX,[0x3bec40]
CMP qword ptr [RAX],RCX
JZ 0x001faea6
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x208],0x0
JZ 0x001fae8a
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x208]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001fae9c
LAB_001fae8a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_001fae9c:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001faeae
LAB_001faea6:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001faeae
LAB_001faeae:
MOV RAX,qword ptr [RBP + -0x38]
POP RBP
RET
|
long tree_search_edge(int8 *param_1,int8 *param_2,int8 *param_3,int param_4)
{
long local_40;
long local_38;
int1 *local_30;
int8 *local_18;
local_30 = (int1 *)*param_1;
*param_2 = null_element;
local_18 = param_2;
for (; local_30 != null_element; local_30 = *(int1 **)(local_30 + param_4)) {
local_18[1] = local_30;
local_18 = local_18 + 1;
}
*param_3 = local_18;
if (*(int1 **)*param_3 == null_element) {
local_40 = 0;
}
else {
if (*(int *)(param_1 + 0x41) == 0) {
local_38 = *(long *)(*(long *)*param_3 + 0x18);
}
else {
local_38 = *(long *)*param_3 + (ulong)*(uint *)(param_1 + 0x41);
}
local_40 = local_38;
}
return local_40;
}
| |
53,777 | my_strxfrm_pad_desc_and_reverse | eloqsql/strings/ctype-simple.c | size_t
my_strxfrm_pad_desc_and_reverse(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level)
{
if (nweights && frmend < strend && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
uint fill_length= MY_MIN((uint) (strend - frmend), nweights * cs->mbminlen);
my_ci_fill(cs, (char*) frmend, fill_length, cs->pad_char);
frmend+= fill_length;
}
my_strxfrm_desc_and_reverse(str, frmend, flags, level);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && frmend < strend)
{
size_t fill_length= strend - frmend;
my_ci_fill(cs, (char*) frmend, fill_length, cs->pad_char);
frmend= strend;
}
return frmend - str;
} | O3 | c | my_strxfrm_pad_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %r12
movl 0x10(%rbp), %ecx
testl %r8d, %r8d
sete %al
cmpq %r15, %rdx
setae %sil
testb $0x40, %r13b
sete %dl
orb %al, %dl
orb %sil, %dl
jne 0x3ba6e
movl %r8d, %ebx
movl %r15d, %eax
subl %r14d, %eax
imull 0x98(%r12), %ebx
cmpl %eax, %ebx
cmovael %eax, %ebx
movzbl 0xb0(%r12), %ecx
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x78(%rax)
movl 0x10(%rbp), %ecx
addq %rbx, %r14
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x3d3c6
testb %r13b, %r13b
jns 0x3baad
cmpq %r15, %r14
jae 0x3baad
movq %r15, %rdx
subq %r14, %rdx
movzbl 0xb0(%r12), %ecx
movq 0xb8(%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x78(%rax)
movq %r15, %r14
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strxfrm_pad_desc_and_reverse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13d, r9d
mov r15, rcx
mov r14, rdx
mov [rbp+var_30], rsi
mov r12, rdi
mov ecx, [rbp+arg_0]
test r8d, r8d
setz al
cmp rdx, r15
setnb sil
test r13b, 40h
setz dl
or dl, al
or dl, sil
jnz short loc_3BA6E
mov ebx, r8d
mov eax, r15d
sub eax, r14d
imul ebx, [r12+98h]
cmp ebx, eax
cmovnb ebx, eax
movzx ecx, byte ptr [r12+0B0h]
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r14
mov rdx, rbx
call qword ptr [rax+78h]
mov ecx, [rbp+arg_0]
add r14, rbx
loc_3BA6E:
mov rbx, [rbp+var_30]
mov rdi, rbx
mov rsi, r14
mov edx, r13d
call my_strxfrm_desc_and_reverse
test r13b, r13b
jns short loc_3BAAD
cmp r14, r15
jnb short loc_3BAAD
mov rdx, r15
sub rdx, r14
movzx ecx, byte ptr [r12+0B0h]
mov rax, [r12+0B8h]
mov rdi, r12
mov rsi, r14
call qword ptr [rax+78h]
mov r14, r15
loc_3BAAD:
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strxfrm_pad_desc_and_reverse(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
int a5,
unsigned int a6,
unsigned int a7)
{
unsigned long long v9; // r14
long long v10; // rcx
long long v11; // rbx
v9 = a3;
v10 = a7;
if ( a3 < a4 && a5 != 0 && (a6 & 0x40) != 0 )
{
v11 = (unsigned int)(*(_DWORD *)(a1 + 152) * a5);
if ( (unsigned int)v11 >= (int)a4 - (int)a3 )
v11 = (unsigned int)(a4 - a3);
(*(void ( **)(long long, unsigned long long, long long, _QWORD))(*(_QWORD *)(a1 + 184) + 120LL))(
a1,
a3,
v11,
*(unsigned __int8 *)(a1 + 176));
v10 = a7;
v9 += v11;
}
my_strxfrm_desc_and_reverse(a2, v9, a6, v10);
if ( (a6 & 0x80u) != 0 && v9 < a4 )
{
(*(void ( **)(long long, unsigned long long, unsigned long long, _QWORD))(*(_QWORD *)(a1 + 184) + 120LL))(
a1,
v9,
a4 - v9,
*(unsigned __int8 *)(a1 + 176));
v9 = a4;
}
return v9 - a2;
}
| my_strxfrm_pad_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13D,R9D
MOV R15,RCX
MOV R14,RDX
MOV qword ptr [RBP + -0x30],RSI
MOV R12,RDI
MOV ECX,dword ptr [RBP + 0x10]
TEST R8D,R8D
SETZ AL
CMP RDX,R15
SETNC SIL
TEST R13B,0x40
SETZ DL
OR DL,AL
OR DL,SIL
JNZ 0x0013ba6e
MOV EBX,R8D
MOV EAX,R15D
SUB EAX,R14D
IMUL EBX,dword ptr [R12 + 0x98]
CMP EBX,EAX
CMOVNC EBX,EAX
MOVZX ECX,byte ptr [R12 + 0xb0]
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R14
MOV RDX,RBX
CALL qword ptr [RAX + 0x78]
MOV ECX,dword ptr [RBP + 0x10]
ADD R14,RBX
LAB_0013ba6e:
MOV RBX,qword ptr [RBP + -0x30]
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R13D
CALL 0x0013d3c6
TEST R13B,R13B
JNS 0x0013baad
CMP R14,R15
JNC 0x0013baad
MOV RDX,R15
SUB RDX,R14
MOVZX ECX,byte ptr [R12 + 0xb0]
MOV RAX,qword ptr [R12 + 0xb8]
MOV RDI,R12
MOV RSI,R14
CALL qword ptr [RAX + 0x78]
MOV R14,R15
LAB_0013baad:
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strxfrm_pad_desc_and_reverse
(long param_1,long param_2,ulong param_3,ulong param_4,int param_5,uint param_6,
int4 param_7)
{
uint uVar1;
uint uVar2;
if (((param_6 & 0x40) != 0 && param_5 != 0) && param_3 < param_4) {
uVar1 = (int)param_4 - (int)param_3;
uVar2 = param_5 * *(int *)(param_1 + 0x98);
if (uVar1 <= uVar2) {
uVar2 = uVar1;
}
(**(code **)(*(long *)(param_1 + 0xb8) + 0x78))
(param_1,param_3,(ulong)uVar2,*(int1 *)(param_1 + 0xb0));
param_3 = param_3 + uVar2;
}
my_strxfrm_desc_and_reverse(param_2,param_3,param_6,param_7);
if (((char)param_6 < '\0') && (param_3 < param_4)) {
(**(code **)(*(long *)(param_1 + 0xb8) + 0x78))
(param_1,param_3,param_4 - param_3,*(int1 *)(param_1 + 0xb0));
param_3 = param_4;
}
return param_3 - param_2;
}
| |
53,778 | 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;
} | O3 | c | copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq 0xb8(%rsi), %rax
movq %rax, 0xb8(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0xc0(%rdi)
movl $0x4, %eax
cmpb $0x1, 0xb2(%rdx)
ja 0x3ab53
movl 0x90(%rsi), %eax
movl %eax, 0x90(%rdi)
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movq 0xa8(%rsi), %rax
movq %rax, 0xa8(%rdi)
movl 0x98(%rsi), %eax
movl %eax, 0x98(%rdi)
movl 0x9c(%rsi), %eax
movl %eax, 0x9c(%rdi)
movb 0x94(%rsi), %al
movb %al, 0x94(%rdi)
movb 0x95(%rsi), %al
movb %al, 0x95(%rdi)
orl $0x2c8, 0xc(%rdi) # imm = 0x2C8
popq %rbp
retq
| copy_uca_collation:
push rbp
mov rbp, rsp
mov rax, [rsi+0B8h]
mov [rdi+0B8h], rax
mov rax, [rsi+0C0h]
mov [rdi+0C0h], rax
mov eax, 4
cmp byte ptr [rdx+0B2h], 1
ja short loc_3AB53
mov eax, [rsi+90h]
loc_3AB53:
mov [rdi+90h], eax
mov rax, [rsi+0A0h]
mov [rdi+0A0h], rax
mov rax, [rsi+0A8h]
mov [rdi+0A8h], rax
mov eax, [rsi+98h]
mov [rdi+98h], eax
mov eax, [rsi+9Ch]
mov [rdi+9Ch], eax
mov al, [rsi+94h]
mov [rdi+94h], al
mov al, [rsi+95h]
mov [rdi+95h], al
or dword ptr [rdi+0Ch], 2C8h
pop rbp
retn
| char copy_uca_collation(long long a1, long long a2, long long a3)
{
int v3; // eax
char result; // al
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
v3 = 4;
if ( *(_BYTE *)(a3 + 178) <= 1u )
v3 = *(_DWORD *)(a2 + 144);
*(_DWORD *)(a1 + 144) = v3;
*(_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);
result = *(_BYTE *)(a2 + 149);
*(_BYTE *)(a1 + 149) = result;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
| copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0xb8]
MOV qword ptr [RDI + 0xb8],RAX
MOV RAX,qword ptr [RSI + 0xc0]
MOV qword ptr [RDI + 0xc0],RAX
MOV EAX,0x4
CMP byte ptr [RDX + 0xb2],0x1
JA 0x0013ab53
MOV EAX,dword ptr [RSI + 0x90]
LAB_0013ab53:
MOV dword ptr [RDI + 0x90],EAX
MOV RAX,qword ptr [RSI + 0xa0]
MOV qword ptr [RDI + 0xa0],RAX
MOV RAX,qword ptr [RSI + 0xa8]
MOV qword ptr [RDI + 0xa8],RAX
MOV EAX,dword ptr [RSI + 0x98]
MOV dword ptr [RDI + 0x98],EAX
MOV EAX,dword ptr [RSI + 0x9c]
MOV dword ptr [RDI + 0x9c],EAX
MOV AL,byte ptr [RSI + 0x94]
MOV byte ptr [RDI + 0x94],AL
MOV AL,byte ptr [RSI + 0x95]
MOV byte ptr [RDI + 0x95],AL
OR dword ptr [RDI + 0xc],0x2c8
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 uVar1;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
uVar1 = 4;
if (*(byte *)(param_3 + 0xb2) < 2) {
uVar1 = *(int4 *)(param_2 + 0x90);
}
*(int4 *)(param_1 + 0x90) = uVar1;
*(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;
}
| |
53,779 | Field_temporal::sql_type_dec_comment(String&, Name const&, unsigned int, Name const&) const | eloqsql/sql/field.cc | void Field_temporal::sql_type_dec_comment(String &res,
const Name &name,
uint dec,
const Name &comment) const
{
CHARSET_INFO *cs=res.charset();
res.length(cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
"%.*s(%u)%s%.*s%s",
(uint) name.length(), name.ptr(),
dec,
comment.length() ? " /* " : "",
(uint) comment.length(), comment.ptr(),
comment.length() ? " */" : ""));
} | O0 | cpp | Field_temporal::sql_type_dec_comment(String&, Name const&, unsigned int, Name const&) const:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movq %r8, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7ec910
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x60(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x7e7810
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x7ebdf0
movl %eax, %eax
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8e3910
movl %eax, -0x74(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8e3930
movq %rax, -0x70(%rbp)
movl -0x3c(%rbp), %r15d
movq -0x48(%rbp), %rdi
callq 0x8e3910
movl %eax, %ecx
leaq 0x7e80d8(%rip), %r14 # 0x13dc7da
leaq 0x7a86a1(%rip), %rax # 0x139cdaa
cmpl $0x0, %ecx
cmovneq %rax, %r14
movq -0x48(%rbp), %rdi
callq 0x8e3910
movl %eax, %ebx
movq -0x48(%rbp), %rdi
callq 0x8e3930
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rdi
callq 0x8e3910
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %r8d
movq -0x70(%rbp), %r9
movq -0x68(%rbp), %r11
movq -0x60(%rbp), %r10
movl %eax, %r12d
leaq 0x7e807d(%rip), %rax # 0x13dc7da
leaq 0x7e8204(%rip), %rcx # 0x13dc968
cmpl $0x0, %r12d
cmovneq %rcx, %rax
leaq 0x7dfbc1(%rip), %rcx # 0x13d4334
movl %r15d, (%rsp)
movq %r14, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq *%r10
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x7ebe10
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
| _ZNK14Field_temporal20sql_type_dec_commentER6StringRK4NamejS4_:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 0A0h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_3C], ecx
mov [rbp+var_48], r8
mov rdi, [rbp+var_30]; this
call _ZNK7Charset7charsetEv; Charset::charset(void)
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
add rax, 8
mov [rbp+var_58], rax
mov rax, [rbp+var_50]
mov rax, [rax+0B8h]
mov rax, [rax+60h]
mov [rbp+var_60], rax
mov rax, [rbp+var_50]
mov [rbp+var_90], rax
mov rdi, [rbp+var_30]
add rdi, 8; this
call _ZNK13Binary_string3ptrEv; Binary_string::ptr(void)
mov [rbp+var_88], rax
mov rdi, [rbp+var_30]
add rdi, 8; this
call _ZNK13Binary_string14alloced_lengthEv; Binary_string::alloced_length(void)
mov eax, eax
mov [rbp+var_80], rax
mov rdi, [rbp+var_38]; this
call _ZNK4Name6lengthEv; Name::length(void)
mov [rbp+var_74], eax
mov rdi, [rbp+var_38]; this
call _ZNK4Name3ptrEv; Name::ptr(void)
mov [rbp+var_70], rax
mov r15d, [rbp+var_3C]
mov rdi, [rbp+var_48]; this
call _ZNK4Name6lengthEv; Name::length(void)
mov ecx, eax
lea r14, byte_13DC7DA
lea rax, asc_139CDAA; " /* "
cmp ecx, 0
cmovnz r14, rax
mov rdi, [rbp+var_48]; this
call _ZNK4Name6lengthEv; Name::length(void)
mov ebx, eax
mov rdi, [rbp+var_48]; this
call _ZNK4Name3ptrEv; Name::ptr(void)
mov [rbp+var_68], rax
mov rdi, [rbp+var_48]; this
call _ZNK4Name6lengthEv; Name::length(void)
mov rdi, [rbp+var_90]
mov rsi, [rbp+var_88]
mov rdx, [rbp+var_80]
mov r8d, [rbp+var_74]
mov r9, [rbp+var_70]
mov r11, [rbp+var_68]
mov r10, [rbp+var_60]
mov r12d, eax
lea rax, byte_13DC7DA
lea rcx, asc_13DC968; " *"
cmp r12d, 0
cmovnz rax, rcx
lea rcx, aSUSSS; "%.*s(%u)%s%.*s%s"
mov [rsp+0C0h+var_C0], r15d
mov [rsp+0C0h+var_B8], r14
mov [rsp+0C0h+var_B0], ebx
mov [rsp+0C0h+var_A8], r11
mov [rsp+0C0h+var_A0], rax
mov al, 0
call r10
mov rdi, [rbp+var_58]; this
mov rsi, rax; unsigned __int64
call _ZN13Binary_string6lengthEm; Binary_string::length(ulong)
add rsp, 0A0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| Binary_string * Field_temporal::sql_type_dec_comment(
Field_temporal *this,
String *a2,
const Name *a3,
int a4,
const Name *a5)
{
const char *v5; // r14
int v6; // ebx
int v7; // r12d
const char *v8; // rax
int v9; // eax
long long v11; // [rsp+38h] [rbp-88h]
long long v12; // [rsp+40h] [rbp-80h]
int v13; // [rsp+4Ch] [rbp-74h]
const char *v14; // [rsp+50h] [rbp-70h]
const char *v15; // [rsp+58h] [rbp-68h]
long long (*v16)(long long, long long, long long, const char *, ...); // [rsp+60h] [rbp-60h]
long long v17; // [rsp+70h] [rbp-50h]
v17 = Charset::charset(a2);
v16 = *(long long (**)(long long, long long, long long, const char *, ...))(*(_QWORD *)(v17 + 184) + 96LL);
v11 = Binary_string::ptr((String *)((char *)a2 + 8));
v12 = (unsigned int)Binary_string::alloced_length((String *)((char *)a2 + 8));
v13 = Name::length(a3);
v14 = (const char *)Name::ptr(a3);
v5 = &byte_13DC7DA;
if ( (unsigned int)Name::length(a5) )
v5 = " /* ";
v6 = Name::length(a5);
v15 = (const char *)Name::ptr(a5);
v7 = Name::length(a5);
v8 = &byte_13DC7DA;
if ( v7 )
v8 = asc_13DC968;
v9 = v16(v17, v11, v12, "%.*s(%u)%s%.*s%s", v13, v14, a4, v5, v6, v15, v8);
return Binary_string::length((String *)((char *)a2 + 8), v9);
}
| Item_func_hybrid_field_type_get_date_with_warn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2e0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24c],R8D
MOV qword ptr [RBP + -0x258],RDI
MOV qword ptr [RBP + -0x260],RSI
MOV qword ptr [RBP + -0x268],RDX
MOV qword ptr [RBP + -0x270],RCX
MOV RAX,qword ptr [RBP + -0x258]
MOV qword ptr [RBP + -0x2a0],RAX
MOV RDI,qword ptr [RBP + -0x268]
CALL 0x00d307d0
MOV qword ptr [RBP + -0x278],RAX
MOV RAX,qword ptr [RBP + -0x260]
MOV qword ptr [RBP + -0x298],RAX
CMP qword ptr [RBP + -0x278],0x0
JZ 0x00bf46db
MOV RAX,qword ptr [RBP + -0x278]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV qword ptr [RBP + -0x2a8],RAX
JMP 0x00bf46e6
LAB_00bf46db:
XOR EAX,EAX
MOV qword ptr [RBP + -0x2a8],RAX
JMP 0x00bf46e6
LAB_00bf46e6:
MOV RAX,qword ptr [RBP + -0x2a8]
MOV qword ptr [RBP + -0x2b0],RAX
CMP qword ptr [RBP + -0x278],0x0
JZ 0x00bf4715
MOV RAX,qword ptr [RBP + -0x278]
MOV RAX,qword ptr [RAX + 0x2b0]
MOV qword ptr [RBP + -0x2b8],RAX
JMP 0x00bf4720
LAB_00bf4715:
XOR EAX,EAX
MOV qword ptr [RBP + -0x2b8],RAX
JMP 0x00bf4720
LAB_00bf4720:
MOV RAX,qword ptr [RBP + -0x2b8]
MOV qword ptr [RBP + -0x2c8],RAX
MOV RDI,qword ptr [RBP + -0x268]
CALL 0x00c077a0
MOV RSI,qword ptr [RBP + -0x298]
MOV RDX,qword ptr [RBP + -0x2b0]
MOV RCX,qword ptr [RBP + -0x2c8]
MOV R8,RAX
MOV R9,qword ptr [RBP + -0x270]
MOV EAX,dword ptr [RBP + -0x24c]
MOV dword ptr [RBP + -0x27c],EAX
MOV EDI,dword ptr [RBP + -0x27c]
MOV RAX,RSP
MOV dword ptr [RAX],EDI
LEA RDI,[RBP + -0x248]
MOV qword ptr [RBP + -0x2c0],RDI
CALL 0x00b25c40
MOV RDI,qword ptr [RBP + -0x2a0]
MOV RCX,qword ptr [RBP + -0x2c0]
MOV RSI,qword ptr [RBP + -0x260]
MOV RDX,qword ptr [RBP + -0x268]
MOV R8,qword ptr [RBP + -0x270]
MOV EAX,dword ptr [RBP + -0x24c]
MOV dword ptr [RBP + -0x280],EAX
MOV R9D,dword ptr [RBP + -0x280]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x430]
LAB_00bf47c3:
CALL RAX
LAB_00bf47c5:
JMP 0x00bf47c7
LAB_00bf47c7:
MOV RAX,qword ptr [RBP + -0x270]
MOV EAX,dword ptr [RAX + 0x24]
SHR EAX,0x1f
MOV byte ptr [RBP + -0x2c9],AL
LEA RDI,[RBP + -0x248]
CALL 0x00b25d80
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00bf4853
MOV AL,byte ptr [RBP + -0x2c9]
AND AL,0x1
ADD RSP,0x2e0
POP RBP
RET
LAB_00bf4853:
CALL 0x00858480
|
/* Type_handler::Item_func_hybrid_field_type_get_date_with_warn(THD*, Item_func_hybrid_field_type*,
st_mysql_time*, date_mode_t) const */
int8 __thiscall
Type_handler::Item_func_hybrid_field_type_get_date_with_warn
(Type_handler *this,int8 param_1,Item *param_2,long param_3,int4 param_5)
{
int4 uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
int8 local_2c0;
int8 local_2b0;
Warn_push local_250 [576];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = Item::field_table_or_null(param_2);
if (lVar2 == 0) {
local_2b0 = 0;
local_2c0 = 0;
}
else {
local_2b0 = *(int8 *)(lVar2 + 0x2a0);
local_2c0 = *(int8 *)(lVar2 + 0x2b0);
}
uVar3 = Item::field_name_or_null(param_2);
Temporal::Warn_push::Warn_push(local_250,param_1,local_2b0,local_2c0,uVar3,param_3,param_5);
/* try { // try from 00bf47c3 to 00bf47c4 has its CatchHandler @ 00bf4809 */
(**(code **)(*(long *)this + 0x430))(this,param_1,param_2,local_250,param_3,param_5);
uVar1 = *(int4 *)(param_3 + 0x24);
Temporal::Warn_push::~Warn_push(local_250);
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),(byte)((uint)uVar1 >> 0x1f));
}
| |
53,780 | test_acc::build_graph(ggml_context*) | monkey531[P]llama/tests/test-backend-ops.cpp | ggml_tensor * build_graph(ggml_context * ctx) override {
ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne_a.data());
ggml_set_param(ctx, a);
ggml_set_name(a, "a");
ggml_tensor * b = ggml_new_tensor(ctx, type, 4, ne_b.data());
ggml_set_param(ctx, b);
ggml_set_name(b, "b");
ggml_tensor * out = ggml_acc(ctx, a, b, a->nb[1], a->nb[2], a->nb[3], b->nb[1]);
ggml_set_name(out, "out");
return out;
} | O3 | cpp | test_acc::build_graph(ggml_context*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl 0x38(%rdi), %esi
leaq 0x40(%rdi), %rcx
movq %rbx, %rdi
movl $0x4, %edx
callq 0xd080
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b8ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0xda90
leaq 0x77e1(%rip), %rsi # 0x44b87
movq %r14, %rdi
callq 0xdb10
movl 0x38(%r15), %esi
leaq 0x60(%r15), %rcx
movq %rbx, %rdi
movl $0x4, %edx
callq 0xd080
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b8ae
movq %rbx, %rdi
movq %r12, %rsi
callq 0xda90
leaq 0x7b02(%rip), %rsi # 0x44ee5
movq %r12, %rdi
callq 0xdb10
movq 0x38(%r14), %rcx
movq 0x40(%r14), %r8
movq 0x48(%r14), %r9
movq 0x38(%r12), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xd7d0
movq %rax, %rbx
leaq 0x7d16(%rip), %rsi # 0x4512e
movq %rax, %rdi
callq 0xdb10
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN8test_acc11build_graphEP12ggml_context:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r15, rdi
mov esi, [rdi+38h]
lea rcx, [rdi+40h]
mov rdi, rbx
mov edx, 4
call _ggml_new_tensor
mov r14, rax
mov rdi, r15
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rdi, rbx
mov rsi, r14
call _ggml_set_param
lea rsi, aViewOfA+8; "a"
mov rdi, r14
call _ggml_set_name
mov esi, [r15+38h]
lea rcx, [r15+60h]
mov rdi, rbx
mov edx, 4
call _ggml_new_tensor
mov r12, rax
mov rdi, r15
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rdi, rbx
mov rsi, r12
call _ggml_set_param
lea rsi, aViewOfB+8; "b"
mov rdi, r12
call _ggml_set_name
mov rcx, [r14+38h]
mov r8, [r14+40h]
mov r9, [r14+48h]
mov rax, [r12+38h]
mov [rsp+28h+var_28], rax
mov rdi, rbx
mov rsi, r14
mov rdx, r12
call _ggml_acc
mov rbx, rax
lea rsi, aSumOfOut+7; "out"
mov rdi, rax
call _ggml_set_name
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long test_acc::build_graph(long long a1, long long a2)
{
_QWORD *v2; // r14
long long v3; // r12
long long v4; // rbx
v2 = (_QWORD *)ggml_new_tensor(a2, *(unsigned int *)(a1 + 56), 4LL);
test_case::add_sentinel(a1, a2);
ggml_set_param(a2, v2);
ggml_set_name(v2, "a");
v3 = ggml_new_tensor(a2, *(unsigned int *)(a1 + 56), 4LL);
test_case::add_sentinel(a1, a2);
ggml_set_param(a2, v3);
ggml_set_name(v3, "b");
v4 = ggml_acc(a2, v2, v3, v2[7], v2[8], v2[9], *(_QWORD *)(v3 + 56));
ggml_set_name(v4, "out");
return v4;
}
| build_graph:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R15,RDI
MOV ESI,dword ptr [RDI + 0x38]
LEA RCX,[RDI + 0x40]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0010d080
MOV R14,RAX
MOV RDI,R15
MOV RSI,RBX
CALL 0x0011b8ae
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010da90
LEA RSI,[0x144b87]
MOV RDI,R14
CALL 0x0010db10
MOV ESI,dword ptr [R15 + 0x38]
LEA RCX,[R15 + 0x60]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0010d080
MOV R12,RAX
MOV RDI,R15
MOV RSI,RBX
CALL 0x0011b8ae
MOV RDI,RBX
MOV RSI,R12
CALL 0x0010da90
LEA RSI,[0x144ee5]
MOV RDI,R12
CALL 0x0010db10
MOV RCX,qword ptr [R14 + 0x38]
MOV R8,qword ptr [R14 + 0x40]
MOV R9,qword ptr [R14 + 0x48]
MOV RAX,qword ptr [R12 + 0x38]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
CALL 0x0010d7d0
MOV RBX,RAX
LEA RSI,[0x14512e]
MOV RDI,RAX
CALL 0x0010db10
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* test_acc::build_graph(ggml_context*) */
int8 __thiscall test_acc::build_graph(test_acc *this,ggml_context *param_1)
{
long lVar1;
long lVar2;
int8 uVar3;
lVar1 = ggml_new_tensor(param_1,*(int4 *)(this + 0x38),4,this + 0x40);
test_case::add_sentinel((test_case *)this,param_1);
ggml_set_param(param_1,lVar1);
ggml_set_name(lVar1,"a");
lVar2 = ggml_new_tensor(param_1,*(int4 *)(this + 0x38),4,this + 0x60);
test_case::add_sentinel((test_case *)this,param_1);
ggml_set_param(param_1,lVar2);
ggml_set_name(lVar2,"b");
uVar3 = ggml_acc(param_1,lVar1,lVar2,*(int8 *)(lVar1 + 0x38),*(int8 *)(lVar1 + 0x40),
*(int8 *)(lVar1 + 0x48),*(int8 *)(lVar2 + 0x38));
ggml_set_name(uVar3,"out");
return uVar3;
}
| |
53,781 | nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | monkey531[P]llama/common/./json.hpp | static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x80860(%rip), %rsi # 0xb612d
leaq 0x80865(%rip), %rdx # 0xb6139
leaq 0x28(%rsp), %rdi
callq 0x22878
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x312c2
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x19a90
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x191f0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x191f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x191f0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x35977
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x196d0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35992
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x196d0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x359a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196d0
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3152a
leaq 0xb3771(%rip), %rax # 0xe9130
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x359d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196d0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x35a67
movq 0x18(%rsp), %rsi
jmp 0x35a5f
movq %rax, %rbx
jmp 0x35a50
movq %rax, %rbx
jmp 0x35a67
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x35a29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x196d0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x1b37b
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x35a67
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x196d0
movq %rbx, %rdi
callq 0x19c00
| _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r15, rdx
mov ebp, esi
mov rbx, rdi
lea r13, [rsp+0C8h+var_90]
mov [r13-10h], r13
lea rsi, aOutOfRange; "out_of_range"
lea rdx, aOutOfRange+0Ch; ""
lea rdi, [rsp+0C8h+var_A0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0C8h+var_80]; int
lea rsi, [rsp+0C8h+var_A0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea r14, [rsp+0C8h+var_50]
mov [r14-10h], r14
xor eax, eax
mov [r14-8], rax
mov [r14], al
lea r12, [rsp+0C8h+var_B0]
mov [r12-10h], r12
mov [r12-8], rax
mov [r12], al
mov rsi, [r15+8]
add rsi, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, qword ptr [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0C8h+var_60]; void *
cmp rdi, r14
jz short loc_35977
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35977:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_35992
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35992:
mov rdi, [rsp+0C8h+var_A0]; void *
cmp rdi, r13
jz short loc_359A9
mov rsi, [rsp+0C8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_359A9:
mov rdx, [rsp+0C8h+var_C0]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, off_E9130
mov [rbx], rax
mov rdi, [rsp+0C8h+var_C0]; void *
cmp rdi, r12
jz short loc_359D9
mov rsi, [rsp+0C8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_359D9:
mov rax, rbx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
cmp rdi, r12
jz short loc_35A67
mov rsi, [rsp+arg_10]
jmp short loc_35A5F
mov rbx, rax
jmp short loc_35A50
mov rbx, rax
jmp short loc_35A67
mov rbx, rdx
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_35A29
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35A29:
lea rdi, [rsp+arg_60]
lea rdx, [rsp+arg_40]
lea r12, [rsp+arg_80]
mov rsi, r14
mov rcx, r15
mov r8d, ebx
mov r9, r12
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__cold_1
mov rbx, [r12]
loc_35A50:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_35A67
mov rsi, [rsp+arg_30]
loc_35A5F:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_35A67:
mov rdi, rbx
call __Unwind_Resume
| nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
_QWORD *a3)
{
char *v5[2]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-B0h] BYREF
void *v7[2]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-90h] BYREF
int v9[2]; // [rsp+48h] [rbp-80h] BYREF
long long v10; // [rsp+50h] [rbp-78h]
long long v11; // [rsp+58h] [rbp-70h] BYREF
void *v12; // [rsp+68h] [rbp-60h]
long long v13; // [rsp+70h] [rbp-58h]
_QWORD v14[10]; // [rsp+78h] [rbp-50h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>((long long)v7, "out_of_range", (long long)"");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v9, (long long)v7, a2);
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v5[0] = (char *)v6;
v5[1] = 0LL;
LOBYTE(v6[0]) = 0;
std::string::reserve(v5, v10 + a3[1]);
std::string::_M_append(v5, *(_QWORD *)v9, v10);
std::string::_M_append(v5, v12, v13);
std::string::_M_append(v5, *a3, a3[1]);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v5[0]);
*(_QWORD *)this = off_E9130;
if ( (_QWORD *)v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
return this;
}
| _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R15,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LAB_001358c6:
LEA RSI,[0x1b612d]
LEA RDX,[0x1b6139]
LEA RDI,[RSP + 0x28]
CALL 0x00122878
LAB_001358de:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
MOV EDX,EBP
CALL 0x001312c2
LEA R14,[RSP + 0x78]
MOV qword ptr [R14 + -0x10],R14
XOR EAX,EAX
MOV qword ptr [R14 + -0x8],RAX
MOV byte ptr [R14],AL
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],RAX
MOV byte ptr [R12],AL
MOV RSI,qword ptr [R15 + 0x8]
ADD RSI,qword ptr [RSP + 0x50]
LAB_0013591d:
LEA RDI,[RSP + 0x8]
CALL 0x00119a90
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x8]
CALL 0x001191f0
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
LEA RDI,[RSP + 0x8]
CALL 0x001191f0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x001191f0
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R14
JZ 0x00135977
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001196d0
LAB_00135977:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00135992
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001196d0
LAB_00135992:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x001359a9
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001196d0
LAB_001359a9:
MOV RDX,qword ptr [RSP + 0x8]
LAB_001359ae:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0013152a
LAB_001359b8:
LEA RAX,[0x1e9130]
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x001359d9
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001196d0
LAB_001359d9:
MOV RAX,RBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(exception *param_1,int param_2,ulong *param_3)
{
char *local_c0;
int8 local_b8;
char local_b0;
int7 uStack_af;
long *local_a0 [2];
long local_90 [2];
long *local_80 [2];
long local_70 [2];
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
/* try { // try from 001358c6 to 001358dd has its CatchHandler @ 00135a07 */
local_a0[0] = local_90;
std::__cxx11::string::_M_construct<char_const*>(local_a0,"out_of_range","");
/* try { // try from 001358de to 001358ee has its CatchHandler @ 00135a02 */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_80,(string *)local_a0,param_2);
local_58 = 0;
local_50 = 0;
local_b8 = 0;
local_b0 = '\0';
/* try { // try from 0013591d to 0013595f has its CatchHandler @ 00135a0c */
local_c0 = &local_b0;
local_60 = &local_50;
std::__cxx11::string::reserve((ulong)&local_c0);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_80[0]);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_60);
std::__cxx11::string::_M_append((char *)&local_c0,*param_3);
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
/* try { // try from 001359ae to 001359b7 has its CatchHandler @ 001359ee */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,local_c0);
*(int ***)param_1 = &PTR__exception_001e9130;
if (local_c0 != &local_b0) {
operator_delete(local_c0,CONCAT71(uStack_af,local_b0) + 1);
}
return param_1;
}
| |
53,782 | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | ATTRIBUTE_NOINLINE
void DemangleInplace(char* out, size_t out_size) {
char demangled[256]; // Big enough for sane demangled symbols.
if (Demangle(out, demangled, sizeof(demangled))) {
// Demangling succeeded. Copy to out if the space allows.
size_t len = strlen(demangled);
if (len + 1 <= out_size) { // +1 for '\0'.
NGLOG_SAFE_ASSERT(len < sizeof(demangled));
memmove(out, demangled, len + 1);
}
}
} | O2 | cpp | nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long):
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x100, %edx # imm = 0x100
callq 0x8fb8
testb %al, %al
je 0x1c619
movq %rsp, %rdi
callq 0x7230
leaq 0x1(%rax), %rdx
cmpq %r14, %rdx
ja 0x1c619
cmpq $0x100, %rax # imm = 0x100
jae 0x1c624
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7470
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
retq
callq 0x7320
| _ZN5nglog5tools12_GLOBAL__N_115DemangleInplaceEPcm:
push r14
push rbx
sub rsp, 108h
mov r14, rsi
mov rbx, rdi
mov rsi, rsp; char *
mov edx, offset qword_100; char *
call _ZN5nglog5tools8DemangleEPKcPcm; nglog::tools::Demangle(char const*,char *,ulong)
test al, al
jz short loc_1C619
mov rdi, rsp
call _strlen
lea rdx, [rax+1]
cmp rdx, r14
ja short loc_1C619
cmp rax, 100h
jnb short loc_1C624
mov rsi, rsp
mov rdi, rbx
call _memcpy
loc_1C619:
add rsp, 108h
pop rbx
pop r14
retn
loc_1C624:
call _abort
| unsigned long long nglog::tools::`anonymous namespace'::DemangleInplace(
nglog::tools::_anonymous_namespace_ *this,
char *a2)
{
unsigned long long result; // rax
char v3[280]; // [rsp+0h] [rbp-118h] BYREF
result = nglog::tools::Demangle(this, v3, (char *)qword_100);
if ( (_BYTE)result )
{
result = strlen(v3);
if ( result + 1 <= (unsigned long long)a2 )
{
if ( result >= 0x100 )
abort(v3);
return memcpy(this, v3, result + 1);
}
}
return result;
}
| DemangleInplace:
PUSH R14
PUSH RBX
SUB RSP,0x108
MOV R14,RSI
MOV RBX,RDI
MOV RSI,RSP
MOV EDX,0x100
CALL 0x00108fb8
TEST AL,AL
JZ 0x0011c619
MOV RDI,RSP
CALL 0x00107230
LEA RDX,[RAX + 0x1]
CMP RDX,R14
JA 0x0011c619
CMP RAX,0x100
JNC 0x0011c624
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00107470
LAB_0011c619:
ADD RSP,0x108
POP RBX
POP R14
RET
LAB_0011c624:
CALL 0x00107320
|
/* nglog::tools::(anonymous namespace)::DemangleInplace(char*, unsigned long) */
void nglog::tools::(anonymous_namespace)::DemangleInplace(char *param_1,ulong param_2)
{
char cVar1;
size_t sVar2;
char acStack_118 [264];
cVar1 = Demangle(param_1,acStack_118,0x100);
if (cVar1 != '\0') {
sVar2 = strlen(acStack_118);
if (sVar2 + 1 <= param_2) {
if (0xff < sVar2) {
/* WARNING: Subroutine does not return */
abort();
}
memcpy(param_1,acStack_118,sVar2 + 1);
}
}
return;
}
| |
53,783 | check_slave_start_position(binlog_send_info*, char const**, rpl_gtid*) | eloqsql/sql/sql_repl.cc | static int
check_slave_start_position(binlog_send_info *info, const char **errormsg,
rpl_gtid *error_gtid)
{
uint32 i;
int err;
slave_connection_state::entry **delete_list= NULL;
uint32 delete_idx= 0;
slave_connection_state *st= &info->gtid_state;
if (rpl_load_gtid_slave_state(info->thd))
{
*errormsg= "Failed to load replication slave GTID state";
err= ER_CANNOT_LOAD_SLAVE_GTID_STATE;
goto end;
}
for (i= 0; i < st->hash.records; ++i)
{
slave_connection_state::entry *slave_gtid_entry=
(slave_connection_state::entry *)my_hash_element(&st->hash, i);
rpl_gtid *slave_gtid= &slave_gtid_entry->gtid;
rpl_gtid master_gtid;
rpl_gtid master_replication_gtid;
rpl_gtid start_gtid;
bool start_at_own_slave_pos=
rpl_global_gtid_slave_state->domain_to_gtid(slave_gtid->domain_id,
&master_replication_gtid) &&
slave_gtid->server_id == master_replication_gtid.server_id &&
slave_gtid->seq_no == master_replication_gtid.seq_no;
if (mysql_bin_log.find_in_binlog_state(slave_gtid->domain_id,
slave_gtid->server_id,
&master_gtid) &&
master_gtid.seq_no >= slave_gtid->seq_no)
{
/*
If connecting slave requests to start at the GTID we last applied when
we were ourselves a slave, then this GTID may not exist in our binlog
(in case of --log-slave-updates=0). So set the flag to disable the
error about missing GTID in the binlog in this case.
*/
if (start_at_own_slave_pos)
slave_gtid_entry->flags|= slave_connection_state::START_OWN_SLAVE_POS;
continue;
}
if (!start_at_own_slave_pos)
{
rpl_gtid domain_gtid;
slave_connection_state *until_gtid_state= info->until_gtid_state;
rpl_gtid *until_gtid;
if (!mysql_bin_log.lookup_domain_in_binlog_state(slave_gtid->domain_id,
&domain_gtid))
{
/*
We do not have anything in this domain, neither in the binlog nor
in the slave state. So we are probably one master in a multi-master
setup, and this domain is served by a different master.
But set a flag so that if we then ever _do_ happen to encounter
anything in this domain, then we will re-check that the requested
slave position exists, and give the error at that time if not.
*/
slave_gtid_entry->flags|= slave_connection_state::START_ON_EMPTY_DOMAIN;
continue;
}
if (info->slave_gtid_ignore_duplicates &&
domain_gtid.seq_no < slave_gtid->seq_no)
{
/*
When --gtid-ignore-duplicates, it is ok for the slave to request
something that we do not have (yet) - they might already have gotten
it through another path in a multi-path replication hierarchy.
*/
continue;
}
if (until_gtid_state &&
( !(until_gtid= until_gtid_state->find(slave_gtid->domain_id)) ||
(mysql_bin_log.find_in_binlog_state(until_gtid->domain_id,
until_gtid->server_id,
&master_gtid) &&
master_gtid.seq_no >= until_gtid->seq_no)))
{
/*
The slave requested to start from a position that is not (yet) in
our binlog, but it also specified an UNTIL condition that _is_ in
our binlog (or a missing UNTIL, which means stop at the very
beginning). So the stop position is before the start position, and
we just delete the entry from the UNTIL hash to mark that this
domain has already reached the UNTIL condition.
*/
if(until_gtid)
until_gtid_state->remove(until_gtid);
continue;
}
*error_gtid= *slave_gtid;
give_error_start_pos_missing_in_binlog(&err, errormsg, error_gtid);
goto end;
}
/*
Ok, so connecting slave asked to start at a GTID that we do not have in
our binlog, but it was in fact the last GTID we applied earlier, when we
were acting as a replication slave.
So this means that we were running as a replication slave without
--log-slave-updates, but now we switched to be a master. It is worth it
to handle this special case, as it allows users to run a simple
master -> slave without --log-slave-updates, and then exchange slave and
master, as long as they make sure the slave is caught up before switching.
*/
/*
First check if we logged something ourselves as a master after being a
slave. This will be seen as a GTID with our own server_id and bigger
seq_no than what is in the slave state.
If we did not log anything ourselves, then start the connecting slave
replicating from the current binlog end position, which in this case
corresponds to our replication slave state and hence what the connecting
slave is requesting.
*/
if (mysql_bin_log.find_in_binlog_state(slave_gtid->domain_id,
global_system_variables.server_id,
&start_gtid) &&
start_gtid.seq_no > slave_gtid->seq_no)
{
/*
Start replication within this domain at the first GTID that we logged
ourselves after becoming a master.
Remember that this starting point is in fact a "fake" GTID which may
not exists in the binlog, so that we do not complain about it in
--gtid-strict-mode.
*/
slave_gtid->server_id= global_system_variables.server_id;
slave_gtid_entry->flags|= slave_connection_state::START_OWN_SLAVE_POS;
}
else if (mysql_bin_log.lookup_domain_in_binlog_state(slave_gtid->domain_id,
&start_gtid))
{
slave_gtid->server_id= start_gtid.server_id;
slave_gtid->seq_no= start_gtid.seq_no;
}
else
{
/*
We do not have _anything_ in our own binlog for this domain. Just
delete the entry in the slave connection state, then it will pick up
anything new that arrives.
We just queue up the deletion and do it later, after the loop, so that
we do not mess up the iteration over the hash.
*/
if (!delete_list)
{
if (!(delete_list= (slave_connection_state::entry **)
my_malloc(PSI_INSTRUMENT_ME,
sizeof(*delete_list) * st->hash.records, MYF(MY_WME))))
{
*errormsg= "Out of memory while checking slave start position";
err= ER_OUT_OF_RESOURCES;
goto end;
}
}
delete_list[delete_idx++]= slave_gtid_entry;
}
}
/* Do any delayed deletes from the hash. */
if (delete_list)
{
for (i= 0; i < delete_idx; ++i)
st->remove(&(delete_list[i]->gtid));
}
err= 0;
end:
if (delete_list)
my_free(delete_list);
return err;
} | O0 | cpp | check_slave_start_position(binlog_send_info*, char const**, rpl_gtid*):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0xa4abf0
cmpl $0x0, %eax
je 0x92eb93
movq -0x10(%rbp), %rax
leaq 0xa68ff6(%rip), %rcx # 0x1397b7a
movq %rcx, (%rax)
movl $0x79a, -0x20(%rbp) # imm = 0x79A
jmp 0x92eecd
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x92ee8f
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x12ab070
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x13aee1c(%rip), %rax # 0x1cdd9e8
movq (%rax), %rdi
movq -0x48(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdx
callq 0xad7740
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x92ebef
jmp 0x92ec18
movq -0x48(%rbp), %rax
movl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl -0x64(%rbp), %ecx
movb %al, -0xa1(%rbp)
jne 0x92ec18
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x60(%rbp), %rax
sete %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x79(%rbp)
movq -0x48(%rbp), %rax
movl (%rax), %esi
movq -0x48(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x13d0601(%rip), %rdi # 0x1cff238
leaq -0x58(%rbp), %rcx
callq 0xd36e20
testb $0x1, %al
jne 0x92ec46
jmp 0x92ec6c
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x92ec6c
testb $0x1, -0x79(%rbp)
je 0x92ec67
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x92ee81
testb $0x1, -0x79(%rbp)
jne 0x92ed8b
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x48(%rbp), %rax
movl (%rax), %esi
leaq 0x13d05a3(%rip), %rdi # 0x1cff238
leaq -0x90(%rbp), %rdx
callq 0xd36e80
testb $0x1, %al
jne 0x92ecb7
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x10(%rax)
jmp 0x92ee81
movq -0x8(%rbp), %rax
testb $0x1, 0x25e(%rax)
je 0x92ecda
movq -0x88(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x92ecda
jmp 0x92ee81
cmpq $0x0, -0x98(%rbp)
je 0x92ed5f
movq -0x98(%rbp), %rdi
movq -0x48(%rbp), %rax
movl (%rax), %esi
callq 0xad9cf0
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x92ed3d
movq -0xa0(%rbp), %rax
movl (%rax), %esi
movq -0xa0(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x13d051b(%rip), %rdi # 0x1cff238
leaq -0x58(%rbp), %rcx
callq 0xd36e20
testb $0x1, %al
jne 0x92ed2c
jmp 0x92ed5f
movq -0x50(%rbp), %rax
movq -0xa0(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x92ed5f
cmpq $0x0, -0xa0(%rbp)
je 0x92ed5a
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0xad9d40
jmp 0x92ee81
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x92f510
jmp 0x92eecd
movq -0x48(%rbp), %rax
movl (%rax), %esi
leaq 0x139a7e8(%rip), %rax # 0x1cc9580
movq 0x2b8(%rax), %rax
movl %eax, %edx
leaq 0x13d0490(%rip), %rdi # 0x1cff238
leaq -0x78(%rbp), %rcx
callq 0xd36e20
testb $0x1, %al
jne 0x92edb7
jmp 0x92edee
movq -0x70(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x92edee
leaq 0x139a7b4(%rip), %rax # 0x1cc9580
movq 0x2b8(%rax), %rax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x92ee7f
movq -0x48(%rbp), %rax
movl (%rax), %esi
leaq 0x13d043d(%rip), %rdi # 0x1cff238
leaq -0x78(%rbp), %rdx
callq 0xd36e80
testb $0x1, %al
jne 0x92ee0a
jmp 0x92ee22
movl -0x74(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x92ee7d
cmpq $0x0, -0x28(%rbp)
jne 0x92ee64
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
shlq $0x3, %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0x12c71a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x92ee62
movq -0x10(%rbp), %rax
leaq 0xa68d50(%rip), %rcx # 0x1397ba6
movq %rcx, (%rax)
movl $0x411, -0x20(%rbp) # imm = 0x411
jmp 0x92eecd
jmp 0x92ee64
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x92ee7f
jmp 0x92ee81
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92eb9a
cmpq $0x0, -0x28(%rbp)
je 0x92eec6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x92eec4
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0xad9d40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92ee9d
jmp 0x92eec6
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x92eedd
movq -0x28(%rbp), %rdi
callq 0x12c7520
movl -0x20(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL26check_slave_start_positionP16binlog_send_infoPPKcP8rpl_gtid:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_28], 0
mov [rbp+var_2C], 0
mov rax, [rbp+var_8]
add rax, 0E8h
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov rdi, [rax+180h]; THD *
call _Z25rpl_load_gtid_slave_stateP3THD; rpl_load_gtid_slave_state(THD *)
cmp eax, 0
jz short loc_92EB93
mov rax, [rbp+var_10]
lea rcx, aFailedToLoadRe_0; "Failed to load replication slave GTID s"...
mov [rax], rcx
mov [rbp+var_20], 79Ah
jmp loc_92EECD
loc_92EB93:
mov [rbp+var_1C], 0
loc_92EB9A:
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_38]
cmp rax, [rcx+18h]
jnb loc_92EE8F
mov rdi, [rbp+var_38]
mov eax, [rbp+var_1C]
mov esi, eax
call my_hash_element
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
lea rax, rpl_global_gtid_slave_state
mov rdi, [rax]
mov rax, [rbp+var_48]
mov esi, [rax]
lea rdx, [rbp+var_68]
call _ZN15rpl_slave_state14domain_to_gtidEjP8rpl_gtid; rpl_slave_state::domain_to_gtid(uint,rpl_gtid *)
mov cl, al
xor eax, eax
test cl, 1
mov [rbp+var_A1], al
jnz short loc_92EBEF
jmp short loc_92EC18
loc_92EBEF:
mov rax, [rbp+var_48]
mov ecx, [rax+4]
xor eax, eax
cmp ecx, [rbp+var_64]
mov [rbp+var_A1], al
jnz short loc_92EC18
mov rax, [rbp+var_48]
mov rax, [rax+8]
cmp rax, [rbp+var_60]
setz al
mov [rbp+var_A1], al
loc_92EC18:
mov al, [rbp+var_A1]
and al, 1
mov [rbp+var_79], al
mov rax, [rbp+var_48]
mov esi, [rax]
mov rax, [rbp+var_48]
mov edx, [rax+4]
lea rdi, mysql_bin_log
lea rcx, [rbp+var_58]
call _ZN13MYSQL_BIN_LOG20find_in_binlog_stateEjjP8rpl_gtid; MYSQL_BIN_LOG::find_in_binlog_state(uint,uint,rpl_gtid *)
test al, 1
jnz short loc_92EC46
jmp short loc_92EC6C
loc_92EC46:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_48]
cmp rax, [rcx+8]
jb short loc_92EC6C
test [rbp+var_79], 1
jz short loc_92EC67
mov rax, [rbp+var_40]
mov ecx, [rax+10h]
or ecx, 1
mov [rax+10h], ecx
loc_92EC67:
jmp loc_92EE81
loc_92EC6C:
test [rbp+var_79], 1
jnz loc_92ED8B
mov rax, [rbp+var_8]
mov rax, [rax+1A0h]
mov [rbp+var_98], rax
mov rax, [rbp+var_48]
mov esi, [rax]
lea rdi, mysql_bin_log
lea rdx, [rbp+var_90]
call _ZN13MYSQL_BIN_LOG29lookup_domain_in_binlog_stateEjP8rpl_gtid; MYSQL_BIN_LOG::lookup_domain_in_binlog_state(uint,rpl_gtid *)
test al, 1
jnz short loc_92ECB7
mov rax, [rbp+var_40]
mov ecx, [rax+10h]
or ecx, 2
mov [rax+10h], ecx
jmp loc_92EE81
loc_92ECB7:
mov rax, [rbp+var_8]
test byte ptr [rax+25Eh], 1
jz short loc_92ECDA
mov rax, [rbp+var_88]
mov rcx, [rbp+var_48]
cmp rax, [rcx+8]
jnb short loc_92ECDA
jmp loc_92EE81
loc_92ECDA:
cmp [rbp+var_98], 0
jz short loc_92ED5F
mov rdi, [rbp+var_98]; this
mov rax, [rbp+var_48]
mov esi, [rax]; unsigned int
call _ZN22slave_connection_state4findEj; slave_connection_state::find(uint)
mov [rbp+var_A0], rax
cmp rax, 0
jz short loc_92ED3D
mov rax, [rbp+var_A0]
mov esi, [rax]
mov rax, [rbp+var_A0]
mov edx, [rax+4]
lea rdi, mysql_bin_log
lea rcx, [rbp+var_58]
call _ZN13MYSQL_BIN_LOG20find_in_binlog_stateEjjP8rpl_gtid; MYSQL_BIN_LOG::find_in_binlog_state(uint,uint,rpl_gtid *)
test al, 1
jnz short loc_92ED2C
jmp short loc_92ED5F
loc_92ED2C:
mov rax, [rbp+var_50]
mov rcx, [rbp+var_A0]
cmp rax, [rcx+8]
jb short loc_92ED5F
loc_92ED3D:
cmp [rbp+var_A0], 0
jz short loc_92ED5A
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_A0]
call _ZN22slave_connection_state6removeEPK8rpl_gtid; slave_connection_state::remove(rpl_gtid const*)
loc_92ED5A:
jmp loc_92EE81
loc_92ED5F:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_18]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rdi, [rbp+var_20]
call _ZL38give_error_start_pos_missing_in_binlogPiPPKcP8rpl_gtid; give_error_start_pos_missing_in_binlog(int *,char const**,rpl_gtid *)
jmp loc_92EECD
loc_92ED8B:
mov rax, [rbp+var_48]
mov esi, [rax]
lea rax, global_system_variables
mov rax, [rax+2B8h]
mov edx, eax
lea rdi, mysql_bin_log
lea rcx, [rbp+var_78]
call _ZN13MYSQL_BIN_LOG20find_in_binlog_stateEjjP8rpl_gtid; MYSQL_BIN_LOG::find_in_binlog_state(uint,uint,rpl_gtid *)
test al, 1
jnz short loc_92EDB7
jmp short loc_92EDEE
loc_92EDB7:
mov rax, [rbp+var_70]
mov rcx, [rbp+var_48]
cmp rax, [rcx+8]
jbe short loc_92EDEE
lea rax, global_system_variables
mov rax, [rax+2B8h]
mov ecx, eax
mov rax, [rbp+var_48]
mov [rax+4], ecx
mov rax, [rbp+var_40]
mov ecx, [rax+10h]
or ecx, 1
mov [rax+10h], ecx
jmp loc_92EE7F
loc_92EDEE:
mov rax, [rbp+var_48]
mov esi, [rax]
lea rdi, mysql_bin_log
lea rdx, [rbp+var_78]
call _ZN13MYSQL_BIN_LOG29lookup_domain_in_binlog_stateEjP8rpl_gtid; MYSQL_BIN_LOG::lookup_domain_in_binlog_state(uint,rpl_gtid *)
test al, 1
jnz short loc_92EE0A
jmp short loc_92EE22
loc_92EE0A:
mov ecx, [rbp+var_74]
mov rax, [rbp+var_48]
mov [rax+4], ecx
mov rcx, [rbp+var_70]
mov rax, [rbp+var_48]
mov [rax+8], rcx
jmp short loc_92EE7D
loc_92EE22:
cmp [rbp+var_28], 0
jnz short loc_92EE64
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
shl rsi, 3
xor edi, edi
mov edx, 10h
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_92EE62
mov rax, [rbp+var_10]
lea rcx, aOutOfMemoryWhi_0; "Out of memory while checking slave star"...
mov [rax], rcx
mov [rbp+var_20], 411h
jmp short loc_92EECD
loc_92EE62:
jmp short $+2
loc_92EE64:
mov rdx, [rbp+var_40]
mov rax, [rbp+var_28]
mov ecx, [rbp+var_2C]
mov esi, ecx
add esi, 1
mov [rbp+var_2C], esi
mov ecx, ecx
mov [rax+rcx*8], rdx
loc_92EE7D:
jmp short $+2
loc_92EE7F:
jmp short $+2
loc_92EE81:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp loc_92EB9A
loc_92EE8F:
cmp [rbp+var_28], 0
jz short loc_92EEC6
mov [rbp+var_1C], 0
loc_92EE9D:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jnb short loc_92EEC4
mov rdi, [rbp+var_38]
mov rax, [rbp+var_28]
mov ecx, [rbp+var_1C]
mov rsi, [rax+rcx*8]
call _ZN22slave_connection_state6removeEPK8rpl_gtid; slave_connection_state::remove(rpl_gtid const*)
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_92EE9D
loc_92EEC4:
jmp short $+2
loc_92EEC6:
mov [rbp+var_20], 0
loc_92EECD:
cmp [rbp+var_28], 0
jz short loc_92EEDD
mov rdi, [rbp+var_28]
call my_free
loc_92EEDD:
mov eax, [rbp+var_20]
add rsp, 0B0h
pop rbp
retn
| long long check_slave_start_position(long long a1, _QWORD *a2, _QWORD *a3)
{
unsigned int *v3; // rcx
_QWORD *v4; // rax
unsigned int v5; // ecx
bool v7; // [rsp+Fh] [rbp-A1h]
unsigned int *v8; // [rsp+10h] [rbp-A0h]
slave_connection_state *v9; // [rsp+18h] [rbp-98h]
_BYTE v10[8]; // [rsp+20h] [rbp-90h] BYREF
unsigned long long v11; // [rsp+28h] [rbp-88h]
bool v12; // [rsp+37h] [rbp-79h]
_BYTE v13[4]; // [rsp+38h] [rbp-78h] BYREF
unsigned int v14; // [rsp+3Ch] [rbp-74h]
unsigned long long v15; // [rsp+40h] [rbp-70h]
_BYTE v16[4]; // [rsp+48h] [rbp-68h] BYREF
int v17; // [rsp+4Ch] [rbp-64h]
long long v18; // [rsp+50h] [rbp-60h]
_BYTE v19[8]; // [rsp+58h] [rbp-58h] BYREF
unsigned long long v20; // [rsp+60h] [rbp-50h]
unsigned int *v21; // [rsp+68h] [rbp-48h]
unsigned int *v22; // [rsp+70h] [rbp-40h]
long long v23; // [rsp+78h] [rbp-38h]
unsigned int v24; // [rsp+84h] [rbp-2Ch]
long long v25; // [rsp+88h] [rbp-28h]
unsigned int v26; // [rsp+90h] [rbp-20h] BYREF
unsigned int i; // [rsp+94h] [rbp-1Ch]
_QWORD *v28; // [rsp+98h] [rbp-18h]
_QWORD *v29; // [rsp+A0h] [rbp-10h]
long long v30; // [rsp+A8h] [rbp-8h]
v30 = a1;
v29 = a2;
v28 = a3;
v25 = 0LL;
v24 = 0;
v23 = a1 + 232;
if ( (unsigned int)rpl_load_gtid_slave_state(*(THD **)(a1 + 384)) )
{
*v29 = "Failed to load replication slave GTID state";
v26 = 1946;
}
else
{
for ( i = 0; (unsigned long long)i < *(_QWORD *)(v23 + 24); ++i )
{
v22 = (unsigned int *)my_hash_element(v23, i);
v21 = v22;
v7 = 0;
if ( (rpl_slave_state::domain_to_gtid(rpl_global_gtid_slave_state, *v22, v16) & 1) != 0 )
{
v7 = 0;
if ( v21[1] == v17 )
v7 = *((_QWORD *)v21 + 1) == v18;
}
v12 = v7;
if ( (MYSQL_BIN_LOG::find_in_binlog_state(&mysql_bin_log, *v21, v21[1], v19) & 1) != 0
&& v20 >= *((_QWORD *)v21 + 1) )
{
if ( v12 )
v22[4] |= 1u;
}
else if ( v12 )
{
if ( (MYSQL_BIN_LOG::find_in_binlog_state(&mysql_bin_log, *v21, (unsigned int)global_system_variables[87], v13) & 1) != 0
&& v15 > *((_QWORD *)v21 + 1) )
{
v21[1] = global_system_variables[87];
v22[4] |= 1u;
}
else if ( (MYSQL_BIN_LOG::lookup_domain_in_binlog_state(&mysql_bin_log, *v21, v13) & 1) != 0 )
{
v21[1] = v14;
*((_QWORD *)v21 + 1) = v15;
}
else
{
if ( !v25 )
{
v25 = my_malloc(0LL, 8LL * *(_QWORD *)(v23 + 24), 16LL);
if ( !v25 )
{
*v29 = "Out of memory while checking slave start position";
v26 = 1041;
goto LABEL_41;
}
}
v5 = v24++;
*(_QWORD *)(v25 + 8LL * v5) = v22;
}
}
else
{
v9 = *(slave_connection_state **)(v30 + 416);
if ( (MYSQL_BIN_LOG::lookup_domain_in_binlog_state(&mysql_bin_log, *v21, v10) & 1) != 0 )
{
if ( (*(_BYTE *)(v30 + 606) & 1) == 0 || v11 >= *((_QWORD *)v21 + 1) )
{
if ( !v9
|| (v8 = (unsigned int *)slave_connection_state::find(v9, *v21)) != 0LL
&& ((MYSQL_BIN_LOG::find_in_binlog_state(&mysql_bin_log, *v8, v8[1], v19) & 1) == 0
|| v20 < *((_QWORD *)v8 + 1)) )
{
v3 = v21;
v4 = v28;
*v28 = *(_QWORD *)v21;
v4[1] = *((_QWORD *)v3 + 1);
give_error_start_pos_missing_in_binlog(&v26, v29, v28);
goto LABEL_41;
}
if ( v8 )
slave_connection_state::remove(v9, v8);
}
}
else
{
v22[4] |= 2u;
}
}
}
if ( v25 )
{
for ( i = 0; i < v24; ++i )
slave_connection_state::remove(v23, *(_QWORD *)(v25 + 8LL * i));
}
v26 = 0;
}
LABEL_41:
if ( v25 )
my_free(v25);
return v26;
}
| get_typelib:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xf8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x340]
ADD RSP,0x10
POP RBP
RET
|
/* Item_field::get_typelib() const */
void __thiscall Item_field::get_typelib(Item_field *this)
{
(**(code **)(**(long **)(this + 0xf8) + 0x340))();
return;
}
| |
53,784 | mysql_select_db_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_select_db_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_select_db,
(parms->mysql, parms->db),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_select_db_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movq %rax, %rdi
callq 0x5d8e7
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_select_db_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov rdi, rax
call mysql_select_db
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_select_db_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
result = mysql_select_db(*a1, a1[1]);
v1[2] = result;
*v1 = 0;
return result;
}
| mysql_select_db_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDI,RAX
CALL 0x0015d8e7
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_select_db_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_select_db(*param_1,param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
53,785 | my_hash_init2 | eloqsql/mysys/hash.c | my_bool
my_hash_init2(PSI_memory_key psi_key, HASH *hash, uint growth_size,
CHARSET_INFO *charset, ulong size, size_t key_offset,
size_t key_length, my_hash_get_key get_key,
my_hash_function hash_function,
void (*free_element)(void*), uint flags)
{
my_bool res;
DBUG_ENTER("my_hash_init2");
DBUG_PRINT("enter",("hash:%p size: %u", hash, (uint) size));
hash->records=0;
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->get_key=get_key;
hash->hash_function= hash_function ? hash_function : my_hash_sort;
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
res= init_dynamic_array2(psi_key, &hash->array, sizeof(HASH_LINK), NULL, size,
growth_size, MYF((flags & HASH_THREAD_SPECIFIC ?
MY_THREAD_SPECIFIC : 0)));
DBUG_RETURN(res);
} | O3 | c | my_hash_init2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %eax
movl 0x30(%rbp), %edx
movq 0x28(%rbp), %r10
movq 0x20(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x10(%rbp), %r14
movq $0x0, 0x18(%rsi)
movq %r9, (%rsi)
movq %r14, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
movq %rbx, 0x50(%rsi)
testq %r11, %r11
jne 0x96a7c
leaq -0x7c(%rip), %r11 # 0x96a00
movq %r11, 0x58(%rsi)
movq %r10, 0x60(%rsi)
movl %edx, 0x20(%rsi)
movq %rcx, 0x68(%rsi)
addq $0x28, %rsi
andl $0x2, %edx
shll $0xf, %edx
movq %rdx, (%rsp)
movl $0x10, %edx
xorl %ecx, %ecx
movl %eax, %r9d
callq 0x949e8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| my_hash_init2:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov eax, edx
mov edx, [rbp+arg_20]
mov r10, [rbp+arg_18]
mov r11, [rbp+arg_10]
mov rbx, [rbp+arg_8]
mov r14, [rbp+arg_0]
mov qword ptr [rsi+18h], 0
mov [rsi], r9
mov [rsi+8], r14
mov qword ptr [rsi+10h], 1
mov [rsi+50h], rbx
test r11, r11
jnz short loc_96A7C
lea r11, my_hash_sort
loc_96A7C:
mov [rsi+58h], r11
mov [rsi+60h], r10
mov [rsi+20h], edx
mov [rsi+68h], rcx
add rsi, 28h ; '('
and edx, 2
shl edx, 0Fh
mov [rsp+20h+var_20], rdx
mov edx, 10h
xor ecx, ecx
mov r9d, eax
call init_dynamic_array2
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long my_hash_init2(
long long a1,
long long a2,
unsigned 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)(long long, long long, long long); // r11
v11 = a9;
*(_QWORD *)(a2 + 24) = 0LL;
*(_QWORD *)a2 = a6;
*(_QWORD *)(a2 + 8) = a7;
*(_QWORD *)(a2 + 16) = 1LL;
*(_QWORD *)(a2 + 80) = a8;
if ( !a9 )
v11 = my_hash_sort;
*(_QWORD *)(a2 + 88) = v11;
*(_QWORD *)(a2 + 96) = a10;
*(_DWORD *)(a2 + 32) = a11;
*(_QWORD *)(a2 + 104) = a4;
return init_dynamic_array2(a1, a2 + 40, 0x10u, 0LL, a5, a3, (unsigned __int8)(a11 & 2) << 15);
}
| my_hash_init2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EAX,EDX
MOV EDX,dword ptr [RBP + 0x30]
MOV R10,qword ptr [RBP + 0x28]
MOV R11,qword ptr [RBP + 0x20]
MOV RBX,qword ptr [RBP + 0x18]
MOV R14,qword ptr [RBP + 0x10]
MOV qword ptr [RSI + 0x18],0x0
MOV qword ptr [RSI],R9
MOV qword ptr [RSI + 0x8],R14
MOV qword ptr [RSI + 0x10],0x1
MOV qword ptr [RSI + 0x50],RBX
TEST R11,R11
JNZ 0x00196a7c
LEA R11,[0x196a00]
LAB_00196a7c:
MOV qword ptr [RSI + 0x58],R11
MOV qword ptr [RSI + 0x60],R10
MOV dword ptr [RSI + 0x20],EDX
MOV qword ptr [RSI + 0x68],RCX
ADD RSI,0x28
AND EDX,0x2
SHL EDX,0xf
MOV qword ptr [RSP],RDX
MOV EDX,0x10
XOR ECX,ECX
MOV R9D,EAX
CALL 0x001949e8
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
void my_hash_init2(int8 param_1,int8 *param_2,int4 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
code *param_9,int8 param_10,uint param_11)
{
param_2[3] = 0;
*param_2 = param_6;
param_2[1] = param_7;
param_2[2] = 1;
param_2[10] = param_8;
if (param_9 == (code *)0x0) {
param_9 = my_hash_sort;
}
param_2[0xb] = param_9;
param_2[0xc] = param_10;
*(uint *)(param_2 + 4) = param_11;
param_2[0xd] = param_4;
init_dynamic_array2(param_1,param_2 + 5,0x10,0,param_5,param_3,(param_11 & 2) << 0xf);
return;
}
| |
53,786 | UnloadRenderTexture | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | void UnloadRenderTexture(RenderTexture2D target)
{
if (target.id > 0)
{
if (target.texture.id > 0)
{
// Color texture attached to FBO is deleted
rlUnloadTexture(target.texture.id);
}
// NOTE: Depth texture/renderbuffer is automatically
// queried and deleted before deleting framebuffer
rlUnloadFramebuffer(target.id);
}
} | O0 | c | UnloadRenderTexture:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x0, (%rax)
jbe 0x10a126
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x10a11b
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xb63c0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0xb69b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| UnloadRenderTexture:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, [rbp+arg_0]
mov [rbp+var_8], rax
cmp dword ptr [rax], 0
jbe short loc_10A126
mov rax, [rbp+var_8]
cmp dword ptr [rax+4], 0
jbe short loc_10A11B
mov rax, [rbp+var_8]
mov edi, [rax+4]
call rlUnloadTexture
loc_10A11B:
mov rax, [rbp+var_8]
mov edi, [rax]
call rlUnloadFramebuffer
loc_10A126:
add rsp, 10h
pop rbp
retn
| long long * UnloadRenderTexture(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long *result; // rax
result = &a7;
if ( (_DWORD)a7 )
{
if ( HIDWORD(a7) )
rlUnloadTexture(SHIDWORD(a7));
return (long long *)rlUnloadFramebuffer(a7);
}
return result;
}
| |||
53,787 | UnloadRenderTexture | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | void UnloadRenderTexture(RenderTexture2D target)
{
if (target.id > 0)
{
if (target.texture.id > 0)
{
// Color texture attached to FBO is deleted
rlUnloadTexture(target.texture.id);
}
// NOTE: Depth texture/renderbuffer is automatically
// queried and deleted before deleting framebuffer
rlUnloadFramebuffer(target.id);
}
} | O3 | c | UnloadRenderTexture:
pushq %rbx
movl 0x10(%rsp), %ebx
testl %ebx, %ebx
je 0x9bc28
leaq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
testl %edi, %edi
je 0x9bc20
callq 0x64b35
movl %ebx, %edi
popq %rbx
jmp 0x64f75
popq %rbx
retq
| UnloadRenderTexture:
push rbx
mov ebx, [rsp+8+arg_0]
test ebx, ebx
jz short loc_9BC28
lea rax, [rsp+8+arg_0]
mov edi, [rax+4]
test edi, edi
jz short loc_9BC20
call rlUnloadTexture
loc_9BC20:
mov edi, ebx
pop rbx
jmp rlUnloadFramebuffer
loc_9BC28:
pop rbx
retn
| long long UnloadRenderTexture(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long result; // rax
if ( (_DWORD)a7 )
{
if ( HIDWORD(a7) )
rlUnloadTexture(HIDWORD(a7));
return rlUnloadFramebuffer(a7);
}
return result;
}
| UnloadRenderTexture:
PUSH RBX
MOV EBX,dword ptr [RSP + 0x10]
TEST EBX,EBX
JZ 0x0019bc28
LEA RAX,[RSP + 0x10]
MOV EDI,dword ptr [RAX + 0x4]
TEST EDI,EDI
JZ 0x0019bc20
CALL 0x00164b35
LAB_0019bc20:
MOV EDI,EBX
POP RBX
JMP 0x00164f75
LAB_0019bc28:
POP RBX
RET
|
void UnloadRenderTexture(void)
{
int iStack0000000000000008;
int iStack000000000000000c;
if (iStack0000000000000008 != 0) {
if (iStack000000000000000c != 0) {
rlUnloadTexture();
}
rlUnloadFramebuffer(iStack0000000000000008);
return;
}
return;
}
| |
53,788 | 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 0x29220
movl 0x8c(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8c(%rbx)
cmpl $0x0, 0x88(%rbx)
je 0xa53b8
leaq 0x58(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29430
cmpl $0x0, 0x88(%rbx)
jne 0xa539c
movl 0x8c(%rbx), %eax
decl %eax
movl $0xffffffff, 0x88(%rbx) # imm = 0xFFFFFFFF
movl %eax, 0x8c(%rbx)
movq %rbx, %rdi
callq 0x291e0
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_A53B8
lea r14, [rbx+58h]
loc_A539C:
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
cmp dword ptr [rbx+88h], 0
jnz short loc_A539C
mov eax, [rbx+8Ch]
dec eax
loc_A53B8:
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 0x00129220
MOV EAX,dword ptr [RBX + 0x8c]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBX + 0x8c],ECX
CMP dword ptr [RBX + 0x88],0x0
JZ 0x001a53b8
LEA R14,[RBX + 0x58]
LAB_001a539c:
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129430
CMP dword ptr [RBX + 0x88],0x0
JNZ 0x001a539c
MOV EAX,dword ptr [RBX + 0x8c]
DEC EAX
LAB_001a53b8:
MOV dword ptr [RBX + 0x88],0xffffffff
MOV dword ptr [RBX + 0x8c],EAX
MOV RDI,RBX
CALL 0x001291e0
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;
}
| |
53,789 | DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat>> const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&) | Depths-CPP/include/depth_anything.hpp | std::vector<cv::Mat> DepthAnything::preprocessBatch(const std::vector<cv::Mat> &images, std::vector<float> &blob, std::vector<int64_t> &inputTensorShape)
{
if (images.empty())
{
throw std::runtime_error("Input images vector is empty.");
}
// Determine common dimensions for all images in the batch
cv::Size batchSize = determineBatchDimensions(images);
// Setup input tensor shape for the batch
int batchCount = static_cast<int>(images.size());
inputTensorShape = {batchCount, 3, batchSize.height, batchSize.width};
// Pre-allocate memory for the blob
blob.reserve(batchCount * 3 * batchSize.height * batchSize.width);
std::vector<cv::Mat> preprocessedImages;
preprocessedImages.reserve(images.size());
// Process each image
for (const cv::Mat &img : images)
{
if (img.empty())
{
throw std::runtime_error("One of the input images is empty.");
}
// Resize image to match batch dimensions
cv::Mat resizedImage = DepthUtils::resize_no_padding(img, batchSize.width, batchSize.height);
preprocessedImages.push_back(resizedImage);
// Convert to float and normalize
cv::Mat floatImage;
resizedImage.convertTo(floatImage, CV_32FC3, 1.0f / 255.0f);
// Apply mean/std normalization
for (int c = 0; c < 3; ++c)
{
floatImage.forEach<cv::Vec3f>([c, this](cv::Vec3f &pixel, const int *) -> void
{ pixel[c] = (pixel[c] - mean[c]) / std[c]; });
}
// Convert from HWC to CHW and add to blob
std::vector<cv::Mat> chw;
cv::split(floatImage, chw);
for (auto &channel : chw)
{
blob.insert(blob.end(), (float *)channel.datastart, (float *)channel.dataend);
}
}
return preprocessedImages;
} | O0 | cpp | DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat>> const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&):
subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x240(%rsp), %rdi
callq 0x2d430
testb $0x1, %al
jne 0x24a1c
jmp 0x24a7a
movl $0x10, %edi
callq 0x23230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x30(%rsp)
leaq 0x1b6ef(%rip), %rsi # 0x40127
callq 0x23060
jmp 0x24a3f
movq 0x30(%rsp), %rdi
movq 0x29565(%rip), %rsi # 0x4dfb0
movq 0x295a6(%rip), %rdx # 0x4dff8
callq 0x23420
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
callq 0x232c0
jmp 0x24fe7
movq 0x48(%rsp), %rsi
movq 0x240(%rsp), %rdx
leaq 0x21c(%rsp), %rdi
callq 0x25000
movq 0x240(%rsp), %rdi
callq 0x2d480
movl %eax, 0x218(%rsp)
movslq 0x218(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq $0x3, 0x1f0(%rsp)
movslq 0x220(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movslq 0x21c(%rsp), %rax
movq %rax, 0x200(%rsp)
leaq 0x1e8(%rsp), %rax
movq %rax, 0x208(%rsp)
movq $0x4, 0x210(%rsp)
movq 0x230(%rsp), %rdi
movq 0x208(%rsp), %rsi
movq 0x210(%rsp), %rdx
callq 0x2cf60
movq 0x238(%rsp), %rdi
movl 0x218(%rsp), %ecx
movl 0x21c(%rsp), %eax
movl 0x220(%rsp), %edx
imull %edx, %ecx
imull %eax, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rsi
callq 0x2d4a0
movq 0x38(%rsp), %rdi
movb $0x0, 0x1e7(%rsp)
callq 0x2d140
movq 0x240(%rsp), %rdi
callq 0x2d480
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x2d5b0
jmp 0x24b7b
movq 0x240(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x2d6f0
movq %rax, 0x1d0(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x2d720
movq %rax, 0x1c8(%rsp)
leaq 0x1d0(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x2d750
testb $0x1, %al
jne 0x24bd3
jmp 0x24fb4
leaq 0x1d0(%rsp), %rdi
callq 0x2d790
movq %rax, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rdi
callq 0x23250
movb %al, 0x2f(%rsp)
jmp 0x24bfb
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x24c05
jmp 0x24c81
movl $0x10, %edi
callq 0x23230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x1b524(%rip), %rsi # 0x40145
callq 0x23060
jmp 0x24c28
movq 0x20(%rsp), %rdi
movq 0x2937c(%rip), %rsi # 0x4dfb0
movq 0x293bd(%rip), %rdx # 0x4dff8
callq 0x23420
jmp 0x24ff4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x24fdd
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
callq 0x232c0
jmp 0x24fdd
movq 0x1c0(%rsp), %rsi
movl 0x21c(%rsp), %edx
movl 0x220(%rsp), %ecx
leaq 0x160(%rsp), %rdi
callq 0x2cfc0
jmp 0x24ca6
movq 0x38(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x2d7a0
jmp 0x24cba
leaq 0x100(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x23070
movq 0x18(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
callq 0x2d0d0
jmp 0x24ce0
leaq 0x160(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
movl $0x15, %edx
vmovsd 0x1b30b(%rip), %xmm0 # 0x40008
vpxor %xmm1, %xmm1, %xmm1
callq 0x236d0
jmp 0x24d08
leaq 0xe8(%rsp), %rdi
callq 0x2d130
movl $0x0, 0xe4(%rsp)
cmpl $0x3, 0xe4(%rsp)
jge 0x24dcd
movq 0x48(%rsp), %rax
movl 0xe4(%rsp), %ecx
movl %ecx, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
leaq 0x100(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x25150
jmp 0x24d60
jmp 0x24d62
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
jmp 0x24d20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x24fa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x24f98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x2d130
jmp 0x24f98
leaq 0xb8(%rsp), %rdi
callq 0x2d140
leaq 0xa0(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x2d150
jmp 0x24df1
leaq 0x88(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x2d190
jmp 0x24e08
leaq 0xa0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x235a0
jmp 0x24e1f
leaq 0x88(%rsp), %rdi
callq 0x2d130
leaq 0xa0(%rsp), %rdi
callq 0x2d1d0
leaq 0xb8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2d1e0
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2d210
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2d240
testb $0x1, %al
jne 0x24e85
jmp 0x24f52
leaq 0x78(%rsp), %rdi
callq 0x2d280
movq %rax, 0x68(%rsp)
movq 0x238(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2d340
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2d370
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq 0x60(%rsp), %rsi
callq 0x2d290
movq %rax, 0x10(%rsp)
jmp 0x24edd
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2d3b0
jmp 0x24e6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x24f8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x24f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x2d130
leaq 0xa0(%rsp), %rdi
callq 0x2d1d0
jmp 0x24f8b
leaq 0xb8(%rsp), %rdi
callq 0x2d3d0
leaq 0x100(%rsp), %rdi
callq 0x230a0
leaq 0x160(%rsp), %rdi
callq 0x230a0
leaq 0x1d0(%rsp), %rdi
callq 0x2d810
jmp 0x24bb5
leaq 0xb8(%rsp), %rdi
callq 0x2d3d0
leaq 0x100(%rsp), %rdi
callq 0x230a0
leaq 0x160(%rsp), %rdi
callq 0x230a0
jmp 0x24fdd
movb $0x1, 0x1e7(%rsp)
testb $0x1, 0x1e7(%rsp)
jne 0x24fd0
movq 0x38(%rsp), %rdi
callq 0x2d3d0
movq 0x40(%rsp), %rax
addq $0x258, %rsp # imm = 0x258
retq
movq 0x38(%rsp), %rdi
callq 0x2d3d0
movq 0x228(%rsp), %rdi
callq 0x23430
nopw %cs:(%rax,%rax)
| _ZN13DepthAnything15preprocessBatchERKSt6vectorIN2cv3MatESaIS2_EERS0_IfSaIfEERS0_IlSaIlEE:
sub rsp, 258h
mov [rsp+258h+var_220], rdi
mov rax, rdi
mov [rsp+258h+var_218], rax
mov [rsp+258h+var_8], rdi
mov [rsp+258h+var_10], rsi
mov [rsp+258h+var_18], rdx
mov [rsp+258h+var_20], rcx
mov [rsp+258h+var_28], r8
mov rax, [rsp+258h+var_10]
mov [rsp+258h+var_210], rax
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE5emptyEv; std::vector<cv::Mat>::empty(void)
test al, 1
jnz short loc_24A1C
jmp short loc_24A7A
loc_24A1C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+258h+var_228], rax
lea rsi, aInputImagesVec; "Input images vector is empty."
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_24A3F:
mov rdi, [rsp+258h+var_228]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+258h+var_228]; void *
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
call ___cxa_free_exception
jmp loc_24FE7
loc_24A7A:
mov rsi, [rsp+258h+var_210]
mov rdx, [rsp+258h+var_18]
lea rdi, [rsp+258h+var_3C]
call _ZN13DepthAnything24determineBatchDimensionsERKSt6vectorIN2cv3MatESaIS2_EE; DepthAnything::determineBatchDimensions(std::vector<cv::Mat> const&)
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE4sizeEv; std::vector<cv::Mat>::size(void)
mov [rsp+258h+var_40], eax
movsxd rax, [rsp+258h+var_40]
mov [rsp+258h+var_70], rax
mov [rsp+258h+var_68], 3
movsxd rax, [rsp+258h+var_38]
mov [rsp+258h+var_60], rax
movsxd rax, [rsp+258h+var_3C]
mov [rsp+258h+var_58], rax
lea rax, [rsp+258h+var_70]
mov [rsp+258h+var_50], rax
mov [rsp+258h+var_48], 4
mov rdi, [rsp+258h+var_28]
mov rsi, [rsp+258h+var_50]
mov rdx, [rsp+258h+var_48]
call _ZNSt6vectorIlSaIlEEaSESt16initializer_listIlE; std::vector<long>::operator=(std::initializer_list<long>)
mov rdi, [rsp+258h+var_20]
mov ecx, [rsp+258h+var_40]
mov eax, [rsp+258h+var_3C]
mov edx, [rsp+258h+var_38]
imul ecx, edx
imul ecx, eax
mov eax, ecx
lea eax, [rax+rax*2]
movsxd rsi, eax
call _ZNSt6vectorIfSaIfEE7reserveEm; std::vector<float>::reserve(ulong)
mov rdi, [rsp+258h+var_220]
mov [rsp+258h+var_71], 0
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE4sizeEv; std::vector<cv::Mat>::size(void)
mov rdi, [rsp+258h+var_220]
mov rsi, rax
call _ZNSt6vectorIN2cv3MatESaIS1_EE7reserveEm; std::vector<cv::Mat>::reserve(ulong)
jmp short $+2
loc_24B7B:
mov rax, [rsp+258h+var_18]
mov [rsp+258h+var_80], rax
mov rdi, [rsp+258h+var_80]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE5beginEv; std::vector<cv::Mat>::begin(void)
mov [rsp+258h+var_88], rax
mov rdi, [rsp+258h+var_80]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE3endEv; std::vector<cv::Mat>::end(void)
mov [rsp+258h+var_90], rax
loc_24BB5:
lea rdi, [rsp+258h+var_88]
lea rsi, [rsp+258h+var_90]
call _ZN9__gnu_cxxneIPKN2cv3MatESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<cv::Mat const*,std::vector<cv::Mat>>(__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>> const&,__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>> const&)
test al, 1
jnz short loc_24BD3
jmp loc_24FB4
loc_24BD3:
lea rdi, [rsp+258h+var_88]
call _ZNK9__gnu_cxx17__normal_iteratorIPKN2cv3MatESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator*(void)
mov [rsp+258h+var_98], rax
mov rdi, [rsp+258h+var_98]; this
call __ZNK2cv3Mat5emptyEv; cv::Mat::empty(void)
mov [rsp+258h+var_229], al
jmp short $+2
loc_24BFB:
mov al, [rsp+258h+var_229]
test al, 1
jnz short loc_24C05
jmp short loc_24C81
loc_24C05:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+258h+var_238], rax
lea rsi, aOneOfTheInputI; "One of the input images is empty."
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_24C28:
mov rdi, [rsp+258h+var_238]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_24FF4
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_24FDD
mov rdi, [rsp+258h+var_238]; void *
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
call ___cxa_free_exception
jmp loc_24FDD
loc_24C81:
mov rsi, [rsp+258h+var_98]; cv::Mat *
mov edx, [rsp+258h+var_3C]; int
mov ecx, [rsp+258h+var_38]; int
lea rdi, [rsp+258h+var_F8]; this
call _ZN10DepthUtils17resize_no_paddingERKN2cv3MatEii; DepthUtils::resize_no_padding(cv::Mat const&,int,int)
jmp short $+2
loc_24CA6:
mov rdi, [rsp+258h+var_220]
lea rsi, [rsp+258h+var_F8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE9push_backERKS1_; std::vector<cv::Mat>::push_back(cv::Mat const&)
jmp short $+2
loc_24CBA:
lea rdi, [rsp+258h+var_158]; this
mov [rsp+258h+var_240], rdi
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
mov rsi, [rsp+258h+var_240]; cv::Mat *
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_24CE0:
lea rdi, [rsp+258h+var_F8]
lea rsi, [rsp+258h+var_170]
mov edx, 15h
vmovsd xmm0, cs:qword_40008
vpxor xmm1, xmm1, xmm1
call __ZNK2cv3Mat9convertToERKNS_12_OutputArrayEidd; cv::Mat::convertTo(cv::_OutputArray const&,int,double,double)
jmp short $+2
loc_24D08:
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
mov [rsp+258h+var_174], 0
loc_24D20:
cmp [rsp+258h+var_174], 3
jge loc_24DCD
mov rax, [rsp+258h+var_210]
mov ecx, [rsp+258h+var_174]
mov [rsp+258h+var_188], ecx
mov [rsp+258h+var_180], rax
lea rdi, [rsp+258h+var_158]
lea rsi, [rsp+258h+var_188]
call _ZN2cv3Mat7forEachINS_3VecIfLi3EEEZN13DepthAnything15preprocessBatchERKSt6vectorIS0_SaIS0_EERS5_IfSaIfEERS5_IlSaIlEEE3$_0EEvRKT0_; cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0>(DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0 const&)
jmp short $+2
loc_24D60:
jmp short $+2
loc_24D62:
mov eax, [rsp+258h+var_174]
add eax, 1
mov [rsp+258h+var_174], eax
jmp short loc_24D20
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_24FA5
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_24F98
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
jmp loc_24F98
loc_24DCD:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
lea rdi, [rsp+258h+var_1B8]; this
lea rsi, [rsp+258h+var_158]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_24DF1:
lea rdi, [rsp+258h+var_1D0]
lea rsi, [rsp+258h+var_1A0]
call _ZN2cv12_OutputArrayC2ERSt6vectorINS_3MatESaIS2_EE; cv::_OutputArray::_OutputArray(std::vector<cv::Mat> &)
jmp short $+2
loc_24E08:
lea rdi, [rsp+258h+var_1B8]
lea rsi, [rsp+258h+var_1D0]
call __ZN2cv5splitERKNS_11_InputArrayERKNS_12_OutputArrayE; cv::split(cv::_InputArray const&,cv::_OutputArray const&)
jmp short $+2
loc_24E1F:
lea rdi, [rsp+258h+var_1D0]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+258h+var_1B8]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rax, [rsp+258h+var_1A0]
mov [rsp+258h+var_1D8], rax
mov rdi, [rsp+258h+var_1D8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE5beginEv; std::vector<cv::Mat>::begin(void)
mov [rsp+258h+var_1E0], rax
mov rdi, [rsp+258h+var_1D8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE3endEv; std::vector<cv::Mat>::end(void)
mov [rsp+258h+var_1E8], rax
loc_24E6D:
lea rdi, [rsp+258h+var_1E0]
lea rsi, [rsp+258h+var_1E8]
call _ZN9__gnu_cxxneIPN2cv3MatESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&,__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&)
test al, 1
jnz short loc_24E85
jmp loc_24F52
loc_24E85:
lea rdi, [rsp+258h+var_1E0]
call _ZNK9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(void)
mov [rsp+258h+var_1F0], rax
mov rdi, [rsp+258h+var_20]
mov [rsp+258h+var_250], rdi
call _ZNSt6vectorIfSaIfEE3endEv; std::vector<float>::end(void)
mov [rsp+258h+var_200], rax
lea rdi, [rsp+258h+var_1F8]
lea rsi, [rsp+258h+var_200]
call _ZN9__gnu_cxx17__normal_iteratorIPKfSt6vectorIfSaIfEEEC2IPfEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameIS9_S8_EE7__valueES5_E6__typeEEE
mov rdi, [rsp+258h+var_250]
mov rax, [rsp+258h+var_1F0]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov rsi, [rsp+258h+var_1F8]
call _ZNSt6vectorIfSaIfEE6insertIPfvEEN9__gnu_cxx17__normal_iteratorIS3_S1_EENS5_IPKfS1_EET_SA_; std::vector<float>::insert<float *,void>(__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,float *,float *)
mov [rsp+258h+var_248], rax
jmp short $+2
loc_24EDD:
mov rax, [rsp+258h+var_248]
mov [rsp+258h+var_208], rax
lea rdi, [rsp+258h+var_1E0]
call _ZN9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(void)
jmp loc_24E6D
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp short loc_24F8B
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp short loc_24F43
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
lea rdi, [rsp+258h+var_1D0]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_24F43:
lea rdi, [rsp+258h+var_1B8]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp short loc_24F8B
loc_24F52:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
lea rdi, [rsp+258h+var_158]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+258h+var_F8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+258h+var_88]
call _ZN9__gnu_cxx17__normal_iteratorIPKN2cv3MatESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator++(void)
jmp loc_24BB5
loc_24F8B:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_24F98:
lea rdi, [rsp+258h+var_158]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
loc_24FA5:
lea rdi, [rsp+258h+var_F8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_24FDD
loc_24FB4:
mov [rsp+258h+var_71], 1
test [rsp+258h+var_71], 1
jnz short loc_24FD0
mov rdi, [rsp+258h+var_220]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_24FD0:
mov rax, [rsp+258h+var_218]
add rsp, 258h
retn
loc_24FDD:
mov rdi, [rsp+258h+var_220]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_24FE7:
mov rdi, [rsp+258h+var_30]
call __Unwind_Resume
loc_24FF4:
nop word ptr [rax+rax+00000000h]
| long long DepthAnything::preprocessBatch(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
double a6,
__m128 _XMM1)
{
long long v7; // rax
const cv::_OutputArray *v9; // rdx
long long v11; // [rsp+8h] [rbp-250h]
std::runtime_error *v12; // [rsp+20h] [rbp-238h]
std::runtime_error *exception; // [rsp+30h] [rbp-228h]
long long v14; // [rsp+58h] [rbp-200h] BYREF
long long v15; // [rsp+60h] [rbp-1F8h] BYREF
long long v16; // [rsp+68h] [rbp-1F0h]
long long v17; // [rsp+70h] [rbp-1E8h] BYREF
long long v18; // [rsp+78h] [rbp-1E0h] BYREF
_BYTE *v19; // [rsp+80h] [rbp-1D8h]
_BYTE v20[24]; // [rsp+88h] [rbp-1D0h] BYREF
_BYTE v21[24]; // [rsp+A0h] [rbp-1B8h] BYREF
_BYTE v22[24]; // [rsp+B8h] [rbp-1A0h] BYREF
int v23; // [rsp+D0h] [rbp-188h] BYREF
long long v24; // [rsp+D8h] [rbp-180h]
int i; // [rsp+E4h] [rbp-174h]
_BYTE v26[24]; // [rsp+E8h] [rbp-170h] BYREF
_BYTE v27[96]; // [rsp+100h] [rbp-158h] BYREF
_BYTE v28[96]; // [rsp+160h] [rbp-F8h] BYREF
cv::Mat *v29; // [rsp+1C0h] [rbp-98h]
long long v30; // [rsp+1C8h] [rbp-90h] BYREF
long long v31; // [rsp+1D0h] [rbp-88h] BYREF
long long v32; // [rsp+1D8h] [rbp-80h]
char v33; // [rsp+1E7h] [rbp-71h]
_QWORD v34[6]; // [rsp+1E8h] [rbp-70h] BYREF
int v35; // [rsp+218h] [rbp-40h]
int v36; // [rsp+21Ch] [rbp-3Ch] BYREF
int v37; // [rsp+220h] [rbp-38h]
long long v38; // [rsp+230h] [rbp-28h]
long long v39; // [rsp+238h] [rbp-20h]
long long v40; // [rsp+240h] [rbp-18h]
long long v41; // [rsp+248h] [rbp-10h]
long long v42; // [rsp+250h] [rbp-8h]
v42 = a1;
v41 = a2;
v40 = a3;
v39 = a4;
v38 = a5;
if ( (std::vector<cv::Mat>::empty(a3) & 1) != 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Input images vector is empty.");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
DepthAnything::determineBatchDimensions(&v36, a2, v40);
v35 = std::vector<cv::Mat>::size(v40);
v34[0] = v35;
v34[1] = 3LL;
v34[2] = v37;
v34[3] = v36;
v34[4] = v34;
v34[5] = 4LL;
std::vector<long>::operator=(v38, v34, 4LL);
std::vector<float>::reserve(v39, 3 * v36 * v37 * v35);
v33 = 0;
std::vector<cv::Mat>::vector(a1);
v7 = std::vector<cv::Mat>::size(v40);
std::vector<cv::Mat>::reserve(a1, v7);
v32 = v40;
v31 = std::vector<cv::Mat>::begin(v40);
v30 = std::vector<cv::Mat>::end(v32);
while ( (__gnu_cxx::operator!=<cv::Mat const*,std::vector<cv::Mat>>(&v31, &v30) & 1) != 0 )
{
v29 = (cv::Mat *)__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator*(&v31);
if ( (cv::Mat::empty(v29) & 1) != 0 )
{
v12 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v12, "One of the input images is empty.");
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
DepthUtils::resize_no_padding((DepthUtils *)v28, v29, v36, v37);
std::vector<cv::Mat>::push_back(a1, v28);
cv::Mat::Mat((cv::Mat *)v27);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v26, (cv::Mat *)v27);
__asm
{
vmovsd xmm0, cs:qword_40008
vpxor xmm1, xmm1, xmm1
}
cv::Mat::convertTo((cv::Mat *)v28, (const cv::_OutputArray *)v26, 21, *(double *)&_XMM0, *(double *)_XMM1.m128_u64);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v26);
for ( i = 0; i < 3; ++i )
{
v23 = i;
v24 = a2;
cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0>(
v27,
&v23);
}
std::vector<cv::Mat>::vector(v22);
cv::_InputArray::_InputArray((cv::_InputArray *)v21, (const cv::Mat *)v27);
cv::_OutputArray::_OutputArray(v20, v22);
cv::split((cv *)v21, (const cv::_InputArray *)v20, v9);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v20);
cv::_InputArray::~_InputArray((cv::_InputArray *)v21);
v19 = v22;
v18 = std::vector<cv::Mat>::begin(v22);
v17 = std::vector<cv::Mat>::end(v19);
while ( (__gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(&v18, &v17) & 1) != 0 )
{
v16 = __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(&v18);
v11 = v39;
v14 = std::vector<float>::end();
__gnu_cxx::__normal_iterator<float const*,std::vector<float>>::__normal_iterator<float *>(&v15, &v14);
std::vector<float>::insert<float *,void>(v11, v15, *(_QWORD *)(v16 + 24), *(_QWORD *)(v16 + 32));
__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(&v18);
}
std::vector<cv::Mat>::~vector(v22);
cv::Mat::~Mat((cv::Mat *)v27);
cv::Mat::~Mat((cv::Mat *)v28);
__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator++(&v31);
}
return a1;
}
| preprocessBatch:
SUB RSP,0x258
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x250],RDI
MOV qword ptr [RSP + 0x248],RSI
MOV qword ptr [RSP + 0x240],RDX
MOV qword ptr [RSP + 0x238],RCX
MOV qword ptr [RSP + 0x230],R8
MOV RAX,qword ptr [RSP + 0x248]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0012d430
TEST AL,0x1
JNZ 0x00124a1c
JMP 0x00124a7a
LAB_00124a1c:
MOV EDI,0x10
CALL 0x00123230
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
LAB_00124a31:
LEA RSI,[0x140127]
CALL 0x00123060
LAB_00124a3d:
JMP 0x00124a3f
LAB_00124a3f:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [0x0014dfb0]
MOV RDX,qword ptr [0x0014dff8]
CALL 0x00123420
LAB_00124a7a:
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x240]
LEA RDI,[RSP + 0x21c]
CALL 0x00125000
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0012d480
MOV dword ptr [RSP + 0x218],EAX
MOVSXD RAX,dword ptr [RSP + 0x218]
MOV qword ptr [RSP + 0x1e8],RAX
MOV qword ptr [RSP + 0x1f0],0x3
MOVSXD RAX,dword ptr [RSP + 0x220]
MOV qword ptr [RSP + 0x1f8],RAX
MOVSXD RAX,dword ptr [RSP + 0x21c]
MOV qword ptr [RSP + 0x200],RAX
LEA RAX,[RSP + 0x1e8]
MOV qword ptr [RSP + 0x208],RAX
MOV qword ptr [RSP + 0x210],0x4
MOV RDI,qword ptr [RSP + 0x230]
MOV RSI,qword ptr [RSP + 0x208]
MOV RDX,qword ptr [RSP + 0x210]
CALL 0x0012cf60
MOV RDI,qword ptr [RSP + 0x238]
MOV ECX,dword ptr [RSP + 0x218]
MOV EAX,dword ptr [RSP + 0x21c]
MOV EDX,dword ptr [RSP + 0x220]
IMUL ECX,EDX
IMUL ECX,EAX
MOV EAX,ECX
LEA EAX,[RAX + RAX*0x2]
MOVSXD RSI,EAX
CALL 0x0012d4a0
MOV RDI,qword ptr [RSP + 0x38]
MOV byte ptr [RSP + 0x1e7],0x0
CALL 0x0012d140
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0012d480
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RAX
LAB_00124b74:
CALL 0x0012d5b0
JMP 0x00124b7b
LAB_00124b7b:
MOV RAX,qword ptr [RSP + 0x240]
MOV qword ptr [RSP + 0x1d8],RAX
MOV RDI,qword ptr [RSP + 0x1d8]
CALL 0x0012d6f0
MOV qword ptr [RSP + 0x1d0],RAX
MOV RDI,qword ptr [RSP + 0x1d8]
CALL 0x0012d720
MOV qword ptr [RSP + 0x1c8],RAX
LAB_00124bb5:
LEA RDI,[RSP + 0x1d0]
LEA RSI,[RSP + 0x1c8]
CALL 0x0012d750
TEST AL,0x1
JNZ 0x00124bd3
JMP 0x00124fb4
LAB_00124bd3:
LEA RDI,[RSP + 0x1d0]
CALL 0x0012d790
MOV qword ptr [RSP + 0x1c0],RAX
MOV RDI,qword ptr [RSP + 0x1c0]
CALL 0x00123250
LAB_00124bf5:
MOV byte ptr [RSP + 0x2f],AL
JMP 0x00124bfb
LAB_00124bfb:
MOV AL,byte ptr [RSP + 0x2f]
TEST AL,0x1
JNZ 0x00124c05
JMP 0x00124c81
LAB_00124c05:
MOV EDI,0x10
CALL 0x00123230
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
LAB_00124c1a:
LEA RSI,[0x140145]
CALL 0x00123060
JMP 0x00124c28
LAB_00124c28:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [0x0014dfb0]
MOV RDX,qword ptr [0x0014dff8]
CALL 0x00123420
LAB_00124c81:
MOV RSI,qword ptr [RSP + 0x1c0]
MOV EDX,dword ptr [RSP + 0x21c]
MOV ECX,dword ptr [RSP + 0x220]
LAB_00124c97:
LEA RDI,[RSP + 0x160]
CALL 0x0012cfc0
JMP 0x00124ca6
LAB_00124ca6:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x160]
CALL 0x0012d7a0
JMP 0x00124cba
LAB_00124cba:
LEA RDI,[RSP + 0x100]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00123070
MOV RSI,qword ptr [RSP + 0x18]
LAB_00124cd1:
LEA RDI,[RSP + 0xe8]
CALL 0x0012d0d0
JMP 0x00124ce0
LAB_00124ce0:
LEA RDI,[RSP + 0x160]
LEA RSI,[RSP + 0xe8]
MOV EDX,0x15
VMOVSD XMM0,qword ptr [0x00140008]
VPXOR XMM1,XMM1,XMM1
CALL 0x001236d0
JMP 0x00124d08
LAB_00124d08:
LEA RDI,[RSP + 0xe8]
CALL 0x0012d130
MOV dword ptr [RSP + 0xe4],0x0
LAB_00124d20:
CMP dword ptr [RSP + 0xe4],0x3
JGE 0x00124dcd
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0xe4]
MOV dword ptr [RSP + 0xd0],ECX
MOV qword ptr [RSP + 0xd8],RAX
LAB_00124d49:
LEA RDI,[RSP + 0x100]
LEA RSI,[RSP + 0xd0]
CALL 0x00125150
JMP 0x00124d60
LAB_00124d60:
JMP 0x00124d62
LAB_00124d62:
MOV EAX,dword ptr [RSP + 0xe4]
ADD EAX,0x1
MOV dword ptr [RSP + 0xe4],EAX
JMP 0x00124d20
LAB_00124dcd:
LEA RDI,[RSP + 0xb8]
CALL 0x0012d140
LAB_00124dda:
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x100]
CALL 0x0012d150
JMP 0x00124df1
LAB_00124df1:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0xb8]
CALL 0x0012d190
JMP 0x00124e08
LAB_00124e08:
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x88]
CALL 0x001235a0
JMP 0x00124e1f
LAB_00124e1f:
LEA RDI,[RSP + 0x88]
CALL 0x0012d130
LEA RDI,[RSP + 0xa0]
CALL 0x0012d1d0
LEA RAX,[RSP + 0xb8]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0012d1e0
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0012d210
MOV qword ptr [RSP + 0x70],RAX
LAB_00124e6d:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x70]
CALL 0x0012d240
TEST AL,0x1
JNZ 0x00124e85
JMP 0x00124f52
LAB_00124e85:
LEA RDI,[RSP + 0x78]
CALL 0x0012d280
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x238]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0012d340
MOV qword ptr [RSP + 0x58],RAX
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x58]
CALL 0x0012d370
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RSP + 0x60]
LAB_00124ed1:
CALL 0x0012d290
LAB_00124ed6:
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00124edd
LAB_00124edd:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x78]
CALL 0x0012d3b0
JMP 0x00124e6d
LAB_00124f52:
LEA RDI,[RSP + 0xb8]
CALL 0x0012d3d0
LEA RDI,[RSP + 0x100]
CALL 0x001230a0
LEA RDI,[RSP + 0x160]
CALL 0x001230a0
LEA RDI,[RSP + 0x1d0]
CALL 0x0012d810
JMP 0x00124bb5
LAB_00124fb4:
MOV byte ptr [RSP + 0x1e7],0x1
TEST byte ptr [RSP + 0x1e7],0x1
JNZ 0x00124fd0
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0012d3d0
LAB_00124fd0:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x258
RET
|
/* WARNING: Removing unreachable block (ram,0x00124fc6) */
/* DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat> > const&,
std::vector<float, std::allocator<float> >&, std::vector<long, std::allocator<long> >&) */
vector * DepthAnything::preprocessBatch(vector *param_1,vector *param_2,vector *param_3)
{
vector<float,std::allocator<float>> *pvVar1;
bool bVar2;
byte bVar3;
ulong uVar4;
runtime_error *prVar5;
vector<float,std::allocator<float>> *in_RCX;
vector<long,std::allocator<long>> *in_R8;
int8 local_200;
int8 local_1f8;
long local_1f0;
int8 local_1e8;
int8 local_1e0;
vector<cv::Mat,std::allocator<cv::Mat>> *local_1d8;
_OutputArray local_1d0 [24];
_InputArray local_1b8 [24];
vector<cv::Mat,std::allocator<cv::Mat>> local_1a0 [24];
int local_188 [2];
vector *local_180;
int local_174;
_OutputArray local_170 [24];
Mat local_158 [96];
DepthUtils local_f8 [96];
Mat *local_98;
int8 local_90;
int8 local_88;
vector<cv::Mat,std::allocator<cv::Mat>> *local_80;
int1 local_71;
long local_70 [3];
long local_58;
long *local_50;
int8 local_48;
int local_40;
int local_3c;
int local_38;
vector<long,std::allocator<long>> *local_28;
vector<float,std::allocator<float>> *local_20;
vector *local_18;
vector *local_10;
vector *local_8;
local_28 = in_R8;
local_20 = in_RCX;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar4 = std::vector<cv::Mat,std::allocator<cv::Mat>>::empty
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_3);
if ((uVar4 & 1) != 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00124a31 to 00124a3c has its CatchHandler @ 00124a57 */
std::runtime_error::runtime_error(prVar5,"Input images vector is empty.");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_0014dfb0,PTR__runtime_error_0014dff8);
}
determineBatchDimensions((vector *)&local_3c);
local_40 = std::vector<cv::Mat,std::allocator<cv::Mat>>::size
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
local_70[0] = (long)local_40;
local_70[1] = 3;
local_70[2] = (long)local_38;
local_58 = (long)local_3c;
local_50 = local_70;
local_48 = 4;
std::vector<long,std::allocator<long>>::operator=(local_28,local_50,4);
std::vector<float,std::allocator<float>>::reserve
(local_20,(long)(local_40 * local_38 * local_3c * 3));
local_71 = 0;
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1);
uVar4 = std::vector<cv::Mat,std::allocator<cv::Mat>>::size
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
/* try { // try from 00124b74 to 00124bf4 has its CatchHandler @ 00124c45 */
std::vector<cv::Mat,std::allocator<cv::Mat>>::reserve
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,uVar4);
local_80 = (vector<cv::Mat,std::allocator<cv::Mat>> *)local_18;
local_88 = std::vector<cv::Mat,std::allocator<cv::Mat>>::begin
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
local_90 = std::vector<cv::Mat,std::allocator<cv::Mat>>::end(local_80);
while( true ) {
bVar2 = __gnu_cxx::operator!=((__normal_iterator *)&local_88,(__normal_iterator *)&local_90);
if (!bVar2) {
return param_1;
}
local_98 = (Mat *)__gnu_cxx::
__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
::operator*((__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
*)&local_88);
bVar3 = cv::Mat::empty();
if ((bVar3 & 1) != 0) break;
/* try { // try from 00124c97 to 00124ca3 has its CatchHandler @ 00124c45 */
DepthUtils::resize_no_padding(local_f8,local_98,local_3c,local_38);
/* try { // try from 00124ca6 to 00124cb7 has its CatchHandler @ 00124d75 */
std::vector<cv::Mat,std::allocator<cv::Mat>>::push_back
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,(Mat *)local_f8);
cv::Mat::Mat(local_158);
/* try { // try from 00124cd1 to 00124cdd has its CatchHandler @ 00124d8e */
cv::_OutputArray::_OutputArray(local_170,local_158);
/* try { // try from 00124ce0 to 00124d05 has its CatchHandler @ 00124da7 */
cv::Mat::convertTo((_OutputArray *)local_f8,(int)local_170,DAT_00140008,0.0);
cv::_OutputArray::~_OutputArray(local_170);
for (local_174 = 0; local_174 < 3; local_174 = local_174 + 1) {
local_188[0] = local_174;
/* try { // try from 00124d49 to 00124d5d has its CatchHandler @ 00124d8e */
local_180 = param_2;
cv::Mat::
forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat,std::allocator<cv::Mat>>const&,std::vector<float,std::allocator<float>>&,std::vector<long,std::allocator<long>>&)::__0>
(local_158,(__0 *)local_188);
}
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector(local_1a0);
/* try { // try from 00124dda to 00124dee has its CatchHandler @ 00124ef6 */
cv::_InputArray::_InputArray(local_1b8,local_158);
/* try { // try from 00124df1 to 00124e05 has its CatchHandler @ 00124f0c */
cv::_OutputArray::_OutputArray(local_1d0,(vector *)local_1a0);
/* try { // try from 00124e08 to 00124e1c has its CatchHandler @ 00124f22 */
cv::split(local_1b8,local_1d0);
cv::_OutputArray::~_OutputArray(local_1d0);
cv::_InputArray::~_InputArray(local_1b8);
local_1d8 = local_1a0;
local_1e0 = std::vector<cv::Mat,std::allocator<cv::Mat>>::begin(local_1d8);
local_1e8 = std::vector<cv::Mat,std::allocator<cv::Mat>>::end(local_1d8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_1e0,(__normal_iterator *)&local_1e8),
bVar2) {
local_1f0 = __gnu_cxx::
__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator*((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
*)&local_1e0);
pvVar1 = local_20;
local_200 = std::vector<float,std::allocator<float>>::end(local_20);
__gnu_cxx::__normal_iterator<float_const*,std::vector<float,std::allocator<float>>>::
__normal_iterator<float*>
((__normal_iterator<float_const*,std::vector<float,std::allocator<float>>> *)
&local_1f8,(__normal_iterator *)&local_200);
/* try { // try from 00124ed1 to 00124ed5 has its CatchHandler @ 00124ef6 */
std::vector<float,std::allocator<float>>::insert<float*,void>
(pvVar1,local_1f8,*(int8 *)(local_1f0 + 0x18),
*(int8 *)(local_1f0 + 0x20));
__gnu_cxx::__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator++((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>> *)
&local_1e0);
}
std::vector<cv::Mat,std::allocator<cv::Mat>>::~vector(local_1a0);
cv::Mat::~Mat(local_158);
cv::Mat::~Mat((Mat *)local_f8);
__gnu_cxx::__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator++((__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>> *)
&local_88);
}
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00124c1a to 00124c25 has its CatchHandler @ 00124c5e */
std::runtime_error::runtime_error(prVar5,"One of the input images is empty.");
/* try { // try from 00124c28 to 00124c3f has its CatchHandler @ 00124c45 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_0014dfb0,PTR__runtime_error_0014dff8);
}
| |
53,790 | ma_search_last | eloqsql/storage/maria/ma_search.c | int _ma_search_last(MARIA_HA *info, MARIA_KEYDEF *keyinfo,
my_off_t pos)
{
uchar *end_of_page;
MARIA_PAGE page;
DBUG_ENTER("_ma_search_last");
if (pos == HA_OFFSET_ERROR)
{
my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
info->cur_row.lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
do
{
if (_ma_fetch_keypage(&page, info, keyinfo, pos,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, info->keyread_buff, 0))
{
info->cur_row.lastpos= HA_OFFSET_ERROR;
DBUG_RETURN(-1);
}
end_of_page= page.buff + page.size;
} while ((pos= _ma_kpos(page.node, end_of_page)) != HA_OFFSET_ERROR);
if (!_ma_get_last_key(&info->last_key, &page, end_of_page))
DBUG_RETURN(-1);
info->cur_row.lastpos= _ma_row_pos_from_key(&info->last_key);
info->cur_row.trid= _ma_trid_from_key(&info->last_key);
info->int_keypos= info->int_maxpos= end_of_page;
info->int_nod_flag= page.node;
info->int_keytree_version= keyinfo->version;
info->last_search_keypage= info->last_keypage;
info->page_changed=info->keyread_buff_used=0;
DBUG_PRINT("exit",("found key at %lu",(ulong) info->cur_row.lastpos));
DBUG_RETURN(0);
} | O3 | c | ma_search_last:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0x5f045
movq %rdx, %rax
movq %rsi, %r14
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq 0x380(%rbx)
callq 0x5fbfe
addq $0x10, %rsp
testb %al, %al
jne 0x5f050
movl -0x38(%rbp), %r15d
movl -0x30(%rbp), %edi
addq -0x48(%rbp), %r15
movq %r15, %rsi
callq 0x5dc0f
cmpq $-0x1, %rax
jne 0x5ef86
leaq 0x200(%rbx), %r12
leaq -0x58(%rbp), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x5e958
testq %rax, %rax
je 0x5f05b
movq %r12, %rdi
callq 0x5dd74
movq %rax, 0x98(%rbx)
movq %r12, %rdi
callq 0x5de2c
movq %rax, 0xc0(%rbx)
movq %r15, 0x3b8(%rbx)
movq %r15, 0x3b0(%rbx)
movl -0x30(%rbp), %eax
movl %eax, 0x3d0(%rbx)
movl 0xb8(%r14), %eax
movl %eax, 0x3d4(%rbx)
movq 0x440(%rbx), %rax
movq %rax, 0x448(%rbx)
movw $0x0, 0x684(%rbx)
xorl %eax, %eax
jmp 0x5f060
callq 0xc14ee
movl $0x78, (%rax)
movq $-0x1, 0x98(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ma_search_last:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz loc_5F045
mov rax, rdx
mov r14, rsi
lea r12, [rbp+var_58]
loc_5EF86:
mov rdi, r12
mov rsi, rbx
mov rdx, r14
mov rcx, rax
xor r8d, r8d
mov r9d, 3
push 0
push qword ptr [rbx+380h]
call _ma_fetch_keypage
add rsp, 10h
test al, al
jnz loc_5F050
mov r15d, [rbp+var_38]
mov edi, [rbp+var_30]
add r15, [rbp+var_48]
mov rsi, r15
call _ma_kpos
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_5EF86
lea r12, [rbx+200h]
lea rsi, [rbp+var_58]
mov rdi, r12
mov rdx, r15
call _ma_get_last_key
test rax, rax
jz short loc_5F05B
mov rdi, r12
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov rdi, r12
call _ma_trid_from_key
mov [rbx+0C0h], rax
mov [rbx+3B8h], r15
mov [rbx+3B0h], r15
mov eax, [rbp+var_30]
mov [rbx+3D0h], eax
mov eax, [r14+0B8h]
mov [rbx+3D4h], eax
mov rax, [rbx+440h]
mov [rbx+448h], rax
mov word ptr [rbx+684h], 0
xor eax, eax
jmp short loc_5F060
loc_5F045:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
loc_5F050:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
loc_5F05B:
mov eax, 0FFFFFFFFh
loc_5F060:
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_search_last(long long a1, long long a2, long long a3)
{
long long v3; // rax
unsigned long long v4; // r15
_BYTE v6[16]; // [rsp+8h] [rbp-58h] BYREF
long long v7; // [rsp+18h] [rbp-48h]
unsigned int v8; // [rsp+28h] [rbp-38h]
unsigned int v9; // [rsp+30h] [rbp-30h]
if ( a3 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 120;
}
else
{
LODWORD(v3) = a3;
while ( !(unsigned __int8)ma_fetch_keypage((unsigned int)v6, a1, a2, v3, 0, 3, *(_QWORD *)(a1 + 896)) )
{
v4 = v7 + v8;
v3 = ma_kpos(v9, v4);
if ( v3 == -1 )
{
if ( !ma_get_last_key(a1 + 512, (long long)v6, v4) )
return 0xFFFFFFFFLL;
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key((long long *)(a1 + 512));
*(_QWORD *)(a1 + 192) = ma_trid_from_key(a1 + 512);
*(_QWORD *)(a1 + 952) = v4;
*(_QWORD *)(a1 + 944) = v4;
*(_DWORD *)(a1 + 976) = v9;
*(_DWORD *)(a1 + 980) = *(_DWORD *)(a2 + 184);
*(_QWORD *)(a1 + 1096) = *(_QWORD *)(a1 + 1088);
*(_WORD *)(a1 + 1668) = 0;
return 0LL;
}
}
}
*(_QWORD *)(a1 + 152) = -1LL;
return 0xFFFFFFFFLL;
}
| _ma_search_last:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CMP RDX,-0x1
JZ 0x0015f045
MOV RAX,RDX
MOV R14,RSI
LEA R12,[RBP + -0x58]
LAB_0015ef86:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R14
MOV RCX,RAX
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH qword ptr [RBX + 0x380]
CALL 0x0015fbfe
ADD RSP,0x10
TEST AL,AL
JNZ 0x0015f050
MOV R15D,dword ptr [RBP + -0x38]
MOV EDI,dword ptr [RBP + -0x30]
ADD R15,qword ptr [RBP + -0x48]
MOV RSI,R15
CALL 0x0015dc0f
CMP RAX,-0x1
JNZ 0x0015ef86
LEA R12,[RBX + 0x200]
LEA RSI,[RBP + -0x58]
MOV RDI,R12
MOV RDX,R15
CALL 0x0015e958
TEST RAX,RAX
JZ 0x0015f05b
MOV RDI,R12
CALL 0x0015dd74
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,R12
CALL 0x0015de2c
MOV qword ptr [RBX + 0xc0],RAX
MOV qword ptr [RBX + 0x3b8],R15
MOV qword ptr [RBX + 0x3b0],R15
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBX + 0x3d0],EAX
MOV EAX,dword ptr [R14 + 0xb8]
MOV dword ptr [RBX + 0x3d4],EAX
MOV RAX,qword ptr [RBX + 0x440]
MOV qword ptr [RBX + 0x448],RAX
MOV word ptr [RBX + 0x684],0x0
XOR EAX,EAX
JMP 0x0015f060
LAB_0015f045:
CALL 0x001c14ee
MOV dword ptr [RAX],0x78
LAB_0015f050:
MOV qword ptr [RBX + 0x98],-0x1
LAB_0015f05b:
MOV EAX,0xffffffff
LAB_0015f060:
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _ma_search_last(long param_1,long param_2,long param_3)
{
long lVar1;
char cVar2;
long lVar3;
int8 uVar4;
int4 *puVar5;
long lVar6;
int1 local_60 [16];
long local_50;
uint local_40;
int4 local_38;
if (param_3 == -1) {
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x78;
LAB_0015f050:
*(int8 *)(param_1 + 0x98) = 0xffffffffffffffff;
}
else {
do {
cVar2 = _ma_fetch_keypage(local_60,param_1,param_2,param_3,0,3,
*(int8 *)(param_1 + 0x380),0);
if (cVar2 != '\0') goto LAB_0015f050;
lVar6 = (ulong)local_40 + local_50;
param_3 = _ma_kpos(local_38,lVar6);
} while (param_3 != -1);
lVar1 = param_1 + 0x200;
lVar3 = _ma_get_last_key(lVar1,local_60,lVar6);
if (lVar3 != 0) {
uVar4 = _ma_row_pos_from_key(lVar1);
*(int8 *)(param_1 + 0x98) = uVar4;
uVar4 = _ma_trid_from_key(lVar1);
*(int8 *)(param_1 + 0xc0) = uVar4;
*(long *)(param_1 + 0x3b8) = lVar6;
*(long *)(param_1 + 0x3b0) = lVar6;
*(int4 *)(param_1 + 0x3d0) = local_38;
*(int4 *)(param_1 + 0x3d4) = *(int4 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0x448) = *(int8 *)(param_1 + 0x440);
*(int2 *)(param_1 + 0x684) = 0;
return 0;
}
}
return 0xffffffff;
}
| |
53,791 | bf_cmpu | bluesky950520[P]quickjs/libbf.c | int bf_cmpu(const bf_t *a, const bf_t *b)
{
slimb_t i;
limb_t len, v1, v2;
if (a->expn != b->expn) {
if (a->expn < b->expn)
return -1;
else
return 1;
}
len = bf_max(a->len, b->len);
for(i = len - 1; i >= 0; i--) {
v1 = get_limbz(a, a->len - len + i);
v2 = get_limbz(b, b->len - len + i);
if (v1 != v2) {
if (v1 < v2)
return -1;
else
return 1;
}
}
return 0;
} | O0 | c | bf_cmpu:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0xed280
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jge 0xed273
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xed340
movl $0x1, 0x34(%rsp)
jmp 0xed340
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xed350
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0xed338
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
subq 0x10(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0xed390
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rsi
subq 0x10(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0xed390
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0xed323
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0xed319
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xed340
movl $0x1, 0x34(%rsp)
jmp 0xed340
jmp 0xed325
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xed2aa
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
| bf_cmpu:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rax, [rsp+38h+var_10]
mov rax, [rax+10h]
mov rcx, [rsp+38h+var_18]
cmp rax, [rcx+10h]
jz short loc_ED280
mov rax, [rsp+38h+var_10]
mov rax, [rax+10h]
mov rcx, [rsp+38h+var_18]
cmp rax, [rcx+10h]
jge short loc_ED273
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp loc_ED340
loc_ED273:
mov [rsp+38h+var_4], 1
jmp loc_ED340
loc_ED280:
mov rax, [rsp+38h+var_10]
mov rdi, [rax+18h]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+18h]
call bf_max
mov [rsp+38h+var_28], rax
mov rax, [rsp+38h+var_28]
sub rax, 1
mov [rsp+38h+var_20], rax
loc_ED2AA:
cmp [rsp+38h+var_20], 0
jl loc_ED338
mov rdi, [rsp+38h+var_10]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+18h]
sub rsi, [rsp+38h+var_28]
add rsi, [rsp+38h+var_20]
call get_limbz
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_18]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+18h]
sub rsi, [rsp+38h+var_28]
add rsi, [rsp+38h+var_20]
call get_limbz
mov [rsp+38h+var_38], rax
mov rax, [rsp+38h+var_30]
cmp rax, [rsp+38h+var_38]
jz short loc_ED323
mov rax, [rsp+38h+var_30]
cmp rax, [rsp+38h+var_38]
jnb short loc_ED319
mov [rsp+38h+var_4], 0FFFFFFFFh
jmp short loc_ED340
loc_ED319:
mov [rsp+38h+var_4], 1
jmp short loc_ED340
loc_ED323:
jmp short $+2
loc_ED325:
mov rax, [rsp+38h+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rsp+38h+var_20], rax
jmp loc_ED2AA
loc_ED338:
mov [rsp+38h+var_4], 0
loc_ED340:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
| long long bf_cmpu(long long a1, long long a2)
{
unsigned long long v3; // [rsp+0h] [rbp-38h]
unsigned long long limbz; // [rsp+8h] [rbp-30h]
long long v5; // [rsp+10h] [rbp-28h]
long long i; // [rsp+18h] [rbp-20h]
if ( *(_QWORD *)(a1 + 16) == *(_QWORD *)(a2 + 16) )
{
v5 = bf_max(*(_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 24));
for ( i = v5 - 1; ; --i )
{
if ( i < 0 )
return 0;
limbz = get_limbz(a1, i + *(_QWORD *)(a1 + 24) - v5);
v3 = get_limbz(a2, i + *(_QWORD *)(a2 + 24) - v5);
if ( limbz != v3 )
break;
}
if ( limbz >= v3 )
return 1;
else
return (unsigned int)-1;
}
else if ( *(_QWORD *)(a1 + 16) >= *(_QWORD *)(a2 + 16) )
{
return 1;
}
else
{
return (unsigned int)-1;
}
}
| bf_cmpu:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x001ed280
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RCX + 0x10]
JGE 0x001ed273
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001ed340
LAB_001ed273:
MOV dword ptr [RSP + 0x34],0x1
JMP 0x001ed340
LAB_001ed280:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x18]
CALL 0x001ed350
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
SUB RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
LAB_001ed2aa:
CMP qword ptr [RSP + 0x18],0x0
JL 0x001ed338
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x18]
SUB RSI,qword ptr [RSP + 0x10]
ADD RSI,qword ptr [RSP + 0x18]
CALL 0x001ed390
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x18]
SUB RSI,qword ptr [RSP + 0x10]
ADD RSI,qword ptr [RSP + 0x18]
CALL 0x001ed390
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP]
JZ 0x001ed323
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP]
JNC 0x001ed319
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x001ed340
LAB_001ed319:
MOV dword ptr [RSP + 0x34],0x1
JMP 0x001ed340
LAB_001ed323:
JMP 0x001ed325
LAB_001ed325:
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001ed2aa
LAB_001ed338:
MOV dword ptr [RSP + 0x34],0x0
LAB_001ed340:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 bf_cmpu(long param_1,long param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
long local_20;
int4 local_4;
if (*(long *)(param_1 + 0x10) == *(long *)(param_2 + 0x10)) {
lVar1 = bf_max(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x18));
local_20 = lVar1;
do {
local_20 = local_20 + -1;
if (local_20 < 0) {
return 0;
}
uVar2 = get_limbz(param_1,(*(long *)(param_1 + 0x18) - lVar1) + local_20);
uVar3 = get_limbz(param_2,(*(long *)(param_2 + 0x18) - lVar1) + local_20);
} while (uVar2 == uVar3);
if (uVar2 < uVar3) {
local_4 = 0xffffffff;
}
else {
local_4 = 1;
}
}
else if (*(long *)(param_1 + 0x10) < *(long *)(param_2 + 0x10)) {
local_4 = 0xffffffff;
}
else {
local_4 = 1;
}
return local_4;
}
| |
53,792 | LexAnalyse | qoraal-tictactoe/build_O0/_deps/qoraal_engine-src/src/tool/lex.c | enum LexToken LexAnalyse(struct LexState * Lexer, const char *Source, int SourceLen, int Line)
{
//struct LexState Lexer;
Lexer->Pos = Source;
Lexer->End = Source + SourceLen;
Lexer->Line = Line;
// Lexer.Mode = LexModeNormal;
//Lexer.EmitExtraNewlines = 0;
Lexer->CharacterPos = 1;
//Lexer.SourceText = Source;
return LexTokenise(Lexer);
} | O0 | c | LexAnalyse:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0xae10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| LexAnalyse:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rcx, [rbp+var_10]
movsxd rax, [rbp+var_14]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+10h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+14h], 1
mov rdi, [rbp+var_8]
call LexTokenise
add rsp, 20h
pop rbp
retn
| long long LexAnalyse(long long a1, long long a2, int a3, int a4)
{
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a3 + a2;
*(_DWORD *)(a1 + 16) = a4;
*(_DWORD *)(a1 + 20) = 1;
return LexTokenise((char **)a1);
}
| LexAnalyse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RAX,dword ptr [RBP + -0x14]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010ae10
ADD RSP,0x20
POP RBP
RET
|
void LexAnalyse(long *param_1,long param_2,int param_3,int4 param_4)
{
*param_1 = param_2;
param_1[1] = param_2 + param_3;
*(int4 *)(param_1 + 2) = param_4;
*(int4 *)((long)param_1 + 0x14) = 1;
LexTokenise(param_1);
return;
}
| |
53,793 | ImPlot::ColormapButton(char const*, ImVec2 const&, int) | zkingston[P]unknot/build_O1/_deps/implot-src/implot.cpp | bool ColormapButton(const char* label, const ImVec2& size_arg, ImPlotColormap cmap) {
ImGuiContext &G = *GImGui;
const ImGuiStyle& style = G.Style;
ImGuiWindow * Window = G.CurrentWindow;
if (Window->SkipItems)
return false;
ImPlotContext& gp = *GImPlot;
cmap = cmap == IMPLOT_AUTO ? gp.Style.Colormap : cmap;
IM_ASSERT_USER_ERROR(cmap >= 0 && cmap < gp.ColormapData.Count, "Invalid colormap index!");
const ImU32* keys = gp.ColormapData.GetKeys(cmap);
const int count = gp.ColormapData.GetKeyCount(cmap);
const bool qual = gp.ColormapData.IsQual(cmap);
const ImVec2 pos = ImGui::GetCurrentWindow()->DC.CursorPos;
const ImVec2 label_size = ImGui::CalcTextSize(label, nullptr, true);
ImVec2 size = ImGui::CalcItemSize(size_arg, label_size.x + style.FramePadding.x * 2.0f, label_size.y + style.FramePadding.y * 2.0f);
const ImRect rect = ImRect(pos.x,pos.y,pos.x+size.x,pos.y+size.y);
RenderColorBar(keys,count,*ImGui::GetWindowDrawList(),rect,false,false,!qual);
const ImU32 text = CalcTextColor(gp.ColormapData.LerpTable(cmap,G.Style.ButtonTextAlign.x));
ImGui::PushStyleColor(ImGuiCol_Button,IM_COL32_BLACK_TRANS);
ImGui::PushStyleColor(ImGuiCol_ButtonHovered,ImVec4(1,1,1,0.1f));
ImGui::PushStyleColor(ImGuiCol_ButtonActive,ImVec4(1,1,1,0.2f));
ImGui::PushStyleColor(ImGuiCol_Text,text);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,0);
const bool pressed = ImGui::Button(label,size);
ImGui::PopStyleColor(4);
ImGui::PopStyleVar(1);
return pressed;
} | O1 | cpp | ImPlot::ColormapButton(char const*, ImVec2 const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x27265d(%rip), %r15 # 0x337030
movq (%r15), %r13
movq 0x1368(%r13), %rax
cmpb $0x0, 0xcf(%rax)
je 0xc49ed
xorl %ebx, %ebx
jmp 0xc4c41
movl %edx, %ebp
movq 0x2722aa(%rip), %r12 # 0x336ca0
cmpl $-0x1, %edx
jne 0xc4a03
movl 0x300(%r12), %ebp
movq %rsi, 0x18(%rsp)
testl %ebp, %ebp
js 0xc4a16
cmpl 0x3c8(%r12), %ebp
jl 0xc4a28
movq %rdi, %rbx
leaq 0x1d0c67(%rip), %rdi # 0x295687
callq 0x2161f4
movq %rbx, %rdi
movq 0x350(%r12), %rax
movslq %ebp, %rbx
movslq (%rax,%rbx,4), %r14
shlq $0x2, %r14
addq 0x330(%r12), %r14
movq 0x340(%r12), %rax
movl (%rax,%rbx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x3b0(%r12), %rax
movzbl (%rax,%rbx), %ebp
movq (%r15), %rax
movq 0x1368(%rax), %rax
movb $0x1, 0xcc(%rax)
movsd 0x118(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movss 0x1ca580(%rip), %xmm0 # 0x28f004
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x1, %edx
callq 0x216f58
movq 0x18(%rsp), %rax
movsd (%rax), %xmm3
movss 0xc2c(%r13), %xmm1
movss 0xc30(%r13), %xmm2
addss %xmm1, %xmm1
addss %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss %xmm2, %xmm2
addss %xmm0, %xmm2
movaps %xmm3, %xmm0
callq 0x2263c1
movlps %xmm0, 0x28(%rsp)
movaps 0x30(%rsp), %xmm1
addps %xmm1, %xmm0
movlhps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
leaq 0x58(%rsp), %r15
movups %xmm1, (%r15)
callq 0x22983c
xorl $0x1, %ebp
movl %ebp, (%rsp)
movq %r14, %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xc3c17
movss 0xc9c(%r13), %xmm0
movq 0x370(%r12), %rcx
movq 0x380(%r12), %rax
movslq (%rax,%rbx,4), %rax
movl (%rcx,%rbx,4), %ecx
movq 0x3b0(%r12), %rdx
cmpb $0x1, (%rdx,%rbx)
jne 0xc4b58
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
decl %ecx
cmpl %ecx, %edx
cmovll %edx, %ecx
testl %edx, %edx
movl $0x0, %edx
cmovsl %edx, %ecx
jmp 0xc4b71
decl %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
addss 0x1ca4b3(%rip), %xmm1 # 0x28f020
cvttss2si %xmm1, %ecx
movslq %ecx, %rcx
addq %rax, %rcx
movq 0x360(%r12), %rax
movl (%rax,%rcx,4), %edi
callq 0x213cb2
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
mulss 0x1d4ff2(%rip), %xmm2 # 0x299b88
mulss 0x1d4fee(%rip), %xmm0 # 0x299b8c
addss %xmm2, %xmm0
mulss 0x1d4fe6(%rip), %xmm1 # 0x299b90
addss %xmm0, %xmm1
xorl %ebp, %ebp
ucomiss 0x1ca469(%rip), %xmm1 # 0x28f020
setbe %bpl
negl %ebp
orl $0xff000000, %ebp # imm = 0xFF000000
movl $0x15, %edi
xorl %esi, %esi
callq 0x215f3f
movaps 0x1d4e9a(%rip), %xmm0 # 0x299a70
leaq 0x40(%rsp), %r14
movaps %xmm0, (%r14)
movl $0x16, %edi
movq %r14, %rsi
callq 0x21608f
movaps 0x1d4e8d(%rip), %xmm0 # 0x299a80
movaps %xmm0, (%r14)
leaq 0x40(%rsp), %rsi
movl $0x17, %edi
callq 0x21608f
xorl %edi, %edi
movl %ebp, %esi
callq 0x215f3f
xorps %xmm0, %xmm0
movl $0xc, %edi
callq 0x2163bf
leaq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x2578d8
movl %eax, %ebx
movl $0x4, %edi
callq 0x216192
movl $0x1, %edi
callq 0x216849
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN6ImPlot14ColormapButtonEPKcRK6ImVec2i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
lea r15, GImGui
mov r13, [r15]
mov rax, [r13+1368h]
cmp byte ptr [rax+0CFh], 0
jz short loc_C49ED
xor ebx, ebx
jmp loc_C4C41
loc_C49ED:
mov ebp, edx
mov r12, cs:GImPlot
cmp edx, 0FFFFFFFFh
jnz short loc_C4A03
mov ebp, [r12+300h]
loc_C4A03:
mov [rsp+98h+var_80], rsi
test ebp, ebp
js short loc_C4A16
cmp ebp, [r12+3C8h]
jl short loc_C4A28
loc_C4A16:
mov rbx, rdi
lea rdi, aInvalidColorma; "Invalid colormap index!"
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
mov rdi, rbx; this
loc_C4A28:
mov rax, [r12+350h]
movsxd rbx, ebp
movsxd r14, dword ptr [rax+rbx*4]
shl r14, 2
add r14, [r12+330h]
mov rax, [r12+340h]
mov eax, [rax+rbx*4]
mov [rsp+98h+var_84], eax
mov rax, [r12+3B0h]
movzx ebp, byte ptr [rax+rbx]
mov rax, [r15]
mov rax, [rax+1368h]
mov byte ptr [rax+0CCh], 1
movsd xmm0, qword ptr [rax+118h]
movaps [rsp+98h+var_68], xmm0
movss xmm0, cs:flt_28F004; float
mov [rsp+98h+var_78], rdi
xor esi, esi; char *
mov edx, (offset dword_0+1); char *
call _ZN5ImGui12CalcTextSizeEPKcS1_bf; ImGui::CalcTextSize(char const*,char const*,bool,float)
mov rax, [rsp+98h+var_80]
movsd xmm3, qword ptr [rax]
movss xmm1, dword ptr [r13+0C2Ch]
movss xmm2, dword ptr [r13+0C30h]
addss xmm1, xmm1
addss xmm1, xmm0
shufps xmm0, xmm0, 55h ; 'U'
addss xmm2, xmm2
addss xmm2, xmm0
movaps xmm0, xmm3
call _ZN5ImGui12CalcItemSizeE6ImVec2ff; ImGui::CalcItemSize(ImVec2,float,float)
movlps qword ptr [rsp+98h+var_70], xmm0
movaps xmm1, [rsp+98h+var_68]
addps xmm0, xmm1
movlhps xmm1, xmm0
lea r15, [rsp+98h+var_40]
movups xmmword ptr [r15], xmm1
call _ZN5ImGui17GetWindowDrawListEv; ImGui::GetWindowDrawList(void)
xor ebp, 1
mov [rsp+98h+var_98], ebp
mov rdi, r14
mov esi, [rsp+98h+var_84]; unsigned int
mov rdx, rax
mov rcx, r15
xor r8d, r8d
xor r9d, r9d
call _ZN6ImPlot14RenderColorBarEPKjiR10ImDrawListRK6ImRectbbb; ImPlot::RenderColorBar(uint const*,int,ImDrawList &,ImRect const&,bool,bool,bool)
movss xmm0, dword ptr [r13+0C9Ch]
mov rcx, [r12+370h]
mov rax, [r12+380h]
movsxd rax, dword ptr [rax+rbx*4]
mov ecx, [rcx+rbx*4]
mov rdx, [r12+3B0h]
cmp byte ptr [rdx+rbx], 1
jnz short loc_C4B58
xorps xmm1, xmm1
cvtsi2ss xmm1, ecx
mulss xmm0, xmm1
cvttss2si edx, xmm0
dec ecx
cmp edx, ecx
cmovl ecx, edx
test edx, edx
mov edx, 0
cmovs ecx, edx
jmp short loc_C4B71
loc_C4B58:
dec ecx
xorps xmm1, xmm1
cvtsi2ss xmm1, ecx
mulss xmm1, xmm0
addss xmm1, dword ptr cs:xmmword_28F020
cvttss2si ecx, xmm1
loc_C4B71:
movsxd rcx, ecx
add rcx, rax
mov rax, [r12+360h]
mov edi, [rax+rcx*4]; this
call _ZN5ImGui23ColorConvertU32ToFloat4Ej; ImGui::ColorConvertU32ToFloat4(uint)
movaps xmm2, xmm0
shufps xmm2, xmm0, 55h ; 'U'
mulss xmm2, cs:dword_299B88
mulss xmm0, cs:dword_299B8C
addss xmm0, xmm2
mulss xmm1, cs:dword_299B90
addss xmm1, xmm0
xor ebp, ebp
ucomiss xmm1, dword ptr cs:xmmword_28F020
setbe bpl
neg ebp
or ebp, 0FF000000h
mov edi, (offset dword_14+1); this
xor esi, esi; int
call _ZN5ImGui14PushStyleColorEij; ImGui::PushStyleColor(int,uint)
movaps xmm0, cs:xmmword_299A70
lea r14, [rsp+98h+var_58]
movaps xmmword ptr [r14], xmm0
mov edi, 16h
mov rsi, r14
call _ZN5ImGui14PushStyleColorEiRK6ImVec4; ImGui::PushStyleColor(int,ImVec4 const&)
movaps xmm0, cs:xmmword_299A80
movaps xmmword ptr [r14], xmm0
lea rsi, [rsp+98h+var_58]
mov edi, 17h
call _ZN5ImGui14PushStyleColorEiRK6ImVec4; ImGui::PushStyleColor(int,ImVec4 const&)
xor edi, edi; this
mov esi, ebp; int
call _ZN5ImGui14PushStyleColorEij; ImGui::PushStyleColor(int,uint)
xorps xmm0, xmm0; float
mov edi, (offset byte_9+3); this
call _ZN5ImGui12PushStyleVarEif; ImGui::PushStyleVar(int,float)
lea rsi, [rsp+98h+var_70]; int
mov rdi, [rsp+98h+var_78]
call _ZN5ImGui6ButtonEPKcRK6ImVec2; ImGui::Button(char const*,ImVec2 const&)
mov ebx, eax
mov edi, offset byte_4; this
call _ZN5ImGui13PopStyleColorEi; ImGui::PopStyleColor(int)
mov edi, (offset dword_0+1); this
call _ZN5ImGui11PopStyleVarEi; ImGui::PopStyleVar(int)
loc_C4C41:
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ImPlot::ColormapButton(ImGui *this, const char *a2, int a3, bool a4)
{
ImGui *v4; // r13
unsigned int v5; // ebx
int v6; // ebp
ImGui *v7; // r12
long long v8; // rbx
long long v9; // r14
char v10; // bp
long long v11; // rax
__m128 v12; // xmm0
int WindowDrawList; // eax
__m128 v14; // xmm0
int v15; // ecx
float v16; // xmm1_4
int v17; // ecx
unsigned int v18; // edx
int v19; // esi
unsigned int v20; // edx
unsigned int v22; // [rsp+14h] [rbp-84h]
int v23[2]; // [rsp+28h] [rbp-70h] BYREF
__m128 v24; // [rsp+30h] [rbp-68h]
__int128 v25; // [rsp+40h] [rbp-58h] BYREF
__m128 v26[4]; // [rsp+58h] [rbp-40h] BYREF
v4 = GImGui;
if ( *(_BYTE *)(*((_QWORD *)GImGui + 621) + 207LL) )
{
return 0;
}
else
{
v6 = a3;
v7 = GImPlot;
if ( a3 == -1 )
v6 = *((_DWORD *)GImPlot + 192);
if ( v6 < 0 || v6 >= *((_DWORD *)GImPlot + 242) )
ImGui::ErrorLog((ImGui *)"Invalid colormap index!", a2);
v8 = v6;
v9 = *((_QWORD *)v7 + 102) + 4LL * *(int *)(*((_QWORD *)v7 + 106) + 4LL * v6);
v22 = *(_DWORD *)(*((_QWORD *)v7 + 104) + 4LL * v6);
v10 = *(_BYTE *)(*((_QWORD *)v7 + 118) + v6);
v11 = *((_QWORD *)GImGui + 621);
*(_BYTE *)(v11 + 204) = 1;
v24 = (__m128)*(unsigned long long *)(v11 + 280);
ImGui::CalcTextSize(this, 0LL, (const char *)&dword_0 + 1, a4, -1.0);
v12 = (__m128)*(unsigned long long *)a2;
*(double *)v12.m128_u64 = ImGui::CalcItemSize(
*(double *)v12.m128_u64,
(float)(*((float *)v4 + 779) + *((float *)v4 + 779)) + -1.0,
(float)(*((float *)v4 + 780) + *((float *)v4 + 780))
+ _mm_shuffle_ps((__m128)0xBF800000, (__m128)0xBF800000, 85).m128_f32[0]);
_mm_storel_ps((double *)v23, v12);
v26[0] = _mm_movelh_ps(v24, _mm_add_ps(v12, v24));
WindowDrawList = ImGui::GetWindowDrawList(this);
ImPlot::RenderColorBar(v9, v22, WindowDrawList, v26[0].m128_f32, 0, 0, v10 ^ 1);
v14 = (__m128)*((unsigned int *)v4 + 807);
v15 = *(_DWORD *)(*((_QWORD *)v7 + 110) + 4 * v8);
if ( *(_BYTE *)(*((_QWORD *)v7 + 118) + v8) == 1 )
{
v16 = (float)v15;
v14.m128_f32[0] = v14.m128_f32[0] * (float)v15;
v17 = v15 - 1;
if ( (int)v14.m128_f32[0] < v17 )
v17 = (int)v14.m128_f32[0];
if ( (int)v14.m128_f32[0] < 0 )
v17 = 0;
}
else
{
v16 = (float)((float)(v15 - 1) * v14.m128_f32[0]) + 0.5;
v17 = (int)v16;
}
ImGui::ColorConvertU32ToFloat4(
(ImGui *)*(unsigned int *)(*((_QWORD *)v7 + 108) + 4 * (*(int *)(*((_QWORD *)v7 + 112) + 4 * v8) + (long long)v17)),
v22);
ImGui::PushStyleColor((ImGui *)((char *)&dword_14 + 1), 0, v18);
v25 = xmmword_299A70;
ImGui::PushStyleColor(22LL, &v25);
v25 = xmmword_299A80;
ImGui::PushStyleColor(23LL, &v25);
v19 = (float)((float)(v16 * 0.114)
+ (float)((float)(v14.m128_f32[0] * 0.29899999)
+ (float)(_mm_shuffle_ps(v14, v14, 85).m128_f32[0] * 0.58700001))) <= 0.5
? -1
: 0xFF000000;
ImGui::PushStyleColor(0LL, v19, v20);
ImGui::PushStyleVar((ImGui *)&byte_9[3], v19, 0.0);
v5 = ImGui::Button(this, v23);
ImGui::PopStyleColor((ImGui *)&byte_4, (int)v23);
ImGui::PopStyleVar((ImGui *)((char *)&dword_0 + 1), (int)v23);
}
return v5;
}
| ColormapButton:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
LEA R15,[0x437030]
MOV R13,qword ptr [R15]
MOV RAX,qword ptr [R13 + 0x1368]
CMP byte ptr [RAX + 0xcf],0x0
JZ 0x001c49ed
XOR EBX,EBX
JMP 0x001c4c41
LAB_001c49ed:
MOV EBP,EDX
MOV R12,qword ptr [0x00436ca0]
CMP EDX,-0x1
JNZ 0x001c4a03
MOV EBP,dword ptr [R12 + 0x300]
LAB_001c4a03:
MOV qword ptr [RSP + 0x18],RSI
TEST EBP,EBP
JS 0x001c4a16
CMP EBP,dword ptr [R12 + 0x3c8]
JL 0x001c4a28
LAB_001c4a16:
MOV RBX,RDI
LEA RDI,[0x395687]
CALL 0x003161f4
MOV RDI,RBX
LAB_001c4a28:
MOV RAX,qword ptr [R12 + 0x350]
MOVSXD RBX,EBP
MOVSXD R14,dword ptr [RAX + RBX*0x4]
SHL R14,0x2
ADD R14,qword ptr [R12 + 0x330]
MOV RAX,qword ptr [R12 + 0x340]
MOV EAX,dword ptr [RAX + RBX*0x4]
MOV dword ptr [RSP + 0x14],EAX
MOV RAX,qword ptr [R12 + 0x3b0]
MOVZX EBP,byte ptr [RAX + RBX*0x1]
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + 0x1368]
MOV byte ptr [RAX + 0xcc],0x1
MOVSD XMM0,qword ptr [RAX + 0x118]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVSS XMM0,dword ptr [0x0038f004]
MOV qword ptr [RSP + 0x20],RDI
XOR ESI,ESI
MOV EDX,0x1
CALL 0x00316f58
MOV RAX,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RAX]
MOVSS XMM1,dword ptr [R13 + 0xc2c]
MOVSS XMM2,dword ptr [R13 + 0xc30]
ADDSS XMM1,XMM1
ADDSS XMM1,XMM0
SHUFPS XMM0,XMM0,0x55
ADDSS XMM2,XMM2
ADDSS XMM2,XMM0
MOVAPS XMM0,XMM3
CALL 0x003263c1
MOVLPS qword ptr [RSP + 0x28],XMM0
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
ADDPS XMM0,XMM1
MOVLHPS XMM1,XMM0
LEA R15,[RSP + 0x58]
MOVUPS xmmword ptr [R15],XMM1
CALL 0x0032983c
XOR EBP,0x1
MOV dword ptr [RSP],EBP
MOV RDI,R14
MOV ESI,dword ptr [RSP + 0x14]
MOV RDX,RAX
MOV RCX,R15
XOR R8D,R8D
XOR R9D,R9D
CALL 0x001c3c17
MOVSS XMM0,dword ptr [R13 + 0xc9c]
MOV RCX,qword ptr [R12 + 0x370]
MOV RAX,qword ptr [R12 + 0x380]
MOVSXD RAX,dword ptr [RAX + RBX*0x4]
MOV ECX,dword ptr [RCX + RBX*0x4]
MOV RDX,qword ptr [R12 + 0x3b0]
CMP byte ptr [RDX + RBX*0x1],0x1
JNZ 0x001c4b58
XORPS XMM1,XMM1
CVTSI2SS XMM1,ECX
MULSS XMM0,XMM1
CVTTSS2SI EDX,XMM0
DEC ECX
CMP EDX,ECX
CMOVL ECX,EDX
TEST EDX,EDX
MOV EDX,0x0
CMOVS ECX,EDX
JMP 0x001c4b71
LAB_001c4b58:
DEC ECX
XORPS XMM1,XMM1
CVTSI2SS XMM1,ECX
MULSS XMM1,XMM0
ADDSS XMM1,dword ptr [0x0038f020]
CVTTSS2SI ECX,XMM1
LAB_001c4b71:
MOVSXD RCX,ECX
ADD RCX,RAX
MOV RAX,qword ptr [R12 + 0x360]
MOV EDI,dword ptr [RAX + RCX*0x4]
CALL 0x00313cb2
MOVAPS XMM2,XMM0
SHUFPS XMM2,XMM0,0x55
MULSS XMM2,dword ptr [0x00399b88]
MULSS XMM0,dword ptr [0x00399b8c]
ADDSS XMM0,XMM2
MULSS XMM1,dword ptr [0x00399b90]
ADDSS XMM1,XMM0
XOR EBP,EBP
UCOMISS XMM1,dword ptr [0x0038f020]
SETBE BPL
NEG EBP
OR EBP,0xff000000
MOV EDI,0x15
XOR ESI,ESI
CALL 0x00315f3f
MOVAPS XMM0,xmmword ptr [0x00399a70]
LEA R14,[RSP + 0x40]
MOVAPS xmmword ptr [R14],XMM0
MOV EDI,0x16
MOV RSI,R14
CALL 0x0031608f
MOVAPS XMM0,xmmword ptr [0x00399a80]
MOVAPS xmmword ptr [R14],XMM0
LEA RSI,[RSP + 0x40]
MOV EDI,0x17
CALL 0x0031608f
XOR EDI,EDI
MOV ESI,EBP
CALL 0x00315f3f
XORPS XMM0,XMM0
MOV EDI,0xc
CALL 0x003163bf
LEA RSI,[RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x003578d8
MOV EBX,EAX
MOV EDI,0x4
CALL 0x00316192
MOV EDI,0x1
CALL 0x00316849
LAB_001c4c41:
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ImPlot::ColormapButton(char const*, ImVec2 const&, int) */
int4 ImPlot::ColormapButton(char *param_1,ImVec2 *param_2,int param_3)
{
byte bVar1;
int iVar2;
long lVar3;
long lVar4;
bool bVar5;
long lVar6;
long lVar7;
int4 uVar8;
ImDrawList *pIVar9;
int iVar10;
int iVar11;
long lVar12;
int8 uVar13;
float fVar14;
int8 local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
float local_40;
float fStack_3c;
float fStack_38;
float fStack_34;
lVar7 = GImGui;
lVar6 = GImPlot;
if (*(char *)(*(long *)(GImGui + 0x1368) + 0xcf) == '\0') {
if (param_3 == -1) {
param_3 = *(int *)(GImPlot + 0x300);
}
if ((param_3 < 0) || (*(int *)(GImPlot + 0x3c8) <= param_3)) {
ImGui::ErrorLog("Invalid colormap index!");
}
lVar12 = (long)param_3;
iVar2 = *(int *)(*(long *)(lVar6 + 0x350) + lVar12 * 4);
lVar3 = *(long *)(lVar6 + 0x330);
iVar10 = *(int *)(*(long *)(lVar6 + 0x340) + lVar12 * 4);
bVar1 = *(byte *)(*(long *)(lVar6 + 0x3b0) + lVar12);
lVar4 = *(long *)(GImGui + 0x1368);
*(int1 *)(lVar4 + 0xcc) = 1;
local_68 = *(int8 *)(lVar4 + 0x118);
uStack_60 = 0;
uVar13 = ImGui::CalcTextSize(param_1,(char *)0x0,true,DAT_0038f004);
local_70 = ImGui::CalcItemSize((int)*(int8 *)param_2,
*(float *)(lVar7 + 0xc2c) + *(float *)(lVar7 + 0xc2c) +
(float)uVar13,
*(float *)(lVar7 + 0xc30) + *(float *)(lVar7 + 0xc30) +
(float)((ulong)uVar13 >> 0x20));
fStack_38 = (float)local_70 + (float)local_68;
fStack_34 = (float)((ulong)local_70 >> 0x20) + local_68._4_4_;
local_40 = (float)local_68;
fStack_3c = local_68._4_4_;
pIVar9 = (ImDrawList *)ImGui::GetWindowDrawList();
RenderColorBar((uint *)((long)iVar2 * 4 + lVar3),iVar10,pIVar9,(ImRect *)&local_40,false,false,
(bool)(bVar1 ^ 1));
iVar2 = *(int *)(*(long *)(lVar6 + 0x370) + lVar12 * 4);
if (*(char *)(*(long *)(lVar6 + 0x3b0) + lVar12) == '\x01') {
fVar14 = (float)iVar2;
iVar11 = (int)(*(float *)(lVar7 + 0xc9c) * fVar14);
iVar10 = iVar2 + -1;
if (iVar11 < iVar2 + -1) {
iVar10 = iVar11;
}
if (iVar11 < 0) {
iVar10 = 0;
}
}
else {
fVar14 = (float)(iVar2 + -1) * *(float *)(lVar7 + 0xc9c) + DAT_0038f020;
iVar10 = (int)fVar14;
}
uVar13 = ImGui::ColorConvertU32ToFloat4
(*(uint *)(*(long *)(lVar6 + 0x360) +
((long)iVar10 +
(long)*(int *)(*(long *)(lVar6 + 0x380) + lVar12 * 4)) * 4));
bVar5 = fVar14 * _DAT_00399b90 +
(float)uVar13 * _DAT_00399b8c + (float)((ulong)uVar13 >> 0x20) * _DAT_00399b88 <=
DAT_0038f020;
ImGui::PushStyleColor(0x15,0);
local_58 = _DAT_00399a70;
uStack_50 = _UNK_00399a78;
ImGui::PushStyleColor(0x16,(ImVec4 *)&local_58);
local_58 = _DAT_00399a80;
uStack_50 = _UNK_00399a88;
ImGui::PushStyleColor(0x17,(ImVec4 *)&local_58);
ImGui::PushStyleColor(0,-(uint)bVar5 | 0xff000000);
ImGui::PushStyleVar(0xc,0.0);
uVar8 = ImGui::Button(param_1,(ImVec2 *)&local_70);
ImGui::PopStyleColor(4);
ImGui::PopStyleVar(1);
}
else {
uVar8 = 0;
}
return uVar8;
}
| |
53,794 | my_snprintf | eloqsql/strings/my_vsnprintf.c | size_t my_snprintf(char* to, size_t n, const char* fmt, ...)
{
size_t result;
va_list args;
va_start(args,fmt);
result= my_vsnprintf(to, n, fmt, args);
va_end(args);
return result;
} | O0 | c | my_snprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x7b45b
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)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, -0x3c(%rbp)
movl $0x18, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x7b3e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_snprintf:
push rbp
mov rbp, rsp
sub rsp, 0F0h
test al, al
jz short loc_7B45B
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_7B45B:
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
lea rax, [rbp+var_F0]
mov [rbp+var_30], rax
lea rax, [rbp+arg_0]
mov [rbp+var_38], rax
mov [rbp+var_3C], 30h ; '0'
mov [rbp+var_40], 18h
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_40]
call my_vsnprintf
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rsp, 0F0h
pop rbp
retn
| _BYTE * my_snprintf(
_BYTE *a1,
long long a2,
char *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-F0h] BYREF
long long v17; // [rsp+18h] [rbp-D8h]
long long v18; // [rsp+20h] [rbp-D0h]
long long v19; // [rsp+28h] [rbp-C8h]
__m128 v20; // [rsp+30h] [rbp-C0h]
__m128 v21; // [rsp+40h] [rbp-B0h]
__m128 v22; // [rsp+50h] [rbp-A0h]
__m128 v23; // [rsp+60h] [rbp-90h]
__m128 v24; // [rsp+70h] [rbp-80h]
__m128 v25; // [rsp+80h] [rbp-70h]
__m128 v26; // [rsp+90h] [rbp-60h]
__m128 v27; // [rsp+A0h] [rbp-50h]
int v28[2]; // [rsp+B0h] [rbp-40h] BYREF
char *v29; // [rsp+B8h] [rbp-38h]
char *v30; // [rsp+C0h] [rbp-30h]
char *v31; // [rsp+D8h] [rbp-18h]
long long v32; // [rsp+E0h] [rbp-10h]
_BYTE *v33; // [rsp+E8h] [rbp-8h]
v20 = a7;
v21 = a8;
v22 = a9;
v23 = a10;
v24 = a11;
v25 = a12;
v26 = a13;
v27 = a14;
v19 = a6;
v18 = a5;
v17 = a4;
v33 = a1;
v32 = a2;
v31 = a3;
v30 = &v16;
v29 = &a15;
v28[1] = 48;
v28[0] = 24;
return my_vsnprintf(a1, a2, a3, v28);
}
| my_snprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
TEST AL,AL
JZ 0x0017b45b
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_0017b45b:
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
LEA RAX,[RBP + -0xf0]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x3c],0x30
MOV dword ptr [RBP + -0x40],0x18
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x40]
CALL 0x0017b3e0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0xf0
POP RBP
RET
|
int8
my_snprintf(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;
int8 uVar1;
int1 local_f8 [24];
int8 local_e0;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_20;
int8 local_18;
int8 local_10;
if (in_AL != '\0') {
local_c8 = param_1;
local_b8 = param_2;
local_a8 = param_3;
local_98 = param_4;
local_88 = param_5;
local_78 = param_6;
local_68 = param_7;
local_58 = param_8;
}
local_38 = local_f8;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x18;
local_e0 = param_12;
local_d8 = param_13;
local_d0 = param_14;
local_20 = param_11;
local_18 = param_10;
local_10 = param_9;
uVar1 = my_vsnprintf(param_9,param_10,param_11,&local_48);
return uVar1;
}
| |
53,795 | common_sampler_init(llama_model const*, common_params_sampling const&) | monkey531[P]llama/common/sampling.cpp | struct common_sampler * common_sampler_init(const struct llama_model * model, const struct common_params_sampling & params) {
const llama_vocab * vocab = llama_model_get_vocab(model);
llama_sampler_chain_params lparams = llama_sampler_chain_default_params();
lparams.no_perf = params.no_perf;
std::vector<const char *> trigger_words;
trigger_words.reserve(params.grammar_trigger_words.size());
for (const auto & str : params.grammar_trigger_words) {
trigger_words.push_back(str.word.c_str());
}
struct llama_sampler * grmr;
if (params.grammar.compare(0, 11, "%llguidance") == 0) {
#ifdef LLAMA_USE_LLGUIDANCE
grmr = llama_sampler_init_llg(vocab, "lark", params.grammar.c_str());
#else
GGML_ABORT("llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
#endif // LLAMA_USE_LLGUIDANCE
} else {
grmr = params.grammar_lazy
? llama_sampler_init_grammar_lazy(vocab, params.grammar.c_str(), "root",
trigger_words.data(), trigger_words.size(),
params.grammar_trigger_tokens.data(), params.grammar_trigger_tokens.size())
: llama_sampler_init_grammar(vocab, params.grammar.c_str(), "root");
}
auto * result = new common_sampler {
/* .params = */ params,
/* .grmr = */ grmr,
/* .chain = */ llama_sampler_chain_init(lparams),
/* .prev = */ ring_buffer<llama_token>(std::max(32, params.n_prev)),
/* .cur = */ {},
/* .cur_p = */ {},
};
llama_sampler_chain_add(result->chain,
llama_sampler_init_logit_bias(
llama_vocab_n_tokens(vocab),
params.logit_bias.size(),
params.logit_bias.data()));
if (params.mirostat == 0) {
for (const auto & cnstr : params.samplers) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY:
{
std::vector<const char *> c_breakers;
c_breakers.reserve(params.dry_sequence_breakers.size());
for (const auto & str : params.dry_sequence_breakers) {
c_breakers.push_back(str.c_str());
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dry (vocab, llama_model_n_ctx_train(model), params.dry_multiplier, params.dry_base, params.dry_allowed_length, params.dry_penalty_last_n, c_breakers.data(), c_breakers.size()));
}
break;
case COMMON_SAMPLER_TYPE_TOP_K:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_k (params.top_k));
break;
case COMMON_SAMPLER_TYPE_TOP_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_p (params.top_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_MIN_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_min_p (params.min_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_XTC:
llama_sampler_chain_add(result->chain, llama_sampler_init_xtc (params.xtc_probability, params.xtc_threshold, params.min_keep, params.seed));
break;
case COMMON_SAMPLER_TYPE_TYPICAL_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_typical (params.typ_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_TEMPERATURE:
llama_sampler_chain_add(result->chain, llama_sampler_init_temp_ext (params.temp, params.dynatemp_range, params.dynatemp_exponent));
break;
case COMMON_SAMPLER_TYPE_INFILL:
llama_sampler_chain_add(result->chain, llama_sampler_init_infill (vocab));
break;
case COMMON_SAMPLER_TYPE_PENALTIES:
llama_sampler_chain_add(result->chain, llama_sampler_init_penalties(params.penalty_last_n, params.penalty_repeat, params.penalty_freq, params.penalty_present));
break;
default:
GGML_ASSERT(false && "unknown sampler type");
}
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dist(params.seed));
} else if (params.mirostat == 1) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat(llama_vocab_n_tokens(vocab), params.seed, params.mirostat_tau, params.mirostat_eta, 100));
} else if (params.mirostat == 2) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat_v2(params.seed, params.mirostat_tau, params.mirostat_eta));
} else {
GGML_ASSERT(false && "unknown mirostat version");
}
return result;
} | O1 | cpp | common_sampler_init(llama_model const*, common_params_sampling const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, 0x58(%rsp)
callq 0x1c1f0
movq %rax, 0x8(%rsp)
callq 0x1bdb0
movb 0x61(%rbx), %bpl
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xc8(%rbx), %rax
subq 0xc0(%rbx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
callq 0xd4062
movq 0xc0(%rbx), %r15
movq 0xc8(%rbx), %r13
cmpq %r13, %r15
je 0xd28f3
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r12
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd4674
addq $0x28, %r15
cmpq %r13, %r15
jne 0xd28d7
leaq 0x98(%rbx), %rdi
leaq 0x29df4(%rip), %rcx # 0xfc6f5
movl $0xb, %edx
xorl %esi, %esi
callq 0x1bbd0
testl %eax, %eax
je 0xd2cfb
movq 0x98(%rbx), %rsi
cmpb $0x1, 0xb8(%rbx)
jne 0xd2962
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
subq %rcx, %r8
sarq $0x3, %r8
movq 0xd8(%rbx), %r9
movq 0xe0(%rbx), %rax
subq %r9, %rax
sarq $0x2, %rax
movq %rax, (%rsp)
leaq 0x293c9(%rip), %rdx # 0xfbd1f
movq 0x8(%rsp), %rdi
callq 0x1b770
jmp 0xd2973
leaq 0x293b6(%rip), %rdx # 0xfbd1f
movq 0x8(%rsp), %rdi
callq 0x1b190
movq %rax, %r12
movl $0x1b8, %edi # imm = 0x1B8
callq 0x1b910
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x58faa
movq %r12, 0x138(%r14)
movzbl %bpl, %edi
callq 0x1b4f0
movq %rax, 0x140(%r14)
movl 0x4(%rbx), %eax
cmpl $0x21, %eax
movl $0x20, %esi
cmovgel %eax, %esi
movq %rsi, 0x148(%r14)
movq %r14, %rdi
addq $0x168, %rdi # imm = 0x168
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movq $0x0, 0x160(%r14)
leaq 0x10(%rsp), %rdx
callq 0x7dca4
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%r14)
movups %xmm0, 0x190(%r14)
movups %xmm0, 0x180(%r14)
movq $0x0, 0x1b0(%r14)
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1c180
movq 0x120(%rbx), %rdx
movq 0x128(%rbx), %rsi
subq %rdx, %rsi
shrq $0x3, %rsi
movl %eax, %edi
callq 0x1bee0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b9e0
movl 0x54(%rbx), %eax
cmpl $0x2, %eax
je 0xd2c83
cmpl $0x1, %eax
je 0xd2c3c
testl %eax, %eax
jne 0xd2d36
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %rbp
cmpq %rbp, %r15
je 0xd2cb9
leaq 0x10(%rsp), %r13
movq %rbp, 0x50(%rsp)
movl (%r15), %eax
decl %eax
cmpl $0x9, %eax
ja 0xd2d15
leaq 0x29a9b(%rip), %rcx # 0xfc530
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
movq %r13, %rdi
callq 0xd4062
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %rbp
cmpq %rbp, %r12
je 0xd2bd5
movq (%r12), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0xd4674
addq $0x20, %r12
jmp 0xd2acb
movq 0x140(%r14), %r12
movl 0x34(%rbx), %edi
movss 0x38(%rbx), %xmm0
movss 0x3c(%rbx), %xmm1
movss 0x40(%rbx), %xmm2
callq 0x1b730
jmp 0xd2bb8
movq 0x140(%r14), %r12
movss 0x24(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1b6f0
jmp 0xd2bb8
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
movss 0x30(%rbx), %xmm2
callq 0x1c140
jmp 0xd2bb8
movq 0x140(%r14), %r12
movss 0x14(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1b130
jmp 0xd2bb8
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1bd60
jmp 0xd2bb8
movq 0x140(%r14), %r12
movss 0x18(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1bc90
jmp 0xd2bb8
movq 0x140(%r14), %r12
movl 0x10(%rbx), %edi
callq 0x1b410
jmp 0xd2bb8
movq 0x140(%r14), %r12
movss 0x1c(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
movslq 0xc(%rbx), %rdi
movl (%rbx), %esi
callq 0x1b2c0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b9e0
addq $0x4, %r15
cmpq %rbp, %r15
jne 0xd2a80
jmp 0xd2cb9
movq 0x140(%r14), %r12
movq 0x58(%rsp), %rdi
callq 0x1b8d0
movss 0x44(%rbx), %xmm0
movss 0x48(%rbx), %xmm1
movl 0x4c(%rbx), %edx
movl 0x50(%rbx), %ecx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
subq %r8, %r9
sarq $0x3, %r9
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x1bf10
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b9e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x50(%rsp), %rbp
je 0xd2bc3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b940
jmp 0xd2bc3
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
callq 0x1b560
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b9e0
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1c180
movl (%rbx), %esi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
movl %eax, %edi
movl $0x64, %edx
callq 0x1c1e0
jmp 0xd2cc7
movq 0x140(%r14), %r15
movss 0x28(%rbx), %xmm0
callq 0x1b560
movq %r15, %rdi
movq %rax, %rsi
callq 0x1b9e0
movq 0x140(%r14), %r12
movl (%rbx), %edi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
callq 0x1bef0
jmp 0xd2cc7
movq 0x140(%r14), %r12
movl (%rbx), %edi
callq 0x1bdd0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1b9e0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd2ce9
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b940
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x299ff(%rip), %rdi # 0xfc701
leaq 0x29a46(%rip), %rdx # 0xfc74f
movl $0xa5, %esi
xorl %eax, %eax
callq 0x1bf20
leaq 0x299e5(%rip), %rdi # 0xfc701
leaq 0x1a868(%rip), %rdx # 0xed58b
leaq 0x29a5d(%rip), %rcx # 0xfc787
movl $0xe5, %esi
xorl %eax, %eax
callq 0x1bf20
leaq 0x299c4(%rip), %rdi # 0xfc701
leaq 0x1a847(%rip), %rdx # 0xed58b
leaq 0x29a5c(%rip), %rcx # 0xfc7a7
movl $0xf0, %esi
xorl %eax, %eax
callq 0x1bf20
jmp 0xd2d9b
jmp 0xd2d5b
movq %rax, %rbx
movq %r14, %rdi
callq 0x25ae4
jmp 0xd2d6b
movq %rax, %rbx
movl $0x1b8, %esi # imm = 0x1B8
movq %r14, %rdi
jmp 0xd2d94
jmp 0xd2d9b
jmp 0xd2d7f
jmp 0xd2d9b
jmp 0xd2d9b
jmp 0xd2d9b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd2d9e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b940
jmp 0xd2d9e
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd2db5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1b940
movq %rbx, %rdi
callq 0x1c040
| _Z19common_sampler_initPK11llama_modelRK22common_params_sampling:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rsi
mov [rsp+98h+var_40], rdi
call _llama_model_get_vocab
mov [rsp+98h+var_90], rax
call _llama_sampler_chain_default_params
mov bpl, [rbx+61h]
xorps xmm0, xmm0
lea rdi, [rsp+98h+var_68]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+0C8h]
sub rax, [rbx+0C0h]
sar rax, 3
mov rsi, 0CCCCCCCCCCCCCCCDh
imul rsi, rax
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r15, [rbx+0C0h]
mov r13, [rbx+0C8h]
cmp r15, r13
jz short loc_D28F3
lea r14, [rsp+98h+var_68]
lea r12, [rsp+98h+var_88]
loc_D28D7:
mov rax, [r15]
mov [rsp+98h+var_88], rax
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r15, 28h ; '('
cmp r15, r13
jnz short loc_D28D7
loc_D28F3:
lea rdi, [rbx+98h]
lea rcx, aLlguidance; "%llguidance"
mov edx, 0Bh
xor esi, esi
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEmmPKc; std::string::compare(ulong,ulong,char const*)
test eax, eax
jz loc_D2CFB
mov rsi, [rbx+98h]
cmp byte ptr [rbx+0B8h], 1
jnz short loc_D2962
mov rcx, [rsp+98h+var_68]
mov r8, [rsp+98h+var_60]
sub r8, rcx
sar r8, 3
mov r9, [rbx+0D8h]
mov rax, [rbx+0E0h]
sub rax, r9
sar rax, 2
mov [rsp+98h+var_98], rax
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar_lazy
jmp short loc_D2973
loc_D2962:
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar
loc_D2973:
mov r12, rax
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
mov rsi, rbx; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov [r14+138h], r12
movzx edi, bpl
call _llama_sampler_chain_init
mov [r14+140h], rax
mov eax, [rbx+4]
cmp eax, 21h ; '!'
mov esi, 20h ; ' '
cmovge esi, eax
mov [r14+148h], rsi
mov rdi, r14
add rdi, 168h
xorps xmm0, xmm0
movups xmmword ptr [r14+150h], xmm0
mov qword ptr [r14+160h], 0
lea rdx, [rsp+98h+var_88]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
xorps xmm0, xmm0
movups xmmword ptr [r14+1A0h], xmm0
movups xmmword ptr [r14+190h], xmm0
movups xmmword ptr [r14+180h], xmm0
mov qword ptr [r14+1B0h], 0
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov rdx, [rbx+120h]
mov rsi, [rbx+128h]
sub rsi, rdx
shr rsi, 3
mov edi, eax
call _llama_sampler_init_logit_bias
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov eax, [rbx+54h]
cmp eax, 2
jz loc_D2C83
cmp eax, 1
jz loc_D2C3C
test eax, eax
jnz loc_D2D36
mov r15, [rbx+80h]
mov rbp, [rbx+88h]
cmp r15, rbp
jz loc_D2CB9
lea r13, [rsp+98h+var_88]
mov [rsp+98h+var_48], rbp
loc_D2A80:
mov eax, [r15]
dec eax; switch 10 cases
cmp eax, 9
ja def_D2A9C; jumptable 00000000000D2A9C default case, case 5
lea rcx, jpt_D2A9C
movsxd rax, ds:(jpt_D2A9C - 0FC530h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_D2A9E:
xorps xmm0, xmm0; jumptable 00000000000D2A9C case 1
movaps xmmword ptr [rsp+98h+var_88], xmm0
mov [rsp+98h+var_78], 0
mov rsi, [rbx+70h]
sub rsi, [rbx+68h]
sar rsi, 5
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r12, [rbx+68h]
mov rbp, [rbx+70h]
loc_D2ACB:
cmp r12, rbp
jz loc_D2BD5
mov rax, [r12]
mov [rsp+98h+var_38], rax
mov rdi, r13
lea rsi, [rsp+98h+var_38]
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r12, 20h ; ' '
jmp short loc_D2ACB
loc_D2AF0:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 10
mov edi, [rbx+34h]
movss xmm0, dword ptr [rbx+38h]
movss xmm1, dword ptr [rbx+3Ch]
movss xmm2, dword ptr [rbx+40h]
call _llama_sampler_init_penalties
jmp loc_D2BB8
loc_D2B13:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 6
movss xmm0, dword ptr [rbx+24h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_typical
jmp loc_D2BB8
loc_D2B2D:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 7
movss xmm0, dword ptr [rbx+28h]
movss xmm1, dword ptr [rbx+2Ch]
movss xmm2, dword ptr [rbx+30h]
call _llama_sampler_init_temp_ext
jmp short loc_D2BB8
loc_D2B4A:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 3
movss xmm0, dword ptr [rbx+14h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_top_p
jmp short loc_D2BB8
loc_D2B61:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 9
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_infill
jmp short loc_D2BB8
loc_D2B74:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 4
movss xmm0, dword ptr [rbx+18h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_min_p
jmp short loc_D2BB8
loc_D2B8B:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 2
mov edi, [rbx+10h]
call _llama_sampler_init_top_k
jmp short loc_D2BB8
loc_D2B9C:
mov r12, [r14+140h]; jumptable 00000000000D2A9C case 8
movss xmm0, dword ptr [rbx+1Ch]
movss xmm1, dword ptr [rbx+20h]
movsxd rdi, dword ptr [rbx+0Ch]
mov esi, [rbx]
call _llama_sampler_init_xtc
loc_D2BB8:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
loc_D2BC3:
add r15, 4
cmp r15, rbp
jnz loc_D2A80
jmp loc_D2CB9
loc_D2BD5:
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_40]
call _llama_model_n_ctx_train
movss xmm0, dword ptr [rbx+44h]
movss xmm1, dword ptr [rbx+48h]
mov edx, [rbx+4Ch]
mov ecx, [rbx+50h]
mov r8, [rsp+98h+var_88]
mov r9, [rsp+98h+var_88+8]
sub r9, r8
sar r9, 3
mov rdi, [rsp+98h+var_90]
mov esi, eax
call _llama_sampler_init_dry
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
mov rbp, [rsp+98h+var_48]
jz short loc_D2BC3
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D2BC3
loc_D2C3C:
mov r12, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov esi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
mov edi, eax
mov edx, 64h ; 'd'
call _llama_sampler_init_mirostat
jmp short loc_D2CC7
loc_D2C83:
mov r15, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r15
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov edi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
call _llama_sampler_init_mirostat_v2
jmp short loc_D2CC7
loc_D2CB9:
mov r12, [r14+140h]
mov edi, [rbx]
call _llama_sampler_init_dist
loc_D2CC7:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_D2CE9
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D2CE9:
mov rax, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D2CFB:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aLlguidanceCmak; "llguidance (cmake -DLLAMA_LLGUIDANCE=ON"...
mov esi, 0A5h
xor eax, eax
call _ggml_abort
def_D2A9C:
lea rdi, aWorkspaceLlm4b_3; jumptable 00000000000D2A9C default case, case 5
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownSa; "false && \"unknown sampler type\""
mov esi, 0E5h
xor eax, eax
call _ggml_abort
loc_D2D36:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownMi; "false && \"unknown mirostat version\""
mov esi, 0F0h
xor eax, eax
call _ggml_abort
jmp short loc_D2D9B
jmp short $+2
loc_D2D5B:
mov rbx, rax
mov rdi, r14; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
jmp short loc_D2D6B
mov rbx, rax
loc_D2D6B:
mov esi, 1B8h
mov rdi, r14
jmp short loc_D2D94
jmp short loc_D2D9B
jmp short loc_D2D7F
jmp short loc_D2D9B
jmp short loc_D2D9B
jmp short loc_D2D9B
loc_D2D7F:
mov rbx, rax
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
jz short loc_D2D9E
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
loc_D2D94:
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D2D9E
loc_D2D9B:
mov rbx, rax
loc_D2D9E:
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_D2DB5
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D2DB5:
mov rdi, rbx
call __Unwind_Resume
| long long common_sampler_init(long long a1, unsigned int *a2)
{
unsigned __int8 v3; // bp
void **v4; // r15
void **i; // r13
long long v6; // rsi
long long inited; // rax
long long v8; // r12
long long v9; // r14
int v10; // eax
unsigned long long v11; // rsi
long long v12; // r12
unsigned int v13; // eax
long long v14; // rax
unsigned int v15; // eax
_DWORD *v16; // r15
_DWORD *v17; // rbp
long long *v18; // r12
long long *v19; // rbp
long long v20; // r12
long long v21; // rax
long long v22; // r12
unsigned int v23; // eax
long long v24; // rax
long long v25; // r12
long long v26; // rax
long long v27; // r12
unsigned int v28; // eax
long long v29; // rax
long long v30; // r15
long long v31; // rax
long long v33; // rax
long long v34; // rbx
long long vocab; // [rsp+8h] [rbp-90h]
void *v36[2]; // [rsp+10h] [rbp-88h] BYREF
long long v37; // [rsp+20h] [rbp-78h]
__int128 v38; // [rsp+30h] [rbp-68h] BYREF
long long v39; // [rsp+40h] [rbp-58h]
_DWORD *v40; // [rsp+50h] [rbp-48h]
long long v41; // [rsp+58h] [rbp-40h]
long long v42[7]; // [rsp+60h] [rbp-38h] BYREF
v41 = a1;
vocab = llama_model_get_vocab(a1);
llama_sampler_chain_default_params();
v3 = *((_BYTE *)a2 + 97);
v38 = 0LL;
v39 = 0LL;
std::vector<char const*>::reserve(
&v38,
0xCCCCCCCCCCCCCCCDLL * ((long long)(*((_QWORD *)a2 + 25) - *((_QWORD *)a2 + 24)) >> 3));
v4 = (void **)*((_QWORD *)a2 + 24);
for ( i = (void **)*((_QWORD *)a2 + 25); v4 != i; v4 += 5 )
{
v36[0] = *v4;
std::vector<char const*>::emplace_back<char const*>(&v38, v36);
}
if ( !(unsigned int)std::string::compare(a2 + 38, 0LL, 11LL, "%llguidance") )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
165LL,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
LABEL_38:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
229LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown sampler type\"");
goto LABEL_39;
}
v6 = *((_QWORD *)a2 + 19);
if ( *((_BYTE *)a2 + 184) == 1 )
inited = llama_sampler_init_grammar_lazy(vocab, v6, "root", v38, (long long)(*((_QWORD *)&v38 + 1) - v38) >> 3);
else
inited = llama_sampler_init_grammar(vocab, v6, "root");
v8 = inited;
v9 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v9, (const common_params_sampling *)a2);
*(_QWORD *)(v9 + 312) = v8;
*(_QWORD *)(v9 + 320) = llama_sampler_chain_init(v3);
v10 = a2[1];
v11 = 32LL;
if ( v10 >= 33 )
v11 = (unsigned int)v10;
*(_QWORD *)(v9 + 328) = v11;
*(_OWORD *)(v9 + 336) = 0LL;
*(_QWORD *)(v9 + 352) = 0LL;
std::vector<int>::vector(v9 + 360, v11);
*(_OWORD *)(v9 + 416) = 0LL;
*(_OWORD *)(v9 + 400) = 0LL;
*(_OWORD *)(v9 + 384) = 0LL;
*(_QWORD *)(v9 + 432) = 0LL;
v12 = *(_QWORD *)(v9 + 320);
v13 = llama_vocab_n_tokens(vocab);
v14 = llama_sampler_init_logit_bias(v13, (*((_QWORD *)a2 + 37) - *((_QWORD *)a2 + 36)) >> 3);
llama_sampler_chain_add(v12, v14);
v15 = a2[21];
if ( v15 == 2 )
{
v30 = *(_QWORD *)(v9 + 320);
v31 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v30, v31);
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_mirostat_v2(*a2, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 == 1 )
{
v25 = *(_QWORD *)(v9 + 320);
v26 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v25, v26);
v27 = *(_QWORD *)(v9 + 320);
v28 = llama_vocab_n_tokens(vocab);
v29 = llama_sampler_init_mirostat(v28, *a2, 100LL, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 )
{
LABEL_39:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
240LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown mirostat version\"");
v34 = v33;
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
_Unwind_Resume(v34);
}
v16 = (_DWORD *)*((_QWORD *)a2 + 16);
v17 = (_DWORD *)*((_QWORD *)a2 + 17);
if ( v16 != v17 )
{
v40 = (_DWORD *)*((_QWORD *)a2 + 17);
while ( 2 )
{
switch ( *v16 )
{
case 1:
*(_OWORD *)v36 = 0LL;
v37 = 0LL;
std::vector<char const*>::reserve(v36, (long long)(*((_QWORD *)a2 + 14) - *((_QWORD *)a2 + 13)) >> 5);
v18 = (long long *)*((_QWORD *)a2 + 13);
v19 = (long long *)*((_QWORD *)a2 + 14);
while ( v18 != v19 )
{
v42[0] = *v18;
std::vector<char const*>::emplace_back<char const*>(v36, v42);
v18 += 4;
}
v22 = *(_QWORD *)(v9 + 320);
v23 = llama_model_n_ctx_train(v41);
v24 = llama_sampler_init_dry(
vocab,
v23,
a2[19],
a2[20],
v36[0],
((char *)v36[1] - (char *)v36[0]) >> 3,
*((float *)a2 + 17),
*((float *)a2 + 18));
llama_sampler_chain_add(v22, v24);
v17 = v40;
if ( v36[0] )
operator delete(v36[0], v37 - (unsigned long long)v36[0]);
goto LABEL_27;
case 2:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_k(a2[4]);
goto LABEL_26;
case 3:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_p((int)a2[3], *((float *)a2 + 5));
goto LABEL_26;
case 4:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_min_p((int)a2[3], *((float *)a2 + 6));
goto LABEL_26;
case 6:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_typical((int)a2[3], *((float *)a2 + 9));
goto LABEL_26;
case 7:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_temp_ext(*((float *)a2 + 10), *((float *)a2 + 11), *((float *)a2 + 12));
goto LABEL_26;
case 8:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_xtc((int)a2[3], *a2, *((float *)a2 + 7), *((float *)a2 + 8));
goto LABEL_26;
case 9:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_infill(vocab);
goto LABEL_26;
case 0xA:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_penalties(a2[13], *((float *)a2 + 14), *((float *)a2 + 15), *((float *)a2 + 16));
LABEL_26:
llama_sampler_chain_add(v20, v21);
LABEL_27:
if ( ++v16 == v17 )
break;
continue;
default:
goto LABEL_38;
}
break;
}
}
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_dist(*a2);
LABEL_34:
llama_sampler_chain_add(v27, v29);
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
return v9;
}
| common_sampler_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
MOV qword ptr [RSP + 0x58],RDI
CALL 0x0011c1f0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0011bdb0
MOV BPL,byte ptr [RBX + 0x61]
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RBX + 0xc8]
SUB RAX,qword ptr [RBX + 0xc0]
SAR RAX,0x3
MOV RSI,-0x3333333333333333
IMUL RSI,RAX
LAB_001d28b5:
CALL 0x001d4062
MOV R15,qword ptr [RBX + 0xc0]
MOV R13,qword ptr [RBX + 0xc8]
CMP R15,R13
JZ 0x001d28f3
LEA R14,[RSP + 0x30]
LEA R12,[RSP + 0x10]
LAB_001d28d7:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x10],RAX
LAB_001d28df:
MOV RDI,R14
MOV RSI,R12
CALL 0x001d4674
ADD R15,0x28
CMP R15,R13
JNZ 0x001d28d7
LAB_001d28f3:
LEA RDI,[RBX + 0x98]
LAB_001d28fa:
LEA RCX,[0x1fc6f5]
MOV EDX,0xb
XOR ESI,ESI
CALL 0x0011bbd0
TEST EAX,EAX
JZ 0x001d2cfb
MOV RSI,qword ptr [RBX + 0x98]
CMP byte ptr [RBX + 0xb8],0x1
JNZ 0x001d2962
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
SUB R8,RCX
SAR R8,0x3
MOV R9,qword ptr [RBX + 0xd8]
MOV RAX,qword ptr [RBX + 0xe0]
SUB RAX,R9
SAR RAX,0x2
MOV qword ptr [RSP],RAX
LEA RDX,[0x1fbd1f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b770
JMP 0x001d2973
LAB_001d2962:
LEA RDX,[0x1fbd1f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b190
LAB_001d2973:
MOV R12,RAX
LAB_001d2976:
MOV EDI,0x1b8
CALL 0x0011b910
LAB_001d2980:
MOV R14,RAX
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00158faa
MOV qword ptr [R14 + 0x138],R12
LAB_001d2995:
MOVZX EDI,BPL
CALL 0x0011b4f0
MOV qword ptr [R14 + 0x140],RAX
MOV EAX,dword ptr [RBX + 0x4]
CMP EAX,0x21
MOV ESI,0x20
CMOVGE ESI,EAX
MOV qword ptr [R14 + 0x148],RSI
MOV RDI,R14
ADD RDI,0x168
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x150],XMM0
MOV qword ptr [R14 + 0x160],0x0
LAB_001d29da:
LEA RDX,[RSP + 0x10]
CALL 0x0017dca4
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x1a0],XMM0
MOVUPS xmmword ptr [R14 + 0x190],XMM0
MOVUPS xmmword ptr [R14 + 0x180],XMM0
MOV qword ptr [R14 + 0x1b0],0x0
MOV R12,qword ptr [R14 + 0x140]
LAB_001d2a11:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011c180
MOV RDX,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RBX + 0x128]
SUB RSI,RDX
SHR RSI,0x3
MOV EDI,EAX
CALL 0x0011bee0
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011b9e0
MOV EAX,dword ptr [RBX + 0x54]
CMP EAX,0x2
JZ 0x001d2c83
CMP EAX,0x1
JZ 0x001d2c3c
TEST EAX,EAX
JNZ 0x001d2d36
MOV R15,qword ptr [RBX + 0x80]
MOV RBP,qword ptr [RBX + 0x88]
CMP R15,RBP
JZ 0x001d2cb9
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x50],RBP
LAB_001d2a80:
MOV EAX,dword ptr [R15]
DEC EAX
CMP EAX,0x9
JA 0x001d2d15
LEA RCX,[0x1fc530]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,qword ptr [RBX + 0x68]
SAR RSI,0x5
LAB_001d2abb:
MOV RDI,R13
CALL 0x001d4062
MOV R12,qword ptr [RBX + 0x68]
MOV RBP,qword ptr [RBX + 0x70]
LAB_001d2acb:
CMP R12,RBP
JZ 0x001d2bd5
MOV RAX,qword ptr [R12]
MOV qword ptr [RSP + 0x60],RAX
LAB_001d2add:
MOV RDI,R13
LEA RSI,[RSP + 0x60]
CALL 0x001d4674
ADD R12,0x20
JMP 0x001d2acb
caseD_a:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x34]
MOVSS XMM0,dword ptr [RBX + 0x38]
MOVSS XMM1,dword ptr [RBX + 0x3c]
MOVSS XMM2,dword ptr [RBX + 0x40]
LAB_001d2b09:
CALL 0x0011b730
JMP 0x001d2bb8
caseD_6:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x24]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011b6f0
JMP 0x001d2bb8
caseD_7:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
MOVSS XMM1,dword ptr [RBX + 0x2c]
MOVSS XMM2,dword ptr [RBX + 0x30]
CALL 0x0011c140
JMP 0x001d2bb8
caseD_3:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x14]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011b130
JMP 0x001d2bb8
caseD_9:
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011bd60
JMP 0x001d2bb8
caseD_4:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x18]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011bc90
JMP 0x001d2bb8
caseD_2:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x10]
CALL 0x0011b410
JMP 0x001d2bb8
caseD_8:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x1c]
MOVSS XMM1,dword ptr [RBX + 0x20]
MOVSXD RDI,dword ptr [RBX + 0xc]
MOV ESI,dword ptr [RBX]
CALL 0x0011b2c0
LAB_001d2bb8:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011b9e0
LAB_001d2bc3:
ADD R15,0x4
CMP R15,RBP
JNZ 0x001d2a80
JMP 0x001d2cb9
LAB_001d2bd5:
MOV R12,qword ptr [R14 + 0x140]
LAB_001d2bdc:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0011b8d0
MOVSS XMM0,dword ptr [RBX + 0x44]
MOVSS XMM1,dword ptr [RBX + 0x48]
MOV EDX,dword ptr [RBX + 0x4c]
MOV ECX,dword ptr [RBX + 0x50]
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
SUB R9,R8
SAR R9,0x3
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,EAX
CALL 0x0011bf10
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011b9e0
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
MOV RBP,qword ptr [RSP + 0x50]
JZ 0x001d2bc3
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0011b940
JMP 0x001d2bc3
LAB_001d2c3c:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
LAB_001d2c48:
CALL 0x0011b560
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011b9e0
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011c180
MOV ESI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
MOV EDI,EAX
MOV EDX,0x64
CALL 0x0011c1e0
JMP 0x001d2cc7
LAB_001d2c83:
MOV R15,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
CALL 0x0011b560
MOV RDI,R15
MOV RSI,RAX
CALL 0x0011b9e0
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
CALL 0x0011bef0
JMP 0x001d2cc7
LAB_001d2cb9:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
CALL 0x0011bdd0
LAB_001d2cc7:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011b9e0
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001d2ce9
MOV RSI,qword ptr [RSP + 0x40]
SUB RSI,RDI
CALL 0x0011b940
LAB_001d2ce9:
MOV RAX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001d2cfb:
LEA RDI,[0x1fc701]
LEA RDX,[0x1fc74f]
MOV ESI,0xa5
XOR EAX,EAX
CALL 0x0011bf20
caseD_5:
LEA RDI,[0x1fc701]
LEA RDX,[0x1ed58b]
LEA RCX,[0x1fc787]
MOV ESI,0xe5
XOR EAX,EAX
CALL 0x0011bf20
LAB_001d2d36:
LEA RDI,[0x1fc701]
LEA RDX,[0x1ed58b]
LEA RCX,[0x1fc7a7]
MOV ESI,0xf0
XOR EAX,EAX
CALL 0x0011bf20
|
/* common_sampler_init(llama_model const*, common_params_sampling const&) */
common_params_sampling * common_sampler_init(llama_model *param_1,common_params_sampling *param_2)
{
common_params_sampling cVar1;
int8 *puVar2;
int iVar3;
int4 uVar4;
int8 uVar5;
int8 uVar6;
common_params_sampling *this;
int8 uVar7;
int4 *puVar8;
allocator *paVar9;
int8 *puVar10;
int4 *puVar11;
char *local_88;
long lStack_80;
long local_78;
void *local_68;
long lStack_60;
long local_58;
int4 *local_48;
llama_model *local_40;
char *local_38;
local_40 = param_1;
uVar5 = llama_model_get_vocab();
llama_sampler_chain_default_params();
cVar1 = param_2[0x61];
local_68 = (void *)0x0;
lStack_60 = 0;
local_58 = 0;
/* try { // try from 001d28b5 to 001d28b9 has its CatchHandler @ 001d2d75 */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_68,
(*(long *)(param_2 + 200) - *(long *)(param_2 + 0xc0) >> 3) * -0x3333333333333333);
puVar10 = *(int8 **)(param_2 + 0xc0);
puVar2 = *(int8 **)(param_2 + 200);
if (puVar10 != puVar2) {
do {
local_88 = (char *)*puVar10;
/* try { // try from 001d28df to 001d28e9 has its CatchHandler @ 001d2d9b */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_68,&local_88);
puVar10 = puVar10 + 5;
} while (puVar10 != puVar2);
}
/* try { // try from 001d28fa to 001d2972 has its CatchHandler @ 001d2d79 */
iVar3 = std::__cxx11::string::compare((ulong)(param_2 + 0x98),0,(char *)0xb);
if (iVar3 == 0) {
/* try { // try from 001d2cfb to 001d2d14 has its CatchHandler @ 001d2d79 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",0xa5,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
}
if (param_2[0xb8] == (common_params_sampling)0x1) {
uVar6 = llama_sampler_init_grammar_lazy
(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001fbd1f,local_68,
lStack_60 - (long)local_68 >> 3,*(long *)(param_2 + 0xd8),
*(long *)(param_2 + 0xe0) - *(long *)(param_2 + 0xd8) >> 2);
}
else {
uVar6 = llama_sampler_init_grammar(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001fbd1f);
}
/* try { // try from 001d2976 to 001d297f has its CatchHandler @ 001d2d7b */
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 001d2980 to 001d298d has its CatchHandler @ 001d2d68 */
common_params_sampling::common_params_sampling(this,param_2);
*(int8 *)(this + 0x138) = uVar6;
/* try { // try from 001d2995 to 001d299d has its CatchHandler @ 001d2d5b */
uVar6 = llama_sampler_chain_init(cVar1);
*(int8 *)(this + 0x140) = uVar6;
paVar9 = (allocator *)0x20;
if (0x20 < (int)*(uint *)(param_2 + 4)) {
paVar9 = (allocator *)(ulong)*(uint *)(param_2 + 4);
}
*(allocator **)(this + 0x148) = paVar9;
*(int8 *)(this + 0x150) = 0;
*(int8 *)(this + 0x158) = 0;
*(int8 *)(this + 0x160) = 0;
/* try { // try from 001d29da to 001d29e3 has its CatchHandler @ 001d2d59 */
std::vector<int,std::allocator<int>>::vector((ulong)(this + 0x168),paVar9);
*(int8 *)(this + 0x1a0) = 0;
*(int8 *)(this + 0x1a8) = 0;
*(int8 *)(this + 400) = 0;
*(int8 *)(this + 0x198) = 0;
*(int8 *)(this + 0x180) = 0;
*(int8 *)(this + 0x188) = 0;
*(int8 *)(this + 0x1b0) = 0;
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d2a11 to 001d2a41 has its CatchHandler @ 001d2d7b */
uVar4 = llama_vocab_n_tokens(uVar5);
uVar7 = llama_sampler_init_logit_bias
(uVar4,(ulong)(*(long *)(param_2 + 0x128) - *(long *)(param_2 + 0x120)) >> 3);
llama_sampler_chain_add(uVar6,uVar7);
iVar3 = *(int *)(param_2 + 0x54);
if (iVar3 == 2) {
uVar5 = *(int8 *)(this + 0x140);
uVar6 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar5,uVar6);
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_mirostat_v2
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),
*(int4 *)param_2);
}
else if (iVar3 == 1) {
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d2c48 to 001d2cd1 has its CatchHandler @ 001d2d7b */
uVar7 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar6,uVar7);
uVar6 = *(int8 *)(this + 0x140);
uVar4 = llama_vocab_n_tokens(uVar5);
uVar5 = llama_sampler_init_mirostat
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),uVar4,
*(int4 *)param_2,100);
}
else {
if (iVar3 != 0) {
/* try { // try from 001d2d36 to 001d2d56 has its CatchHandler @ 001d2d7b */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
0xf0,"GGML_ASSERT(%s) failed","false && \"unknown mirostat version\"");
}
puVar11 = *(int4 **)(param_2 + 0x80);
puVar8 = *(int4 **)(param_2 + 0x88);
if (puVar11 != puVar8) {
local_48 = puVar8;
do {
switch(*puVar11) {
case 1:
local_88 = (char *)0x0;
lStack_80 = 0;
local_78 = 0;
/* try { // try from 001d2abb to 001d2ac2 has its CatchHandler @ 001d2d77 */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_88,
*(long *)(param_2 + 0x70) - *(long *)(param_2 + 0x68) >> 5);
puVar2 = *(int8 **)(param_2 + 0x70);
for (puVar10 = *(int8 **)(param_2 + 0x68); puVar10 != puVar2; puVar10 = puVar10 + 4)
{
local_38 = (char *)*puVar10;
/* try { // try from 001d2add to 001d2ae9 has its CatchHandler @ 001d2d7f */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_88,&local_38);
}
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d2bdc to 001d2c1d has its CatchHandler @ 001d2d77 */
uVar4 = llama_model_n_ctx_train(local_40);
uVar7 = llama_sampler_init_dry
(*(int4 *)(param_2 + 0x44),*(int4 *)(param_2 + 0x48),uVar5,
uVar4,*(int4 *)(param_2 + 0x4c),*(int4 *)(param_2 + 0x50),
local_88,lStack_80 - (long)local_88 >> 3);
llama_sampler_chain_add(uVar6,uVar7);
puVar8 = local_48;
if (local_88 != (char *)0x0) {
operator_delete(local_88,local_78 - (long)local_88);
}
goto LAB_001d2bc3;
case 2:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_k(*(int4 *)(param_2 + 0x10));
break;
case 3:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_p
(*(int4 *)(param_2 + 0x14),(long)*(int *)(param_2 + 0xc));
break;
case 4:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_min_p
(*(int4 *)(param_2 + 0x18),(long)*(int *)(param_2 + 0xc));
break;
default:
/* try { // try from 001d2d15 to 001d2d35 has its CatchHandler @ 001d2d57 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp"
,0xe5,"GGML_ASSERT(%s) failed","false && \"unknown sampler type\"");
case 6:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_typical
(*(int4 *)(param_2 + 0x24),(long)*(int *)(param_2 + 0xc));
break;
case 7:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_temp_ext
(*(int4 *)(param_2 + 0x28),*(int4 *)(param_2 + 0x2c),
*(int4 *)(param_2 + 0x30));
break;
case 8:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_xtc
(*(int4 *)(param_2 + 0x1c),*(int4 *)(param_2 + 0x20),
(long)*(int *)(param_2 + 0xc),*(int4 *)param_2);
break;
case 9:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_infill(uVar5);
break;
case 10:
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001d2b09 to 001d2bc2 has its CatchHandler @ 001d2d7d */
uVar7 = llama_sampler_init_penalties
(*(int4 *)(param_2 + 0x38),*(int4 *)(param_2 + 0x3c),
*(int4 *)(param_2 + 0x40),*(int4 *)(param_2 + 0x34));
}
llama_sampler_chain_add(uVar6,uVar7);
LAB_001d2bc3:
puVar11 = puVar11 + 1;
} while (puVar11 != puVar8);
}
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_dist(*(int4 *)param_2);
}
llama_sampler_chain_add(uVar6,uVar5);
if (local_68 != (void *)0x0) {
operator_delete(local_68,local_58 - (long)local_68);
}
return this;
}
| |
53,796 | common_sampler_init(llama_model const*, common_params_sampling const&) | monkey531[P]llama/common/sampling.cpp | struct common_sampler * common_sampler_init(const struct llama_model * model, const struct common_params_sampling & params) {
const llama_vocab * vocab = llama_model_get_vocab(model);
llama_sampler_chain_params lparams = llama_sampler_chain_default_params();
lparams.no_perf = params.no_perf;
std::vector<const char *> trigger_words;
trigger_words.reserve(params.grammar_trigger_words.size());
for (const auto & str : params.grammar_trigger_words) {
trigger_words.push_back(str.word.c_str());
}
struct llama_sampler * grmr;
if (params.grammar.compare(0, 11, "%llguidance") == 0) {
#ifdef LLAMA_USE_LLGUIDANCE
grmr = llama_sampler_init_llg(vocab, "lark", params.grammar.c_str());
#else
GGML_ABORT("llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
#endif // LLAMA_USE_LLGUIDANCE
} else {
grmr = params.grammar_lazy
? llama_sampler_init_grammar_lazy(vocab, params.grammar.c_str(), "root",
trigger_words.data(), trigger_words.size(),
params.grammar_trigger_tokens.data(), params.grammar_trigger_tokens.size())
: llama_sampler_init_grammar(vocab, params.grammar.c_str(), "root");
}
auto * result = new common_sampler {
/* .params = */ params,
/* .grmr = */ grmr,
/* .chain = */ llama_sampler_chain_init(lparams),
/* .prev = */ ring_buffer<llama_token>(std::max(32, params.n_prev)),
/* .cur = */ {},
/* .cur_p = */ {},
};
llama_sampler_chain_add(result->chain,
llama_sampler_init_logit_bias(
llama_vocab_n_tokens(vocab),
params.logit_bias.size(),
params.logit_bias.data()));
if (params.mirostat == 0) {
for (const auto & cnstr : params.samplers) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY:
{
std::vector<const char *> c_breakers;
c_breakers.reserve(params.dry_sequence_breakers.size());
for (const auto & str : params.dry_sequence_breakers) {
c_breakers.push_back(str.c_str());
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dry (vocab, llama_model_n_ctx_train(model), params.dry_multiplier, params.dry_base, params.dry_allowed_length, params.dry_penalty_last_n, c_breakers.data(), c_breakers.size()));
}
break;
case COMMON_SAMPLER_TYPE_TOP_K:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_k (params.top_k));
break;
case COMMON_SAMPLER_TYPE_TOP_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_p (params.top_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_MIN_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_min_p (params.min_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_XTC:
llama_sampler_chain_add(result->chain, llama_sampler_init_xtc (params.xtc_probability, params.xtc_threshold, params.min_keep, params.seed));
break;
case COMMON_SAMPLER_TYPE_TYPICAL_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_typical (params.typ_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_TEMPERATURE:
llama_sampler_chain_add(result->chain, llama_sampler_init_temp_ext (params.temp, params.dynatemp_range, params.dynatemp_exponent));
break;
case COMMON_SAMPLER_TYPE_INFILL:
llama_sampler_chain_add(result->chain, llama_sampler_init_infill (vocab));
break;
case COMMON_SAMPLER_TYPE_PENALTIES:
llama_sampler_chain_add(result->chain, llama_sampler_init_penalties(params.penalty_last_n, params.penalty_repeat, params.penalty_freq, params.penalty_present));
break;
default:
GGML_ASSERT(false && "unknown sampler type");
}
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dist(params.seed));
} else if (params.mirostat == 1) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat(llama_vocab_n_tokens(vocab), params.seed, params.mirostat_tau, params.mirostat_eta, 100));
} else if (params.mirostat == 2) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat_v2(params.seed, params.mirostat_tau, params.mirostat_eta));
} else {
GGML_ASSERT(false && "unknown mirostat version");
}
return result;
} | O3 | cpp | common_sampler_init(llama_model const*, common_params_sampling const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, 0x58(%rsp)
callq 0x1b180
movq %rax, 0x8(%rsp)
callq 0x1ad50
movb 0x61(%rbx), %bpl
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xc8(%rbx), %rax
subq 0xc0(%rbx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
callq 0xce190
movq 0xc0(%rbx), %r15
movq 0xc8(%rbx), %r13
cmpq %r13, %r15
je 0xccaab
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r12
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xce7d2
addq $0x28, %r15
cmpq %r13, %r15
jne 0xcca8f
leaq 0x98(%rbx), %rdi
leaq 0x2878c(%rip), %rcx # 0xf5245
movl $0xb, %edx
xorl %esi, %esi
callq 0x1ab80
testl %eax, %eax
je 0xcceb3
movq 0x98(%rbx), %rsi
cmpb $0x1, 0xb8(%rbx)
jne 0xccb1a
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
subq %rcx, %r8
sarq $0x3, %r8
movq 0xd8(%rbx), %r9
movq 0xe0(%rbx), %rax
subq %r9, %rax
sarq $0x2, %rax
movq %rax, (%rsp)
leaq 0x27d61(%rip), %rdx # 0xf486f
movq 0x8(%rsp), %rdi
callq 0x1a740
jmp 0xccb2b
leaq 0x27d4e(%rip), %rdx # 0xf486f
movq 0x8(%rsp), %rdi
callq 0x1a190
movq %rax, %r12
movl $0x1b8, %edi # imm = 0x1B8
callq 0x1a8c0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x54326
movq %r12, 0x138(%r14)
movzbl %bpl, %edi
callq 0x1a4e0
movq %rax, 0x140(%r14)
movl 0x4(%rbx), %eax
cmpl $0x21, %eax
movl $0x20, %esi
cmovgel %eax, %esi
movq %rsi, 0x148(%r14)
movq %r14, %rdi
addq $0x168, %rdi # imm = 0x168
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movq $0x0, 0x160(%r14)
leaq 0x10(%rsp), %rdx
callq 0x78ca2
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%r14)
movups %xmm0, 0x190(%r14)
movups %xmm0, 0x180(%r14)
movq $0x0, 0x1b0(%r14)
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1b110
movq 0x120(%rbx), %rdx
movq 0x128(%rbx), %rsi
subq %rdx, %rsi
shrq $0x3, %rsi
movl %eax, %edi
callq 0x1ae80
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movl 0x54(%rbx), %eax
cmpl $0x2, %eax
je 0xcce3b
cmpl $0x1, %eax
je 0xccdf4
testl %eax, %eax
jne 0xcceee
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %rbp
cmpq %rbp, %r15
je 0xcce71
leaq 0x10(%rsp), %r13
movq %rbp, 0x50(%rsp)
movl (%r15), %eax
decl %eax
cmpl $0x9, %eax
ja 0xccecd
leaq 0x28433(%rip), %rcx # 0xf5080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
movq %r13, %rdi
callq 0xce190
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %rbp
cmpq %rbp, %r12
je 0xccd8d
movq (%r12), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0xce7d2
addq $0x20, %r12
jmp 0xccc83
movq 0x140(%r14), %r12
movl 0x34(%rbx), %edi
movss 0x38(%rbx), %xmm0
movss 0x3c(%rbx), %xmm1
movss 0x40(%rbx), %xmm2
callq 0x1a700
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x24(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1a6c0
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
movss 0x30(%rbx), %xmm2
callq 0x1b0d0
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x14(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1a130
jmp 0xccd70
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1ad00
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x18(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1ac30
jmp 0xccd70
movq 0x140(%r14), %r12
movl 0x10(%rbx), %edi
callq 0x1a410
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x1c(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
movslq 0xc(%rbx), %rdi
movl (%rbx), %esi
callq 0x1a2c0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
addq $0x4, %r15
cmpq %rbp, %r15
jne 0xccc38
jmp 0xcce71
movq 0x140(%r14), %r12
movq 0x58(%rsp), %rdi
callq 0x1a880
movss 0x44(%rbx), %xmm0
movss 0x48(%rbx), %xmm1
movl 0x4c(%rbx), %edx
movl 0x50(%rbx), %ecx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
subq %r8, %r9
sarq $0x3, %r9
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x1aeb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x50(%rsp), %rbp
je 0xccd7b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
jmp 0xccd7b
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
callq 0x1a550
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1b110
movl (%rbx), %esi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
movl %eax, %edi
movl $0x64, %edx
callq 0x1b170
jmp 0xcce7f
movq 0x140(%r14), %r15
movss 0x28(%rbx), %xmm0
callq 0x1a550
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x140(%r14), %r12
movl (%rbx), %edi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
callq 0x1ae90
jmp 0xcce7f
movq 0x140(%r14), %r12
movl (%rbx), %edi
callq 0x1ad70
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xccea1
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28397(%rip), %rdi # 0xf5251
leaq 0x283de(%rip), %rdx # 0xf529f
movl $0xa5, %esi
xorl %eax, %eax
callq 0x1aec0
leaq 0x2837d(%rip), %rdi # 0xf5251
leaq 0x1932f(%rip), %rdx # 0xe620a
leaq 0x283f5(%rip), %rcx # 0xf52d7
movl $0xe5, %esi
xorl %eax, %eax
callq 0x1aec0
leaq 0x2835c(%rip), %rdi # 0xf5251
leaq 0x1930e(%rip), %rdx # 0xe620a
leaq 0x283f4(%rip), %rcx # 0xf52f7
movl $0xf0, %esi
xorl %eax, %eax
callq 0x1aec0
jmp 0xccf53
jmp 0xccf13
movq %rax, %rbx
movq %r14, %rdi
callq 0x21742
jmp 0xccf23
movq %rax, %rbx
movl $0x1b8, %esi # imm = 0x1B8
movq %r14, %rdi
jmp 0xccf4c
jmp 0xccf53
jmp 0xccf37
jmp 0xccf53
jmp 0xccf53
jmp 0xccf53
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xccf56
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
jmp 0xccf56
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xccf6d
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %rbx, %rdi
callq 0x1afd0
| _Z19common_sampler_initPK11llama_modelRK22common_params_sampling:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rsi
mov [rsp+98h+var_40], rdi
call _llama_model_get_vocab
mov [rsp+98h+var_90], rax
call _llama_sampler_chain_default_params
mov bpl, [rbx+61h]
xorps xmm0, xmm0
lea rdi, [rsp+98h+var_68]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+0C8h]
sub rax, [rbx+0C0h]
sar rax, 3
mov rsi, 0CCCCCCCCCCCCCCCDh
imul rsi, rax
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r15, [rbx+0C0h]
mov r13, [rbx+0C8h]
cmp r15, r13
jz short loc_CCAAB
lea r14, [rsp+98h+var_68]
lea r12, [rsp+98h+var_88]
loc_CCA8F:
mov rax, [r15]
mov [rsp+98h+var_88], rax
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r15, 28h ; '('
cmp r15, r13
jnz short loc_CCA8F
loc_CCAAB:
lea rdi, [rbx+98h]
lea rcx, aLlguidance; "%llguidance"
mov edx, 0Bh
xor esi, esi
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEmmPKc; std::string::compare(ulong,ulong,char const*)
test eax, eax
jz loc_CCEB3
mov rsi, [rbx+98h]
cmp byte ptr [rbx+0B8h], 1
jnz short loc_CCB1A
mov rcx, [rsp+98h+var_68]
mov r8, [rsp+98h+var_60]
sub r8, rcx
sar r8, 3
mov r9, [rbx+0D8h]
mov rax, [rbx+0E0h]
sub rax, r9
sar rax, 2
mov [rsp+98h+var_98], rax
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar_lazy
jmp short loc_CCB2B
loc_CCB1A:
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar
loc_CCB2B:
mov r12, rax
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
mov rsi, rbx; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov [r14+138h], r12
movzx edi, bpl
call _llama_sampler_chain_init
mov [r14+140h], rax
mov eax, [rbx+4]
cmp eax, 21h ; '!'
mov esi, 20h ; ' '
cmovge esi, eax
mov [r14+148h], rsi
mov rdi, r14
add rdi, 168h
xorps xmm0, xmm0
movups xmmword ptr [r14+150h], xmm0
mov qword ptr [r14+160h], 0
lea rdx, [rsp+98h+var_88]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
xorps xmm0, xmm0
movups xmmword ptr [r14+1A0h], xmm0
movups xmmword ptr [r14+190h], xmm0
movups xmmword ptr [r14+180h], xmm0
mov qword ptr [r14+1B0h], 0
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov rdx, [rbx+120h]
mov rsi, [rbx+128h]
sub rsi, rdx
shr rsi, 3
mov edi, eax
call _llama_sampler_init_logit_bias
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov eax, [rbx+54h]
cmp eax, 2
jz loc_CCE3B
cmp eax, 1
jz loc_CCDF4
test eax, eax
jnz loc_CCEEE
mov r15, [rbx+80h]
mov rbp, [rbx+88h]
cmp r15, rbp
jz loc_CCE71
lea r13, [rsp+98h+var_88]
mov [rsp+98h+var_48], rbp
loc_CCC38:
mov eax, [r15]
dec eax; switch 10 cases
cmp eax, 9
ja def_CCC54; jumptable 00000000000CCC54 default case, case 5
lea rcx, jpt_CCC54
movsxd rax, ds:(jpt_CCC54 - 0F5080h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_CCC56:
xorps xmm0, xmm0; jumptable 00000000000CCC54 case 1
movaps xmmword ptr [rsp+98h+var_88], xmm0
mov [rsp+98h+var_78], 0
mov rsi, [rbx+70h]
sub rsi, [rbx+68h]
sar rsi, 5
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r12, [rbx+68h]
mov rbp, [rbx+70h]
loc_CCC83:
cmp r12, rbp
jz loc_CCD8D
mov rax, [r12]
mov [rsp+98h+var_38], rax
mov rdi, r13
lea rsi, [rsp+98h+var_38]
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r12, 20h ; ' '
jmp short loc_CCC83
loc_CCCA8:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 10
mov edi, [rbx+34h]
movss xmm0, dword ptr [rbx+38h]
movss xmm1, dword ptr [rbx+3Ch]
movss xmm2, dword ptr [rbx+40h]
call _llama_sampler_init_penalties
jmp loc_CCD70
loc_CCCCB:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 6
movss xmm0, dword ptr [rbx+24h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_typical
jmp loc_CCD70
loc_CCCE5:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 7
movss xmm0, dword ptr [rbx+28h]
movss xmm1, dword ptr [rbx+2Ch]
movss xmm2, dword ptr [rbx+30h]
call _llama_sampler_init_temp_ext
jmp short loc_CCD70
loc_CCD02:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 3
movss xmm0, dword ptr [rbx+14h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_top_p
jmp short loc_CCD70
loc_CCD19:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 9
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_infill
jmp short loc_CCD70
loc_CCD2C:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 4
movss xmm0, dword ptr [rbx+18h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_min_p
jmp short loc_CCD70
loc_CCD43:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 2
mov edi, [rbx+10h]
call _llama_sampler_init_top_k
jmp short loc_CCD70
loc_CCD54:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 8
movss xmm0, dword ptr [rbx+1Ch]
movss xmm1, dword ptr [rbx+20h]
movsxd rdi, dword ptr [rbx+0Ch]
mov esi, [rbx]
call _llama_sampler_init_xtc
loc_CCD70:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
loc_CCD7B:
add r15, 4
cmp r15, rbp
jnz loc_CCC38
jmp loc_CCE71
loc_CCD8D:
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_40]
call _llama_model_n_ctx_train
movss xmm0, dword ptr [rbx+44h]
movss xmm1, dword ptr [rbx+48h]
mov edx, [rbx+4Ch]
mov ecx, [rbx+50h]
mov r8, [rsp+98h+var_88]
mov r9, [rsp+98h+var_88+8]
sub r9, r8
sar r9, 3
mov rdi, [rsp+98h+var_90]
mov esi, eax
call _llama_sampler_init_dry
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
mov rbp, [rsp+98h+var_48]
jz short loc_CCD7B
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CCD7B
loc_CCDF4:
mov r12, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov esi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
mov edi, eax
mov edx, 64h ; 'd'
call _llama_sampler_init_mirostat
jmp short loc_CCE7F
loc_CCE3B:
mov r15, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r15
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov edi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
call _llama_sampler_init_mirostat_v2
jmp short loc_CCE7F
loc_CCE71:
mov r12, [r14+140h]
mov edi, [rbx]
call _llama_sampler_init_dist
loc_CCE7F:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_CCEA1
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CCEA1:
mov rax, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CCEB3:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aLlguidanceCmak; "llguidance (cmake -DLLAMA_LLGUIDANCE=ON"...
mov esi, 0A5h
xor eax, eax
call _ggml_abort
def_CCC54:
lea rdi, aWorkspaceLlm4b_3; jumptable 00000000000CCC54 default case, case 5
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownSa; "false && \"unknown sampler type\""
mov esi, 0E5h
xor eax, eax
call _ggml_abort
loc_CCEEE:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownMi; "false && \"unknown mirostat version\""
mov esi, 0F0h
xor eax, eax
call _ggml_abort
jmp short loc_CCF53
jmp short $+2
loc_CCF13:
mov rbx, rax
mov rdi, r14; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
jmp short loc_CCF23
mov rbx, rax
loc_CCF23:
mov esi, 1B8h
mov rdi, r14
jmp short loc_CCF4C
jmp short loc_CCF53
jmp short loc_CCF37
jmp short loc_CCF53
jmp short loc_CCF53
jmp short loc_CCF53
loc_CCF37:
mov rbx, rax
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
jz short loc_CCF56
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
loc_CCF4C:
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CCF56
loc_CCF53:
mov rbx, rax
loc_CCF56:
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_CCF6D
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CCF6D:
mov rdi, rbx
call __Unwind_Resume
| long long common_sampler_init(long long a1, unsigned int *a2)
{
unsigned __int8 v3; // bp
void **v4; // r15
void **i; // r13
long long v6; // rsi
long long inited; // rax
long long v8; // r12
long long v9; // r14
int v10; // eax
unsigned long long v11; // rsi
long long v12; // r12
unsigned int v13; // eax
long long v14; // rax
unsigned int v15; // eax
_DWORD *v16; // r15
_DWORD *v17; // rbp
long long *v18; // r12
long long *v19; // rbp
long long v20; // r12
long long v21; // rax
long long v22; // r12
unsigned int v23; // eax
long long v24; // rax
long long v25; // r12
long long v26; // rax
long long v27; // r12
unsigned int v28; // eax
long long v29; // rax
long long v30; // r15
long long v31; // rax
long long v33; // rax
long long v34; // rbx
long long vocab; // [rsp+8h] [rbp-90h]
void *v36[2]; // [rsp+10h] [rbp-88h] BYREF
long long v37; // [rsp+20h] [rbp-78h]
__int128 v38; // [rsp+30h] [rbp-68h] BYREF
long long v39; // [rsp+40h] [rbp-58h]
_DWORD *v40; // [rsp+50h] [rbp-48h]
long long v41; // [rsp+58h] [rbp-40h]
long long v42[7]; // [rsp+60h] [rbp-38h] BYREF
v41 = a1;
vocab = llama_model_get_vocab(a1, a2);
llama_sampler_chain_default_params();
v3 = *((_BYTE *)a2 + 97);
v38 = 0LL;
v39 = 0LL;
std::vector<char const*>::reserve(
&v38,
0xCCCCCCCCCCCCCCCDLL * ((long long)(*((_QWORD *)a2 + 25) - *((_QWORD *)a2 + 24)) >> 3));
v4 = (void **)*((_QWORD *)a2 + 24);
for ( i = (void **)*((_QWORD *)a2 + 25); v4 != i; v4 += 5 )
{
v36[0] = *v4;
std::vector<char const*>::emplace_back<char const*>(&v38, v36);
}
if ( !(unsigned int)std::string::compare(a2 + 38, 0LL, 11LL, "%llguidance") )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
165LL,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
LABEL_38:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
229LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown sampler type\"");
goto LABEL_39;
}
v6 = *((_QWORD *)a2 + 19);
if ( *((_BYTE *)a2 + 184) == 1 )
inited = llama_sampler_init_grammar_lazy(vocab, v6, "root", v38, (long long)(*((_QWORD *)&v38 + 1) - v38) >> 3);
else
inited = llama_sampler_init_grammar(vocab, v6, "root");
v8 = inited;
v9 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v9, (const common_params_sampling *)a2);
*(_QWORD *)(v9 + 312) = v8;
*(_QWORD *)(v9 + 320) = llama_sampler_chain_init(v3);
v10 = a2[1];
v11 = 32LL;
if ( v10 >= 33 )
v11 = (unsigned int)v10;
*(_QWORD *)(v9 + 328) = v11;
*(_OWORD *)(v9 + 336) = 0LL;
*(_QWORD *)(v9 + 352) = 0LL;
std::vector<int>::vector(v9 + 360, v11);
*(_OWORD *)(v9 + 416) = 0LL;
*(_OWORD *)(v9 + 400) = 0LL;
*(_OWORD *)(v9 + 384) = 0LL;
*(_QWORD *)(v9 + 432) = 0LL;
v12 = *(_QWORD *)(v9 + 320);
v13 = llama_vocab_n_tokens(vocab);
v14 = llama_sampler_init_logit_bias(v13, (*((_QWORD *)a2 + 37) - *((_QWORD *)a2 + 36)) >> 3);
llama_sampler_chain_add(v12, v14);
v15 = a2[21];
if ( v15 == 2 )
{
v30 = *(_QWORD *)(v9 + 320);
v31 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v30, v31);
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_mirostat_v2(*a2, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 == 1 )
{
v25 = *(_QWORD *)(v9 + 320);
v26 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v25, v26);
v27 = *(_QWORD *)(v9 + 320);
v28 = llama_vocab_n_tokens(vocab);
v29 = llama_sampler_init_mirostat(v28, *a2, 100LL, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 )
{
LABEL_39:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
240LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown mirostat version\"");
v34 = v33;
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
_Unwind_Resume(v34);
}
v16 = (_DWORD *)*((_QWORD *)a2 + 16);
v17 = (_DWORD *)*((_QWORD *)a2 + 17);
if ( v16 != v17 )
{
v40 = (_DWORD *)*((_QWORD *)a2 + 17);
while ( 2 )
{
switch ( *v16 )
{
case 1:
*(_OWORD *)v36 = 0LL;
v37 = 0LL;
std::vector<char const*>::reserve(v36, (long long)(*((_QWORD *)a2 + 14) - *((_QWORD *)a2 + 13)) >> 5);
v18 = (long long *)*((_QWORD *)a2 + 13);
v19 = (long long *)*((_QWORD *)a2 + 14);
while ( v18 != v19 )
{
v42[0] = *v18;
std::vector<char const*>::emplace_back<char const*>(v36, v42);
v18 += 4;
}
v22 = *(_QWORD *)(v9 + 320);
v23 = llama_model_n_ctx_train(v41);
v24 = llama_sampler_init_dry(
vocab,
v23,
a2[19],
a2[20],
v36[0],
((char *)v36[1] - (char *)v36[0]) >> 3,
*((float *)a2 + 17),
*((float *)a2 + 18));
llama_sampler_chain_add(v22, v24);
v17 = v40;
if ( v36[0] )
operator delete(v36[0], v37 - (unsigned long long)v36[0]);
goto LABEL_27;
case 2:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_k(a2[4]);
goto LABEL_26;
case 3:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_p((int)a2[3], *((float *)a2 + 5));
goto LABEL_26;
case 4:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_min_p((int)a2[3], *((float *)a2 + 6));
goto LABEL_26;
case 6:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_typical((int)a2[3], *((float *)a2 + 9));
goto LABEL_26;
case 7:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_temp_ext(*((float *)a2 + 10), *((float *)a2 + 11), *((float *)a2 + 12));
goto LABEL_26;
case 8:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_xtc((int)a2[3], *a2, *((float *)a2 + 7), *((float *)a2 + 8));
goto LABEL_26;
case 9:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_infill(vocab);
goto LABEL_26;
case 0xA:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_penalties(a2[13], *((float *)a2 + 14), *((float *)a2 + 15), *((float *)a2 + 16));
LABEL_26:
llama_sampler_chain_add(v20, v21);
LABEL_27:
if ( ++v16 == v17 )
break;
continue;
default:
goto LABEL_38;
}
break;
}
}
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_dist(*a2);
LABEL_34:
llama_sampler_chain_add(v27, v29);
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
return v9;
}
| |||
53,797 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O1 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x4db68
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r14), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r14, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x4d9fb
leaq 0x10(%rsp), %rdi
callq 0x4c6a4
testb %bpl, %bpl
jne 0x4d9a8
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4db89
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x4db3c
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4da05
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x4db3c
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4da5f
cmpl $0x2, %ecx
jne 0x4db8e
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40e1a
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x4db38
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4db58
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3f802
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3f802
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2c53c
movq %r15, %rdi
xorl %esi, %esi
callq 0x3f802
movq %r15, %rdi
callq 0x4c76e
movq (%rbx), %r14
jmp 0x4db38
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x4db9c
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r14, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x4dad1
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x4db3c
cmpq $0x0, 0x70(%rbx)
je 0x4dbbd
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3f802
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3f802
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x2c53c
movq %r15, %rdi
xorl %esi, %esi
callq 0x3f802
movq %r15, %rdi
callq 0x4c76e
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x4db41
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3f802
movq %r15, %rdi
callq 0x4c76e
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5fc3e(%rip), %rdi # 0xad7ad
leaq 0x5e40b(%rip), %rdx # 0xabf81
leaq 0x610bc(%rip), %rcx # 0xaec39
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x18af0
callq 0x18250
leaq 0x610b8(%rip), %rcx # 0xaec4d
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x4dba8
leaq 0x610e8(%rip), %rcx # 0xaec8b
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x5fbfe(%rip), %rdi # 0xad7ad
leaq 0x5e3cb(%rip), %rdx # 0xabf81
xorl %eax, %eax
callq 0x18af0
leaq 0x5fbe9(%rip), %rdi # 0xad7ad
leaq 0x5e3b6(%rip), %rdx # 0xabf81
leaq 0x610d1(%rip), %rcx # 0xaeca3
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x18af0
jmp 0x4dbe0
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3f802
movq %r14, %rdi
callq 0x4c76e
movq %rbx, %rdi
callq 0x18bc0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRSB_EESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_4DB68
mov ecx, ecx
mov r14, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r14+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r14
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_4D9FB
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
test bpl, bpl
jnz short loc_4D9A8
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_4DB89
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_4DB3C
loc_4D9A8:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_4DA05
mov rax, [rax-8]
test rax, rax
jz loc_4DB3C
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_4DA5F
cmp ecx, 2
jnz loc_4DB8E
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_4DB38
loc_4D9FB:
xor ebx, ebx
xor r14d, r14d
jmp loc_4DB58
loc_4DA05:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
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, 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 r14, [rbx]
jmp loc_4DB38
loc_4DA5F:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_4DB9C
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r14+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r14
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_4DAD1
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_4DAD1:
test rdx, rdx
jz short loc_4DB3C
cmp qword ptr [rbx+70h], 0
jz loc_4DBBD
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
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, 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 r14, [rbx+70h]
loc_4DB38:
mov bl, 1
jmp short loc_4DB41
loc_4DB3C:
xor ebx, ebx
xor r14d, r14d
loc_4DB41:
lea r15, [rsp+68h+var_58]
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()
loc_4DB58:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4DB68:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_4DB89:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_4DB8E:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_4DBA8
loc_4DB9C:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_4DBA8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_4DBBD:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_4DBE0:
mov rbx, rax
lea r14, [rsp+68h+var_58]
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, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<std::string&>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rax
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_((char *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(char **)a1,
(char *)v27);
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v25);
return v4;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v21,
"GGML_ASSERT(%s) failed",
v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(char **)(a1 + 112),
(char *)&v26);
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v4 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<std::__cxx11::string&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0014db68
MOV ECX,ECX
MOV R14,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R14 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R14
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0014d9fb
LEA RDI,[RSP + 0x10]
CALL 0x0014c6a4
TEST BPL,BPL
JNZ 0x0014d9a8
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0014db89
LEA RDI,[RBX + 0x80]
LAB_0014d98b:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0014db3c
LAB_0014d9a8:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0014da05
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0014db3c
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0014da5f
CMP ECX,0x2
JNZ 0x0014db8e
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x00140e1a
LAB_0014d9e2:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0014db38
LAB_0014d9fb:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0014db58
LAB_0014da05:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013f802
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013f802
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0012c53c
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013f802
MOV RDI,R15
CALL 0x0014c76e
MOV R14,qword ptr [RBX]
JMP 0x0014db38
LAB_0014da5f:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0014db9c
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R14
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0014dad1
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0014dad1:
TEST RDX,RDX
JZ 0x0014db3c
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0014dbbd
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013f802
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013f802
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x0012c53c
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013f802
MOV RDI,R15
CALL 0x0014c76e
MOV R14,qword ptr [RBX + 0x70]
LAB_0014db38:
MOV BL,0x1
JMP 0x0014db41
LAB_0014db3c:
XOR EBX,EBX
XOR R14D,R14D
LAB_0014db41:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013f802
MOV RDI,R15
CALL 0x0014c76e
LAB_0014db58:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014db68:
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
LEA RCX,[0x1aec39]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00118af0
LAB_0014db89:
CALL 0x00118250
LAB_0014db8e:
LEA RCX,[0x1aec4d]
MOV ESI,0x1c4b
JMP 0x0014dba8
LAB_0014db9c:
LEA RCX,[0x1aec8b]
MOV ESI,0x1c57
LAB_0014dba8:
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
XOR EAX,EAX
CALL 0x00118af0
LAB_0014dbbd:
LEA RDI,[0x1ad7ad]
LEA RDX,[0x1abf81]
LEA RCX,[0x1aeca3]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00118af0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<std::__cxx11::string&>(std::__cxx11::string&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<std::__cxx11::string&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58 [8];
int8 uStack_50;
data local_48 [8];
int8 uStack_40;
data local_38 [8];
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0014db58;
}
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58);
if (param_2) {
LAB_0014d9a8:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
uStack_30 = uStack_50;
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_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81(local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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,local_38);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0014db3c;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_0014dba8;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_0014db3c;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0014dbbd to 0014dbdd has its CatchHandler @ 0014dbde */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
uStack_40 = uStack_50;
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_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81(local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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 + 0x70),local_48);
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(bVar7);
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_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0014dba8:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 0014db89 to 0014dbbc has its CatchHandler @ 0014dbe0 */
std::__throw_bad_function_call();
}
/* try { // try from 0014d98b to 0014d9e1 has its CatchHandler @ 0014dbe0 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,local_58);
if (cVar2 != '\0') goto LAB_0014d9a8;
LAB_0014db3c:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_58);
LAB_0014db58:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
53,798 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool) | monkey531[P]llama/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<bool&>(bool&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x4ccaa
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r14), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r14, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x4cb3d
leaq 0x10(%rsp), %rdi
callq 0x4b7e0
testb %bpl, %bpl
jne 0x4caea
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4cccb
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x4cc7e
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4cb47
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x4cc7e
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4cba1
cmpl $0x2, %ecx
jne 0x4ccd0
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40348
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x4cc7a
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4cc9a
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ecbc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3ecbc
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2bda6
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ecbc
movq %r15, %rdi
callq 0x4b8aa
movq (%rbx), %r14
jmp 0x4cc7a
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x4ccde
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r14), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r14, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x4cc13
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x4cc7e
cmpq $0x0, 0x70(%rbx)
je 0x4ccff
leaq 0x10(%rsp), %r14
movups (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ecbc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3ecbc
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x2bda6
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ecbc
movq %r15, %rdi
callq 0x4b8aa
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x4cc83
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3ecbc
movq %r15, %rdi
callq 0x4b8aa
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5daec(%rip), %rdi # 0xaa79d
leaq 0x5c2b9(%rip), %rdx # 0xa8f71
leaq 0x5ef6a(%rip), %rcx # 0xabc29
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x18af0
callq 0x18250
leaq 0x5ef66(%rip), %rcx # 0xabc3d
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x4ccea
leaq 0x5ef96(%rip), %rcx # 0xabc7b
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x5daac(%rip), %rdi # 0xaa79d
leaq 0x5c279(%rip), %rdx # 0xa8f71
xorl %eax, %eax
callq 0x18af0
leaq 0x5da97(%rip), %rdi # 0xaa79d
leaq 0x5c264(%rip), %rdx # 0xa8f71
leaq 0x5ef7f(%rip), %rcx # 0xabc93
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x18af0
jmp 0x4cd22
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3ecbc
movq %r14, %rdi
callq 0x4b8aa
movq %rbx, %rdi
callq 0x18bc0
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRSB_EESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_4CCAA
mov ecx, ecx
mov r14, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r14+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r14
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_4CB3D
lea rdi, [rsp+68h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
test bpl, bpl
jnz short loc_4CAEA
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_4CCCB
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_4CC7E
loc_4CAEA:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_4CB47
mov rax, [rax-8]
test rax, rax
jz loc_4CC7E
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_4CBA1
cmp ecx, 2
jnz loc_4CCD0
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_4CC7A
loc_4CB3D:
xor ebx, ebx
xor r14d, r14d
jmp loc_4CC9A
loc_4CB47:
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
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, 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 r14, [rbx]
jmp loc_4CC7A
loc_4CBA1:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_4CCDE
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r14+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r14
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_4CC13
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_4CC13:
test rdx, rdx
jz short loc_4CC7E
cmp qword ptr [rbx+70h], 0
jz loc_4CCFF
lea r14, [rsp+68h+var_58]
movups xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
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, 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 r14, [rbx+70h]
loc_4CC7A:
mov bl, 1
jmp short loc_4CC83
loc_4CC7E:
xor ebx, ebx
xor r14d, r14d
loc_4CC83:
lea r15, [rsp+68h+var_58]
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()
loc_4CC9A:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4CCAA:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_4CCCB:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_4CCD0:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_4CCEA
loc_4CCDE:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_4CCEA:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_4CCFF:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_4CD22:
mov rbx, rax
lea r14, [rsp+68h+var_58]
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, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<std::string&>(
long long a1,
long long a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rax
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_((char *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(char **)a1,
(char *)v27);
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 *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)&v25);
return v4;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v21,
"GGML_ASSERT(%s) failed",
v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(char **)(a1 + 112),
(char *)&v26);
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 *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void ***)&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v4 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<std::__cxx11::string&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0014ccaa
MOV ECX,ECX
MOV R14,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R14 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R14
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0014cb3d
LEA RDI,[RSP + 0x10]
CALL 0x0014b7e0
TEST BPL,BPL
JNZ 0x0014caea
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0014cccb
LEA RDI,[RBX + 0x80]
LAB_0014cacd:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0014cc7e
LAB_0014caea:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0014cb47
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0014cc7e
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0014cba1
CMP ECX,0x2
JNZ 0x0014ccd0
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x00140348
LAB_0014cb24:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0014cc7a
LAB_0014cb3d:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0014cc9a
LAB_0014cb47:
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ecbc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013ecbc
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0012bda6
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013ecbc
MOV RDI,R15
CALL 0x0014b8aa
MOV R14,qword ptr [RBX]
JMP 0x0014cc7a
LAB_0014cba1:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0014ccde
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R14 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R14
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0014cc13
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0014cc13:
TEST RDX,RDX
JZ 0x0014cc7e
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0014ccff
LEA R14,[RSP + 0x10]
MOVUPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013ecbc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013ecbc
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x0012bda6
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013ecbc
MOV RDI,R15
CALL 0x0014b8aa
MOV R14,qword ptr [RBX + 0x70]
LAB_0014cc7a:
MOV BL,0x1
JMP 0x0014cc83
LAB_0014cc7e:
XOR EBX,EBX
XOR R14D,R14D
LAB_0014cc83:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013ecbc
MOV RDI,R15
CALL 0x0014b8aa
LAB_0014cc9a:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014ccaa:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1abc29]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00118af0
LAB_0014cccb:
CALL 0x00118250
LAB_0014ccd0:
LEA RCX,[0x1abc3d]
MOV ESI,0x1c4b
JMP 0x0014ccea
LAB_0014ccde:
LEA RCX,[0x1abc7b]
MOV ESI,0x1c57
LAB_0014ccea:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
XOR EAX,EAX
CALL 0x00118af0
LAB_0014ccff:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1abc93]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00118af0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<std::__cxx11::string&>(std::__cxx11::string&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<std::__cxx11::string&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
basic_json local_58 [8];
int8 uStack_50;
data local_48 [8];
int8 uStack_40;
data local_38 [8];
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0014cc9a;
}
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58);
if (param_2) {
LAB_0014caea:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
uStack_30 = uStack_50;
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_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81(local_38,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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,local_38);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0014cc7e;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_0014ccea;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_0014cc7e;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0014ccff to 0014cd1f has its CatchHandler @ 0014cd20 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
uStack_40 = uStack_50;
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_58,0));
local_58[0] = (basic_json)0x0;
uStack_50 = 0;
bVar7 = SUB81(local_48,0);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
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 + 0x70),local_48);
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(bVar7);
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_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0014ccea:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 0014cccb to 0014ccfe has its CatchHandler @ 0014cd22 */
std::__throw_bad_function_call();
}
/* try { // try from 0014cacd to 0014cb23 has its CatchHandler @ 0014cd22 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,local_58);
if (cVar2 != '\0') goto LAB_0014caea;
LAB_0014cc7e:
uVar5 = 0;
lVar8 = 0;
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_58);
LAB_0014cc9a:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
53,799 | testing::internal::CreateArgvFromArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-death-test.cc | static std::vector<char*> CreateArgvFromArgs(std::vector<std::string>& args) {
std::vector<char*> result;
result.reserve(args.size() + 1);
for (auto& arg : args) {
result.push_back(&arg[0]);
}
result.push_back(nullptr); // Extra null terminator.
return result;
} | O0 | cpp | testing::internal::CreateArgvFromArgs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&):
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x12e260
movq 0x68(%rsp), %rdi
callq 0x1240f0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x12e270
jmp 0xf5931
movq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x125840
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1258f0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x12e380
xorb $-0x1, %al
testb $0x1, %al
jne 0xf5970
jmp 0xf59d7
leaq 0x40(%rsp), %rdi
callq 0x12e3c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12e400
movq %rax, 0x8(%rsp)
jmp 0xf5994
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x12e3d0
jmp 0xf59af
jmp 0xf59b1
leaq 0x40(%rsp), %rdi
callq 0x12e430
jmp 0xf5959
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x123e70
jmp 0xf5a11
movq 0x18(%rsp), %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x12e3d0
jmp 0xf59f1
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0xf5a07
movq 0x18(%rsp), %rdi
callq 0x123e70
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x15dd0
nopl (%rax,%rax)
| _ZN7testing8internalL18CreateArgvFromArgsERSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EE:
sub rsp, 78h
mov [rsp+78h+var_60], rdi
mov rax, rdi
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_8], rdi
mov [rsp+78h+var_10], rsi
mov [rsp+78h+var_11], 0
call _ZNSt6vectorIPcSaIS0_EEC2Ev; std::vector<char *>::vector(void)
mov rdi, [rsp+78h+var_10]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rdi, [rsp+78h+var_60]
mov rsi, rax
inc rsi
call _ZNSt6vectorIPcSaIS0_EE7reserveEm; std::vector<char *>::reserve(ulong)
jmp short $+2
loc_F5931:
mov rax, [rsp+78h+var_10]
mov [rsp+78h+var_30], rax
mov rdi, [rsp+78h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rsp+78h+var_38], rax
mov rdi, [rsp+78h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rsp+78h+var_40], rax
loc_F5959:
lea rdi, [rsp+78h+var_38]
lea rsi, [rsp+78h+var_40]
call _ZN9__gnu_cxxeqIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
xor al, 0FFh
test al, 1
jnz short loc_F5970
jmp short loc_F59D7
loc_F5970:
lea rdi, [rsp+78h+var_38]
call _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(void)
mov [rsp+78h+var_48], rax
mov rdi, [rsp+78h+var_48]
xor eax, eax
mov esi, eax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov [rsp+78h+var_70], rax
jmp short $+2
loc_F5994:
mov rdi, [rsp+78h+var_60]
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_50], rax
lea rsi, [rsp+78h+var_50]
call _ZNSt6vectorIPcSaIS0_EE9push_backEOS0_; std::vector<char *>::push_back(char *&&)
jmp short $+2
loc_F59AF:
jmp short $+2
loc_F59B1:
lea rdi, [rsp+78h+var_38]
call _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(void)
jmp short loc_F5959
mov rdi, [rsp+arg_10]
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
call _ZNSt6vectorIPcSaIS0_EED2Ev; std::vector<char *>::~vector()
jmp short loc_F5A11
loc_F59D7:
mov rdi, [rsp+78h+var_60]
mov [rsp+78h+var_58], 0
lea rsi, [rsp+78h+var_58]
call _ZNSt6vectorIPcSaIS0_EE9push_backEOS0_; std::vector<char *>::push_back(char *&&)
jmp short $+2
loc_F59F1:
mov [rsp+78h+var_11], 1
test [rsp+78h+var_11], 1
jnz short loc_F5A07
mov rdi, [rsp+78h+var_60]
call _ZNSt6vectorIPcSaIS0_EED2Ev; std::vector<char *>::~vector()
loc_F5A07:
mov rax, [rsp+78h+var_68]
add rsp, 78h
retn
loc_F5A11:
mov rdi, [rsp+arg_50]
call __Unwind_Resume
| long long testing::internal::CreateArgvFromArgs(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+20h] [rbp-58h] BYREF
long long v5; // [rsp+28h] [rbp-50h] BYREF
long long v6; // [rsp+30h] [rbp-48h]
long long v7; // [rsp+38h] [rbp-40h] BYREF
_QWORD v8[4]; // [rsp+40h] [rbp-38h] BYREF
char v9; // [rsp+67h] [rbp-11h]
long long v10; // [rsp+68h] [rbp-10h]
long long v11; // [rsp+70h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = 0;
std::vector<char *>::vector();
v2 = std::vector<std::string>::size(a2);
std::vector<char *>::reserve(a1, v2 + 1);
v8[1] = a2;
v8[0] = std::vector<std::string>::begin(a2);
v7 = std::vector<std::string>::end(a2);
while ( (__gnu_cxx::operator==<std::string *,std::vector<std::string>>(v8, &v7) & 1) == 0 )
{
v6 = __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(v8);
v5 = std::string::operator[](v6, 0LL);
std::vector<char *>::push_back(a1, &v5);
__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(v8);
}
v4 = 0LL;
std::vector<char *>::push_back(a1, &v4);
return a1;
}
| CreateArgvFromArgs:
SUB RSP,0x78
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],RSI
MOV byte ptr [RSP + 0x67],0x0
CALL 0x0022e260
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x002240f0
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,RAX
INC RSI
LAB_001f592a:
CALL 0x0022e270
JMP 0x001f5931
LAB_001f5931:
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00225840
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x002258f0
MOV qword ptr [RSP + 0x38],RAX
LAB_001f5959:
LEA RDI,[RSP + 0x40]
LEA RSI,[RSP + 0x38]
CALL 0x0022e380
XOR AL,0xff
TEST AL,0x1
JNZ 0x001f5970
JMP 0x001f59d7
LAB_001f5970:
LEA RDI,[RSP + 0x40]
CALL 0x0022e3c0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0022e400
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001f5994
LAB_001f5994:
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
LEA RSI,[RSP + 0x28]
CALL 0x0022e3d0
JMP 0x001f59af
LAB_001f59af:
JMP 0x001f59b1
LAB_001f59b1:
LEA RDI,[RSP + 0x40]
CALL 0x0022e430
JMP 0x001f5959
LAB_001f59d7:
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],0x0
LEA RSI,[RSP + 0x20]
CALL 0x0022e3d0
LAB_001f59ef:
JMP 0x001f59f1
LAB_001f59f1:
MOV byte ptr [RSP + 0x67],0x1
TEST byte ptr [RSP + 0x67],0x1
JNZ 0x001f5a07
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00223e70
LAB_001f5a07:
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x78
RET
|
/* WARNING: Removing unreachable block (ram,0x001f59fd) */
/* testing::internal::CreateArgvFromArgs(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > >&) */
internal * __thiscall testing::internal::CreateArgvFromArgs(internal *this,vector *param_1)
{
byte bVar1;
long lVar2;
char *local_58;
char *local_50;
string *local_48;
int8 local_40;
int8 local_38;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_30;
int1 local_11;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_10;
internal *local_8;
local_11 = 0;
local_10 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1;
local_8 = this;
std::vector<char*,std::allocator<char*>>::vector((vector<char*,std::allocator<char*>> *)this);
lVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size(local_10);
/* try { // try from 001f592a to 001f59ee has its CatchHandler @ 001f59bd */
std::vector<char*,std::allocator<char*>>::reserve
((vector<char*,std::allocator<char*>> *)this,lVar2 + 1);
local_30 = local_10;
local_38 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin(local_10)
;
local_40 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end(local_30);
while (bVar1 = _ZN9__gnu_cxxeqIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_38,&local_40), ((bVar1 ^ 0xff) & 1) != 0) {
local_48 = (string *)
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_38);
local_50 = (char *)std::__cxx11::string::operator[](local_48,0);
std::vector<char*,std::allocator<char*>>::push_back
((vector<char*,std::allocator<char*>> *)this,&local_50);
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_38);
}
local_58 = (char *)0x0;
std::vector<char*,std::allocator<char*>>::push_back
((vector<char*,std::allocator<char*>> *)this,&local_58);
return this;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.